git.sesse.net Git - ffmpeg/blob - libavformat/rtmpproto.c

   1 /*
   2  * RTMP network protocol
   3  * Copyright (c) 2009 Konstantin Shishkov
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * RTMP protocol
  25  */
  26
  27 #include "libavcodec/bytestream.h"
  28 #include "libavutil/avstring.h"
  29 #include "libavutil/base64.h"
  30 #include "libavutil/intfloat.h"
  31 #include "libavutil/lfg.h"
  32 #include "libavutil/md5.h"
  33 #include "libavutil/opt.h"
  34 #include "libavutil/random_seed.h"
  35 #include "libavutil/sha.h"
  36 #include "avformat.h"
  37 #include "internal.h"
  38
  39 #include "network.h"
  40
  41 #include "flv.h"
  42 #include "rtmp.h"
  43 #include "rtmpcrypt.h"
  44 #include "rtmppkt.h"
  45 #include "url.h"
  46
  47 #if CONFIG_ZLIB
  48 #include <zlib.h>
  49 #endif
  50
  51 #define APP_MAX_LENGTH 1024
  52 #define PLAYPATH_MAX_LENGTH 256
  53 #define TCURL_MAX_LENGTH 512
  54 #define FLASHVER_MAX_LENGTH 64
  55 #define RTMP_PKTDATA_DEFAULT_SIZE 4096
  56
  57 /** RTMP protocol handler state */
  58 typedef enum {
  59     STATE_START,      ///< client has not done anything yet
  60     STATE_HANDSHAKED, ///< client has performed handshake
  61     STATE_FCPUBLISH,  ///< client FCPublishing stream (for output)
  62     STATE_PLAYING,    ///< client has started receiving multimedia data from server
  63     STATE_PUBLISHING, ///< client has started sending multimedia data to server (for output)
  64     STATE_RECEIVING,  ///< received a publish command (for input)
  65     STATE_STOPPED,    ///< the broadcast has been stopped
  66 } ClientState;
  67
  68 typedef struct TrackedMethod {
  69     char *name;
  70     int id;
  71 } TrackedMethod;
  72
  73 /** protocol handler context */
  74 typedef struct RTMPContext {
  75     const AVClass *class;
  76     URLContext*   stream;                     ///< TCP stream used in interactions with RTMP server
  77     RTMPPacket    prev_pkt[2][RTMP_CHANNELS]; ///< packet history used when reading and sending packets
  78     int           in_chunk_size;              ///< size of the chunks incoming RTMP packets are divided into
  79     int           out_chunk_size;             ///< size of the chunks outgoing RTMP packets are divided into
  80     int           is_input;                   ///< input/output flag
  81     char          *playpath;                  ///< stream identifier to play (with possible "mp4:" prefix)
  82     int           live;                       ///< 0: recorded, -1: live, -2: both
  83     char          *app;                       ///< name of application
  84     char          *conn;                      ///< append arbitrary AMF data to the Connect message
  85     ClientState   state;                      ///< current state
  86     int           main_channel_id;            ///< an additional channel ID which is used for some invocations
  87     uint8_t*      flv_data;                   ///< buffer with data for demuxer
  88     int           flv_size;                   ///< current buffer size
  89     int           flv_off;                    ///< number of bytes read from current buffer
  90     int           flv_nb_packets;             ///< number of flv packets published
  91     RTMPPacket    out_pkt;                    ///< rtmp packet, created from flv a/v or metadata (for output)
  92     uint32_t      client_report_size;         ///< number of bytes after which client should report to server
  93     uint32_t      bytes_read;                 ///< number of bytes read from server
  94     uint32_t      last_bytes_read;            ///< number of bytes read last reported to server
  95     int           skip_bytes;                 ///< number of bytes to skip from the input FLV stream in the next write call
  96     uint8_t       flv_header[11];             ///< partial incoming flv packet header
  97     int           flv_header_bytes;           ///< number of initialized bytes in flv_header
  98     int           nb_invokes;                 ///< keeps track of invoke messages
  99     char*         tcurl;                      ///< url of the target stream
 100     char*         flashver;                   ///< version of the flash plugin
 101     char*         swfhash;                    ///< SHA256 hash of the decompressed SWF file (32 bytes)
 102     int           swfhash_len;                ///< length of the SHA256 hash
 103     int           swfsize;                    ///< size of the decompressed SWF file
 104     char*         swfurl;                     ///< url of the swf player
 105     char*         swfverify;                  ///< URL to player swf file, compute hash/size automatically
 106     char          swfverification[42];        ///< hash of the SWF verification
 107     char*         pageurl;                    ///< url of the web page
 108     char*         subscribe;                  ///< name of live stream to subscribe
 109     int           server_bw;                  ///< server bandwidth
 110     int           client_buffer_time;         ///< client buffer time in ms
 111     int           flush_interval;             ///< number of packets flushed in the same request (RTMPT only)
 112     int           encrypted;                  ///< use an encrypted connection (RTMPE only)
 113     TrackedMethod*tracked_methods;            ///< tracked methods buffer
 114     int           nb_tracked_methods;         ///< number of tracked methods
 115     int           tracked_methods_size;       ///< size of the tracked methods buffer
 116     int           listen;                     ///< listen mode flag
 117     int           listen_timeout;             ///< listen timeout to wait for new connections
 118     int           nb_streamid;                ///< The next stream id to return on createStream calls
 119     char          username[50];
 120     char          password[50];
 121     char          auth_params[500];
 122     int           do_reconnect;
 123     int           auth_tried;
 124 } RTMPContext;
 125
 126 #define PLAYER_KEY_OPEN_PART_LEN 30   ///< length of partial key used for first client digest signing
 127 /** Client key used for digest signing */
 128 static const uint8_t rtmp_player_key[] = {
 129     'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
 130     'F', 'l', 'a', 's', 'h', ' ', 'P', 'l', 'a', 'y', 'e', 'r', ' ', '0', '0', '1',
 131
 132     0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
 133     0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
 134     0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
 135 };
 136
 137 #define SERVER_KEY_OPEN_PART_LEN 36   ///< length of partial key used for first server digest signing
 138 /** Key used for RTMP server digest signing */
 139 static const uint8_t rtmp_server_key[] = {
 140     'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
 141     'F', 'l', 'a', 's', 'h', ' ', 'M', 'e', 'd', 'i', 'a', ' ',
 142     'S', 'e', 'r', 'v', 'e', 'r', ' ', '0', '0', '1',
 143
 144     0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
 145     0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
 146     0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
 147 };
 148
 149 static int add_tracked_method(RTMPContext *rt, const char *name, int id)
 150 {
 151     void *ptr;
 152
 153     if (rt->nb_tracked_methods + 1 > rt->tracked_methods_size) {
 154         rt->tracked_methods_size = (rt->nb_tracked_methods + 1) * 2;
 155         ptr = av_realloc(rt->tracked_methods,
 156                          rt->tracked_methods_size * sizeof(*rt->tracked_methods));
 157         if (!ptr)
 158             return AVERROR(ENOMEM);
 159         rt->tracked_methods = ptr;
 160     }
 161
 162     rt->tracked_methods[rt->nb_tracked_methods].name = av_strdup(name);
 163     if (!rt->tracked_methods[rt->nb_tracked_methods].name)
 164         return AVERROR(ENOMEM);
 165     rt->tracked_methods[rt->nb_tracked_methods].id = id;
 166     rt->nb_tracked_methods++;
 167
 168     return 0;
 169 }
 170
 171 static void del_tracked_method(RTMPContext *rt, int index)
 172 {
 173     memmove(&rt->tracked_methods[index], &rt->tracked_methods[index + 1],
 174             sizeof(*rt->tracked_methods) * (rt->nb_tracked_methods - index - 1));
 175     rt->nb_tracked_methods--;
 176 }
 177
 178 static int find_tracked_method(URLContext *s, RTMPPacket *pkt, int offset,
 179                                char **tracked_method)
 180 {
 181     RTMPContext *rt = s->priv_data;
 182     GetByteContext gbc;
 183     double pkt_id;
 184     int ret;
 185     int i;
 186
 187     bytestream2_init(&gbc, pkt->data + offset, pkt->data_size - offset);
 188     if ((ret = ff_amf_read_number(&gbc, &pkt_id)) < 0)
 189         return ret;
 190
 191     for (i = 0; i < rt->nb_tracked_methods; i++) {
 192         if (rt->tracked_methods[i].id != pkt_id)
 193             continue;
 194
 195         *tracked_method = rt->tracked_methods[i].name;
 196         del_tracked_method(rt, i);
 197         break;
 198     }
 199
 200     return 0;
 201 }
 202
 203 static void free_tracked_methods(RTMPContext *rt)
 204 {
 205     int i;
 206
 207     for (i = 0; i < rt->nb_tracked_methods; i ++)
 208         av_free(rt->tracked_methods[i].name);
 209     av_free(rt->tracked_methods);
 210     rt->tracked_methods      = NULL;
 211     rt->tracked_methods_size = 0;
 212     rt->nb_tracked_methods   = 0;
 213 }
 214
 215 static int rtmp_send_packet(RTMPContext *rt, RTMPPacket *pkt, int track)
 216 {
 217     int ret;
 218
 219     if (pkt->type == RTMP_PT_INVOKE && track) {
 220         GetByteContext gbc;
 221         char name[128];
 222         double pkt_id;
 223         int len;
 224
 225         bytestream2_init(&gbc, pkt->data, pkt->data_size);
 226         if ((ret = ff_amf_read_string(&gbc, name, sizeof(name), &len)) < 0)
 227             goto fail;
 228
 229         if ((ret = ff_amf_read_number(&gbc, &pkt_id)) < 0)
 230             goto fail;
 231
 232         if ((ret = add_tracked_method(rt, name, pkt_id)) < 0)
 233             goto fail;
 234     }
 235
 236     ret = ff_rtmp_packet_write(rt->stream, pkt, rt->out_chunk_size,
 237                                rt->prev_pkt[1]);
 238 fail:
 239     ff_rtmp_packet_destroy(pkt);
 240     return ret;
 241 }
 242
 243 static int rtmp_write_amf_data(URLContext *s, char *param, uint8_t **p)
 244 {
 245     char *field, *value;
 246     char type;
 247
 248     /* The type must be B for Boolean, N for number, S for string, O for
 249      * object, or Z for null. For Booleans the data must be either 0 or 1 for
 250      * FALSE or TRUE, respectively. Likewise for Objects the data must be
 251      * 0 or 1 to end or begin an object, respectively. Data items in subobjects
 252      * may be named, by prefixing the type with 'N' and specifying the name
 253      * before the value (ie. NB:myFlag:1). This option may be used multiple times
 254      * to construct arbitrary AMF sequences. */
 255     if (param[0] && param[1] == ':') {
 256         type = param[0];
 257         value = param + 2;
 258     } else if (param[0] == 'N' && param[1] && param[2] == ':') {
 259         type = param[1];
 260         field = param + 3;
 261         value = strchr(field, ':');
 262         if (!value)
 263             goto fail;
 264         *value = '\0';
 265         value++;
 266
 267         ff_amf_write_field_name(p, field);
 268     } else {
 269         goto fail;
 270     }
 271
 272     switch (type) {
 273     case 'B':
 274         ff_amf_write_bool(p, value[0] != '0');
 275         break;
 276     case 'S':
 277         ff_amf_write_string(p, value);
 278         break;
 279     case 'N':
 280         ff_amf_write_number(p, strtod(value, NULL));
 281         break;
 282     case 'Z':
 283         ff_amf_write_null(p);
 284         break;
 285     case 'O':
 286         if (value[0] != '0')
 287             ff_amf_write_object_start(p);
 288         else
 289             ff_amf_write_object_end(p);
 290         break;
 291     default:
 292         goto fail;
 293         break;
 294     }
 295
 296     return 0;
 297
 298 fail:
 299     av_log(s, AV_LOG_ERROR, "Invalid AMF parameter: %s\n", param);
 300     return AVERROR(EINVAL);
 301 }
 302
 303 /**
 304  * Generate 'connect' call and send it to the server.
 305  */
 306 static int gen_connect(URLContext *s, RTMPContext *rt)
 307 {
 308     RTMPPacket pkt;
 309     uint8_t *p;
 310     int ret;
 311
 312     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 313                                      0, 4096 + APP_MAX_LENGTH)) < 0)
 314         return ret;
 315
 316     p = pkt.data;
 317
 318     ff_amf_write_string(&p, "connect");
 319     ff_amf_write_number(&p, ++rt->nb_invokes);
 320     ff_amf_write_object_start(&p);
 321     ff_amf_write_field_name(&p, "app");
 322     ff_amf_write_string2(&p, rt->app, rt->auth_params);
 323
 324     if (!rt->is_input) {
 325         ff_amf_write_field_name(&p, "type");
 326         ff_amf_write_string(&p, "nonprivate");
 327     }
 328     ff_amf_write_field_name(&p, "flashVer");
 329     ff_amf_write_string(&p, rt->flashver);
 330
 331     if (rt->swfurl) {
 332         ff_amf_write_field_name(&p, "swfUrl");
 333         ff_amf_write_string(&p, rt->swfurl);
 334     }
 335
 336     ff_amf_write_field_name(&p, "tcUrl");
 337     ff_amf_write_string2(&p, rt->tcurl, rt->auth_params);
 338     if (rt->is_input) {
 339         ff_amf_write_field_name(&p, "fpad");
 340         ff_amf_write_bool(&p, 0);
 341         ff_amf_write_field_name(&p, "capabilities");
 342         ff_amf_write_number(&p, 15.0);
 343
 344         /* Tell the server we support all the audio codecs except
 345          * SUPPORT_SND_INTEL (0x0008) and SUPPORT_SND_UNUSED (0x0010)
 346          * which are unused in the RTMP protocol implementation. */
 347         ff_amf_write_field_name(&p, "audioCodecs");
 348         ff_amf_write_number(&p, 4071.0);
 349         ff_amf_write_field_name(&p, "videoCodecs");
 350         ff_amf_write_number(&p, 252.0);
 351         ff_amf_write_field_name(&p, "videoFunction");
 352         ff_amf_write_number(&p, 1.0);
 353
 354         if (rt->pageurl) {
 355             ff_amf_write_field_name(&p, "pageUrl");
 356             ff_amf_write_string(&p, rt->pageurl);
 357         }
 358     }
 359     ff_amf_write_object_end(&p);
 360
 361     if (rt->conn) {
 362         char *param = rt->conn;
 363
 364         // Write arbitrary AMF data to the Connect message.
 365         while (param != NULL) {
 366             char *sep;
 367             param += strspn(param, " ");
 368             if (!*param)
 369                 break;
 370             sep = strchr(param, ' ');
 371             if (sep)
 372                 *sep = '\0';
 373             if ((ret = rtmp_write_amf_data(s, param, &p)) < 0) {
 374                 // Invalid AMF parameter.
 375                 ff_rtmp_packet_destroy(&pkt);
 376                 return ret;
 377             }
 378
 379             if (sep)
 380                 param = sep + 1;
 381             else
 382                 break;
 383         }
 384     }
 385
 386     pkt.data_size = p - pkt.data;
 387
 388     return rtmp_send_packet(rt, &pkt, 1);
 389 }
 390
 391 static int read_connect(URLContext *s, RTMPContext *rt)
 392 {
 393     RTMPPacket pkt = { 0 };
 394     uint8_t *p;
 395     const uint8_t *cp;
 396     int ret;
 397     char command[64];
 398     int stringlen;
 399     double seqnum;
 400     uint8_t tmpstr[256];
 401     GetByteContext gbc;
 402
 403     if ((ret = ff_rtmp_packet_read(rt->stream, &pkt, rt->in_chunk_size,
 404                                    rt->prev_pkt[1])) < 0)
 405         return ret;
 406     cp = pkt.data;
 407     bytestream2_init(&gbc, cp, pkt.data_size);
 408     if (ff_amf_read_string(&gbc, command, sizeof(command), &stringlen)) {
 409         av_log(s, AV_LOG_ERROR, "Unable to read command string\n");
 410         ff_rtmp_packet_destroy(&pkt);
 411         return AVERROR_INVALIDDATA;
 412     }
 413     if (strcmp(command, "connect")) {
 414         av_log(s, AV_LOG_ERROR, "Expecting connect, got %s\n", command);
 415         ff_rtmp_packet_destroy(&pkt);
 416         return AVERROR_INVALIDDATA;
 417     }
 418     ret = ff_amf_read_number(&gbc, &seqnum);
 419     if (ret)
 420         av_log(s, AV_LOG_WARNING, "SeqNum not found\n");
 421     /* Here one could parse an AMF Object with data as flashVers and others. */
 422     ret = ff_amf_get_field_value(gbc.buffer,
 423                                  gbc.buffer + bytestream2_get_bytes_left(&gbc),
 424                                  "app", tmpstr, sizeof(tmpstr));
 425     if (ret)
 426         av_log(s, AV_LOG_WARNING, "App field not found in connect\n");
 427     if (!ret && strcmp(tmpstr, rt->app))
 428         av_log(s, AV_LOG_WARNING, "App field don't match up: %s <-> %s\n",
 429                tmpstr, rt->app);
 430     ff_rtmp_packet_destroy(&pkt);
 431
 432     // Send Window Acknowledgement Size (as defined in speficication)
 433     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
 434                                      RTMP_PT_SERVER_BW, 0, 4)) < 0)
 435         return ret;
 436     p = pkt.data;
 437     bytestream_put_be32(&p, rt->server_bw);
 438     pkt.data_size = p - pkt.data;
 439     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
 440                                rt->prev_pkt[1]);
 441     ff_rtmp_packet_destroy(&pkt);
 442     if (ret < 0)
 443         return ret;
 444     // Send Peer Bandwidth
 445     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
 446                                      RTMP_PT_CLIENT_BW, 0, 5)) < 0)
 447         return ret;
 448     p = pkt.data;
 449     bytestream_put_be32(&p, rt->server_bw);
 450     bytestream_put_byte(&p, 2); // dynamic
 451     pkt.data_size = p - pkt.data;
 452     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
 453                                rt->prev_pkt[1]);
 454     ff_rtmp_packet_destroy(&pkt);
 455     if (ret < 0)
 456         return ret;
 457
 458     // Ping request
 459     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL,
 460                                      RTMP_PT_PING, 0, 6)) < 0)
 461         return ret;
 462
 463     p = pkt.data;
 464     bytestream_put_be16(&p, 0); // 0 -> Stream Begin
 465     bytestream_put_be32(&p, 0);
 466     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
 467                                rt->prev_pkt[1]);
 468     ff_rtmp_packet_destroy(&pkt);
 469     if (ret < 0)
 470         return ret;
 471
 472     // Chunk size
 473     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
 474                                      RTMP_PT_CHUNK_SIZE, 0, 4)) < 0)
 475         return ret;
 476
 477     p = pkt.data;
 478     bytestream_put_be32(&p, rt->out_chunk_size);
 479     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
 480                                rt->prev_pkt[1]);
 481     ff_rtmp_packet_destroy(&pkt);
 482     if (ret < 0)
 483         return ret;
 484
 485     // Send result_ NetConnection.Connect.Success to connect
 486     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
 487                                      RTMP_PT_INVOKE, 0,
 488                                      RTMP_PKTDATA_DEFAULT_SIZE)) < 0)
 489         return ret;
 490
 491     p = pkt.data;
 492     ff_amf_write_string(&p, "_result");
 493     ff_amf_write_number(&p, seqnum);
 494
 495     ff_amf_write_object_start(&p);
 496     ff_amf_write_field_name(&p, "fmsVer");
 497     ff_amf_write_string(&p, "FMS/3,0,1,123");
 498     ff_amf_write_field_name(&p, "capabilities");
 499     ff_amf_write_number(&p, 31);
 500     ff_amf_write_object_end(&p);
 501
 502     ff_amf_write_object_start(&p);
 503     ff_amf_write_field_name(&p, "level");
 504     ff_amf_write_string(&p, "status");
 505     ff_amf_write_field_name(&p, "code");
 506     ff_amf_write_string(&p, "NetConnection.Connect.Success");
 507     ff_amf_write_field_name(&p, "description");
 508     ff_amf_write_string(&p, "Connection succeeded.");
 509     ff_amf_write_field_name(&p, "objectEncoding");
 510     ff_amf_write_number(&p, 0);
 511     ff_amf_write_object_end(&p);
 512
 513     pkt.data_size = p - pkt.data;
 514     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
 515                                rt->prev_pkt[1]);
 516     ff_rtmp_packet_destroy(&pkt);
 517     if (ret < 0)
 518         return ret;
 519
 520     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL,
 521                                      RTMP_PT_INVOKE, 0, 30)) < 0)
 522         return ret;
 523     p = pkt.data;
 524     ff_amf_write_string(&p, "onBWDone");
 525     ff_amf_write_number(&p, 0);
 526     ff_amf_write_null(&p);
 527     ff_amf_write_number(&p, 8192);
 528     pkt.data_size = p - pkt.data;
 529     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->out_chunk_size,
 530                                rt->prev_pkt[1]);
 531     ff_rtmp_packet_destroy(&pkt);
 532
 533     return ret;
 534 }
 535
 536 /**
 537  * Generate 'releaseStream' call and send it to the server. It should make
 538  * the server release some channel for media streams.
 539  */
 540 static int gen_release_stream(URLContext *s, RTMPContext *rt)
 541 {
 542     RTMPPacket pkt;
 543     uint8_t *p;
 544     int ret;
 545
 546     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 547                                      0, 29 + strlen(rt->playpath))) < 0)
 548         return ret;
 549
 550     av_log(s, AV_LOG_DEBUG, "Releasing stream...\n");
 551     p = pkt.data;
 552     ff_amf_write_string(&p, "releaseStream");
 553     ff_amf_write_number(&p, ++rt->nb_invokes);
 554     ff_amf_write_null(&p);
 555     ff_amf_write_string(&p, rt->playpath);
 556
 557     return rtmp_send_packet(rt, &pkt, 1);
 558 }
 559
 560 /**
 561  * Generate 'FCPublish' call and send it to the server. It should make
 562  * the server preapare for receiving media streams.
 563  */
 564 static int gen_fcpublish_stream(URLContext *s, RTMPContext *rt)
 565 {
 566     RTMPPacket pkt;
 567     uint8_t *p;
 568     int ret;
 569
 570     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 571                                      0, 25 + strlen(rt->playpath))) < 0)
 572         return ret;
 573
 574     av_log(s, AV_LOG_DEBUG, "FCPublish stream...\n");
 575     p = pkt.data;
 576     ff_amf_write_string(&p, "FCPublish");
 577     ff_amf_write_number(&p, ++rt->nb_invokes);
 578     ff_amf_write_null(&p);
 579     ff_amf_write_string(&p, rt->playpath);
 580
 581     return rtmp_send_packet(rt, &pkt, 1);
 582 }
 583
 584 /**
 585  * Generate 'FCUnpublish' call and send it to the server. It should make
 586  * the server destroy stream.
 587  */
 588 static int gen_fcunpublish_stream(URLContext *s, RTMPContext *rt)
 589 {
 590     RTMPPacket pkt;
 591     uint8_t *p;
 592     int ret;
 593
 594     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 595                                      0, 27 + strlen(rt->playpath))) < 0)
 596         return ret;
 597
 598     av_log(s, AV_LOG_DEBUG, "UnPublishing stream...\n");
 599     p = pkt.data;
 600     ff_amf_write_string(&p, "FCUnpublish");
 601     ff_amf_write_number(&p, ++rt->nb_invokes);
 602     ff_amf_write_null(&p);
 603     ff_amf_write_string(&p, rt->playpath);
 604
 605     return rtmp_send_packet(rt, &pkt, 0);
 606 }
 607
 608 /**
 609  * Generate 'createStream' call and send it to the server. It should make
 610  * the server allocate some channel for media streams.
 611  */
 612 static int gen_create_stream(URLContext *s, RTMPContext *rt)
 613 {
 614     RTMPPacket pkt;
 615     uint8_t *p;
 616     int ret;
 617
 618     av_log(s, AV_LOG_DEBUG, "Creating stream...\n");
 619
 620     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 621                                      0, 25)) < 0)
 622         return ret;
 623
 624     p = pkt.data;
 625     ff_amf_write_string(&p, "createStream");
 626     ff_amf_write_number(&p, ++rt->nb_invokes);
 627     ff_amf_write_null(&p);
 628
 629     return rtmp_send_packet(rt, &pkt, 1);
 630 }
 631
 632
 633 /**
 634  * Generate 'deleteStream' call and send it to the server. It should make
 635  * the server remove some channel for media streams.
 636  */
 637 static int gen_delete_stream(URLContext *s, RTMPContext *rt)
 638 {
 639     RTMPPacket pkt;
 640     uint8_t *p;
 641     int ret;
 642
 643     av_log(s, AV_LOG_DEBUG, "Deleting stream...\n");
 644
 645     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 646                                      0, 34)) < 0)
 647         return ret;
 648
 649     p = pkt.data;
 650     ff_amf_write_string(&p, "deleteStream");
 651     ff_amf_write_number(&p, ++rt->nb_invokes);
 652     ff_amf_write_null(&p);
 653     ff_amf_write_number(&p, rt->main_channel_id);
 654
 655     return rtmp_send_packet(rt, &pkt, 0);
 656 }
 657
 658 /**
 659  * Generate client buffer time and send it to the server.
 660  */
 661 static int gen_buffer_time(URLContext *s, RTMPContext *rt)
 662 {
 663     RTMPPacket pkt;
 664     uint8_t *p;
 665     int ret;
 666
 667     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
 668                                      1, 10)) < 0)
 669         return ret;
 670
 671     p = pkt.data;
 672     bytestream_put_be16(&p, 3);
 673     bytestream_put_be32(&p, rt->main_channel_id);
 674     bytestream_put_be32(&p, rt->client_buffer_time);
 675
 676     return rtmp_send_packet(rt, &pkt, 0);
 677 }
 678
 679 /**
 680  * Generate 'play' call and send it to the server, then ping the server
 681  * to start actual playing.
 682  */
 683 static int gen_play(URLContext *s, RTMPContext *rt)
 684 {
 685     RTMPPacket pkt;
 686     uint8_t *p;
 687     int ret;
 688
 689     av_log(s, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
 690
 691     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE,
 692                                      0, 29 + strlen(rt->playpath))) < 0)
 693         return ret;
 694
 695     pkt.extra = rt->main_channel_id;
 696
 697     p = pkt.data;
 698     ff_amf_write_string(&p, "play");
 699     ff_amf_write_number(&p, ++rt->nb_invokes);
 700     ff_amf_write_null(&p);
 701     ff_amf_write_string(&p, rt->playpath);
 702     ff_amf_write_number(&p, rt->live);
 703
 704     return rtmp_send_packet(rt, &pkt, 1);
 705 }
 706
 707 /**
 708  * Generate 'publish' call and send it to the server.
 709  */
 710 static int gen_publish(URLContext *s, RTMPContext *rt)
 711 {
 712     RTMPPacket pkt;
 713     uint8_t *p;
 714     int ret;
 715
 716     av_log(s, AV_LOG_DEBUG, "Sending publish command for '%s'\n", rt->playpath);
 717
 718     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SOURCE_CHANNEL, RTMP_PT_INVOKE,
 719                                      0, 30 + strlen(rt->playpath))) < 0)
 720         return ret;
 721
 722     pkt.extra = rt->main_channel_id;
 723
 724     p = pkt.data;
 725     ff_amf_write_string(&p, "publish");
 726     ff_amf_write_number(&p, ++rt->nb_invokes);
 727     ff_amf_write_null(&p);
 728     ff_amf_write_string(&p, rt->playpath);
 729     ff_amf_write_string(&p, "live");
 730
 731     return rtmp_send_packet(rt, &pkt, 1);
 732 }
 733
 734 /**
 735  * Generate ping reply and send it to the server.
 736  */
 737 static int gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
 738 {
 739     RTMPPacket pkt;
 740     uint8_t *p;
 741     int ret;
 742
 743     if (ppkt->data_size < 6) {
 744         av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
 745                ppkt->data_size);
 746         return AVERROR_INVALIDDATA;
 747     }
 748
 749     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
 750                                      ppkt->timestamp + 1, 6)) < 0)
 751         return ret;
 752
 753     p = pkt.data;
 754     bytestream_put_be16(&p, 7);
 755     bytestream_put_be32(&p, AV_RB32(ppkt->data+2));
 756
 757     return rtmp_send_packet(rt, &pkt, 0);
 758 }
 759
 760 /**
 761  * Generate SWF verification message and send it to the server.
 762  */
 763 static int gen_swf_verification(URLContext *s, RTMPContext *rt)
 764 {
 765     RTMPPacket pkt;
 766     uint8_t *p;
 767     int ret;
 768
 769     av_log(s, AV_LOG_DEBUG, "Sending SWF verification...\n");
 770     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
 771                                      0, 44)) < 0)
 772         return ret;
 773
 774     p = pkt.data;
 775     bytestream_put_be16(&p, 27);
 776     memcpy(p, rt->swfverification, 42);
 777
 778     return rtmp_send_packet(rt, &pkt, 0);
 779 }
 780
 781 /**
 782  * Generate server bandwidth message and send it to the server.
 783  */
 784 static int gen_server_bw(URLContext *s, RTMPContext *rt)
 785 {
 786     RTMPPacket pkt;
 787     uint8_t *p;
 788     int ret;
 789
 790     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_SERVER_BW,
 791                                      0, 4)) < 0)
 792         return ret;
 793
 794     p = pkt.data;
 795     bytestream_put_be32(&p, rt->server_bw);
 796
 797     return rtmp_send_packet(rt, &pkt, 0);
 798 }
 799
 800 /**
 801  * Generate check bandwidth message and send it to the server.
 802  */
 803 static int gen_check_bw(URLContext *s, RTMPContext *rt)
 804 {
 805     RTMPPacket pkt;
 806     uint8_t *p;
 807     int ret;
 808
 809     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 810                                      0, 21)) < 0)
 811         return ret;
 812
 813     p = pkt.data;
 814     ff_amf_write_string(&p, "_checkbw");
 815     ff_amf_write_number(&p, ++rt->nb_invokes);
 816     ff_amf_write_null(&p);
 817
 818     return rtmp_send_packet(rt, &pkt, 1);
 819 }
 820
 821 /**
 822  * Generate report on bytes read so far and send it to the server.
 823  */
 824 static int gen_bytes_read(URLContext *s, RTMPContext *rt, uint32_t ts)
 825 {
 826     RTMPPacket pkt;
 827     uint8_t *p;
 828     int ret;
 829
 830     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_BYTES_READ,
 831                                      ts, 4)) < 0)
 832         return ret;
 833
 834     p = pkt.data;
 835     bytestream_put_be32(&p, rt->bytes_read);
 836
 837     return rtmp_send_packet(rt, &pkt, 0);
 838 }
 839
 840 static int gen_fcsubscribe_stream(URLContext *s, RTMPContext *rt,
 841                                   const char *subscribe)
 842 {
 843     RTMPPacket pkt;
 844     uint8_t *p;
 845     int ret;
 846
 847     if ((ret = ff_rtmp_packet_create(&pkt, RTMP_SYSTEM_CHANNEL, RTMP_PT_INVOKE,
 848                                      0, 27 + strlen(subscribe))) < 0)
 849         return ret;
 850
 851     p = pkt.data;
 852     ff_amf_write_string(&p, "FCSubscribe");
 853     ff_amf_write_number(&p, ++rt->nb_invokes);
 854     ff_amf_write_null(&p);
 855     ff_amf_write_string(&p, subscribe);
 856
 857     return rtmp_send_packet(rt, &pkt, 1);
 858 }
 859
 860 int ff_rtmp_calc_digest(const uint8_t *src, int len, int gap,
 861                         const uint8_t *key, int keylen, uint8_t *dst)
 862 {
 863     struct AVSHA *sha;
 864     uint8_t hmac_buf[64+32] = {0};
 865     int i;
 866
 867     sha = av_sha_alloc();
 868     if (!sha)
 869         return AVERROR(ENOMEM);
 870
 871     if (keylen < 64) {
 872         memcpy(hmac_buf, key, keylen);
 873     } else {
 874         av_sha_init(sha, 256);
 875         av_sha_update(sha,key, keylen);
 876         av_sha_final(sha, hmac_buf);
 877     }
 878     for (i = 0; i < 64; i++)
 879         hmac_buf[i] ^= HMAC_IPAD_VAL;
 880
 881     av_sha_init(sha, 256);
 882     av_sha_update(sha, hmac_buf, 64);
 883     if (gap <= 0) {
 884         av_sha_update(sha, src, len);
 885     } else { //skip 32 bytes used for storing digest
 886         av_sha_update(sha, src, gap);
 887         av_sha_update(sha, src + gap + 32, len - gap - 32);
 888     }
 889     av_sha_final(sha, hmac_buf + 64);
 890
 891     for (i = 0; i < 64; i++)
 892         hmac_buf[i] ^= HMAC_IPAD_VAL ^ HMAC_OPAD_VAL; //reuse XORed key for opad
 893     av_sha_init(sha, 256);
 894     av_sha_update(sha, hmac_buf, 64+32);
 895     av_sha_final(sha, dst);
 896
 897     av_free(sha);
 898
 899     return 0;
 900 }
 901
 902 int ff_rtmp_calc_digest_pos(const uint8_t *buf, int off, int mod_val,
 903                             int add_val)
 904 {
 905     int i, digest_pos = 0;
 906
 907     for (i = 0; i < 4; i++)
 908         digest_pos += buf[i + off];
 909     digest_pos = digest_pos % mod_val + add_val;
 910
 911     return digest_pos;
 912 }
 913
 914 /**
 915  * Put HMAC-SHA2 digest of packet data (except for the bytes where this digest
 916  * will be stored) into that packet.
 917  *
 918  * @param buf handshake data (1536 bytes)
 919  * @param encrypted use an encrypted connection (RTMPE)
 920  * @return offset to the digest inside input data
 921  */
 922 static int rtmp_handshake_imprint_with_digest(uint8_t *buf, int encrypted)
 923 {
 924     int ret, digest_pos;
 925
 926     if (encrypted)
 927         digest_pos = ff_rtmp_calc_digest_pos(buf, 772, 728, 776);
 928     else
 929         digest_pos = ff_rtmp_calc_digest_pos(buf, 8, 728, 12);
 930
 931     ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
 932                               rtmp_player_key, PLAYER_KEY_OPEN_PART_LEN,
 933                               buf + digest_pos);
 934     if (ret < 0)
 935         return ret;
 936
 937     return digest_pos;
 938 }
 939
 940 /**
 941  * Verify that the received server response has the expected digest value.
 942  *
 943  * @param buf handshake data received from the server (1536 bytes)
 944  * @param off position to search digest offset from
 945  * @return 0 if digest is valid, digest position otherwise
 946  */
 947 static int rtmp_validate_digest(uint8_t *buf, int off)
 948 {
 949     uint8_t digest[32];
 950     int ret, digest_pos;
 951
 952     digest_pos = ff_rtmp_calc_digest_pos(buf, off, 728, off + 4);
 953
 954     ret = ff_rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
 955                               rtmp_server_key, SERVER_KEY_OPEN_PART_LEN,
 956                               digest);
 957     if (ret < 0)
 958         return ret;
 959
 960     if (!memcmp(digest, buf + digest_pos, 32))
 961         return digest_pos;
 962     return 0;
 963 }
 964
 965 static int rtmp_calc_swf_verification(URLContext *s, RTMPContext *rt,
 966                                       uint8_t *buf)
 967 {
 968     uint8_t *p;
 969     int ret;
 970
 971     if (rt->swfhash_len != 32) {
 972         av_log(s, AV_LOG_ERROR,
 973                "Hash of the decompressed SWF file is not 32 bytes long.\n");
 974         return AVERROR(EINVAL);
 975     }
 976
 977     p = &rt->swfverification[0];
 978     bytestream_put_byte(&p, 1);
 979     bytestream_put_byte(&p, 1);
 980     bytestream_put_be32(&p, rt->swfsize);
 981     bytestream_put_be32(&p, rt->swfsize);
 982
 983     if ((ret = ff_rtmp_calc_digest(rt->swfhash, 32, 0, buf, 32, p)) < 0)
 984         return ret;
 985
 986     return 0;
 987 }
 988
 989 #if CONFIG_ZLIB
 990 static int rtmp_uncompress_swfplayer(uint8_t *in_data, int64_t in_size,
 991                                      uint8_t **out_data, int64_t *out_size)
 992 {
 993     z_stream zs = { 0 };
 994     void *ptr;
 995     int size;
 996     int ret = 0;
 997
 998     zs.avail_in = in_size;
 999     zs.next_in  = in_data;
1000     ret = inflateInit(&zs);
1001     if (ret != Z_OK)
1002         return AVERROR_UNKNOWN;
1003
1004     do {
1005         uint8_t tmp_buf[16384];
1006
1007         zs.avail_out = sizeof(tmp_buf);
1008         zs.next_out  = tmp_buf;
1009
1010         ret = inflate(&zs, Z_NO_FLUSH);
1011         if (ret != Z_OK && ret != Z_STREAM_END) {
1012             ret = AVERROR_UNKNOWN;
1013             goto fail;
1014         }
1015
1016         size = sizeof(tmp_buf) - zs.avail_out;
1017         if (!(ptr = av_realloc(*out_data, *out_size + size))) {
1018             ret = AVERROR(ENOMEM);
1019             goto fail;
1020         }
1021         *out_data = ptr;
1022
1023         memcpy(*out_data + *out_size, tmp_buf, size);
1024         *out_size += size;
1025     } while (zs.avail_out == 0);
1026
1027 fail:
1028     inflateEnd(&zs);
1029     return ret;
1030 }
1031 #endif
1032
1033 static int rtmp_calc_swfhash(URLContext *s)
1034 {
1035     RTMPContext *rt = s->priv_data;
1036     uint8_t *in_data = NULL, *out_data = NULL, *swfdata;
1037     int64_t in_size, out_size;
1038     URLContext *stream;
1039     char swfhash[32];
1040     int swfsize;
1041     int ret = 0;
1042
1043     /* Get the SWF player file. */
1044     if ((ret = ffurl_open(&stream, rt->swfverify, AVIO_FLAG_READ,
1045                           &s->interrupt_callback, NULL)) < 0) {
1046         av_log(s, AV_LOG_ERROR, "Cannot open connection %s.\n", rt->swfverify);
1047         goto fail;
1048     }
1049
1050     if ((in_size = ffurl_seek(stream, 0, AVSEEK_SIZE)) < 0) {
1051         ret = AVERROR(EIO);
1052         goto fail;
1053     }
1054
1055     if (!(in_data = av_malloc(in_size))) {
1056         ret = AVERROR(ENOMEM);
1057         goto fail;
1058     }
1059
1060     if ((ret = ffurl_read_complete(stream, in_data, in_size)) < 0)
1061         goto fail;
1062
1063     if (in_size < 3) {
1064         ret = AVERROR_INVALIDDATA;
1065         goto fail;
1066     }
1067
1068     if (!memcmp(in_data, "CWS", 3)) {
1069         /* Decompress the SWF player file using Zlib. */
1070         if (!(out_data = av_malloc(8))) {
1071             ret = AVERROR(ENOMEM);
1072             goto fail;
1073         }
1074         *in_data = 'F'; // magic stuff
1075         memcpy(out_data, in_data, 8);
1076         out_size = 8;
1077
1078 #if CONFIG_ZLIB
1079         if ((ret = rtmp_uncompress_swfplayer(in_data + 8, in_size - 8,
1080                                              &out_data, &out_size)) < 0)
1081             goto fail;
1082 #else
1083         av_log(s, AV_LOG_ERROR,
1084                "Zlib is required for decompressing the SWF player file.\n");
1085         ret = AVERROR(EINVAL);
1086         goto fail;
1087 #endif
1088         swfsize = out_size;
1089         swfdata = out_data;
1090     } else {
1091         swfsize = in_size;
1092         swfdata = in_data;
1093     }
1094
1095     /* Compute the SHA256 hash of the SWF player file. */
1096     if ((ret = ff_rtmp_calc_digest(swfdata, swfsize, 0,
1097                                    "Genuine Adobe Flash Player 001", 30,
1098                                    swfhash)) < 0)
1099         goto fail;
1100
1101     /* Set SWFVerification parameters. */
1102     av_opt_set_bin(rt, "rtmp_swfhash", swfhash, 32, 0);
1103     rt->swfsize = swfsize;
1104
1105 fail:
1106     av_freep(&in_data);
1107     av_freep(&out_data);
1108     ffurl_close(stream);
1109     return ret;
1110 }
1111
1112 /**
1113  * Perform handshake with the server by means of exchanging pseudorandom data
1114  * signed with HMAC-SHA2 digest.
1115  *
1116  * @return 0 if handshake succeeds, negative value otherwise
1117  */
1118 static int rtmp_handshake(URLContext *s, RTMPContext *rt)
1119 {
1120     AVLFG rnd;
1121     uint8_t tosend    [RTMP_HANDSHAKE_PACKET_SIZE+1] = {
1122         3,                // unencrypted data
1123         0, 0, 0, 0,       // client uptime
1124         RTMP_CLIENT_VER1,
1125         RTMP_CLIENT_VER2,
1126         RTMP_CLIENT_VER3,
1127         RTMP_CLIENT_VER4,
1128     };
1129     uint8_t clientdata[RTMP_HANDSHAKE_PACKET_SIZE];
1130     uint8_t serverdata[RTMP_HANDSHAKE_PACKET_SIZE+1];
1131     int i;
1132     int server_pos, client_pos;
1133     uint8_t digest[32], signature[32];
1134     int ret, type = 0;
1135
1136     av_log(s, AV_LOG_DEBUG, "Handshaking...\n");
1137
1138     av_lfg_init(&rnd, 0xDEADC0DE);
1139     // generate handshake packet - 1536 bytes of pseudorandom data
1140     for (i = 9; i <= RTMP_HANDSHAKE_PACKET_SIZE; i++)
1141         tosend[i] = av_lfg_get(&rnd) >> 24;
1142
1143     if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1144         /* When the client wants to use RTMPE, we have to change the command
1145          * byte to 0x06 which means to use encrypted data and we have to set
1146          * the flash version to at least 9.0.115.0. */
1147         tosend[0] = 6;
1148         tosend[5] = 128;
1149         tosend[6] = 0;
1150         tosend[7] = 3;
1151         tosend[8] = 2;
1152
1153         /* Initialize the Diffie-Hellmann context and generate the public key
1154          * to send to the server. */
1155         if ((ret = ff_rtmpe_gen_pub_key(rt->stream, tosend + 1)) < 0)
1156             return ret;
1157     }
1158
1159     client_pos = rtmp_handshake_imprint_with_digest(tosend + 1, rt->encrypted);
1160     if (client_pos < 0)
1161         return client_pos;
1162
1163     if ((ret = ffurl_write(rt->stream, tosend,
1164                            RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
1165         av_log(s, AV_LOG_ERROR, "Cannot write RTMP handshake request\n");
1166         return ret;
1167     }
1168
1169     if ((ret = ffurl_read_complete(rt->stream, serverdata,
1170                                    RTMP_HANDSHAKE_PACKET_SIZE + 1)) < 0) {
1171         av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
1172         return ret;
1173     }
1174
1175     if ((ret = ffurl_read_complete(rt->stream, clientdata,
1176                                    RTMP_HANDSHAKE_PACKET_SIZE)) < 0) {
1177         av_log(s, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
1178         return ret;
1179     }
1180
1181     av_log(s, AV_LOG_DEBUG, "Type answer %d\n", serverdata[0]);
1182     av_log(s, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
1183            serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
1184
1185     if (rt->is_input && serverdata[5] >= 3) {
1186         server_pos = rtmp_validate_digest(serverdata + 1, 772);
1187         if (server_pos < 0)
1188             return server_pos;
1189
1190         if (!server_pos) {
1191             type = 1;
1192             server_pos = rtmp_validate_digest(serverdata + 1, 8);
1193             if (server_pos < 0)
1194                 return server_pos;
1195
1196             if (!server_pos) {
1197                 av_log(s, AV_LOG_ERROR, "Server response validating failed\n");
1198                 return AVERROR(EIO);
1199             }
1200         }
1201
1202         /* Generate SWFVerification token (SHA256 HMAC hash of decompressed SWF,
1203          * key are the last 32 bytes of the server handshake. */
1204         if (rt->swfsize) {
1205             if ((ret = rtmp_calc_swf_verification(s, rt, serverdata + 1 +
1206                                                   RTMP_HANDSHAKE_PACKET_SIZE - 32)) < 0)
1207                 return ret;
1208         }
1209
1210         ret = ff_rtmp_calc_digest(tosend + 1 + client_pos, 32, 0,
1211                                   rtmp_server_key, sizeof(rtmp_server_key),
1212                                   digest);
1213         if (ret < 0)
1214             return ret;
1215
1216         ret = ff_rtmp_calc_digest(clientdata, RTMP_HANDSHAKE_PACKET_SIZE - 32,
1217                                   0, digest, 32, signature);
1218         if (ret < 0)
1219             return ret;
1220
1221         if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1222             /* Compute the shared secret key sent by the server and initialize
1223              * the RC4 encryption. */
1224             if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
1225                                                    tosend + 1, type)) < 0)
1226                 return ret;
1227
1228             /* Encrypt the signature received by the server. */
1229             ff_rtmpe_encrypt_sig(rt->stream, signature, digest, serverdata[0]);
1230         }
1231
1232         if (memcmp(signature, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
1233             av_log(s, AV_LOG_ERROR, "Signature mismatch\n");
1234             return AVERROR(EIO);
1235         }
1236
1237         for (i = 0; i < RTMP_HANDSHAKE_PACKET_SIZE; i++)
1238             tosend[i] = av_lfg_get(&rnd) >> 24;
1239         ret = ff_rtmp_calc_digest(serverdata + 1 + server_pos, 32, 0,
1240                                   rtmp_player_key, sizeof(rtmp_player_key),
1241                                   digest);
1242         if (ret < 0)
1243             return ret;
1244
1245         ret = ff_rtmp_calc_digest(tosend, RTMP_HANDSHAKE_PACKET_SIZE - 32, 0,
1246                                   digest, 32,
1247                                   tosend + RTMP_HANDSHAKE_PACKET_SIZE - 32);
1248         if (ret < 0)
1249             return ret;
1250
1251         if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1252             /* Encrypt the signature to be send to the server. */
1253             ff_rtmpe_encrypt_sig(rt->stream, tosend +
1254                                  RTMP_HANDSHAKE_PACKET_SIZE - 32, digest,
1255                                  serverdata[0]);
1256         }
1257
1258         // write reply back to the server
1259         if ((ret = ffurl_write(rt->stream, tosend,
1260                                RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1261             return ret;
1262
1263         if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1264             /* Set RC4 keys for encryption and update the keystreams. */
1265             if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
1266                 return ret;
1267         }
1268     } else {
1269         if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1270             /* Compute the shared secret key sent by the server and initialize
1271              * the RC4 encryption. */
1272             if ((ret = ff_rtmpe_compute_secret_key(rt->stream, serverdata + 1,
1273                             tosend + 1, 1)) < 0)
1274                 return ret;
1275
1276             if (serverdata[0] == 9) {
1277                 /* Encrypt the signature received by the server. */
1278                 ff_rtmpe_encrypt_sig(rt->stream, signature, digest,
1279                                      serverdata[0]);
1280             }
1281         }
1282
1283         if ((ret = ffurl_write(rt->stream, serverdata + 1,
1284                                RTMP_HANDSHAKE_PACKET_SIZE)) < 0)
1285             return ret;
1286
1287         if (CONFIG_FFRTMPCRYPT_PROTOCOL && rt->encrypted) {
1288             /* Set RC4 keys for encryption and update the keystreams. */
1289             if ((ret = ff_rtmpe_update_keystream(rt->stream)) < 0)
1290                 return ret;
1291         }
1292     }
1293
1294     return 0;
1295 }
1296
1297 static int rtmp_receive_hs_packet(RTMPContext* rt, uint32_t *first_int,
1298                                   uint32_t *second_int, char *arraydata,
1299                                   int size)
1300 {
1301     int inoutsize;
1302
1303     inoutsize = ffurl_read_complete(rt->stream, arraydata,
1304                                     RTMP_HANDSHAKE_PACKET_SIZE);
1305     if (inoutsize <= 0)
1306         return AVERROR(EIO);
1307     if (inoutsize != RTMP_HANDSHAKE_PACKET_SIZE) {
1308         av_log(rt, AV_LOG_ERROR, "Erroneous Message size %d"
1309                " not following standard\n", (int)inoutsize);
1310         return AVERROR(EINVAL);
1311     }
1312
1313     *first_int  = AV_RB32(arraydata);
1314     *second_int = AV_RB32(arraydata + 4);
1315     return 0;
1316 }
1317
1318 static int rtmp_send_hs_packet(RTMPContext* rt, uint32_t first_int,
1319                                uint32_t second_int, char *arraydata, int size)
1320 {
1321     int inoutsize;
1322
1323     AV_WB32(arraydata, first_int);
1324     AV_WB32(arraydata + 4, first_int);
1325     inoutsize = ffurl_write(rt->stream, arraydata,
1326                             RTMP_HANDSHAKE_PACKET_SIZE);
1327     if (inoutsize != RTMP_HANDSHAKE_PACKET_SIZE) {
1328         av_log(rt, AV_LOG_ERROR, "Unable to write answer\n");
1329         return AVERROR(EIO);
1330     }
1331
1332     return 0;
1333 }
1334
1335 /**
1336  * rtmp handshake server side
1337  */
1338 static int rtmp_server_handshake(URLContext *s, RTMPContext *rt)
1339 {
1340     uint8_t buffer[RTMP_HANDSHAKE_PACKET_SIZE];
1341     uint32_t hs_epoch;
1342     uint32_t hs_my_epoch;
1343     uint8_t hs_c1[RTMP_HANDSHAKE_PACKET_SIZE];
1344     uint8_t hs_s1[RTMP_HANDSHAKE_PACKET_SIZE];
1345     uint32_t zeroes;
1346     uint32_t temp       = 0;
1347     int randomidx       = 0;
1348     int inoutsize       = 0;
1349     int ret;
1350
1351     inoutsize = ffurl_read_complete(rt->stream, buffer, 1);       // Receive C0
1352     if (inoutsize <= 0) {
1353         av_log(s, AV_LOG_ERROR, "Unable to read handshake\n");
1354         return AVERROR(EIO);
1355     }
1356     // Check Version
1357     if (buffer[0] != 3) {
1358         av_log(s, AV_LOG_ERROR, "RTMP protocol version mismatch\n");
1359         return AVERROR(EIO);
1360     }
1361     if (ffurl_write(rt->stream, buffer, 1) <= 0) {                 // Send S0
1362         av_log(s, AV_LOG_ERROR,
1363                "Unable to write answer - RTMP S0\n");
1364         return AVERROR(EIO);
1365     }
1366     /* Receive C1 */
1367     ret = rtmp_receive_hs_packet(rt, &hs_epoch, &zeroes, hs_c1,
1368                                  RTMP_HANDSHAKE_PACKET_SIZE);
1369     if (ret) {
1370         av_log(s, AV_LOG_ERROR, "RTMP Handshake C1 Error\n");
1371         return ret;
1372     }
1373     if (zeroes)
1374         av_log(s, AV_LOG_WARNING, "Erroneous C1 Message zero != 0\n");
1375     /* Send S1 */
1376     /* By now same epoch will be sent */
1377     hs_my_epoch = hs_epoch;
1378     /* Generate random */
1379     for (randomidx = 8; randomidx < (RTMP_HANDSHAKE_PACKET_SIZE);
1380          randomidx += 4)
1381         AV_WB32(hs_s1 + randomidx, av_get_random_seed());
1382
1383     ret = rtmp_send_hs_packet(rt, hs_my_epoch, 0, hs_s1,
1384                               RTMP_HANDSHAKE_PACKET_SIZE);
1385     if (ret) {
1386         av_log(s, AV_LOG_ERROR, "RTMP Handshake S1 Error\n");
1387         return ret;
1388     }
1389     /* Send S2 */
1390     ret = rtmp_send_hs_packet(rt, hs_epoch, 0, hs_c1,
1391                               RTMP_HANDSHAKE_PACKET_SIZE);
1392     if (ret) {
1393         av_log(s, AV_LOG_ERROR, "RTMP Handshake S2 Error\n");
1394         return ret;
1395     }
1396     /* Receive C2 */
1397     ret = rtmp_receive_hs_packet(rt, &temp, &zeroes, buffer,
1398                                  RTMP_HANDSHAKE_PACKET_SIZE);
1399     if (ret) {
1400         av_log(s, AV_LOG_ERROR, "RTMP Handshake C2 Error\n");
1401         return ret;
1402     }
1403     if (temp != hs_my_epoch)
1404         av_log(s, AV_LOG_WARNING,
1405                "Erroneous C2 Message epoch does not match up with C1 epoch\n");
1406     if (memcmp(buffer + 8, hs_s1 + 8,
1407                RTMP_HANDSHAKE_PACKET_SIZE - 8))
1408         av_log(s, AV_LOG_WARNING,
1409                "Erroneous C2 Message random does not match up\n");
1410
1411     return 0;
1412 }
1413
1414 static int handle_chunk_size(URLContext *s, RTMPPacket *pkt)
1415 {
1416     RTMPContext *rt = s->priv_data;
1417     int ret;
1418
1419     if (pkt->data_size < 4) {
1420         av_log(s, AV_LOG_ERROR,
1421                "Too short chunk size change packet (%d)\n",
1422                pkt->data_size);
1423         return AVERROR_INVALIDDATA;
1424     }
1425
1426     if (!rt->is_input) {
1427         /* Send the same chunk size change packet back to the server,
1428          * setting the outgoing chunk size to the same as the incoming one. */
1429         if ((ret = ff_rtmp_packet_write(rt->stream, pkt, rt->out_chunk_size,
1430                                         rt->prev_pkt[1])) < 0)
1431             return ret;
1432         rt->out_chunk_size = AV_RB32(pkt->data);
1433     }
1434
1435     rt->in_chunk_size = AV_RB32(pkt->data);
1436     if (rt->in_chunk_size <= 0) {
1437         av_log(s, AV_LOG_ERROR, "Incorrect chunk size %d\n",
1438                rt->in_chunk_size);
1439         return AVERROR_INVALIDDATA;
1440     }
1441     av_log(s, AV_LOG_DEBUG, "New incoming chunk size = %d\n",
1442            rt->in_chunk_size);
1443
1444     return 0;
1445 }
1446
1447 static int handle_ping(URLContext *s, RTMPPacket *pkt)
1448 {
1449     RTMPContext *rt = s->priv_data;
1450     int t, ret;
1451
1452     if (pkt->data_size < 2) {
1453         av_log(s, AV_LOG_ERROR, "Too short ping packet (%d)\n",
1454                pkt->data_size);
1455         return AVERROR_INVALIDDATA;
1456     }
1457
1458     t = AV_RB16(pkt->data);
1459     if (t == 6) {
1460         if ((ret = gen_pong(s, rt, pkt)) < 0)
1461             return ret;
1462     } else if (t == 26) {
1463         if (rt->swfsize) {
1464             if ((ret = gen_swf_verification(s, rt)) < 0)
1465                 return ret;
1466         } else {
1467             av_log(s, AV_LOG_WARNING, "Ignoring SWFVerification request.\n");
1468         }
1469     }
1470
1471     return 0;
1472 }
1473
1474 static int handle_client_bw(URLContext *s, RTMPPacket *pkt)
1475 {
1476     RTMPContext *rt = s->priv_data;
1477
1478     if (pkt->data_size < 4) {
1479         av_log(s, AV_LOG_ERROR,
1480                "Client bandwidth report packet is less than 4 bytes long (%d)\n",
1481                pkt->data_size);
1482         return AVERROR_INVALIDDATA;
1483     }
1484
1485     rt->client_report_size = AV_RB32(pkt->data);
1486     if (rt->client_report_size <= 0) {
1487         av_log(s, AV_LOG_ERROR, "Incorrect client bandwidth %d\n",
1488                 rt->client_report_size);
1489         return AVERROR_INVALIDDATA;
1490
1491     }
1492     av_log(s, AV_LOG_DEBUG, "Client bandwidth = %d\n", rt->client_report_size);
1493     rt->client_report_size >>= 1;
1494
1495     return 0;
1496 }
1497
1498 static int handle_server_bw(URLContext *s, RTMPPacket *pkt)
1499 {
1500     RTMPContext *rt = s->priv_data;
1501
1502     if (pkt->data_size < 4) {
1503         av_log(s, AV_LOG_ERROR,
1504                "Too short server bandwidth report packet (%d)\n",
1505                pkt->data_size);
1506         return AVERROR_INVALIDDATA;
1507     }
1508
1509     rt->server_bw = AV_RB32(pkt->data);
1510     if (rt->server_bw <= 0) {
1511         av_log(s, AV_LOG_ERROR, "Incorrect server bandwidth %d\n",
1512                rt->server_bw);
1513         return AVERROR_INVALIDDATA;
1514     }
1515     av_log(s, AV_LOG_DEBUG, "Server bandwidth = %d\n", rt->server_bw);
1516
1517     return 0;
1518 }
1519
1520 static int do_adobe_auth(RTMPContext *rt, const char *user, const char *salt,
1521                          const char *opaque, const char *challenge)
1522 {
1523     uint8_t hash[16];
1524     char hashstr[AV_BASE64_SIZE(sizeof(hash))], challenge2[10];
1525     struct AVMD5 *md5 = av_md5_alloc();
1526     if (!md5)
1527         return AVERROR(ENOMEM);
1528
1529     snprintf(challenge2, sizeof(challenge2), "%08x", av_get_random_seed());
1530
1531     av_md5_init(md5);
1532     av_md5_update(md5, user, strlen(user));
1533     av_md5_update(md5, salt, strlen(salt));
1534     av_md5_update(md5, rt->password, strlen(rt->password));
1535     av_md5_final(md5, hash);
1536     av_base64_encode(hashstr, sizeof(hashstr), hash,
1537                      sizeof(hash));
1538     av_md5_init(md5);
1539     av_md5_update(md5, hashstr, strlen(hashstr));
1540     if (opaque)
1541         av_md5_update(md5, opaque, strlen(opaque));
1542     else if (challenge)
1543         av_md5_update(md5, challenge, strlen(challenge));
1544     av_md5_update(md5, challenge2, strlen(challenge2));
1545     av_md5_final(md5, hash);
1546     av_base64_encode(hashstr, sizeof(hashstr), hash,
1547                      sizeof(hash));
1548     snprintf(rt->auth_params, sizeof(rt->auth_params),
1549              "?authmod=%s&user=%s&challenge=%s&response=%s",
1550              "adobe", user, challenge2, hashstr);
1551     if (opaque)
1552         av_strlcatf(rt->auth_params, sizeof(rt->auth_params),
1553                     "&opaque=%s", opaque);
1554
1555     av_free(md5);
1556     return 0;
1557 }
1558
1559 static int do_llnw_auth(RTMPContext *rt, const char *user, const char *nonce)
1560 {
1561     uint8_t hash[16];
1562     char hashstr1[33], hashstr2[33];
1563     const char *realm = "live";
1564     const char *method = "publish";
1565     const char *qop = "auth";
1566     const char *nc = "00000001";
1567     char cnonce[10];
1568     struct AVMD5 *md5 = av_md5_alloc();
1569     if (!md5)
1570         return AVERROR(ENOMEM);
1571
1572     snprintf(cnonce, sizeof(cnonce), "%08x", av_get_random_seed());
1573
1574     av_md5_init(md5);
1575     av_md5_update(md5, user, strlen(user));
1576     av_md5_update(md5, ":", 1);
1577     av_md5_update(md5, realm, strlen(realm));
1578     av_md5_update(md5, ":", 1);
1579     av_md5_update(md5, rt->password, strlen(rt->password));
1580     av_md5_final(md5, hash);
1581     ff_data_to_hex(hashstr1, hash, 16, 1);
1582     hashstr1[32] = '\0';
1583
1584     av_md5_init(md5);
1585     av_md5_update(md5, method, strlen(method));
1586     av_md5_update(md5, ":/", 2);
1587     av_md5_update(md5, rt->app, strlen(rt->app));
1588     av_md5_final(md5, hash);
1589     ff_data_to_hex(hashstr2, hash, 16, 1);
1590     hashstr2[32] = '\0';
1591
1592     av_md5_init(md5);
1593     av_md5_update(md5, hashstr1, strlen(hashstr1));
1594     av_md5_update(md5, ":", 1);
1595     if (nonce)
1596         av_md5_update(md5, nonce, strlen(nonce));
1597     av_md5_update(md5, ":", 1);
1598     av_md5_update(md5, nc, strlen(nc));
1599     av_md5_update(md5, ":", 1);
1600     av_md5_update(md5, cnonce, strlen(cnonce));
1601     av_md5_update(md5, ":", 1);
1602     av_md5_update(md5, qop, strlen(qop));
1603     av_md5_update(md5, ":", 1);
1604     av_md5_update(md5, hashstr2, strlen(hashstr2));
1605     av_md5_final(md5, hash);
1606     ff_data_to_hex(hashstr1, hash, 16, 1);
1607
1608     snprintf(rt->auth_params, sizeof(rt->auth_params),
1609              "?authmod=%s&user=%s&nonce=%s&cnonce=%s&nc=%s&response=%s",
1610              "llnw", user, nonce, cnonce, nc, hashstr1);
1611
1612     av_free(md5);
1613     return 0;
1614 }
1615
1616 static int handle_connect_error(URLContext *s, const char *desc)
1617 {
1618     RTMPContext *rt = s->priv_data;
1619     char buf[300], *ptr, authmod[15];
1620     int i = 0, ret = 0;
1621     const char *user = "", *salt = "", *opaque = NULL,
1622                *challenge = NULL, *cptr = NULL, *nonce = NULL;
1623
1624     if (!(cptr = strstr(desc, "authmod=adobe")) &&
1625         !(cptr = strstr(desc, "authmod=llnw"))) {
1626         av_log(s, AV_LOG_ERROR,
1627                "Unknown connect error (unsupported authentication method?)\n");
1628         return AVERROR_UNKNOWN;
1629     }
1630     cptr += strlen("authmod=");
1631     while (*cptr && *cptr != ' ' && i < sizeof(authmod) - 1)
1632         authmod[i++] = *cptr++;
1633     authmod[i] = '\0';
1634
1635     if (!rt->username[0] || !rt->password[0]) {
1636         av_log(s, AV_LOG_ERROR, "No credentials set\n");
1637         return AVERROR_UNKNOWN;
1638     }
1639
1640     if (strstr(desc, "?reason=authfailed")) {
1641         av_log(s, AV_LOG_ERROR, "Incorrect username/password\n");
1642         return AVERROR_UNKNOWN;
1643     } else if (strstr(desc, "?reason=nosuchuser")) {
1644         av_log(s, AV_LOG_ERROR, "Incorrect username\n");
1645         return AVERROR_UNKNOWN;
1646     }
1647
1648     if (rt->auth_tried) {
1649         av_log(s, AV_LOG_ERROR, "Authentication failed\n");
1650         return AVERROR_UNKNOWN;
1651     }
1652
1653     rt->auth_params[0] = '\0';
1654
1655     if (strstr(desc, "code=403 need auth")) {
1656         snprintf(rt->auth_params, sizeof(rt->auth_params),
1657                  "?authmod=%s&user=%s", authmod, rt->username);
1658         return 0;
1659     }
1660
1661     if (!(cptr = strstr(desc, "?reason=needauth"))) {
1662         av_log(s, AV_LOG_ERROR, "No auth parameters found\n");
1663         return AVERROR_UNKNOWN;
1664     }
1665
1666     av_strlcpy(buf, cptr + 1, sizeof(buf));
1667     ptr = buf;
1668
1669     while (ptr) {
1670         char *next  = strchr(ptr, '&');
1671         char *value = strchr(ptr, '=');
1672         if (next)
1673             *next++ = '\0';
1674         if (value)
1675             *value++ = '\0';
1676         if (!strcmp(ptr, "user")) {
1677             user = value;
1678         } else if (!strcmp(ptr, "salt")) {
1679             salt = value;
1680         } else if (!strcmp(ptr, "opaque")) {
1681             opaque = value;
1682         } else if (!strcmp(ptr, "challenge")) {
1683             challenge = value;
1684         } else if (!strcmp(ptr, "nonce")) {
1685             nonce = value;
1686         }
1687         ptr = next;
1688     }
1689
1690     if (!strcmp(authmod, "adobe")) {
1691         if ((ret = do_adobe_auth(rt, user, salt, opaque, challenge)) < 0)
1692             return ret;
1693     } else {
1694         if ((ret = do_llnw_auth(rt, user, nonce)) < 0)
1695             return ret;
1696     }
1697
1698     rt->auth_tried = 1;
1699     return 0;
1700 }
1701
1702 static int handle_invoke_error(URLContext *s, RTMPPacket *pkt)
1703 {
1704     RTMPContext *rt = s->priv_data;
1705     const uint8_t *data_end = pkt->data + pkt->data_size;
1706     char *tracked_method = NULL;
1707     int level = AV_LOG_ERROR;
1708     uint8_t tmpstr[256];
1709     int ret;
1710
1711     if ((ret = find_tracked_method(s, pkt, 9, &tracked_method)) < 0)
1712         return ret;
1713
1714     if (!ff_amf_get_field_value(pkt->data + 9, data_end,
1715                                 "description", tmpstr, sizeof(tmpstr))) {
1716         if (tracked_method && (!strcmp(tracked_method, "_checkbw")      ||
1717                                !strcmp(tracked_method, "releaseStream") ||
1718                                !strcmp(tracked_method, "FCSubscribe")   ||
1719                                !strcmp(tracked_method, "FCPublish"))) {
1720             /* Gracefully ignore Adobe-specific historical artifact errors. */
1721             level = AV_LOG_WARNING;
1722             ret = 0;
1723         } else if (tracked_method && !strcmp(tracked_method, "connect")) {
1724             ret = handle_connect_error(s, tmpstr);
1725             if (!ret) {
1726                 rt->do_reconnect = 1;
1727                 level = AV_LOG_VERBOSE;
1728             }
1729         } else
1730             ret = AVERROR_UNKNOWN;
1731         av_log(s, level, "Server error: %s\n", tmpstr);
1732     }
1733
1734     av_free(tracked_method);
1735     return ret;
1736 }
1737
1738 static int send_invoke_response(URLContext *s, RTMPPacket *pkt)
1739 {
1740     RTMPContext *rt = s->priv_data;
1741     double seqnum;
1742     char filename[64];
1743     char command[64];
1744     char statusmsg[128];
1745     int stringlen;
1746     char *pchar;
1747     const uint8_t *p = pkt->data;
1748     uint8_t *pp      = NULL;
1749     RTMPPacket spkt  = { 0 };
1750     GetByteContext gbc;
1751     int ret;
1752
1753     bytestream2_init(&gbc, p, pkt->data_size);
1754     if (ff_amf_read_string(&gbc, command, sizeof(command),
1755                            &stringlen)) {
1756         av_log(s, AV_LOG_ERROR, "Error in PT_INVOKE\n");
1757         return AVERROR_INVALIDDATA;
1758     }
1759
1760     ret = ff_amf_read_number(&gbc, &seqnum);
1761     if (ret)
1762         return ret;
1763     ret = ff_amf_read_null(&gbc);
1764     if (ret)
1765         return ret;
1766     if (!strcmp(command, "FCPublish") ||
1767         !strcmp(command, "publish")) {
1768         ret = ff_amf_read_string(&gbc, filename,
1769                                  sizeof(filename), &stringlen);
1770         // check with url
1771         if (s->filename) {
1772             pchar = strrchr(s->filename, '/');
1773             if (!pchar) {
1774                 av_log(s, AV_LOG_WARNING,
1775                        "Unable to find / in url %s, bad format\n",
1776                        s->filename);
1777                 pchar = s->filename;
1778             }
1779             pchar++;
1780             if (strcmp(pchar, filename))
1781                 av_log(s, AV_LOG_WARNING, "Unexpected stream %s, expecting"
1782                        " %s\n", filename, pchar);
1783         }
1784         rt->state = STATE_RECEIVING;
1785     }
1786
1787     if (!strcmp(command, "FCPublish")) {
1788         if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1789                                          RTMP_PT_INVOKE, 0,
1790                                          RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1791             av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1792             return ret;
1793         }
1794         pp = spkt.data;
1795         ff_amf_write_string(&pp, "onFCPublish");
1796     } else if (!strcmp(command, "publish")) {
1797         PutByteContext pbc;
1798         // Send Stream Begin 1
1799         if ((ret = ff_rtmp_packet_create(&spkt, RTMP_NETWORK_CHANNEL,
1800                                          RTMP_PT_PING, 0, 6)) < 0) {
1801             av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1802             return ret;
1803         }
1804         pp = spkt.data;
1805         bytestream2_init_writer(&pbc, pp, spkt.data_size);
1806         bytestream2_put_be16(&pbc, 0);          // 0 -> Stream Begin
1807         bytestream2_put_be32(&pbc, rt->nb_streamid);
1808         ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1809                                    rt->prev_pkt[1]);
1810         ff_rtmp_packet_destroy(&spkt);
1811         if (ret < 0)
1812             return ret;
1813
1814         // Send onStatus(NetStream.Publish.Start)
1815         if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1816                                          RTMP_PT_INVOKE, 0,
1817                                          RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1818             av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1819             return ret;
1820         }
1821         spkt.extra = pkt->extra;
1822         pp = spkt.data;
1823         ff_amf_write_string(&pp, "onStatus");
1824         ff_amf_write_number(&pp, 0);
1825         ff_amf_write_null(&pp);
1826
1827         ff_amf_write_object_start(&pp);
1828         ff_amf_write_field_name(&pp, "level");
1829         ff_amf_write_string(&pp, "status");
1830         ff_amf_write_field_name(&pp, "code");
1831         ff_amf_write_string(&pp, "NetStream.Publish.Start");
1832         ff_amf_write_field_name(&pp, "description");
1833         snprintf(statusmsg, sizeof(statusmsg),
1834                  "%s is now published", filename);
1835         ff_amf_write_string(&pp, statusmsg);
1836         ff_amf_write_field_name(&pp, "details");
1837         ff_amf_write_string(&pp, filename);
1838         ff_amf_write_field_name(&pp, "clientid");
1839         snprintf(statusmsg, sizeof(statusmsg), "%s", LIBAVFORMAT_IDENT);
1840         ff_amf_write_string(&pp, statusmsg);
1841         ff_amf_write_object_end(&pp);
1842
1843     } else {
1844         if ((ret = ff_rtmp_packet_create(&spkt, RTMP_SYSTEM_CHANNEL,
1845                                          RTMP_PT_INVOKE, 0,
1846                                          RTMP_PKTDATA_DEFAULT_SIZE)) < 0) {
1847             av_log(s, AV_LOG_ERROR, "Unable to create response packet\n");
1848             return ret;
1849         }
1850         pp = spkt.data;
1851         ff_amf_write_string(&pp, "_result");
1852         ff_amf_write_number(&pp, seqnum);
1853         ff_amf_write_null(&pp);
1854         if (!strcmp(command, "createStream")) {
1855             rt->nb_streamid++;
1856             if (rt->nb_streamid == 0 || rt->nb_streamid == 2)
1857                 rt->nb_streamid++; /* Values 0 and 2 are reserved */
1858             ff_amf_write_number(&pp, rt->nb_streamid);
1859             /* By now we don't control which streams are removed in
1860              * deleteStream. There is no stream creation control
1861              * if a client creates more than 2^32 - 2 streams. */
1862         }
1863     }
1864     spkt.data_size = pp - spkt.data;
1865     ret = ff_rtmp_packet_write(rt->stream, &spkt, rt->out_chunk_size,
1866                                rt->prev_pkt[1]);
1867     ff_rtmp_packet_destroy(&spkt);
1868     return ret;
1869 }
1870
1871 static int handle_invoke_result(URLContext *s, RTMPPacket *pkt)
1872 {
1873     RTMPContext *rt = s->priv_data;
1874     char *tracked_method = NULL;
1875     int ret = 0;
1876
1877     if ((ret = find_tracked_method(s, pkt, 10, &tracked_method)) < 0)
1878         return ret;
1879
1880     if (!tracked_method) {
1881         /* Ignore this reply when the current method is not tracked. */
1882         return ret;
1883     }
1884
1885     if (!memcmp(tracked_method, "connect", 7)) {
1886         if (!rt->is_input) {
1887             if ((ret = gen_release_stream(s, rt)) < 0)
1888                 goto fail;
1889
1890             if ((ret = gen_fcpublish_stream(s, rt)) < 0)
1891                 goto fail;
1892         } else {
1893             if ((ret = gen_server_bw(s, rt)) < 0)
1894                 goto fail;
1895         }
1896
1897         if ((ret = gen_create_stream(s, rt)) < 0)
1898             goto fail;
1899
1900         if (rt->is_input) {
1901             /* Send the FCSubscribe command when the name of live
1902              * stream is defined by the user or if it's a live stream. */
1903             if (rt->subscribe) {
1904                 if ((ret = gen_fcsubscribe_stream(s, rt, rt->subscribe)) < 0)
1905                     goto fail;
1906             } else if (rt->live == -1) {
1907                 if ((ret = gen_fcsubscribe_stream(s, rt, rt->playpath)) < 0)
1908                     goto fail;
1909             }
1910         }
1911     } else if (!memcmp(tracked_method, "createStream", 12)) {
1912         //extract a number from the result
1913         if (pkt->data[10] || pkt->data[19] != 5 || pkt->data[20]) {
1914             av_log(s, AV_LOG_WARNING, "Unexpected reply on connect()\n");
1915         } else {
1916             rt->main_channel_id = av_int2double(AV_RB64(pkt->data + 21));
1917         }
1918
1919         if (!rt->is_input) {
1920             if ((ret = gen_publish(s, rt)) < 0)
1921                 goto fail;
1922         } else {
1923             if ((ret = gen_play(s, rt)) < 0)
1924                 goto fail;
1925             if ((ret = gen_buffer_time(s, rt)) < 0)
1926                 goto fail;
1927         }
1928     }
1929
1930 fail:
1931     av_free(tracked_method);
1932     return ret;
1933 }
1934
1935 static int handle_invoke_status(URLContext *s, RTMPPacket *pkt)
1936 {
1937     RTMPContext *rt = s->priv_data;
1938     const uint8_t *data_end = pkt->data + pkt->data_size;
1939     const uint8_t *ptr = pkt->data + 11;
1940     uint8_t tmpstr[256];
1941     int i, t;
1942
1943     for (i = 0; i < 2; i++) {
1944         t = ff_amf_tag_size(ptr, data_end);
1945         if (t < 0)
1946             return 1;
1947         ptr += t;
1948     }
1949
1950     t = ff_amf_get_field_value(ptr, data_end, "level", tmpstr, sizeof(tmpstr));
1951     if (!t && !strcmp(tmpstr, "error")) {
1952         if (!ff_amf_get_field_value(ptr, data_end,
1953                                     "description", tmpstr, sizeof(tmpstr)))
1954             av_log(s, AV_LOG_ERROR, "Server error: %s\n", tmpstr);
1955         return -1;
1956     }
1957
1958     t = ff_amf_get_field_value(ptr, data_end, "code", tmpstr, sizeof(tmpstr));
1959     if (!t && !strcmp(tmpstr, "NetStream.Play.Start")) rt->state = STATE_PLAYING;
1960     if (!t && !strcmp(tmpstr, "NetStream.Play.Stop")) rt->state = STATE_STOPPED;
1961     if (!t && !strcmp(tmpstr, "NetStream.Play.UnpublishNotify")) rt->state = STATE_STOPPED;
1962     if (!t && !strcmp(tmpstr, "NetStream.Publish.Start")) rt->state = STATE_PUBLISHING;
1963
1964     return 0;
1965 }
1966
1967 static int handle_invoke(URLContext *s, RTMPPacket *pkt)
1968 {
1969     RTMPContext *rt = s->priv_data;
1970     int ret = 0;
1971
1972     //TODO: check for the messages sent for wrong state?
1973     if (!memcmp(pkt->data, "\002\000\006_error", 9)) {
1974         if ((ret = handle_invoke_error(s, pkt)) < 0)
1975             return ret;
1976     } else if (!memcmp(pkt->data, "\002\000\007_result", 10)) {
1977         if ((ret = handle_invoke_result(s, pkt)) < 0)
1978             return ret;
1979     } else if (!memcmp(pkt->data, "\002\000\010onStatus", 11)) {
1980         if ((ret = handle_invoke_status(s, pkt)) < 0)
1981             return ret;
1982     } else if (!memcmp(pkt->data, "\002\000\010onBWDone", 11)) {
1983         if ((ret = gen_check_bw(s, rt)) < 0)
1984             return ret;
1985     } else if (!memcmp(pkt->data, "\002\000\015releaseStream", 16) ||
1986                !memcmp(pkt->data, "\002\000\011FCPublish", 12)     ||
1987                !memcmp(pkt->data, "\002\000\007publish", 10)       ||
1988                !memcmp(pkt->data, "\002\000\010_checkbw", 11)      ||
1989                !memcmp(pkt->data, "\002\000\014createStream", 15)) {
1990         if ((ret = send_invoke_response(s, pkt)) < 0)
1991             return ret;
1992     }
1993
1994     return ret;
1995 }
1996
1997 static int handle_notify(URLContext *s, RTMPPacket *pkt) {
1998     RTMPContext *rt  = s->priv_data;
1999     const uint8_t *p = NULL;
2000     uint8_t *cp      = NULL;
2001     uint8_t commandbuffer[64];
2002     char statusmsg[128];
2003     int stringlen;
2004     GetByteContext gbc;
2005     PutByteContext pbc;
2006     uint32_t ts;
2007     int old_flv_size;
2008     const uint8_t *datatowrite;
2009     unsigned datatowritelength;
2010
2011     p = pkt->data;
2012     bytestream2_init(&gbc, p, pkt->data_size);
2013     if (ff_amf_read_string(&gbc, commandbuffer, sizeof(commandbuffer),
2014                            &stringlen))
2015         return AVERROR_INVALIDDATA;
2016     if (!strcmp(commandbuffer, "@setDataFrame")) {
2017         datatowrite       = gbc.buffer;
2018         datatowritelength = bytestream2_get_bytes_left(&gbc);
2019         if (ff_amf_read_string(&gbc, statusmsg,
2020                                sizeof(statusmsg), &stringlen))
2021             return AVERROR_INVALIDDATA;
2022         if (strcmp(statusmsg, "onMetaData")) {
2023             av_log(s, AV_LOG_INFO, "Expecting onMetadata but got %s\n",
2024                    statusmsg);
2025             return 0;
2026         }
2027
2028         /* Provide ECMAArray to flv */
2029         ts = pkt->timestamp;
2030
2031         // generate packet header and put data into buffer for FLV demuxer
2032         if (rt->flv_off < rt->flv_size) {
2033             old_flv_size  = rt->flv_size;
2034             rt->flv_size += datatowritelength + 15;
2035         } else {
2036             old_flv_size = 0;
2037             rt->flv_size = datatowritelength + 15;
2038             rt->flv_off  = 0;
2039         }
2040
2041         cp = av_realloc(rt->flv_data, rt->flv_size);
2042         if (!cp)
2043             return AVERROR(ENOMEM);
2044         rt->flv_data = cp;
2045         bytestream2_init_writer(&pbc, cp, rt->flv_size);
2046         bytestream2_skip_p(&pbc, old_flv_size);
2047         bytestream2_put_byte(&pbc, pkt->type);
2048         bytestream2_put_be24(&pbc, datatowritelength);
2049         bytestream2_put_be24(&pbc, ts);
2050         bytestream2_put_byte(&pbc, ts >> 24);
2051         bytestream2_put_be24(&pbc, 0);
2052         bytestream2_put_buffer(&pbc, datatowrite, datatowritelength);
2053         bytestream2_put_be32(&pbc, 0);
2054     }
2055     return 0;
2056 }
2057
2058 /**
2059  * Parse received packet and possibly perform some action depending on
2060  * the packet contents.
2061  * @return 0 for no errors, negative values for serious errors which prevent
2062  *         further communications, positive values for uncritical errors
2063  */
2064 static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
2065 {
2066     int ret;
2067
2068 #ifdef DEBUG
2069     ff_rtmp_packet_dump(s, pkt);
2070 #endif
2071
2072     switch (pkt->type) {
2073     case RTMP_PT_BYTES_READ:
2074         av_dlog(s, "received bytes read report\n");
2075         break;
2076     case RTMP_PT_CHUNK_SIZE:
2077         if ((ret = handle_chunk_size(s, pkt)) < 0)
2078             return ret;
2079         break;
2080     case RTMP_PT_PING:
2081         if ((ret = handle_ping(s, pkt)) < 0)
2082             return ret;
2083         break;
2084     case RTMP_PT_CLIENT_BW:
2085         if ((ret = handle_client_bw(s, pkt)) < 0)
2086             return ret;
2087         break;
2088     case RTMP_PT_SERVER_BW:
2089         if ((ret = handle_server_bw(s, pkt)) < 0)
2090             return ret;
2091         break;
2092     case RTMP_PT_INVOKE:
2093         if ((ret = handle_invoke(s, pkt)) < 0)
2094             return ret;
2095         break;
2096     case RTMP_PT_VIDEO:
2097     case RTMP_PT_AUDIO:
2098     case RTMP_PT_METADATA:
2099     case RTMP_PT_NOTIFY:
2100         /* Audio, Video and Metadata packets are parsed in get_packet() */
2101         break;
2102     default:
2103         av_log(s, AV_LOG_VERBOSE, "Unknown packet type received 0x%02X\n", pkt->type);
2104         break;
2105     }
2106     return 0;
2107 }
2108
2109 /**
2110  * Interact with the server by receiving and sending RTMP packets until
2111  * there is some significant data (media data or expected status notification).
2112  *
2113  * @param s          reading context
2114  * @param for_header non-zero value tells function to work until it
2115  * gets notification from the server that playing has been started,
2116  * otherwise function will work until some media data is received (or
2117  * an error happens)
2118  * @return 0 for successful operation, negative value in case of error
2119  */
2120 static int get_packet(URLContext *s, int for_header)
2121 {
2122     RTMPContext *rt = s->priv_data;
2123     int ret;
2124     uint8_t *p;
2125     const uint8_t *next;
2126     uint32_t data_size;
2127     uint32_t ts, cts, pts=0;
2128
2129     if (rt->state == STATE_STOPPED)
2130         return AVERROR_EOF;
2131
2132     for (;;) {
2133         RTMPPacket rpkt = { 0 };
2134         if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
2135                                        rt->in_chunk_size, rt->prev_pkt[0])) <= 0) {
2136             if (ret == 0) {
2137                 return AVERROR(EAGAIN);
2138             } else {
2139                 return AVERROR(EIO);
2140             }
2141         }
2142         rt->bytes_read += ret;
2143         if (rt->bytes_read - rt->last_bytes_read > rt->client_report_size) {
2144             av_log(s, AV_LOG_DEBUG, "Sending bytes read report\n");
2145             if ((ret = gen_bytes_read(s, rt, rpkt.timestamp + 1)) < 0)
2146                 return ret;
2147             rt->last_bytes_read = rt->bytes_read;
2148         }
2149
2150         ret = rtmp_parse_result(s, rt, &rpkt);
2151         if (ret < 0) {//serious error in current packet
2152             ff_rtmp_packet_destroy(&rpkt);
2153             return ret;
2154         }
2155         if (rt->do_reconnect && for_header) {
2156             ff_rtmp_packet_destroy(&rpkt);
2157             return 0;
2158         }
2159         if (rt->state == STATE_STOPPED) {
2160             ff_rtmp_packet_destroy(&rpkt);
2161             return AVERROR_EOF;
2162         }
2163         if (for_header && (rt->state == STATE_PLAYING    ||
2164                            rt->state == STATE_PUBLISHING ||
2165                            rt->state == STATE_RECEIVING)) {
2166             ff_rtmp_packet_destroy(&rpkt);
2167             return 0;
2168         }
2169         if (!rpkt.data_size || !rt->is_input) {
2170             ff_rtmp_packet_destroy(&rpkt);
2171             continue;
2172         }
2173         if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||
2174            (rpkt.type == RTMP_PT_NOTIFY && !memcmp("\002\000\012onMetaData", rpkt.data, 13))) {
2175             ts = rpkt.timestamp;
2176
2177             // generate packet header and put data into buffer for FLV demuxer
2178             rt->flv_off  = 0;
2179             rt->flv_size = rpkt.data_size + 15;
2180             rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);
2181             bytestream_put_byte(&p, rpkt.type);
2182             bytestream_put_be24(&p, rpkt.data_size);
2183             bytestream_put_be24(&p, ts);
2184             bytestream_put_byte(&p, ts >> 24);
2185             bytestream_put_be24(&p, 0);
2186             bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);
2187             bytestream_put_be32(&p, 0);
2188             ff_rtmp_packet_destroy(&rpkt);
2189             return 0;
2190         } else if (rpkt.type == RTMP_PT_NOTIFY) {
2191             ret = handle_notify(s, &rpkt);
2192             ff_rtmp_packet_destroy(&rpkt);
2193             if (ret) {
2194                 av_log(s, AV_LOG_ERROR, "Handle notify error\n");
2195                 return ret;
2196             }
2197             return 0;
2198         } else if (rpkt.type == RTMP_PT_METADATA) {
2199             // we got raw FLV data, make it available for FLV demuxer
2200             rt->flv_off  = 0;
2201             rt->flv_size = rpkt.data_size;
2202             rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
2203             /* rewrite timestamps */
2204             next = rpkt.data;
2205             ts = rpkt.timestamp;
2206             while (next - rpkt.data < rpkt.data_size - 11) {
2207                 next++;
2208                 data_size = bytestream_get_be24(&next);
2209                 p=next;
2210                 cts = bytestream_get_be24(&next);
2211                 cts |= bytestream_get_byte(&next) << 24;
2212                 if (pts==0)
2213                     pts=cts;
2214                 ts += cts - pts;
2215                 pts = cts;
2216                 bytestream_put_be24(&p, ts);
2217                 bytestream_put_byte(&p, ts >> 24);
2218                 next += data_size + 3 + 4;
2219             }
2220             memcpy(rt->flv_data, rpkt.data, rpkt.data_size);
2221             ff_rtmp_packet_destroy(&rpkt);
2222             return 0;
2223         }
2224         ff_rtmp_packet_destroy(&rpkt);
2225     }
2226 }
2227
2228 static int rtmp_close(URLContext *h)
2229 {
2230     RTMPContext *rt = h->priv_data;
2231     int ret = 0;
2232
2233     if (!rt->is_input) {
2234         rt->flv_data = NULL;
2235         if (rt->out_pkt.data_size)
2236             ff_rtmp_packet_destroy(&rt->out_pkt);
2237         if (rt->state > STATE_FCPUBLISH)
2238             ret = gen_fcunpublish_stream(h, rt);
2239     }
2240     if (rt->state > STATE_HANDSHAKED)
2241         ret = gen_delete_stream(h, rt);
2242
2243     free_tracked_methods(rt);
2244     av_freep(&rt->flv_data);
2245     ffurl_close(rt->stream);
2246     return ret;
2247 }
2248
2249 /**
2250  * Open RTMP connection and verify that the stream can be played.
2251  *
2252  * URL syntax: rtmp://server[:port][/app][/playpath]
2253  *             where 'app' is first one or two directories in the path
2254  *             (e.g. /ondemand/, /flash/live/, etc.)
2255  *             and 'playpath' is a file name (the rest of the path,
2256  *             may be prefixed with "mp4:")
2257  */
2258 static int rtmp_open(URLContext *s, const char *uri, int flags)
2259 {
2260     RTMPContext *rt = s->priv_data;
2261     char proto[8], hostname[256], path[1024], auth[100], *fname;
2262     char *old_app;
2263     uint8_t buf[2048];
2264     int port;
2265     AVDictionary *opts = NULL;
2266     int ret;
2267
2268     if (rt->listen_timeout > 0)
2269         rt->listen = 1;
2270
2271     rt->is_input = !(flags & AVIO_FLAG_WRITE);
2272
2273     av_url_split(proto, sizeof(proto), auth, sizeof(auth),
2274                  hostname, sizeof(hostname), &port,
2275                  path, sizeof(path), s->filename);
2276
2277     if (auth[0]) {
2278         char *ptr = strchr(auth, ':');
2279         if (ptr) {
2280             *ptr = '\0';
2281             av_strlcpy(rt->username, auth, sizeof(rt->username));
2282             av_strlcpy(rt->password, ptr + 1, sizeof(rt->password));
2283         }
2284     }
2285
2286     if (rt->listen && strcmp(proto, "rtmp")) {
2287         av_log(s, AV_LOG_ERROR, "rtmp_listen not available for %s\n",
2288                proto);
2289         return AVERROR(EINVAL);
2290     }
2291     if (!strcmp(proto, "rtmpt") || !strcmp(proto, "rtmpts")) {
2292         if (!strcmp(proto, "rtmpts"))
2293             av_dict_set(&opts, "ffrtmphttp_tls", "1", 1);
2294
2295         /* open the http tunneling connection */
2296         ff_url_join(buf, sizeof(buf), "ffrtmphttp", NULL, hostname, port, NULL);
2297     } else if (!strcmp(proto, "rtmps")) {
2298         /* open the tls connection */
2299         if (port < 0)
2300             port = RTMPS_DEFAULT_PORT;
2301         ff_url_join(buf, sizeof(buf), "tls", NULL, hostname, port, NULL);
2302     } else if (!strcmp(proto, "rtmpe") || (!strcmp(proto, "rtmpte"))) {
2303         if (!strcmp(proto, "rtmpte"))
2304             av_dict_set(&opts, "ffrtmpcrypt_tunneling", "1", 1);
2305
2306         /* open the encrypted connection */
2307         ff_url_join(buf, sizeof(buf), "ffrtmpcrypt", NULL, hostname, port, NULL);
2308         rt->encrypted = 1;
2309     } else {
2310         /* open the tcp connection */
2311         if (port < 0)
2312             port = RTMP_DEFAULT_PORT;
2313         if (rt->listen)
2314             ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port,
2315                         "?listen&listen_timeout=%d",
2316                         rt->listen_timeout * 1000);
2317         else
2318             ff_url_join(buf, sizeof(buf), "tcp", NULL, hostname, port, NULL);
2319     }
2320
2321 reconnect:
2322     if ((ret = ffurl_open(&rt->stream, buf, AVIO_FLAG_READ_WRITE,
2323                           &s->interrupt_callback, &opts)) < 0) {
2324         av_log(s , AV_LOG_ERROR, "Cannot open connection %s\n", buf);
2325         goto fail;
2326     }
2327
2328     if (rt->swfverify) {
2329         if ((ret = rtmp_calc_swfhash(s)) < 0)
2330             goto fail;
2331     }
2332
2333     rt->state = STATE_START;
2334     if (!rt->listen && (ret = rtmp_handshake(s, rt)) < 0)
2335         goto fail;
2336     if (rt->listen && (ret = rtmp_server_handshake(s, rt)) < 0)
2337         goto fail;
2338
2339     rt->out_chunk_size = 128;
2340     rt->in_chunk_size  = 128; // Probably overwritten later
2341     rt->state = STATE_HANDSHAKED;
2342
2343     // Keep the application name when it has been defined by the user.
2344     old_app = rt->app;
2345
2346     rt->app = av_malloc(APP_MAX_LENGTH);
2347     if (!rt->app) {
2348         ret = AVERROR(ENOMEM);
2349         goto fail;
2350     }
2351
2352     //extract "app" part from path
2353     if (!strncmp(path, "/ondemand/", 10)) {
2354         fname = path + 10;
2355         memcpy(rt->app, "ondemand", 9);
2356     } else {
2357         char *next = *path ? path + 1 : path;
2358         char *p = strchr(next, '/');
2359         if (!p) {
2360             fname = next;
2361             rt->app[0] = '\0';
2362         } else {
2363             // make sure we do not mismatch a playpath for an application instance
2364             char *c = strchr(p + 1, ':');
2365             fname = strchr(p + 1, '/');
2366             if (!fname || (c && c < fname)) {
2367                 fname = p + 1;
2368                 av_strlcpy(rt->app, path + 1, FFMIN(p - path, APP_MAX_LENGTH));
2369             } else {
2370                 fname++;
2371                 av_strlcpy(rt->app, path + 1, FFMIN(fname - path - 1, APP_MAX_LENGTH));
2372             }
2373         }
2374     }
2375
2376     if (old_app) {
2377         // The name of application has been defined by the user, override it.
2378         if (strlen(old_app) >= APP_MAX_LENGTH) {
2379             ret = AVERROR(EINVAL);
2380             goto fail;
2381         }
2382         av_free(rt->app);
2383         rt->app = old_app;
2384     }
2385
2386     if (!rt->playpath) {
2387         int len = strlen(fname);
2388
2389         rt->playpath = av_malloc(PLAYPATH_MAX_LENGTH);
2390         if (!rt->playpath) {
2391             ret = AVERROR(ENOMEM);
2392             goto fail;
2393         }
2394
2395         if (!strchr(fname, ':') && len >= 4 &&
2396             (!strcmp(fname + len - 4, ".f4v") ||
2397              !strcmp(fname + len - 4, ".mp4"))) {
2398             memcpy(rt->playpath, "mp4:", 5);
2399         } else if (len >= 4 && !strcmp(fname + len - 4, ".flv")) {
2400             fname[len - 4] = '\0';
2401         } else {
2402             rt->playpath[0] = 0;
2403         }
2404         av_strlcat(rt->playpath, fname, PLAYPATH_MAX_LENGTH);
2405     }
2406
2407     if (!rt->tcurl) {
2408         rt->tcurl = av_malloc(TCURL_MAX_LENGTH);
2409         if (!rt->tcurl) {
2410             ret = AVERROR(ENOMEM);
2411             goto fail;
2412         }
2413         ff_url_join(rt->tcurl, TCURL_MAX_LENGTH, proto, NULL, hostname,
2414                     port, "/%s", rt->app);
2415     }
2416
2417     if (!rt->flashver) {
2418         rt->flashver = av_malloc(FLASHVER_MAX_LENGTH);
2419         if (!rt->flashver) {
2420             ret = AVERROR(ENOMEM);
2421             goto fail;
2422         }
2423         if (rt->is_input) {
2424             snprintf(rt->flashver, FLASHVER_MAX_LENGTH, "%s %d,%d,%d,%d",
2425                     RTMP_CLIENT_PLATFORM, RTMP_CLIENT_VER1, RTMP_CLIENT_VER2,
2426                     RTMP_CLIENT_VER3, RTMP_CLIENT_VER4);
2427         } else {
2428             snprintf(rt->flashver, FLASHVER_MAX_LENGTH,
2429                     "FMLE/3.0 (compatible; %s)", LIBAVFORMAT_IDENT);
2430         }
2431     }
2432
2433     rt->client_report_size = 1048576;
2434     rt->bytes_read = 0;
2435     rt->last_bytes_read = 0;
2436     rt->server_bw = 2500000;
2437
2438     av_log(s, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
2439            proto, path, rt->app, rt->playpath);
2440     if (!rt->listen) {
2441         if ((ret = gen_connect(s, rt)) < 0)
2442             goto fail;
2443     } else {
2444         if (read_connect(s, s->priv_data) < 0)
2445             goto fail;
2446         rt->is_input = 1;
2447     }
2448
2449     do {
2450         ret = get_packet(s, 1);
2451     } while (ret == EAGAIN);
2452     if (ret < 0)
2453         goto fail;
2454
2455     if (rt->do_reconnect) {
2456         ffurl_close(rt->stream);
2457         rt->stream       = NULL;
2458         rt->do_reconnect = 0;
2459         rt->nb_invokes   = 0;
2460         memset(rt->prev_pkt, 0, sizeof(rt->prev_pkt));
2461         free_tracked_methods(rt);
2462         goto reconnect;
2463     }
2464
2465     if (rt->is_input) {
2466         // generate FLV header for demuxer
2467         rt->flv_size = 13;
2468         rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
2469         rt->flv_off  = 0;
2470         memcpy(rt->flv_data, "FLV\1\5\0\0\0\011\0\0\0\0", rt->flv_size);
2471     } else {
2472         rt->flv_size = 0;
2473         rt->flv_data = NULL;
2474         rt->flv_off  = 0;
2475         rt->skip_bytes = 13;
2476     }
2477
2478     s->max_packet_size = rt->stream->max_packet_size;
2479     s->is_streamed     = 1;
2480     return 0;
2481
2482 fail:
2483     av_dict_free(&opts);
2484     rtmp_close(s);
2485     return ret;
2486 }
2487
2488 static int rtmp_read(URLContext *s, uint8_t *buf, int size)
2489 {
2490     RTMPContext *rt = s->priv_data;
2491     int orig_size = size;
2492     int ret;
2493
2494     while (size > 0) {
2495         int data_left = rt->flv_size - rt->flv_off;
2496
2497         if (data_left >= size) {
2498             memcpy(buf, rt->flv_data + rt->flv_off, size);
2499             rt->flv_off += size;
2500             return orig_size;
2501         }
2502         if (data_left > 0) {
2503             memcpy(buf, rt->flv_data + rt->flv_off, data_left);
2504             buf  += data_left;
2505             size -= data_left;
2506             rt->flv_off = rt->flv_size;
2507             return data_left;
2508         }
2509         if ((ret = get_packet(s, 0)) < 0)
2510            return ret;
2511     }
2512     return orig_size;
2513 }
2514
2515 static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
2516 {
2517     RTMPContext *rt = s->priv_data;
2518     int size_temp = size;
2519     int pktsize, pkttype;
2520     uint32_t ts;
2521     const uint8_t *buf_temp = buf;
2522     uint8_t c;
2523     int ret;
2524
2525     do {
2526         if (rt->skip_bytes) {
2527             int skip = FFMIN(rt->skip_bytes, size_temp);
2528             buf_temp       += skip;
2529             size_temp      -= skip;
2530             rt->skip_bytes -= skip;
2531             continue;
2532         }
2533
2534         if (rt->flv_header_bytes < 11) {
2535             const uint8_t *header = rt->flv_header;
2536             int copy = FFMIN(11 - rt->flv_header_bytes, size_temp);
2537             bytestream_get_buffer(&buf_temp, rt->flv_header + rt->flv_header_bytes, copy);
2538             rt->flv_header_bytes += copy;
2539             size_temp            -= copy;
2540             if (rt->flv_header_bytes < 11)
2541                 break;
2542
2543             pkttype = bytestream_get_byte(&header);
2544             pktsize = bytestream_get_be24(&header);
2545             ts = bytestream_get_be24(&header);
2546             ts |= bytestream_get_byte(&header) << 24;
2547             bytestream_get_be24(&header);
2548             rt->flv_size = pktsize;
2549
2550             //force 12bytes header
2551             if (((pkttype == RTMP_PT_VIDEO || pkttype == RTMP_PT_AUDIO) && ts == 0) ||
2552                 pkttype == RTMP_PT_NOTIFY) {
2553                 if (pkttype == RTMP_PT_NOTIFY)
2554                     pktsize += 16;
2555                 rt->prev_pkt[1][RTMP_SOURCE_CHANNEL].channel_id = 0;
2556             }
2557
2558             //this can be a big packet, it's better to send it right here
2559             if ((ret = ff_rtmp_packet_create(&rt->out_pkt, RTMP_SOURCE_CHANNEL,
2560                                              pkttype, ts, pktsize)) < 0)
2561                 return ret;
2562
2563             rt->out_pkt.extra = rt->main_channel_id;
2564             rt->flv_data = rt->out_pkt.data;
2565
2566             if (pkttype == RTMP_PT_NOTIFY)
2567                 ff_amf_write_string(&rt->flv_data, "@setDataFrame");
2568         }
2569
2570         if (rt->flv_size - rt->flv_off > size_temp) {
2571             bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, size_temp);
2572             rt->flv_off += size_temp;
2573             size_temp = 0;
2574         } else {
2575             bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);
2576             size_temp   -= rt->flv_size - rt->flv_off;
2577             rt->flv_off += rt->flv_size - rt->flv_off;
2578         }
2579
2580         if (rt->flv_off == rt->flv_size) {
2581             rt->skip_bytes = 4;
2582
2583             if ((ret = rtmp_send_packet(rt, &rt->out_pkt, 0)) < 0)
2584                 return ret;
2585             rt->flv_size = 0;
2586             rt->flv_off = 0;
2587             rt->flv_header_bytes = 0;
2588             rt->flv_nb_packets++;
2589         }
2590     } while (buf_temp - buf < size);
2591
2592     if (rt->flv_nb_packets < rt->flush_interval)
2593         return size;
2594     rt->flv_nb_packets = 0;
2595
2596     /* set stream into nonblocking mode */
2597     rt->stream->flags |= AVIO_FLAG_NONBLOCK;
2598
2599     /* try to read one byte from the stream */
2600     ret = ffurl_read(rt->stream, &c, 1);
2601
2602     /* switch the stream back into blocking mode */
2603     rt->stream->flags &= ~AVIO_FLAG_NONBLOCK;
2604
2605     if (ret == AVERROR(EAGAIN)) {
2606         /* no incoming data to handle */
2607         return size;
2608     } else if (ret < 0) {
2609         return ret;
2610     } else if (ret == 1) {
2611         RTMPPacket rpkt = { 0 };
2612
2613         if ((ret = ff_rtmp_packet_read_internal(rt->stream, &rpkt,
2614                                                 rt->in_chunk_size,
2615                                                 rt->prev_pkt[0], c)) <= 0)
2616              return ret;
2617
2618         if ((ret = rtmp_parse_result(s, rt, &rpkt)) < 0)
2619             return ret;
2620
2621         ff_rtmp_packet_destroy(&rpkt);
2622     }
2623
2624     return size;
2625 }
2626
2627 #define OFFSET(x) offsetof(RTMPContext, x)
2628 #define DEC AV_OPT_FLAG_DECODING_PARAM
2629 #define ENC AV_OPT_FLAG_ENCODING_PARAM
2630
2631 static const AVOption rtmp_options[] = {
2632     {"rtmp_app", "Name of application to connect to on the RTMP server", OFFSET(app), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2633     {"rtmp_buffer", "Set buffer time in milliseconds. The default is 3000.", OFFSET(client_buffer_time), AV_OPT_TYPE_INT, {.i64 = 3000}, 0, INT_MAX, DEC|ENC},
2634     {"rtmp_conn", "Append arbitrary AMF data to the Connect message", OFFSET(conn), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2635     {"rtmp_flashver", "Version of the Flash plugin used to run the SWF player.", OFFSET(flashver), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2636     {"rtmp_flush_interval", "Number of packets flushed in the same request (RTMPT only).", OFFSET(flush_interval), AV_OPT_TYPE_INT, {.i64 = 10}, 0, INT_MAX, ENC},
2637     {"rtmp_live", "Specify that the media is a live stream.", OFFSET(live), AV_OPT_TYPE_INT, {.i64 = -2}, INT_MIN, INT_MAX, DEC, "rtmp_live"},
2638     {"any", "both", 0, AV_OPT_TYPE_CONST, {.i64 = -2}, 0, 0, DEC, "rtmp_live"},
2639     {"live", "live stream", 0, AV_OPT_TYPE_CONST, {.i64 = -1}, 0, 0, DEC, "rtmp_live"},
2640     {"recorded", "recorded stream", 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, DEC, "rtmp_live"},
2641     {"rtmp_pageurl", "URL of the web page in which the media was embedded. By default no value will be sent.", OFFSET(pageurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
2642     {"rtmp_playpath", "Stream identifier to play or to publish", OFFSET(playpath), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2643     {"rtmp_subscribe", "Name of live stream to subscribe to. Defaults to rtmp_playpath.", OFFSET(subscribe), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
2644     {"rtmp_swfhash", "SHA256 hash of the decompressed SWF file (32 bytes).", OFFSET(swfhash), AV_OPT_TYPE_BINARY, .flags = DEC},
2645     {"rtmp_swfsize", "Size of the decompressed SWF file, required for SWFVerification.", OFFSET(swfsize), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, DEC},
2646     {"rtmp_swfurl", "URL of the SWF player. By default no value will be sent", OFFSET(swfurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2647     {"rtmp_swfverify", "URL to player swf file, compute hash/size automatically.", OFFSET(swfverify), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC},
2648     {"rtmp_tcurl", "URL of the target stream. Defaults to proto://host[:port]/app.", OFFSET(tcurl), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
2649     {"rtmp_listen", "Listen for incoming rtmp connections", OFFSET(listen), AV_OPT_TYPE_INT, {.i64 = 0}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
2650     {"timeout", "Maximum timeout (in seconds) to wait for incoming connections. -1 is infinite. Implies -rtmp_listen 1",  OFFSET(listen_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC, "rtmp_listen" },
2651     { NULL },
2652 };
2653
2654 #define RTMP_PROTOCOL(flavor)                    \
2655 static const AVClass flavor##_class = {          \
2656     .class_name = #flavor,                       \
2657     .item_name  = av_default_item_name,          \
2658     .option     = rtmp_options,                  \
2659     .version    = LIBAVUTIL_VERSION_INT,         \
2660 };                                               \
2661                                                  \
2662 URLProtocol ff_##flavor##_protocol = {           \
2663     .name           = #flavor,                   \
2664     .url_open       = rtmp_open,                 \
2665     .url_read       = rtmp_read,                 \
2666     .url_write      = rtmp_write,                \
2667     .url_close      = rtmp_close,                \
2668     .priv_data_size = sizeof(RTMPContext),       \
2669     .flags          = URL_PROTOCOL_FLAG_NETWORK, \
2670     .priv_data_class= &flavor##_class,           \
2671 };
2672
2673
2674 RTMP_PROTOCOL(rtmp)
2675 RTMP_PROTOCOL(rtmpe)
2676 RTMP_PROTOCOL(rtmps)
2677 RTMP_PROTOCOL(rtmpt)
2678 RTMP_PROTOCOL(rtmpte)
2679 RTMP_PROTOCOL(rtmpts)