modules/access_output/http.c

   1 /*****************************************************************************
   2  * http.c
   3  *****************************************************************************
   4  * Copyright (C) 2001-2009 VLC authors and VideoLAN
   5  *
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *          Remi Denis-Courmont
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <stdint.h>
  33
  34 #include <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_sout.h>
  37 #include <vlc_block.h>
  38
  39
  40 #include <vlc_httpd.h>
  41
  42 /*****************************************************************************
  43  * Module descriptor
  44  *****************************************************************************/
  45 static int  Open ( vlc_object_t * );
  46 static void Close( vlc_object_t * );
  47
  48 #define SOUT_CFG_PREFIX "sout-http-"
  49
  50 #define USER_TEXT N_("Username")
  51 #define USER_LONGTEXT N_("Username that will be " \
  52                          "requested to access the stream." )
  53 #define PASS_TEXT N_("Password")
  54 #define PASS_LONGTEXT N_("Password that will be " \
  55                          "requested to access the stream." )
  56 #define MIME_TEXT N_("Mime")
  57 #define MIME_LONGTEXT N_("MIME returned by the server (autodetected " \
  58                         "if not specified)." )
  59 #define METACUBE_TEXT N_("Metacube")
  60 #define METACUBE_LONGTEXT N_("Use the Metacube protocol. Needed for streaming " \
  61                              "to the Cubemap reflector.")
  62
  63
  64 vlc_module_begin ()
  65     set_description( N_("HTTP stream output") )
  66     set_capability( "sout access", 0 )
  67     set_shortname( "HTTP" )
  68     add_shortcut( "http", "https", "mmsh" )
  69     set_category( CAT_SOUT )
  70     set_subcategory( SUBCAT_SOUT_ACO )
  71     add_string( SOUT_CFG_PREFIX "user", "",
  72                 USER_TEXT, USER_LONGTEXT, true )
  73     add_password(SOUT_CFG_PREFIX "pwd", "", PASS_TEXT, PASS_LONGTEXT)
  74     add_string( SOUT_CFG_PREFIX "mime", "",
  75                 MIME_TEXT, MIME_LONGTEXT, true )
  76     add_bool( SOUT_CFG_PREFIX "metacube", false,
  77               METACUBE_TEXT, METACUBE_LONGTEXT, true )
  78     set_callbacks( Open, Close )
  79 vlc_module_end ()
  80
  81
  82 /*****************************************************************************
  83  * Exported prototypes
  84  *****************************************************************************/
  85 static const char *const ppsz_sout_options[] = {
  86     "user", "pwd", "mime", "metacube", NULL
  87 };
  88
  89 static ssize_t Write( sout_access_out_t *, block_t * );
  90 static int Control( sout_access_out_t *, int, va_list );
  91
  92 typedef struct
  93 {
  94     /* host */
  95     httpd_host_t        *p_httpd_host;
  96
  97     /* stream */
  98     httpd_stream_t      *p_httpd_stream;
  99
 100     /* gather header from stream */
 101     int                 i_header_allocated;
 102     int                 i_header_size;
 103     uint8_t             *p_header;
 104     bool                b_header_complete;
 105     bool                b_metacube;
 106     bool                b_has_keyframes;
 107 } sout_access_out_sys_t;
 108
 109 /* Definitions for the Metacube2 protocol, used to communicate with Cubemap. */
 110
 111 static const uint8_t METACUBE2_SYNC[8] = {'c', 'u', 'b', 'e', '!', 'm', 'a', 'p'};
 112 #define METACUBE_FLAGS_HEADER 0x1
 113 #define METACUBE_FLAGS_NOT_SUITABLE_FOR_STREAM_START 0x2
 114
 115 struct metacube2_block_header
 116 {
 117     char sync[8];    /* METACUBE2_SYNC */
 118     uint32_t size;   /* Network byte order. Does not include header. */
 119     uint16_t flags;  /* Network byte order. METACUBE_FLAGS_*. */
 120     uint16_t csum;   /* Network byte order. CRC16 of size and flags. */
 121 };
 122
 123 /*
 124  * Implementation of Metacube2 utility functions. Taken from the Cubemap
 125  * distribution and then relicensed by the author to LGPL2.1+ for inclusion
 126  * into VLC.
 127  */
 128
 129 /*
 130  * https://www.ece.cmu.edu/~koopman/pubs/KoopmanCRCWebinar9May2012.pdf
 131  * recommends this for messages as short as ours (see table at page 34).
 132  */
 133 #define METACUBE2_CRC_POLYNOMIAL 0x8FDB
 134
 135 /* Semi-random starting value to make sure all-zero won't pass. */
 136 #define METACUBE2_CRC_START 0x1234
 137
 138 /* This code is based on code generated by pycrc. */
 139 static uint16_t metacube2_compute_crc(const struct metacube2_block_header *hdr)
 140 {
 141     static const int data_len = sizeof(hdr->size) + sizeof(hdr->flags);
 142     const uint8_t *data = (uint8_t *)&hdr->size;
 143     uint16_t crc = METACUBE2_CRC_START;
 144
 145     for (int i = 0; i < data_len; ++i) {
 146         uint8_t c = data[i];
 147         for (int j = 0; j < 8; j++) {
 148             int bit = crc & 0x8000;
 149             crc = (crc << 1) | ((c >> (7 - j)) & 0x01);
 150             if (bit) {
 151                 crc ^= METACUBE2_CRC_POLYNOMIAL;
 152             }
 153         }
 154     }
 155
 156     /* Finalize. */
 157     for (int i = 0; i < 16; i++) {
 158         int bit = crc & 0x8000;
 159         crc = crc << 1;
 160         if (bit) {
 161             crc ^= METACUBE2_CRC_POLYNOMIAL;
 162         }
 163     }
 164
 165     return crc;
 166 }
 167
 168 /*****************************************************************************
 169  * Open: open the file
 170  *****************************************************************************/
 171 static int Open( vlc_object_t *p_this )
 172 {
 173     sout_access_out_t       *p_access = (sout_access_out_t*)p_this;
 174     sout_access_out_sys_t   *p_sys;
 175
 176     char                *psz_user;
 177     char                *psz_pwd;
 178     char                *psz_mime;
 179
 180     if( !( p_sys = p_access->p_sys =
 181                 malloc( sizeof( sout_access_out_sys_t ) ) ) )
 182         return VLC_ENOMEM ;
 183
 184     config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
 185
 186     const char *path = p_access->psz_path;
 187     path += strcspn( path, "/" );
 188     if( path > p_access->psz_path )
 189     {
 190         const char *port = strrchr( p_access->psz_path, ':' );
 191         if( port != NULL && strchr( port, ']' ) != NULL )
 192             port = NULL; /* IPv6 numeral */
 193         if( port != p_access->psz_path )
 194         {
 195             int len = (port ? port : path) - p_access->psz_path;
 196             msg_Warn( p_access, "\"%.*s\" HTTP host might be ignored in "
 197                       "multiple-host configurations, use at your own risks.",
 198                       len, p_access->psz_path );
 199             msg_Info( p_access, "Consider passing --http-host=IP on the "
 200                                 "command line instead." );
 201
 202             char host[len + 1];
 203             strncpy( host, p_access->psz_path, len );
 204             host[len] = '\0';
 205
 206             var_Create( p_access, "http-host", VLC_VAR_STRING );
 207             var_SetString( p_access, "http-host", host );
 208         }
 209         if( port != NULL )
 210         {
 211             /* int len = path - ++port;
 212             msg_Info( p_access, "Consider passing --%s-port=%.*s on the "
 213                                 "command line instead.",
 214                       strcasecmp( p_access->psz_access, "https" )
 215                       ? "http" : "https", len, port ); */
 216             port++;
 217
 218             int bind_port = atoi( port );
 219             if( bind_port > 0 )
 220             {
 221                 const char *var = strcasecmp( p_access->psz_access, "https" )
 222                                   ? "http-port" : "https-port";
 223                 var_Create( p_access, var, VLC_VAR_INTEGER );
 224                 var_SetInteger( p_access, var, bind_port );
 225             }
 226         }
 227     }
 228     if( !*path )
 229         path = "/";
 230
 231     /* TLS support */
 232     if( p_access->psz_access && !strcmp( p_access->psz_access, "https" ) )
 233         p_sys->p_httpd_host = vlc_https_HostNew( VLC_OBJECT(p_access) );
 234     else
 235         p_sys->p_httpd_host = vlc_http_HostNew( VLC_OBJECT(p_access) );
 236
 237     if( p_sys->p_httpd_host == NULL )
 238     {
 239         msg_Err( p_access, "cannot start HTTP server" );
 240         free( p_sys );
 241         return VLC_EGENERIC;
 242     }
 243
 244     psz_user = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "user" );
 245     psz_pwd = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "pwd" );
 246     if( p_access->psz_access && !strcmp( p_access->psz_access, "mmsh" ) )
 247     {
 248         psz_mime = strdup( "video/x-ms-asf-stream" );
 249     }
 250     else
 251     {
 252         psz_mime = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "mime" );
 253     }
 254
 255     p_sys->b_metacube = var_GetBool( p_access, SOUT_CFG_PREFIX "metacube" );
 256     p_sys->b_has_keyframes = false;
 257
 258     p_sys->p_httpd_stream =
 259         httpd_StreamNew( p_sys->p_httpd_host, path, psz_mime,
 260                          psz_user, psz_pwd );
 261     free( psz_user );
 262     free( psz_pwd );
 263     free( psz_mime );
 264
 265     if( p_sys->p_httpd_stream == NULL )
 266     {
 267         msg_Err( p_access, "cannot add stream %s", path );
 268         httpd_HostDelete( p_sys->p_httpd_host );
 269
 270         free( p_sys );
 271         return VLC_EGENERIC;
 272     }
 273
 274     if( p_sys->b_metacube )
 275     {
 276         const httpd_header headers[] = {
 277             { (char *)"Content-encoding", (char *)"metacube" }
 278         };
 279         int err = httpd_StreamSetHTTPHeaders( p_sys->p_httpd_stream, headers,
 280                                               ARRAY_SIZE(headers) );
 281         if( err != VLC_SUCCESS )
 282         {
 283             free( p_sys );
 284             return err;
 285         }
 286     }
 287
 288     p_sys->i_header_allocated = 1024;
 289     p_sys->i_header_size      = 0;
 290     p_sys->p_header           = xmalloc( p_sys->i_header_allocated );
 291     p_sys->b_header_complete  = false;
 292
 293     p_access->pf_write       = Write;
 294     p_access->pf_control     = Control;
 295
 296     return VLC_SUCCESS;
 297 }
 298
 299 /*****************************************************************************
 300  * Close: close the target
 301  *****************************************************************************/
 302 static void Close( vlc_object_t * p_this )
 303 {
 304     sout_access_out_t       *p_access = (sout_access_out_t*)p_this;
 305     sout_access_out_sys_t   *p_sys = p_access->p_sys;
 306
 307     httpd_StreamDelete( p_sys->p_httpd_stream );
 308     httpd_HostDelete( p_sys->p_httpd_host );
 309
 310     free( p_sys->p_header );
 311
 312     msg_Dbg( p_access, "Close" );
 313
 314     free( p_sys );
 315 }
 316
 317 static int Control( sout_access_out_t *p_access, int i_query, va_list args )
 318 {
 319     (void)p_access;
 320
 321     switch( i_query )
 322     {
 323         case ACCESS_OUT_CONTROLS_PACE:
 324             *va_arg( args, bool * ) = false;
 325             break;
 326
 327         default:
 328             return VLC_EGENERIC;
 329     }
 330     return VLC_SUCCESS;
 331 }
 332
 333 /*****************************************************************************
 334  * Write:
 335  *****************************************************************************/
 336 static ssize_t Write( sout_access_out_t *p_access, block_t *p_buffer )
 337 {
 338     sout_access_out_sys_t *p_sys = p_access->p_sys;
 339     int i_err = 0;
 340     int i_len = 0;
 341
 342     while( p_buffer )
 343     {
 344         block_t *p_next;
 345
 346         if( p_buffer->i_flags & BLOCK_FLAG_HEADER )
 347         {
 348             /* gather header */
 349             if( p_sys->b_header_complete )
 350             {
 351                 /* free previously gathered header */
 352                 p_sys->i_header_size = 0;
 353                 p_sys->b_header_complete = false;
 354             }
 355             if( (int)(p_buffer->i_buffer + p_sys->i_header_size) >
 356                 p_sys->i_header_allocated )
 357             {
 358                 p_sys->i_header_allocated =
 359                     p_buffer->i_buffer + p_sys->i_header_size + 1024;
 360                 p_sys->p_header = xrealloc( p_sys->p_header,
 361                                                   p_sys->i_header_allocated );
 362             }
 363             memcpy( &p_sys->p_header[p_sys->i_header_size],
 364                     p_buffer->p_buffer,
 365                     p_buffer->i_buffer );
 366             p_sys->i_header_size += p_buffer->i_buffer;
 367         }
 368         else if( !p_sys->b_header_complete )
 369         {
 370             p_sys->b_header_complete = true;
 371
 372             if ( p_sys->b_metacube )
 373             {
 374                 struct metacube2_block_header hdr;
 375                 memcpy( hdr.sync, METACUBE2_SYNC, sizeof( METACUBE2_SYNC ) );
 376                 hdr.size = hton32( p_sys->i_header_size );
 377                 hdr.flags = hton16( METACUBE_FLAGS_HEADER );
 378                 hdr.csum = hton16( metacube2_compute_crc( &hdr ) );
 379
 380                 int i_header_size = p_sys->i_header_size + sizeof( hdr );
 381                 block_t *p_hdr_block = block_Alloc( i_header_size );
 382                 if( p_hdr_block == NULL ) {
 383                     block_ChainRelease( p_buffer );
 384                     return VLC_ENOMEM;
 385                 }
 386                 p_hdr_block->i_flags = 0;
 387                 memcpy( p_hdr_block->p_buffer, &hdr, sizeof( hdr ) );
 388                 memcpy( p_hdr_block->p_buffer + sizeof( hdr ), p_sys->p_header, p_sys->i_header_size );
 389
 390                 /* send the combined header here instead of sending them as regular
 391                  * data, so that we get them as a single Metacube header block */
 392                 httpd_StreamHeader( p_sys->p_httpd_stream, p_hdr_block->p_buffer, p_hdr_block->i_buffer );
 393                 httpd_StreamSend( p_sys->p_httpd_stream, p_hdr_block );
 394
 395                 block_Release( p_hdr_block );
 396             }
 397             else
 398             {
 399                 httpd_StreamHeader( p_sys->p_httpd_stream, p_sys->p_header,
 400                                     p_sys->i_header_size );
 401             }
 402         }
 403
 404         i_len += p_buffer->i_buffer;
 405
 406         if( p_buffer->i_flags & BLOCK_FLAG_TYPE_I )
 407         {
 408             p_sys->b_has_keyframes = true;
 409         }
 410
 411         p_next = p_buffer->p_next;
 412
 413         if( p_sys->b_metacube )
 414         {
 415             /* header data is combined into one packet and sent earlier */
 416             if( p_buffer->i_flags & BLOCK_FLAG_HEADER ) {
 417                 block_Release( p_buffer );
 418                 p_buffer = p_next;
 419                 continue;
 420             }
 421
 422             /* prepend Metacube header */
 423             struct metacube2_block_header hdr;
 424             memcpy( hdr.sync, METACUBE2_SYNC, sizeof( METACUBE2_SYNC ) );
 425             hdr.size = hton32( p_buffer->i_buffer );
 426             hdr.flags = hton16( 0 );
 427             if( p_buffer->i_flags & BLOCK_FLAG_HEADER )
 428                 hdr.flags |= hton16( METACUBE_FLAGS_HEADER );
 429             if( p_sys->b_has_keyframes && !( p_buffer->i_flags & BLOCK_FLAG_TYPE_I ) )
 430                 hdr.flags |= hton16( METACUBE_FLAGS_NOT_SUITABLE_FOR_STREAM_START );
 431             hdr.csum = hton16( metacube2_compute_crc( &hdr ) );
 432
 433             p_buffer = block_Realloc( p_buffer, sizeof( hdr ), p_buffer->i_buffer );
 434             if( p_buffer == NULL ) {
 435                 block_ChainRelease( p_next );
 436                 return VLC_ENOMEM;
 437             }
 438             memcpy( p_buffer->p_buffer, &hdr, sizeof( hdr ) );
 439         }
 440
 441         /* send data */
 442         i_err = httpd_StreamSend( p_sys->p_httpd_stream, p_buffer );
 443
 444         block_Release( p_buffer );
 445         p_buffer = p_next;
 446
 447         if( i_err < 0 )
 448         {
 449             break;
 450         }
 451     }
 452
 453     if( i_err < 0 )
 454     {
 455         block_ChainRelease( p_buffer );
 456     }
 457
 458     return( i_err < 0 ? VLC_EGENERIC : i_len );
 459 }