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

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

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavformat/rtmpproto.c @ 7195 – Rev 6147