Use enum instead of integer types where appropriate.
[ffmpeg.git] / libavformat / rtmpproto.c
1 /*
2  * RTMP network protocol
3  * Copyright (c) 2009 Kostya 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 libavformat/rtmpproto.c
24  * RTMP protocol
25  */
26
27 #include "libavcodec/bytestream.h"
28 #include "libavutil/avstring.h"
29 #include "libavutil/lfg.h"
30 #include "libavutil/sha.h"
31 #include "avformat.h"
32
33 #include "network.h"
34
35 #include "flv.h"
36 #include "rtmp.h"
37 #include "rtmppkt.h"
38
39 /* we can't use av_log() with URLContext yet... */
40 #if LIBAVFORMAT_VERSION_MAJOR < 53
41 #define LOG_CONTEXT NULL
42 #else
43 #define LOG_CONTEXT s
44 #endif
45
46 /** RTMP protocol handler state */
47 typedef enum {
48     STATE_START,      ///< client has not done anything yet
49     STATE_HANDSHAKED, ///< client has performed handshake
50     STATE_CONNECTING, ///< client connected to server successfully
51     STATE_READY,      ///< client has sent all needed commands and waits for server reply
52     STATE_PLAYING,    ///< client has started receiving multimedia data from server
53 } ClientState;
54
55 /** protocol handler context */
56 typedef struct RTMPContext {
57     URLContext*   stream;                     ///< TCP stream used in interactions with RTMP server
58     RTMPPacket    prev_pkt[2][RTMP_CHANNELS]; ///< packet history used when reading and sending packets
59     int           chunk_size;                 ///< size of the chunks RTMP packets are divided into
60     char          playpath[256];              ///< path to filename to play (with possible "mp4:" prefix)
61     ClientState   state;                      ///< current state
62     int           main_channel_id;            ///< an additional channel ID which is used for some invocations
63     uint8_t*      flv_data;                   ///< buffer with data for demuxer
64     int           flv_size;                   ///< current buffer size
65     int           flv_off;                    ///< number of bytes read from current buffer
66     uint32_t      video_ts;                   ///< current video timestamp in milliseconds
67     uint32_t      audio_ts;                   ///< current audio timestamp in milliseconds
68 } RTMPContext;
69
70 #define PLAYER_KEY_OPEN_PART_LEN 30   ///< length of partial key used for first client digest signing
71 /** Client key used for digest signing */
72 static const uint8_t rtmp_player_key[] = {
73     'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
74     'F', 'l', 'a', 's', 'h', ' ', 'P', 'l', 'a', 'y', 'e', 'r', ' ', '0', '0', '1',
75
76     0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
77     0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
78     0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
79 };
80
81 #define SERVER_KEY_OPEN_PART_LEN 36   ///< length of partial key used for first server digest signing
82 /** Key used for RTMP server digest signing */
83 static const uint8_t rtmp_server_key[] = {
84     'G', 'e', 'n', 'u', 'i', 'n', 'e', ' ', 'A', 'd', 'o', 'b', 'e', ' ',
85     'F', 'l', 'a', 's', 'h', ' ', 'M', 'e', 'd', 'i', 'a', ' ',
86     'S', 'e', 'r', 'v', 'e', 'r', ' ', '0', '0', '1',
87
88     0xF0, 0xEE, 0xC2, 0x4A, 0x80, 0x68, 0xBE, 0xE8, 0x2E, 0x00, 0xD0, 0xD1, 0x02,
89     0x9E, 0x7E, 0x57, 0x6E, 0xEC, 0x5D, 0x2D, 0x29, 0x80, 0x6F, 0xAB, 0x93, 0xB8,
90     0xE6, 0x36, 0xCF, 0xEB, 0x31, 0xAE
91 };
92
93 /**
94  * Generates 'connect' call and sends it to the server.
95  */
96 static void gen_connect(URLContext *s, RTMPContext *rt, const char *proto,
97                         const char *host, int port, const char *app)
98 {
99     RTMPPacket pkt;
100     uint8_t ver[32], *p;
101     char tcurl[512];
102
103     ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0, 4096);
104     p = pkt.data;
105
106     snprintf(tcurl, sizeof(tcurl), "%s://%s:%d/%s", proto, host, port, app);
107     ff_amf_write_string(&p, "connect");
108     ff_amf_write_number(&p, 1.0);
109     ff_amf_write_object_start(&p);
110     ff_amf_write_field_name(&p, "app");
111     ff_amf_write_string(&p, app);
112
113     snprintf(ver, sizeof(ver), "%s %d,%d,%d,%d", RTMP_CLIENT_PLATFORM, RTMP_CLIENT_VER1,
114              RTMP_CLIENT_VER2, RTMP_CLIENT_VER3, RTMP_CLIENT_VER4);
115     ff_amf_write_field_name(&p, "flashVer");
116     ff_amf_write_string(&p, ver);
117     ff_amf_write_field_name(&p, "tcUrl");
118     ff_amf_write_string(&p, tcurl);
119     ff_amf_write_field_name(&p, "fpad");
120     ff_amf_write_bool(&p, 0);
121     ff_amf_write_field_name(&p, "capabilities");
122     ff_amf_write_number(&p, 15.0);
123     ff_amf_write_field_name(&p, "audioCodecs");
124     ff_amf_write_number(&p, 1639.0);
125     ff_amf_write_field_name(&p, "videoCodecs");
126     ff_amf_write_number(&p, 252.0);
127     ff_amf_write_field_name(&p, "videoFunction");
128     ff_amf_write_number(&p, 1.0);
129     ff_amf_write_object_end(&p);
130
131     pkt.data_size = p - pkt.data;
132
133     ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
134 }
135
136 /**
137  * Generates 'createStream' call and sends it to the server. It should make
138  * the server allocate some channel for media streams.
139  */
140 static void gen_create_stream(URLContext *s, RTMPContext *rt)
141 {
142     RTMPPacket pkt;
143     uint8_t *p;
144
145     av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Creating stream...\n");
146     ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0, 25);
147
148     p = pkt.data;
149     ff_amf_write_string(&p, "createStream");
150     ff_amf_write_number(&p, 3.0);
151     ff_amf_write_null(&p);
152
153     ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
154     ff_rtmp_packet_destroy(&pkt);
155 }
156
157 /**
158  * Generates 'play' call and sends it to the server, then pings the server
159  * to start actual playing.
160  */
161 static void gen_play(URLContext *s, RTMPContext *rt)
162 {
163     RTMPPacket pkt;
164     uint8_t *p;
165
166     av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Sending play command for '%s'\n", rt->playpath);
167     ff_rtmp_packet_create(&pkt, RTMP_VIDEO_CHANNEL, RTMP_PT_INVOKE, 0,
168                           20 + strlen(rt->playpath));
169     pkt.extra = rt->main_channel_id;
170
171     p = pkt.data;
172     ff_amf_write_string(&p, "play");
173     ff_amf_write_number(&p, 0.0);
174     ff_amf_write_null(&p);
175     ff_amf_write_string(&p, rt->playpath);
176
177     ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
178     ff_rtmp_packet_destroy(&pkt);
179
180     // set client buffer time disguised in ping packet
181     ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING, 1, 10);
182
183     p = pkt.data;
184     bytestream_put_be16(&p, 3);
185     bytestream_put_be32(&p, 1);
186     bytestream_put_be32(&p, 256); //TODO: what is a good value here?
187
188     ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
189     ff_rtmp_packet_destroy(&pkt);
190 }
191
192 /**
193  * Generates ping reply and sends it to the server.
194  */
195 static void gen_pong(URLContext *s, RTMPContext *rt, RTMPPacket *ppkt)
196 {
197     RTMPPacket pkt;
198     uint8_t *p;
199
200     ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING, ppkt->timestamp + 1, 6);
201     p = pkt.data;
202     bytestream_put_be16(&p, 7);
203     bytestream_put_be32(&p, AV_RB32(ppkt->data+2) + 1);
204     ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size, rt->prev_pkt[1]);
205     ff_rtmp_packet_destroy(&pkt);
206 }
207
208 //TODO: Move HMAC code somewhere. Eventually.
209 #define HMAC_IPAD_VAL 0x36
210 #define HMAC_OPAD_VAL 0x5C
211
212 /**
213  * Calculates HMAC-SHA2 digest for RTMP handshake packets.
214  *
215  * @param src    input buffer
216  * @param len    input buffer length (should be 1536)
217  * @param gap    offset in buffer where 32 bytes should not be taken into account
218  *               when calculating digest (since it will be used to store that digest)
219  * @param key    digest key
220  * @param keylen digest key length
221  * @param dst    buffer where calculated digest will be stored (32 bytes)
222  */
223 static void rtmp_calc_digest(const uint8_t *src, int len, int gap,
224                              const uint8_t *key, int keylen, uint8_t *dst)
225 {
226     struct AVSHA *sha;
227     uint8_t hmac_buf[64+32] = {0};
228     int i;
229
230     sha = av_mallocz(av_sha_size);
231
232     if (keylen < 64) {
233         memcpy(hmac_buf, key, keylen);
234     } else {
235         av_sha_init(sha, 256);
236         av_sha_update(sha,key, keylen);
237         av_sha_final(sha, hmac_buf);
238     }
239     for (i = 0; i < 64; i++)
240         hmac_buf[i] ^= HMAC_IPAD_VAL;
241
242     av_sha_init(sha, 256);
243     av_sha_update(sha, hmac_buf, 64);
244     if (gap <= 0) {
245         av_sha_update(sha, src, len);
246     } else { //skip 32 bytes used for storing digest
247         av_sha_update(sha, src, gap);
248         av_sha_update(sha, src + gap + 32, len - gap - 32);
249     }
250     av_sha_final(sha, hmac_buf + 64);
251
252     for (i = 0; i < 64; i++)
253         hmac_buf[i] ^= HMAC_IPAD_VAL ^ HMAC_OPAD_VAL; //reuse XORed key for opad
254     av_sha_init(sha, 256);
255     av_sha_update(sha, hmac_buf, 64+32);
256     av_sha_final(sha, dst);
257
258     av_free(sha);
259 }
260
261 /**
262  * Puts HMAC-SHA2 digest of packet data (except for the bytes where this digest
263  * will be stored) into that packet.
264  *
265  * @param buf handshake data (1536 bytes)
266  * @return offset to the digest inside input data
267  */
268 static int rtmp_handshake_imprint_with_digest(uint8_t *buf)
269 {
270     int i, digest_pos = 0;
271
272     for (i = 8; i < 12; i++)
273         digest_pos += buf[i];
274     digest_pos = (digest_pos % 728) + 12;
275
276     rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
277                      rtmp_player_key, PLAYER_KEY_OPEN_PART_LEN,
278                      buf + digest_pos);
279     return digest_pos;
280 }
281
282 /**
283  * Verifies that the received server response has the expected digest value.
284  *
285  * @param buf handshake data received from the server (1536 bytes)
286  * @param off position to search digest offset from
287  * @return 0 if digest is valid, digest position otherwise
288  */
289 static int rtmp_validate_digest(uint8_t *buf, int off)
290 {
291     int i, digest_pos = 0;
292     uint8_t digest[32];
293
294     for (i = 0; i < 4; i++)
295         digest_pos += buf[i + off];
296     digest_pos = (digest_pos % 728) + off + 4;
297
298     rtmp_calc_digest(buf, RTMP_HANDSHAKE_PACKET_SIZE, digest_pos,
299                      rtmp_server_key, SERVER_KEY_OPEN_PART_LEN,
300                      digest);
301     if (!memcmp(digest, buf + digest_pos, 32))
302         return digest_pos;
303     return 0;
304 }
305
306 /**
307  * Performs handshake with the server by means of exchanging pseudorandom data
308  * signed with HMAC-SHA2 digest.
309  *
310  * @return 0 if handshake succeeds, negative value otherwise
311  */
312 static int rtmp_handshake(URLContext *s, RTMPContext *rt)
313 {
314     AVLFG rnd;
315     uint8_t tosend    [RTMP_HANDSHAKE_PACKET_SIZE+1] = {
316         3,                // unencrypted data
317         0, 0, 0, 0,       // client uptime
318         RTMP_CLIENT_VER1,
319         RTMP_CLIENT_VER2,
320         RTMP_CLIENT_VER3,
321         RTMP_CLIENT_VER4,
322     };
323     uint8_t clientdata[RTMP_HANDSHAKE_PACKET_SIZE];
324     uint8_t serverdata[RTMP_HANDSHAKE_PACKET_SIZE+1];
325     int i;
326     int server_pos, client_pos;
327     uint8_t digest[32];
328
329     av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Handshaking...\n");
330
331     av_lfg_init(&rnd, 0xDEADC0DE);
332     // generate handshake packet - 1536 bytes of pseudorandom data
333     for (i = 9; i <= RTMP_HANDSHAKE_PACKET_SIZE; i++)
334         tosend[i] = av_lfg_get(&rnd) >> 24;
335     client_pos = rtmp_handshake_imprint_with_digest(tosend + 1);
336
337     url_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE + 1);
338     i = url_read_complete(rt->stream, serverdata, RTMP_HANDSHAKE_PACKET_SIZE + 1);
339     if (i != RTMP_HANDSHAKE_PACKET_SIZE + 1) {
340         av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
341         return -1;
342     }
343     i = url_read_complete(rt->stream, clientdata, RTMP_HANDSHAKE_PACKET_SIZE);
344     if (i != RTMP_HANDSHAKE_PACKET_SIZE) {
345         av_log(LOG_CONTEXT, AV_LOG_ERROR, "Cannot read RTMP handshake response\n");
346         return -1;
347     }
348
349     av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Server version %d.%d.%d.%d\n",
350            serverdata[5], serverdata[6], serverdata[7], serverdata[8]);
351
352     server_pos = rtmp_validate_digest(serverdata + 1, 772);
353     if (!server_pos) {
354         server_pos = rtmp_validate_digest(serverdata + 1, 8);
355         if (!server_pos) {
356             av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server response validating failed\n");
357             return -1;
358         }
359     }
360
361     rtmp_calc_digest(tosend + 1 + client_pos, 32, 0,
362                      rtmp_server_key, sizeof(rtmp_server_key),
363                      digest);
364     rtmp_calc_digest(clientdata, RTMP_HANDSHAKE_PACKET_SIZE-32, 0,
365                      digest, 32,
366                      digest);
367     if (memcmp(digest, clientdata + RTMP_HANDSHAKE_PACKET_SIZE - 32, 32)) {
368         av_log(LOG_CONTEXT, AV_LOG_ERROR, "Signature mismatch\n");
369         return -1;
370     }
371
372     for (i = 0; i < RTMP_HANDSHAKE_PACKET_SIZE; i++)
373         tosend[i] = av_lfg_get(&rnd) >> 24;
374     rtmp_calc_digest(serverdata + 1 + server_pos, 32, 0,
375                      rtmp_player_key, sizeof(rtmp_player_key),
376                      digest);
377     rtmp_calc_digest(tosend,  RTMP_HANDSHAKE_PACKET_SIZE - 32, 0,
378                      digest, 32,
379                      tosend + RTMP_HANDSHAKE_PACKET_SIZE - 32);
380
381     // write reply back to the server
382     url_write(rt->stream, tosend, RTMP_HANDSHAKE_PACKET_SIZE);
383     return 0;
384 }
385
386 /**
387  * Parses received packet and may perform some action depending on
388  * the packet contents.
389  * @return 0 for no errors, negative values for serious errors which prevent
390  *         further communications, positive values for uncritical errors
391  */
392 static int rtmp_parse_result(URLContext *s, RTMPContext *rt, RTMPPacket *pkt)
393 {
394     int i, t;
395     const uint8_t *data_end = pkt->data + pkt->data_size;
396
397     switch (pkt->type) {
398     case RTMP_PT_CHUNK_SIZE:
399         if (pkt->data_size != 4) {
400             av_log(LOG_CONTEXT, AV_LOG_ERROR,
401                    "Chunk size change packet is not 4 bytes long (%d)\n", pkt->data_size);
402             return -1;
403         }
404         rt->chunk_size = AV_RB32(pkt->data);
405         if (rt->chunk_size <= 0) {
406             av_log(LOG_CONTEXT, AV_LOG_ERROR, "Incorrect chunk size %d\n", rt->chunk_size);
407             return -1;
408         }
409         av_log(LOG_CONTEXT, AV_LOG_DEBUG, "New chunk size = %d\n", rt->chunk_size);
410         break;
411     case RTMP_PT_PING:
412         t = AV_RB16(pkt->data);
413         if (t == 6)
414             gen_pong(s, rt, pkt);
415         break;
416     case RTMP_PT_INVOKE:
417         //TODO: check for the messages sent for wrong state?
418         if (!memcmp(pkt->data, "\002\000\006_error", 9)) {
419             uint8_t tmpstr[256];
420
421             if (!ff_amf_get_field_value(pkt->data + 9, data_end,
422                                         "description", tmpstr, sizeof(tmpstr)))
423                 av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
424             return -1;
425         } else if (!memcmp(pkt->data, "\002\000\007_result", 10)) {
426             switch (rt->state) {
427             case STATE_HANDSHAKED:
428                 gen_create_stream(s, rt);
429                 rt->state = STATE_CONNECTING;
430                 break;
431             case STATE_CONNECTING:
432                 //extract a number from the result
433                 if (pkt->data[10] || pkt->data[19] != 5 || pkt->data[20]) {
434                     av_log(LOG_CONTEXT, AV_LOG_WARNING, "Unexpected reply on connect()\n");
435                 } else {
436                     rt->main_channel_id = (int) av_int2dbl(AV_RB64(pkt->data + 21));
437                 }
438                 gen_play(s, rt);
439                 rt->state = STATE_READY;
440                 break;
441             }
442         } else if (!memcmp(pkt->data, "\002\000\010onStatus", 11)) {
443             const uint8_t* ptr = pkt->data + 11;
444             uint8_t tmpstr[256];
445             int t;
446
447             for (i = 0; i < 2; i++) {
448                 t = ff_amf_tag_size(ptr, data_end);
449                 if (t < 0)
450                     return 1;
451                 ptr += t;
452             }
453             t = ff_amf_get_field_value(ptr, data_end,
454                                        "level", tmpstr, sizeof(tmpstr));
455             if (!t && !strcmp(tmpstr, "error")) {
456                 if (!ff_amf_get_field_value(ptr, data_end,
457                                             "description", tmpstr, sizeof(tmpstr)))
458                     av_log(LOG_CONTEXT, AV_LOG_ERROR, "Server error: %s\n",tmpstr);
459                 return -1;
460             }
461             t = ff_amf_get_field_value(ptr, data_end,
462                                        "code", tmpstr, sizeof(tmpstr));
463             if (!t && !strcmp(tmpstr, "NetStream.Play.Start")) {
464                 rt->state = STATE_PLAYING;
465                 return 0;
466             }
467         }
468         break;
469     }
470     return 0;
471 }
472
473 /**
474  * Interacts with the server by receiving and sending RTMP packets until
475  * there is some significant data (media data or expected status notification).
476  *
477  * @param s          reading context
478  * @param for_header non-zero value tells function to work until it gets notification from the server that playing has been started, otherwise function will work until some media data is received (or an error happens)
479  * @return 0 for successful operation, negative value in case of error
480  */
481 static int get_packet(URLContext *s, int for_header)
482 {
483     RTMPContext *rt = s->priv_data;
484     int ret;
485
486     for(;;) {
487         RTMPPacket rpkt;
488         if ((ret = ff_rtmp_packet_read(rt->stream, &rpkt,
489                                        rt->chunk_size, rt->prev_pkt[0])) != 0) {
490             if (ret > 0) {
491                 return AVERROR(EAGAIN);
492             } else {
493                 return AVERROR(EIO);
494             }
495         }
496
497         ret = rtmp_parse_result(s, rt, &rpkt);
498         if (ret < 0) {//serious error in current packet
499             ff_rtmp_packet_destroy(&rpkt);
500             return -1;
501         }
502         if (for_header && rt->state == STATE_PLAYING) {
503             ff_rtmp_packet_destroy(&rpkt);
504             return 0;
505         }
506         if (!rpkt.data_size) {
507             ff_rtmp_packet_destroy(&rpkt);
508             continue;
509         }
510         if (rpkt.type == RTMP_PT_VIDEO || rpkt.type == RTMP_PT_AUDIO ||
511             rpkt.type == RTMP_PT_NOTIFY) {
512             uint8_t *p;
513             uint32_t ts = rpkt.timestamp;
514
515             if (rpkt.type == RTMP_PT_VIDEO) {
516                 rt->video_ts += rpkt.timestamp;
517                 ts = rt->video_ts;
518             } else if (rpkt.type == RTMP_PT_AUDIO) {
519                 rt->audio_ts += rpkt.timestamp;
520                 ts = rt->audio_ts;
521             }
522             // generate packet header and put data into buffer for FLV demuxer
523             rt->flv_off  = 0;
524             rt->flv_size = rpkt.data_size + 15;
525             rt->flv_data = p = av_realloc(rt->flv_data, rt->flv_size);
526             bytestream_put_byte(&p, rpkt.type);
527             bytestream_put_be24(&p, rpkt.data_size);
528             bytestream_put_be24(&p, ts);
529             bytestream_put_byte(&p, ts >> 24);
530             bytestream_put_be24(&p, 0);
531             bytestream_put_buffer(&p, rpkt.data, rpkt.data_size);
532             bytestream_put_be32(&p, 0);
533             ff_rtmp_packet_destroy(&rpkt);
534             return 0;
535         } else if (rpkt.type == RTMP_PT_METADATA) {
536             // we got raw FLV data, make it available for FLV demuxer
537             rt->flv_off  = 0;
538             rt->flv_size = rpkt.data_size;
539             rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
540             memcpy(rt->flv_data, rpkt.data, rpkt.data_size);
541             ff_rtmp_packet_destroy(&rpkt);
542             return 0;
543         }
544         ff_rtmp_packet_destroy(&rpkt);
545     }
546     return 0;
547 }
548
549 static int rtmp_close(URLContext *h)
550 {
551     RTMPContext *rt = h->priv_data;
552
553     av_freep(&rt->flv_data);
554     url_close(rt->stream);
555     av_free(rt);
556     return 0;
557 }
558
559 /**
560  * Opens RTMP connection and verifies that the stream can be played.
561  *
562  * URL syntax: rtmp://server[:port][/app][/playpath]
563  *             where 'app' is first one or two directories in the path
564  *             (e.g. /ondemand/, /flash/live/, etc.)
565  *             and 'playpath' is a file name (the rest of the path,
566  *             may be prefixed with "mp4:")
567  */
568 static int rtmp_open(URLContext *s, const char *uri, int flags)
569 {
570     RTMPContext *rt;
571     char proto[8], hostname[256], path[1024], app[128], *fname;
572     uint8_t buf[2048];
573     int port, is_input;
574     int ret;
575
576     is_input = !(flags & URL_WRONLY);
577
578     rt = av_mallocz(sizeof(RTMPContext));
579     if (!rt)
580         return AVERROR(ENOMEM);
581     s->priv_data = rt;
582
583     url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname), &port,
584               path, sizeof(path), s->filename);
585
586     if (port < 0)
587         port = RTMP_DEFAULT_PORT;
588     snprintf(buf, sizeof(buf), "tcp://%s:%d", hostname, port);
589
590     if (url_open(&rt->stream, buf, URL_RDWR) < 0)
591         goto fail;
592
593     if (!is_input) {
594         av_log(LOG_CONTEXT, AV_LOG_ERROR, "RTMP output is not supported yet.\n");
595         goto fail;
596     } else {
597         rt->state = STATE_START;
598         if (rtmp_handshake(s, rt))
599             return -1;
600
601         rt->chunk_size = 128;
602         rt->state = STATE_HANDSHAKED;
603         //extract "app" part from path
604         if (!strncmp(path, "/ondemand/", 10)) {
605             fname = path + 10;
606             memcpy(app, "ondemand", 9);
607         } else {
608             char *p = strchr(path + 1, '/');
609             if (!p) {
610                 fname = path + 1;
611                 app[0] = '\0';
612             } else {
613                 char *c = strchr(p + 1, ':');
614                 fname = strchr(p + 1, '/');
615                 if (!fname || c < fname) {
616                     fname = p + 1;
617                     av_strlcpy(app, path + 1, p - path);
618                 } else {
619                     fname++;
620                     av_strlcpy(app, path + 1, fname - path - 1);
621                 }
622             }
623         }
624         if (!strchr(fname, ':') &&
625             (!strcmp(fname + strlen(fname) - 4, ".f4v") ||
626              !strcmp(fname + strlen(fname) - 4, ".mp4"))) {
627             memcpy(rt->playpath, "mp4:", 5);
628         } else {
629             rt->playpath[0] = 0;
630         }
631         strncat(rt->playpath, fname, sizeof(rt->playpath) - 5);
632
633         av_log(LOG_CONTEXT, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
634                proto, path, app, rt->playpath);
635         gen_connect(s, rt, proto, hostname, port, app);
636
637         do {
638             ret = get_packet(s, 1);
639         } while (ret == EAGAIN);
640         if (ret < 0)
641             goto fail;
642         // generate FLV header for demuxer
643         rt->flv_size = 13;
644         rt->flv_data = av_realloc(rt->flv_data, rt->flv_size);
645         rt->flv_off  = 0;
646         memcpy(rt->flv_data, "FLV\1\5\0\0\0\011\0\0\0\0", rt->flv_size);
647     }
648
649     s->max_packet_size = url_get_max_packet_size(rt->stream);
650     s->is_streamed     = 1;
651     return 0;
652
653 fail:
654     rtmp_close(s);
655     return AVERROR(EIO);
656 }
657
658 static int rtmp_read(URLContext *s, uint8_t *buf, int size)
659 {
660     RTMPContext *rt = s->priv_data;
661     int orig_size = size;
662     int ret;
663
664     while (size > 0) {
665         int data_left = rt->flv_size - rt->flv_off;
666
667         if (data_left >= size) {
668             memcpy(buf, rt->flv_data + rt->flv_off, size);
669             rt->flv_off += size;
670             return orig_size;
671         }
672         if (data_left > 0) {
673             memcpy(buf, rt->flv_data + rt->flv_off, data_left);
674             buf  += data_left;
675             size -= data_left;
676             rt->flv_off = rt->flv_size;
677         }
678         if ((ret = get_packet(s, 0)) < 0)
679            return ret;
680     }
681     return orig_size;
682 }
683
684 static int rtmp_write(URLContext *h, uint8_t *buf, int size)
685 {
686     return 0;
687 }
688
689 URLProtocol rtmp_protocol = {
690     "rtmp",
691     rtmp_open,
692     rtmp_read,
693     rtmp_write,
694     NULL, /* seek */
695     rtmp_close,
696 };