WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavformat/rtmpproto.c

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

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavformat/rtmpproto.c – Rev 4349