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