FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* RTSP/SDP client
3			* Copyright (c) 2002 Fabrice Bellard
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			#include "config_components.h"
23
24			#include "libavutil/avassert.h"
25			#include "libavutil/base64.h"
26			#include "libavutil/bprint.h"
27			#include "libavutil/avstring.h"
28			#include "libavutil/intreadwrite.h"
29			#include "libavutil/mathematics.h"
30			#include "libavutil/mem.h"
31			#include "libavutil/parseutils.h"
32			#include "libavutil/random_seed.h"
33			#include "libavutil/dict.h"
34			#include "libavutil/opt.h"
35			#include "libavutil/time.h"
36			#include "libavcodec/codec_desc.h"
37			#include "avformat.h"
38			#include "avio_internal.h"
39			#include "demux.h"
40
41			#if HAVE_POLL_H
42			#include <poll.h>
43			#endif
44			#include "internal.h"
45			#include "network.h"
46			#include "os_support.h"
47			#include "http.h"
48			#include "rtsp.h"
49
50			#include "rtpdec.h"
51			#include "rtpproto.h"
52			#include "rdt.h"
53			#include "rtpdec_formats.h"
54			#include "rtpenc_chain.h"
55			#include "url.h"
56			#include "tls.h"
57			#include "rtpenc.h"
58			#include "mpegts.h"
59			#include "version.h"
60
61			/* Default timeout values for read packet in seconds */
62			#define READ_PACKET_TIMEOUT_S 10
63			#define RECVBUF_SIZE 10 * RTP_MAX_PACKET_LENGTH
64			#define DEFAULT_REORDERING_DELAY 100000
65
66			#define OFFSET(x) offsetof(RTSPState, x)
67			#define DEC AV_OPT_FLAG_DECODING_PARAM
68			#define ENC AV_OPT_FLAG_ENCODING_PARAM
69
70			#define RTSP_FLAG_OPTS(name, longname) \
71			{ name, longname, OFFSET(rtsp_flags), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC, .unit = "rtsp_flags" }, \
72			{ "filter_src", "only receive packets from the negotiated peer IP", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_FILTER_SRC}, 0, 0, DEC, .unit = "rtsp_flags" }
73
74			#define RTSP_MEDIATYPE_OPTS(name, longname) \
75			{ name, longname, OFFSET(media_type_mask), AV_OPT_TYPE_FLAGS, { .i64 = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1 }, INT_MIN, INT_MAX, DEC, .unit = "allowed_media_types" }, \
76			{ "video", "Video", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_VIDEO}, 0, 0, DEC, .unit = "allowed_media_types" }, \
77			{ "audio", "Audio", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_AUDIO}, 0, 0, DEC, .unit = "allowed_media_types" }, \
78			{ "data", "Data", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_DATA}, 0, 0, DEC, .unit = "allowed_media_types" }, \
79			{ "subtitle", "Subtitle", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << AVMEDIA_TYPE_SUBTITLE}, 0, 0, DEC, .unit = "allowed_media_types" }
80
81			#define COMMON_OPTS() \
82			{ "reorder_queue_size", "set number of packets to buffer for handling of reordered packets", OFFSET(reordering_queue_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC }, \
83			{ "buffer_size", "Underlying protocol send/receive buffer size", OFFSET(buffer_size), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, DEC|ENC }, \
84			{ "pkt_size", "Underlying protocol send packet size", OFFSET(pkt_size), AV_OPT_TYPE_INT, { .i64 = 1472 }, -1, INT_MAX, ENC } \
85
86
87			const AVOption ff_rtsp_options[] = {
88			{ "initial_pause", "do not start playing the stream immediately", OFFSET(initial_pause), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },
89			FF_RTP_FLAG_OPTS(RTSPState, rtp_muxer_flags),
90			{ "rtsp_transport", "set RTSP transport protocols", OFFSET(lower_transport_mask), AV_OPT_TYPE_FLAGS, {.i64 = 0}, INT_MIN, INT_MAX, DEC|ENC, .unit = "rtsp_transport" }, \
91			{ "udp", "UDP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP}, 0, 0, DEC|ENC, .unit = "rtsp_transport" }, \
92			{ "tcp", "TCP", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_TCP}, 0, 0, DEC|ENC, .unit = "rtsp_transport" }, \
93			{ "udp_multicast", "UDP multicast", 0, AV_OPT_TYPE_CONST, {.i64 = 1 << RTSP_LOWER_TRANSPORT_UDP_MULTICAST}, 0, 0, DEC, .unit = "rtsp_transport" },
94			{ "http", "HTTP tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTP)}, 0, 0, DEC, .unit = "rtsp_transport" },
95			{ "https", "HTTPS tunneling", 0, AV_OPT_TYPE_CONST, {.i64 = (1 << RTSP_LOWER_TRANSPORT_HTTPS )}, 0, 0, DEC, .unit = "rtsp_transport" },
96			RTSP_FLAG_OPTS("rtsp_flags", "set RTSP flags"),
97			{ "listen", "wait for incoming connections", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_LISTEN}, 0, 0, DEC, .unit = "rtsp_flags" },
98			{ "prefer_tcp", "try RTP via TCP first, if available", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_PREFER_TCP}, 0, 0, DEC|ENC, .unit = "rtsp_flags" },
99			{ "satip_raw", "export raw MPEG-TS stream instead of demuxing", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_SATIP_RAW}, 0, 0, DEC, .unit = "rtsp_flags" },
100			RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
101			{ "min_port", "set minimum local UDP port", OFFSET(rtp_port_min), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MIN}, 0, 65535, DEC|ENC },
102			{ "max_port", "set maximum local UDP port", OFFSET(rtp_port_max), AV_OPT_TYPE_INT, {.i64 = RTSP_RTP_PORT_MAX}, 0, 65535, DEC|ENC },
103			{ "listen_timeout", "set maximum timeout (in seconds) to wait for incoming connections (-1 is infinite, imply flag listen)", OFFSET(initial_timeout), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, DEC },
104			{ "timeout", "set timeout (in microseconds) of socket I/O operations", OFFSET(stimeout), AV_OPT_TYPE_INT64, {.i64 = 0}, INT_MIN, INT64_MAX, DEC },
105			COMMON_OPTS(),
106			{ "user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = LIBAVFORMAT_IDENT}, 0, 0, DEC },
107
108			// TLS options
109			FF_TLS_CLIENT_OPTIONS(RTSPState, tls_opts),
110			{ NULL },
111			};
112
113			static const AVOption sdp_options[] = {
114			RTSP_FLAG_OPTS("sdp_flags", "SDP flags"),
115			{ "custom_io", "use custom I/O", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_CUSTOM_IO}, 0, 0, DEC, .unit = "rtsp_flags" },
116			{ "rtcp_to_source", "send RTCP packets to the source address of received packets", 0, AV_OPT_TYPE_CONST, {.i64 = RTSP_FLAG_RTCP_TO_SOURCE}, 0, 0, DEC, .unit = "rtsp_flags" },
117			{ "listen_timeout", "set maximum timeout (in seconds) to wait for incoming connections", OFFSET(stimeout), AV_OPT_TYPE_DURATION, {.i64 = READ_PACKET_TIMEOUT_S*1000000}, INT_MIN, INT64_MAX, DEC },
118			{ "localaddr", "local address", OFFSET(localaddr),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
119			RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
120			COMMON_OPTS(),
121			{ NULL },
122			};
123
124			static const AVOption rtp_options[] = {
125			RTSP_FLAG_OPTS("rtp_flags", "set RTP flags"),
126			{ "listen_timeout", "set maximum timeout (in seconds) to wait for incoming connections", OFFSET(stimeout), AV_OPT_TYPE_DURATION, {.i64 = READ_PACKET_TIMEOUT_S*1000000}, INT_MIN, INT64_MAX, DEC },
127			{ "localaddr", "local address", OFFSET(localaddr),AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC }, \
128			RTSP_MEDIATYPE_OPTS("allowed_media_types", "set media types to accept from the server"),
129			COMMON_OPTS(),
130			{ NULL },
131			};
132
133
134		✗	static AVDictionary *map_to_opts(RTSPState *rt)
135			{
136		✗	AVDictionary *opts = NULL;
137
138		✗	av_dict_set_int(&opts, "buffer_size", rt->buffer_size, 0);
139		✗	av_dict_set_int(&opts, "pkt_size", rt->pkt_size, 0);
140		✗	if (rt->localaddr && rt->localaddr[0])
141		✗	av_dict_set(&opts, "localaddr", rt->localaddr, 0);
142
143		✗	return opts;
144			}
145
146			#define ERR_RET(c) \
147			do { \
148			int ret = c; \
149			if (ret < 0) \
150			return ret; \
151			} while (0)
152
153			/**
154			* Add the TLS options of the given RTSPState to the dict
155			*/
156		✗	static int copy_tls_opts_dict(RTSPState *rt, AVDictionary **dict)
157			{
158		✗	ERR_RET(av_dict_set_int(dict, "tls_verify", rt->tls_opts.verify, 0));
159		✗	ERR_RET(av_dict_set(dict, "ca_file", rt->tls_opts.ca_file, 0));
160		✗	ERR_RET(av_dict_set(dict, "cert_file", rt->tls_opts.cert_file, 0));
161		✗	ERR_RET(av_dict_set(dict, "key_file", rt->tls_opts.key_file, 0));
162		✗	ERR_RET(av_dict_set(dict, "verifyhost", rt->tls_opts.host, 0));
163
164		✗	return 0;
165			}
166
167			#undef ERR_RET
168
169		✗	static void get_word_until_chars(char *buf, int buf_size,
170			const char *sep, const char **pp)
171			{
172			const char *p;
173			char *q;
174
175		✗	p = *pp;
176		✗	p += strspn(p, SPACE_CHARS);
177		✗	q = buf;
178		✗	while (!strchr(sep, *p) && *p != '\0') {
179		✗	if ((q - buf) < buf_size - 1)
180		✗	*q++ = *p;
181		✗	p++;
182			}
183		✗	if (buf_size > 0)
184		✗	*q = '\0';
185		✗	*pp = p;
186		✗	}
187
188		✗	static void get_word_sep(char *buf, int buf_size, const char *sep,
189			const char **pp)
190			{
191		✗	if (**pp == '/') (*pp)++;
192		✗	get_word_until_chars(buf, buf_size, sep, pp);
193		✗	}
194
195		✗	static void get_word(char *buf, int buf_size, const char **pp)
196			{
197		✗	get_word_until_chars(buf, buf_size, SPACE_CHARS, pp);
198		✗	}
199
200			/** Parse a string p in the form of Range:npt=xx-xx, and determine the start
201			* and end time.
202			* Used for seeking in the rtp stream.
203			*/
204		✗	static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
205			{
206			char buf[256];
207
208		✗	p += strspn(p, SPACE_CHARS);
209		✗	if (!av_stristart(p, "npt=", &p))
210		✗	return;
211
212		✗	*start = AV_NOPTS_VALUE;
213		✗	*end = AV_NOPTS_VALUE;
214
215		✗	get_word_sep(buf, sizeof(buf), "-", &p);
216		✗	if (av_parse_time(start, buf, 1) < 0)
217		✗	return;
218		✗	if (*p == '-') {
219		✗	p++;
220		✗	get_word_sep(buf, sizeof(buf), "-", &p);
221		✗	if (av_parse_time(end, buf, 1) < 0)
222		✗	av_log(NULL, AV_LOG_DEBUG, "Failed to parse interval end specification '%s'\n", buf);
223			}
224			}
225
226		✗	static int get_sockaddr(AVFormatContext *s,
227			const char *buf, struct sockaddr_storage *sock)
228			{
229		✗	struct addrinfo hints = { 0 }, *ai = NULL;
230			int ret;
231
232		✗	hints.ai_flags = AI_NUMERICHOST;
233		✗	if ((ret = getaddrinfo(buf, NULL, &hints, &ai))) {
234		✗	av_log(s, AV_LOG_ERROR, "getaddrinfo(%s): %s\n",
235			buf,
236			gai_strerror(ret));
237		✗	return -1;
238			}
239		✗	memcpy(sock, ai->ai_addr, FFMIN(sizeof(*sock), ai->ai_addrlen));
240		✗	freeaddrinfo(ai);
241		✗	return 0;
242			}
243
244			#if CONFIG_RTPDEC
245		✗	static void init_rtp_handler(const RTPDynamicProtocolHandler *handler,
246			RTSPStream *rtsp_st, AVStream *st)
247			{
248		✗	AVCodecParameters *par = st ? st->codecpar : NULL;
249		✗	if (!handler)
250		✗	return;
251		✗	if (par)
252		✗	par->codec_id = handler->codec_id;
253		✗	rtsp_st->dynamic_handler = handler;
254		✗	if (st)
255		✗	ffstream(st)->need_parsing = handler->need_parsing;
256		✗	if (handler->priv_data_size) {
257		✗	rtsp_st->dynamic_protocol_context = av_mallocz(handler->priv_data_size);
258		✗	if (!rtsp_st->dynamic_protocol_context)
259		✗	rtsp_st->dynamic_handler = NULL;
260			}
261			}
262
263		✗	static void finalize_rtp_handler_init(AVFormatContext *s, RTSPStream *rtsp_st,
264			AVStream *st)
265			{
266		✗	if (rtsp_st->dynamic_handler && rtsp_st->dynamic_handler->init) {
267		✗	int ret = rtsp_st->dynamic_handler->init(s, st ? st->index : -1,
268			rtsp_st->dynamic_protocol_context);
269		✗	if (ret < 0) {
270		✗	if (rtsp_st->dynamic_protocol_context) {
271		✗	if (rtsp_st->dynamic_handler->close)
272		✗	rtsp_st->dynamic_handler->close(
273			rtsp_st->dynamic_protocol_context);
274		✗	av_free(rtsp_st->dynamic_protocol_context);
275			}
276		✗	rtsp_st->dynamic_protocol_context = NULL;
277		✗	rtsp_st->dynamic_handler = NULL;
278			}
279			}
280		✗	}
281
282			#if CONFIG_RTSP_DEMUXER
283		✗	static int init_satip_stream(AVFormatContext *s)
284			{
285		✗	RTSPState *rt = s->priv_data;
286		✗	RTSPStream *rtsp_st = av_mallocz(sizeof(RTSPStream));
287		✗	if (!rtsp_st)
288		✗	return AVERROR(ENOMEM);
289		✗	dynarray_add(&rt->rtsp_streams,
290			&rt->nb_rtsp_streams, rtsp_st);
291
292		✗	rtsp_st->sdp_payload_type = 33; // MP2T
293		✗	av_strlcpy(rtsp_st->control_url,
294		✗	rt->control_uri, sizeof(rtsp_st->control_url));
295
296		✗	if (rt->rtsp_flags & RTSP_FLAG_SATIP_RAW) {
297		✗	AVStream *st = avformat_new_stream(s, NULL);
298		✗	if (!st)
299		✗	return AVERROR(ENOMEM);
300		✗	st->id = rt->nb_rtsp_streams - 1;
301		✗	rtsp_st->stream_index = st->index;
302		✗	st->codecpar->codec_type = AVMEDIA_TYPE_DATA;
303		✗	st->codecpar->codec_id = AV_CODEC_ID_MPEG2TS;
304			} else {
305		✗	rtsp_st->stream_index = -1;
306		✗	init_rtp_handler(&ff_mpegts_dynamic_handler, rtsp_st, NULL);
307		✗	finalize_rtp_handler_init(s, rtsp_st, NULL);
308			}
309		✗	return 0;
310			}
311			#endif
312
313			/* parse the rtpmap description: <codec_name>/<clock_rate>[/<other params>] */
314		✗	static int sdp_parse_rtpmap(AVFormatContext *s,
315			AVStream *st, RTSPStream *rtsp_st,
316			int payload_type, const char *p)
317			{
318		✗	AVCodecParameters *par = st->codecpar;
319			char buf[256];
320			int i;
321			const AVCodecDescriptor *desc;
322			const char *c_name;
323
324			/* See if we can handle this kind of payload.
325			* The space should normally not be there but some Real streams or
326			* particular servers ("RealServer Version 6.1.3.970", see issue 1658)
327			* have a trailing space. */
328		✗	get_word_sep(buf, sizeof(buf), "/ ", &p);
329		✗	if (payload_type < RTP_PT_PRIVATE) {
330			/* We are in a standard case
331			* (from http://www.iana.org/assignments/rtp-parameters). */
332		✗	par->codec_id = ff_rtp_codec_id(buf, par->codec_type);
333			}
334
335		✗	if (par->codec_id == AV_CODEC_ID_NONE) {
336			const RTPDynamicProtocolHandler *handler =
337		✗	ff_rtp_handler_find_by_name(buf, par->codec_type);
338		✗	init_rtp_handler(handler, rtsp_st, st);
339			/* If no dynamic handler was found, check with the list of standard
340			* allocated types, if such a stream for some reason happens to
341			* use a private payload type. This isn't handled in rtpdec.c, since
342			* the format name from the rtpmap line never is passed into rtpdec. */
343		✗	if (!rtsp_st->dynamic_handler)
344		✗	par->codec_id = ff_rtp_codec_id(buf, par->codec_type);
345			}
346
347		✗	desc = avcodec_descriptor_get(par->codec_id);
348		✗	if (desc && desc->name)
349		✗	c_name = desc->name;
350			else
351		✗	c_name = "(null)";
352
353		✗	get_word_sep(buf, sizeof(buf), "/", &p);
354		✗	i = atoi(buf);
355		✗	switch (par->codec_type) {
356		✗	case AVMEDIA_TYPE_AUDIO:
357		✗	av_log(s, AV_LOG_DEBUG, "audio codec set to: %s\n", c_name);
358		✗	par->sample_rate = RTSP_DEFAULT_AUDIO_SAMPLERATE;
359		✗	par->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;
360		✗	if (i > 0) {
361		✗	par->sample_rate = i;
362		✗	avpriv_set_pts_info(st, 32, 1, par->sample_rate);
363		✗	get_word_sep(buf, sizeof(buf), "/", &p);
364		✗	i = atoi(buf);
365		✗	if (i > 0)
366		✗	av_channel_layout_default(&par->ch_layout, i);
367			}
368		✗	av_log(s, AV_LOG_DEBUG, "audio samplerate set to: %i\n",
369			par->sample_rate);
370		✗	av_log(s, AV_LOG_DEBUG, "audio channels set to: %i\n",
371			par->ch_layout.nb_channels);
372		✗	break;
373		✗	case AVMEDIA_TYPE_VIDEO:
374		✗	av_log(s, AV_LOG_DEBUG, "video codec set to: %s\n", c_name);
375		✗	if (i > 0)
376		✗	avpriv_set_pts_info(st, 32, 1, i);
377		✗	break;
378		✗	default:
379		✗	break;
380			}
381		✗	finalize_rtp_handler_init(s, rtsp_st, st);
382		✗	return 0;
383			}
384
385			/* parse the attribute line from the fmtp a line of an sdp response. This
386			* is broken out as a function because it is used in rtp_h264.c, which is
387			* forthcoming. */
388		✗	int ff_rtsp_next_attr_and_value(const char **p, char *attr, int attr_size,
389			char *value, int value_size)
390			{
391		✗	*p += strspn(*p, SPACE_CHARS);
392		✗	if (**p) {
393		✗	get_word_sep(attr, attr_size, "=", p);
394		✗	if (**p == '=')
395		✗	(*p)++;
396		✗	get_word_sep(value, value_size, ";", p);
397		✗	if (**p == ';')
398		✗	(*p)++;
399		✗	return 1;
400			}
401		✗	return 0;
402			}
403
404			typedef struct SDPParseState {
405			/* SDP only */
406			struct sockaddr_storage default_ip;
407			int default_ttl;
408			int skip_media; ///< set if an unknown m= line occurs
409			int nb_default_include_source_addrs; /**< Number of source-specific multicast include source IP address (from SDP content) */
410			struct RTSPSource **default_include_source_addrs; /**< Source-specific multicast include source IP address (from SDP content) */
411			int nb_default_exclude_source_addrs; /**< Number of source-specific multicast exclude source IP address (from SDP content) */
412			struct RTSPSource **default_exclude_source_addrs; /**< Source-specific multicast exclude source IP address (from SDP content) */
413			int seen_rtpmap;
414			int seen_fmtp;
415			char delayed_fmtp[2048];
416			} SDPParseState;
417
418		✗	static void copy_default_source_addrs(struct RTSPSource **addrs, int count,
419			struct RTSPSource ***dest, int *dest_count)
420			{
421			RTSPSource *rtsp_src, *rtsp_src2;
422			int i;
423		✗	for (i = 0; i < count; i++) {
424		✗	rtsp_src = addrs[i];
425		✗	rtsp_src2 = av_memdup(rtsp_src, sizeof(*rtsp_src));
426		✗	if (!rtsp_src2)
427		✗	continue;
428		✗	dynarray_add(dest, dest_count, rtsp_src2);
429			}
430		✗	}
431
432		✗	static void parse_fmtp(AVFormatContext *s, RTSPState *rt,
433			int payload_type, const char *line)
434			{
435			int i;
436
437		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
438		✗	RTSPStream *rtsp_st = rt->rtsp_streams[i];
439		✗	if (rtsp_st->sdp_payload_type == payload_type &&
440		✗	rtsp_st->dynamic_handler &&
441		✗	rtsp_st->dynamic_handler->parse_sdp_a_line) {
442		✗	rtsp_st->dynamic_handler->parse_sdp_a_line(s, rtsp_st->stream_index,
443			rtsp_st->dynamic_protocol_context, line);
444			}
445			}
446		✗	}
447
448		✗	static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
449			int letter, const char *buf)
450			{
451		✗	RTSPState *rt = s->priv_data;
452			char buf1[64], st_type[64];
453			const char *p;
454			enum AVMediaType codec_type;
455			int payload_type;
456			AVStream *st;
457			RTSPStream *rtsp_st;
458			RTSPSource *rtsp_src;
459			struct sockaddr_storage sdp_ip;
460			int ttl;
461
462		✗	av_log(s, AV_LOG_TRACE, "sdp: %c='%s'\n", letter, buf);
463
464		✗	p = buf;
465		✗	if (s1->skip_media && letter != 'm')
466		✗	return;
467		✗	switch (letter) {
468		✗	case 'c':
469		✗	get_word(buf1, sizeof(buf1), &p);
470		✗	if (strcmp(buf1, "IN") != 0)
471		✗	return;
472		✗	get_word(buf1, sizeof(buf1), &p);
473		✗	if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6"))
474		✗	return;
475		✗	get_word_sep(buf1, sizeof(buf1), "/", &p);
476		✗	if (get_sockaddr(s, buf1, &sdp_ip))
477		✗	return;
478		✗	ttl = 16;
479		✗	if (*p == '/') {
480		✗	p++;
481		✗	get_word_sep(buf1, sizeof(buf1), "/", &p);
482		✗	ttl = atoi(buf1);
483			}
484		✗	if (s->nb_streams == 0) {
485		✗	s1->default_ip = sdp_ip;
486		✗	s1->default_ttl = ttl;
487			} else {
488		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
489		✗	rtsp_st->sdp_ip = sdp_ip;
490		✗	rtsp_st->sdp_ttl = ttl;
491			}
492		✗	break;
493		✗	case 's':
494		✗	av_dict_set(&s->metadata, "title", p, 0);
495		✗	break;
496		✗	case 'i':
497		✗	if (s->nb_streams == 0) {
498		✗	av_dict_set(&s->metadata, "comment", p, 0);
499		✗	break;
500			}
501		✗	break;
502		✗	case 'm':
503			/* new stream */
504		✗	s1->skip_media = 0;
505		✗	s1->seen_fmtp = 0;
506		✗	s1->seen_rtpmap = 0;
507		✗	codec_type = AVMEDIA_TYPE_UNKNOWN;
508		✗	get_word(st_type, sizeof(st_type), &p);
509		✗	if (!strcmp(st_type, "audio")) {
510		✗	codec_type = AVMEDIA_TYPE_AUDIO;
511		✗	} else if (!strcmp(st_type, "video")) {
512		✗	codec_type = AVMEDIA_TYPE_VIDEO;
513		✗	} else if (!strcmp(st_type, "application")) {
514		✗	codec_type = AVMEDIA_TYPE_DATA;
515		✗	} else if (!strcmp(st_type, "text")) {
516		✗	codec_type = AVMEDIA_TYPE_SUBTITLE;
517			}
518		✗	if (codec_type == AVMEDIA_TYPE_UNKNOWN ||
519		✗	!(rt->media_type_mask & (1 << codec_type)) ||
520		✗	rt->nb_rtsp_streams >= s->max_streams
521			) {
522		✗	s1->skip_media = 1;
523		✗	return;
524			}
525		✗	rtsp_st = av_mallocz(sizeof(RTSPStream));
526		✗	if (!rtsp_st)
527		✗	return;
528		✗	rtsp_st->stream_index = -1;
529		✗	dynarray_add(&rt->rtsp_streams, &rt->nb_rtsp_streams, rtsp_st);
530
531		✗	rtsp_st->sdp_ip = s1->default_ip;
532		✗	rtsp_st->sdp_ttl = s1->default_ttl;
533
534		✗	copy_default_source_addrs(s1->default_include_source_addrs,
535			s1->nb_default_include_source_addrs,
536			&rtsp_st->include_source_addrs,
537			&rtsp_st->nb_include_source_addrs);
538		✗	copy_default_source_addrs(s1->default_exclude_source_addrs,
539			s1->nb_default_exclude_source_addrs,
540			&rtsp_st->exclude_source_addrs,
541			&rtsp_st->nb_exclude_source_addrs);
542
543		✗	get_word(buf1, sizeof(buf1), &p); /* port */
544		✗	rtsp_st->sdp_port = atoi(buf1);
545
546		✗	get_word(buf1, sizeof(buf1), &p); /* protocol */
547		✗	if (!strcmp(buf1, "udp"))
548		✗	rt->transport = RTSP_TRANSPORT_RAW;
549		✗	else if (strstr(buf1, "/AVPF") || strstr(buf1, "/SAVPF"))
550		✗	rtsp_st->feedback = 1;
551
552			/* XXX: handle list of formats */
553		✗	get_word(buf1, sizeof(buf1), &p); /* format list */
554		✗	rtsp_st->sdp_payload_type = atoi(buf1);
555
556		✗	if (!strcmp(ff_rtp_enc_name(rtsp_st->sdp_payload_type), "MP2T")) {
557			/* no corresponding stream */
558		✗	if (rt->transport == RTSP_TRANSPORT_RAW) {
559		✗	if (CONFIG_RTPDEC && !rt->ts)
560		✗	rt->ts = avpriv_mpegts_parse_open(s);
561			} else {
562			const RTPDynamicProtocolHandler *handler;
563		✗	handler = ff_rtp_handler_find_by_id(
564			rtsp_st->sdp_payload_type, AVMEDIA_TYPE_DATA);
565		✗	init_rtp_handler(handler, rtsp_st, NULL);
566		✗	finalize_rtp_handler_init(s, rtsp_st, NULL);
567			}
568		✗	} else if (rt->server_type == RTSP_SERVER_WMS &&
569			codec_type == AVMEDIA_TYPE_DATA) {
570			/* RTX stream, a stream that carries all the other actual
571			* audio/video streams. Don't expose this to the callers. */
572			} else {
573		✗	st = avformat_new_stream(s, NULL);
574		✗	if (!st)
575		✗	return;
576		✗	st->id = rt->nb_rtsp_streams - 1;
577		✗	rtsp_st->stream_index = st->index;
578		✗	st->codecpar->codec_type = codec_type;
579		✗	if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
580			const RTPDynamicProtocolHandler *handler;
581			/* if standard payload type, we can find the codec right now */
582		✗	ff_rtp_get_codec_info(st->codecpar, rtsp_st->sdp_payload_type);
583		✗	if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
584		✗	st->codecpar->sample_rate > 0)
585		✗	avpriv_set_pts_info(st, 32, 1, st->codecpar->sample_rate);
586			/* Even static payload types may need a custom depacketizer */
587		✗	handler = ff_rtp_handler_find_by_id(
588		✗	rtsp_st->sdp_payload_type, st->codecpar->codec_type);
589		✗	init_rtp_handler(handler, rtsp_st, st);
590		✗	finalize_rtp_handler_init(s, rtsp_st, st);
591			}
592		✗	if (rt->default_lang[0])
593		✗	av_dict_set(&st->metadata, "language", rt->default_lang, 0);
594			}
595			/* put a default control url */
596		✗	av_strlcpy(rtsp_st->control_url, rt->control_uri,
597			sizeof(rtsp_st->control_url));
598		✗	break;
599		✗	case 'a':
600		✗	if (av_strstart(p, "control:", &p)) {
601		✗	if (rt->nb_rtsp_streams == 0) {
602		✗	if (!strncmp(p, "rtsp://", 7))
603		✗	av_strlcpy(rt->control_uri, p,
604			sizeof(rt->control_uri));
605			} else {
606			char proto[32];
607			/* get the control url */
608		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
609
610			/* XXX: may need to add full url resolution */
611		✗	av_url_split(proto, sizeof(proto), NULL, 0, NULL, 0,
612			NULL, NULL, 0, p);
613		✗	if (proto[0] == '\0') {
614			/* relative control URL */
615		✗	size_t len = strlen(rtsp_st->control_url);
616		✗	if (len == 0 || rtsp_st->control_url[len - 1] != '/')
617		✗	av_strlcat(rtsp_st->control_url, "/",
618			sizeof(rtsp_st->control_url));
619		✗	av_strlcat(rtsp_st->control_url, p,
620			sizeof(rtsp_st->control_url));
621			} else
622		✗	av_strlcpy(rtsp_st->control_url, p,
623			sizeof(rtsp_st->control_url));
624			}
625		✗	} else if (av_strstart(p, "rtpmap:", &p) && s->nb_streams > 0) {
626			/* NOTE: rtpmap is only supported AFTER the 'm=' tag */
627		✗	get_word(buf1, sizeof(buf1), &p);
628		✗	payload_type = atoi(buf1);
629		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
630		✗	if (rtsp_st->stream_index >= 0) {
631		✗	st = s->streams[rtsp_st->stream_index];
632		✗	sdp_parse_rtpmap(s, st, rtsp_st, payload_type, p);
633			}
634		✗	s1->seen_rtpmap = 1;
635		✗	if (s1->seen_fmtp) {
636		✗	parse_fmtp(s, rt, payload_type, s1->delayed_fmtp);
637			}
638		✗	} else if (av_strstart(p, "fmtp:", &p) ||
639		✗	av_strstart(p, "framesize:", &p)) {
640			// let dynamic protocol handlers have a stab at the line.
641		✗	get_word(buf1, sizeof(buf1), &p);
642		✗	payload_type = atoi(buf1);
643		✗	if (s1->seen_rtpmap) {
644		✗	parse_fmtp(s, rt, payload_type, buf);
645			} else {
646		✗	s1->seen_fmtp = 1;
647		✗	av_strlcpy(s1->delayed_fmtp, buf, sizeof(s1->delayed_fmtp));
648			}
649		✗	} else if (av_strstart(p, "framerate:", &p) && s->nb_streams > 0) {
650			// RFC 8866
651			double framerate;
652		✗	if (av_sscanf(p, "%lf%c", &framerate, &(char){0}) == 1) {
653		✗	st = s->streams[s->nb_streams - 1];
654		✗	st->avg_frame_rate = av_d2q(framerate, INT_MAX);
655			}
656		✗	} else if (av_strstart(p, "ssrc:", &p) && s->nb_streams > 0) {
657		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
658		✗	get_word(buf1, sizeof(buf1), &p);
659		✗	rtsp_st->ssrc = strtoll(buf1, NULL, 10);
660		✗	} else if (av_strstart(p, "range:", &p)) {
661			int64_t start, end;
662
663			// this is so that seeking on a streamed file can work.
664		✗	rtsp_parse_range_npt(p, &start, &end);
665		✗	s->start_time = start;
666			/* AV_NOPTS_VALUE means live broadcast (and can't seek) */
667		✗	if (end != AV_NOPTS_VALUE)
668		✗	s->duration = end - start;
669		✗	} else if (av_strstart(p, "lang:", &p)) {
670		✗	if (s->nb_streams > 0) {
671		✗	get_word(buf1, sizeof(buf1), &p);
672		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
673		✗	if (rtsp_st->stream_index >= 0) {
674		✗	st = s->streams[rtsp_st->stream_index];
675		✗	av_dict_set(&st->metadata, "language", buf1, 0);
676			}
677			} else
678		✗	get_word(rt->default_lang, sizeof(rt->default_lang), &p);
679		✗	} else if (av_strstart(p, "IsRealDataType:integer;",&p)) {
680		✗	if (atoi(p) == 1)
681		✗	rt->transport = RTSP_TRANSPORT_RDT;
682		✗	} else if (av_strstart(p, "SampleRate:integer;", &p) &&
683		✗	s->nb_streams > 0) {
684			long sample_rate;
685
686		✗	errno = 0;
687		✗	sample_rate = strtol(p, NULL, 10);
688		✗	if (errno == ERANGE || sample_rate <= 0 || sample_rate > INT_MAX) {
689		✗	av_log(s, AV_LOG_WARNING,
690			"Invalid SampleRate %ld in SDP, ignoring\n", sample_rate);
691			} else {
692		✗	st = s->streams[s->nb_streams - 1];
693		✗	st->codecpar->sample_rate = sample_rate;
694			}
695		✗	} else if (av_strstart(p, "crypto:", &p) && s->nb_streams > 0) {
696			// RFC 4568
697		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
698		✗	get_word(buf1, sizeof(buf1), &p); // ignore tag
699		✗	get_word(rtsp_st->crypto_suite, sizeof(rtsp_st->crypto_suite), &p);
700		✗	p += strspn(p, SPACE_CHARS);
701		✗	if (av_strstart(p, "inline:", &p))
702		✗	get_word(rtsp_st->crypto_params, sizeof(rtsp_st->crypto_params), &p);
703		✗	} else if (av_strstart(p, "source-filter:", &p)) {
704		✗	int exclude = 0;
705		✗	get_word(buf1, sizeof(buf1), &p);
706		✗	if (strcmp(buf1, "incl") && strcmp(buf1, "excl"))
707		✗	return;
708		✗	exclude = !strcmp(buf1, "excl");
709
710		✗	get_word(buf1, sizeof(buf1), &p);
711		✗	if (strcmp(buf1, "IN") != 0)
712		✗	return;
713		✗	get_word(buf1, sizeof(buf1), &p);
714		✗	if (strcmp(buf1, "IP4") && strcmp(buf1, "IP6") && strcmp(buf1, "*"))
715		✗	return;
716			// not checking that the destination address actually matches or is wildcard
717		✗	get_word(buf1, sizeof(buf1), &p);
718
719		✗	while (*p != '\0') {
720		✗	rtsp_src = av_mallocz(sizeof(*rtsp_src));
721		✗	if (!rtsp_src)
722		✗	return;
723		✗	get_word(rtsp_src->addr, sizeof(rtsp_src->addr), &p);
724		✗	if (exclude) {
725		✗	if (s->nb_streams == 0) {
726		✗	dynarray_add(&s1->default_exclude_source_addrs, &s1->nb_default_exclude_source_addrs, rtsp_src);
727			} else {
728		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
729		✗	dynarray_add(&rtsp_st->exclude_source_addrs, &rtsp_st->nb_exclude_source_addrs, rtsp_src);
730			}
731			} else {
732		✗	if (s->nb_streams == 0) {
733		✗	dynarray_add(&s1->default_include_source_addrs, &s1->nb_default_include_source_addrs, rtsp_src);
734			} else {
735		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
736		✗	dynarray_add(&rtsp_st->include_source_addrs, &rtsp_st->nb_include_source_addrs, rtsp_src);
737			}
738			}
739			}
740			} else {
741		✗	if (rt->server_type == RTSP_SERVER_WMS)
742		✗	ff_wms_parse_sdp_a_line(s, p);
743		✗	if (s->nb_streams > 0) {
744		✗	rtsp_st = rt->rtsp_streams[rt->nb_rtsp_streams - 1];
745
746		✗	if (rt->server_type == RTSP_SERVER_REAL)
747		✗	ff_real_parse_sdp_a_line(s, rtsp_st->stream_index, p);
748
749		✗	if (rtsp_st->dynamic_handler &&
750		✗	rtsp_st->dynamic_handler->parse_sdp_a_line)
751		✗	rtsp_st->dynamic_handler->parse_sdp_a_line(s,
752			rtsp_st->stream_index,
753			rtsp_st->dynamic_protocol_context, buf);
754			}
755			}
756		✗	break;
757			}
758			}
759
760		✗	int ff_sdp_parse(AVFormatContext *s, const char *content)
761			{
762			const char *p;
763			int letter, i;
764			char buf[SDP_MAX_SIZE], *q;
765		✗	SDPParseState sdp_parse_state = { { 0 } }, *s1 = &sdp_parse_state;
766
767		✗	s->duration = AV_NOPTS_VALUE;
768
769		✗	p = content;
770			for (;;) {
771		✗	p += strspn(p, SPACE_CHARS);
772		✗	letter = *p;
773		✗	if (letter == '\0')
774		✗	break;
775		✗	p++;
776		✗	if (*p != '=')
777		✗	goto next_line;
778		✗	p++;
779			/* get the content */
780		✗	q = buf;
781		✗	while (*p != '\n' && *p != '\r' && *p != '\0') {
782		✗	if ((q - buf) < sizeof(buf) - 1)
783		✗	*q++ = *p;
784		✗	p++;
785			}
786		✗	*q = '\0';
787		✗	sdp_parse_line(s, s1, letter, buf);
788		✗	next_line:
789		✗	while (*p != '\n' && *p != '\0')
790		✗	p++;
791		✗	if (*p == '\n')
792		✗	p++;
793			}
794
795		✗	for (i = 0; i < s1->nb_default_include_source_addrs; i++)
796		✗	av_freep(&s1->default_include_source_addrs[i]);
797		✗	av_freep(&s1->default_include_source_addrs);
798		✗	for (i = 0; i < s1->nb_default_exclude_source_addrs; i++)
799		✗	av_freep(&s1->default_exclude_source_addrs[i]);
800		✗	av_freep(&s1->default_exclude_source_addrs);
801
802		✗	if (s->duration == AV_NOPTS_VALUE)
803		✗	s->ctx_flags |= AVFMTCTX_UNSEEKABLE;
804
805		✗	return 0;
806			}
807			#endif /* CONFIG_RTPDEC */
808
809		✗	void ff_rtsp_undo_setup(AVFormatContext *s, int send_packets)
810			{
811		✗	RTSPState *rt = s->priv_data;
812			int i;
813
814		✗	rt->stored_msg.expected_seq = -1;
815		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
816		✗	RTSPStream *rtsp_st = rt->rtsp_streams[i];
817		✗	if (!rtsp_st)
818		✗	continue;
819		✗	if (rtsp_st->transport_priv) {
820		✗	if (s->oformat) {
821		✗	AVFormatContext *rtpctx = rtsp_st->transport_priv;
822		✗	av_write_trailer(rtpctx);
823		✗	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
824		✗	if (CONFIG_RTSP_MUXER && rtpctx->pb && send_packets)
825		✗	ff_rtsp_tcp_write_packet(s, rtsp_st);
826		✗	ffio_free_dyn_buf(&rtpctx->pb);
827			} else {
828		✗	avio_closep(&rtpctx->pb);
829			}
830		✗	avformat_free_context(rtpctx);
831		✗	} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT)
832		✗	ff_rdt_parse_close(rtsp_st->transport_priv);
833		✗	else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP)
834		✗	ff_rtp_parse_close(rtsp_st->transport_priv);
835			}
836		✗	rtsp_st->transport_priv = NULL;
837		✗	ffurl_closep(&rtsp_st->rtp_handle);
838			}
839		✗	}
840
841			/* close and free RTSP streams */
842		✗	void ff_rtsp_close_streams(AVFormatContext *s)
843			{
844		✗	RTSPState *rt = s->priv_data;
845			int i, j;
846			RTSPStream *rtsp_st;
847
848		✗	ff_rtsp_undo_setup(s, 0);
849		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
850		✗	rtsp_st = rt->rtsp_streams[i];
851		✗	if (rtsp_st) {
852		✗	if (rtsp_st->dynamic_handler && rtsp_st->dynamic_protocol_context) {
853		✗	if (rtsp_st->dynamic_handler->close)
854		✗	rtsp_st->dynamic_handler->close(
855		✗	rtsp_st->dynamic_protocol_context);
856		✗	av_free(rtsp_st->dynamic_protocol_context);
857			}
858		✗	for (j = 0; j < rtsp_st->nb_include_source_addrs; j++)
859		✗	av_freep(&rtsp_st->include_source_addrs[j]);
860		✗	av_freep(&rtsp_st->include_source_addrs);
861		✗	for (j = 0; j < rtsp_st->nb_exclude_source_addrs; j++)
862		✗	av_freep(&rtsp_st->exclude_source_addrs[j]);
863		✗	av_freep(&rtsp_st->exclude_source_addrs);
864
865		✗	av_freep(&rtsp_st);
866			}
867			}
868		✗	av_freep(&rt->rtsp_streams);
869		✗	if (rt->asf_ctx) {
870		✗	avformat_close_input(&rt->asf_ctx);
871			}
872		✗	if (CONFIG_RTPDEC && rt->ts)
873		✗	avpriv_mpegts_parse_close(rt->ts);
874		✗	av_freep(&rt->p);
875		✗	av_freep(&rt->recvbuf);
876		✗	}
877
878		✗	int ff_rtsp_open_transport_ctx(AVFormatContext *s, RTSPStream *rtsp_st)
879			{
880		✗	RTSPState *rt = s->priv_data;
881		✗	AVStream *st = NULL;
882		✗	int reordering_queue_size = rt->reordering_queue_size;
883		✗	if (reordering_queue_size < 0) {
884		✗	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_TCP || !s->max_delay)
885		✗	reordering_queue_size = 0;
886			else
887		✗	reordering_queue_size = RTP_REORDER_QUEUE_DEFAULT_SIZE;
888			}
889
890			/* open the RTP context */
891		✗	if (rtsp_st->stream_index >= 0)
892		✗	st = s->streams[rtsp_st->stream_index];
893		✗	if (!st)
894		✗	s->ctx_flags |= AVFMTCTX_NOHEADER;
895
896		✗	if (CONFIG_RTSP_MUXER && s->oformat && st) {
897		✗	int ret = ff_rtp_chain_mux_open((AVFormatContext **)&rtsp_st->transport_priv,
898			s, st, rtsp_st->rtp_handle,
899			rt->pkt_size,
900			rtsp_st->stream_index);
901			/* Ownership of rtp_handle is passed to the rtp mux context */
902		✗	rtsp_st->rtp_handle = NULL;
903		✗	if (ret < 0)
904		✗	return ret;
905		✗	st->time_base = ((AVFormatContext*)rtsp_st->transport_priv)->streams[0]->time_base;
906		✗	} else if (rt->transport == RTSP_TRANSPORT_RAW) {
907		✗	return 0; // Don't need to open any parser here
908		✗	} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RDT && st)
909		✗	rtsp_st->transport_priv = ff_rdt_parse_open(s, st->index,
910		✗	rtsp_st->dynamic_protocol_context,
911			rtsp_st->dynamic_handler);
912			else if (CONFIG_RTPDEC)
913		✗	rtsp_st->transport_priv = ff_rtp_parse_open(s, st,
914			rtsp_st->sdp_payload_type,
915			reordering_queue_size);
916
917		✗	if (!rtsp_st->transport_priv) {
918		✗	return AVERROR(ENOMEM);
919		✗	} else if (CONFIG_RTPDEC && rt->transport == RTSP_TRANSPORT_RTP &&
920		✗	s->iformat) {
921		✗	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
922		✗	rtpctx->ssrc = rtsp_st->ssrc;
923		✗	if (rtsp_st->dynamic_handler) {
924		✗	ff_rtp_parse_set_dynamic_protocol(rtsp_st->transport_priv,
925			rtsp_st->dynamic_protocol_context,
926			rtsp_st->dynamic_handler);
927			}
928		✗	if (rtsp_st->crypto_suite[0]) {
929		✗	int ret = ff_rtp_parse_set_crypto(rtsp_st->transport_priv,
930		✗	rtsp_st->crypto_suite,
931		✗	rtsp_st->crypto_params);
932		✗	if (ret < 0) {
933		✗	av_log(s, AV_LOG_ERROR,
934			"SRTP setup failed for suite '%s'\n",
935		✗	rtsp_st->crypto_suite);
936		✗	return ret;
937			}
938			}
939			}
940
941		✗	return 0;
942			}
943
944			#if CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER
945		✗	static void rtsp_parse_range(int *min_ptr, int *max_ptr, const char **pp)
946			{
947			const char *q;
948			char *p;
949			int v;
950
951		✗	q = *pp;
952		✗	q += strspn(q, SPACE_CHARS);
953		✗	v = strtol(q, &p, 10);
954		✗	if (*p == '-') {
955		✗	p++;
956		✗	*min_ptr = v;
957		✗	v = strtol(p, &p, 10);
958		✗	*max_ptr = v;
959			} else {
960		✗	*min_ptr = v;
961		✗	*max_ptr = v;
962			}
963		✗	*pp = p;
964		✗	}
965
966			/* XXX: only one transport specification is parsed */
967		✗	static void rtsp_parse_transport(AVFormatContext *s,
968			RTSPMessageHeader *reply, const char *p)
969			{
970			char transport_protocol[16];
971			char profile[16];
972			char lower_transport[16];
973			char parameter[16];
974			RTSPTransportField *th;
975			char buf[256];
976
977		✗	reply->nb_transports = 0;
978
979			for (;;) {
980		✗	p += strspn(p, SPACE_CHARS);
981		✗	if (*p == '\0')
982		✗	break;
983
984		✗	th = &reply->transports[reply->nb_transports];
985
986		✗	get_word_sep(transport_protocol, sizeof(transport_protocol),
987			"/", &p);
988		✗	if (!av_strcasecmp (transport_protocol, "rtp")) {
989		✗	get_word_sep(profile, sizeof(profile), "/;,", &p);
990		✗	lower_transport[0] = '\0';
991			/* rtp/avp/<protocol> */
992		✗	if (*p == '/') {
993		✗	get_word_sep(lower_transport, sizeof(lower_transport),
994			";,", &p);
995			}
996		✗	th->transport = RTSP_TRANSPORT_RTP;
997		✗	} else if (!av_strcasecmp (transport_protocol, "x-pn-tng") ||
998		✗	!av_strcasecmp (transport_protocol, "x-real-rdt")) {
999			/* x-pn-tng/<protocol> */
1000		✗	get_word_sep(lower_transport, sizeof(lower_transport), "/;,", &p);
1001		✗	profile[0] = '\0';
1002		✗	th->transport = RTSP_TRANSPORT_RDT;
1003		✗	} else if (!av_strcasecmp(transport_protocol, "raw")) {
1004		✗	get_word_sep(profile, sizeof(profile), "/;,", &p);
1005		✗	lower_transport[0] = '\0';
1006			/* raw/raw/<protocol> */
1007		✗	if (*p == '/') {
1008		✗	get_word_sep(lower_transport, sizeof(lower_transport),
1009			";,", &p);
1010			}
1011		✗	th->transport = RTSP_TRANSPORT_RAW;
1012			} else {
1013		✗	break;
1014			}
1015		✗	if (!av_strcasecmp(lower_transport, "TCP"))
1016		✗	th->lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1017			else
1018		✗	th->lower_transport = RTSP_LOWER_TRANSPORT_UDP;
1019
1020		✗	if (*p == ';')
1021		✗	p++;
1022			/* get each parameter */
1023		✗	while (*p != '\0' && *p != ',') {
1024		✗	get_word_sep(parameter, sizeof(parameter), "=;,", &p);
1025		✗	if (!strcmp(parameter, "port")) {
1026		✗	if (*p == '=') {
1027		✗	p++;
1028		✗	rtsp_parse_range(&th->port_min, &th->port_max, &p);
1029			}
1030		✗	} else if (!strcmp(parameter, "client_port")) {
1031		✗	if (*p == '=') {
1032		✗	p++;
1033		✗	rtsp_parse_range(&th->client_port_min,
1034			&th->client_port_max, &p);
1035			}
1036		✗	} else if (!strcmp(parameter, "server_port")) {
1037		✗	if (*p == '=') {
1038		✗	p++;
1039		✗	rtsp_parse_range(&th->server_port_min,
1040			&th->server_port_max, &p);
1041			}
1042		✗	} else if (!strcmp(parameter, "interleaved")) {
1043		✗	if (*p == '=') {
1044		✗	p++;
1045		✗	rtsp_parse_range(&th->interleaved_min,
1046			&th->interleaved_max, &p);
1047			}
1048		✗	} else if (!strcmp(parameter, "multicast")) {
1049		✗	if (th->lower_transport == RTSP_LOWER_TRANSPORT_UDP)
1050		✗	th->lower_transport = RTSP_LOWER_TRANSPORT_UDP_MULTICAST;
1051		✗	} else if (!strcmp(parameter, "ttl")) {
1052		✗	if (*p == '=') {
1053			char *end;
1054		✗	p++;
1055		✗	th->ttl = strtol(p, &end, 10);
1056		✗	p = end;
1057			}
1058		✗	} else if (!strcmp(parameter, "destination")) {
1059		✗	if (*p == '=') {
1060		✗	p++;
1061		✗	get_word_sep(buf, sizeof(buf), ";,", &p);
1062		✗	get_sockaddr(s, buf, &th->destination);
1063			}
1064		✗	} else if (!strcmp(parameter, "source")) {
1065		✗	if (*p == '=') {
1066		✗	p++;
1067		✗	get_word_sep(buf, sizeof(buf), ";,", &p);
1068		✗	av_strlcpy(th->source, buf, sizeof(th->source));
1069			}
1070		✗	} else if (!strcmp(parameter, "mode")) {
1071		✗	if (*p == '=') {
1072		✗	p++;
1073		✗	get_word_sep(buf, sizeof(buf), ";, ", &p);
1074		✗	if (!av_strcasecmp(buf, "record") ||
1075		✗	!av_strcasecmp(buf, "receive"))
1076		✗	th->mode_record = 1;
1077			}
1078			}
1079
1080		✗	while (*p != ';' && *p != '\0' && *p != ',')
1081		✗	p++;
1082		✗	if (*p == ';')
1083		✗	p++;
1084			}
1085		✗	if (*p == ',')
1086		✗	p++;
1087
1088		✗	reply->nb_transports++;
1089		✗	if (reply->nb_transports >= RTSP_MAX_TRANSPORTS)
1090		✗	break;
1091			}
1092		✗	}
1093
1094		✗	static void handle_rtp_info(RTSPState *rt, const char *url,
1095			uint32_t seq, uint32_t rtptime)
1096			{
1097			int i;
1098		✗	if (!rtptime || !url[0])
1099		✗	return;
1100		✗	if (rt->transport != RTSP_TRANSPORT_RTP)
1101		✗	return;
1102		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
1103		✗	RTSPStream *rtsp_st = rt->rtsp_streams[i];
1104		✗	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
1105		✗	if (!rtpctx)
1106		✗	continue;
1107		✗	if (!strcmp(rtsp_st->control_url, url)) {
1108		✗	rtpctx->base_timestamp = rtptime;
1109		✗	break;
1110			}
1111			}
1112			}
1113
1114		✗	static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
1115			{
1116		✗	int read = 0;
1117		✗	char key[20], value[MAX_URL_SIZE], url[MAX_URL_SIZE] = "";
1118		✗	uint32_t seq = 0, rtptime = 0;
1119
1120			for (;;) {
1121		✗	p += strspn(p, SPACE_CHARS);
1122		✗	if (!*p)
1123		✗	break;
1124		✗	get_word_sep(key, sizeof(key), "=", &p);
1125		✗	if (*p != '=')
1126		✗	break;
1127		✗	p++;
1128		✗	get_word_sep(value, sizeof(value), ";, ", &p);
1129		✗	read++;
1130		✗	if (!strcmp(key, "url"))
1131		✗	av_strlcpy(url, value, sizeof(url));
1132		✗	else if (!strcmp(key, "seq"))
1133		✗	seq = strtoul(value, NULL, 10);
1134		✗	else if (!strcmp(key, "rtptime"))
1135		✗	rtptime = strtoul(value, NULL, 10);
1136		✗	if (*p == ',') {
1137		✗	handle_rtp_info(rt, url, seq, rtptime);
1138		✗	url[0] = '\0';
1139		✗	seq = rtptime = 0;
1140		✗	read = 0;
1141			}
1142		✗	if (*p)
1143		✗	p++;
1144			}
1145		✗	if (read > 0)
1146		✗	handle_rtp_info(rt, url, seq, rtptime);
1147		✗	}
1148
1149		✗	void ff_rtsp_parse_line(AVFormatContext *s,
1150			RTSPMessageHeader *reply, const char *buf,
1151			RTSPState *rt, const char *method)
1152			{
1153			const char *p;
1154
1155			/* NOTE: we do case independent match for broken servers */
1156		✗	p = buf;
1157		✗	if (av_stristart(p, "Session:", &p)) {
1158			int t;
1159		✗	get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
1160		✗	if (av_stristart(p, ";timeout=", &p) &&
1161		✗	(t = strtol(p, NULL, 10)) > 0) {
1162		✗	reply->timeout = t;
1163			}
1164		✗	} else if (av_stristart(p, "Content-Length:", &p)) {
1165		✗	reply->content_length = strtol(p, NULL, 10);
1166		✗	} else if (av_stristart(p, "Transport:", &p)) {
1167		✗	rtsp_parse_transport(s, reply, p);
1168		✗	} else if (av_stristart(p, "CSeq:", &p)) {
1169		✗	reply->seq = strtol(p, NULL, 10);
1170		✗	} else if (av_stristart(p, "Range:", &p)) {
1171		✗	rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
1172		✗	} else if (av_stristart(p, "RealChallenge1:", &p)) {
1173		✗	p += strspn(p, SPACE_CHARS);
1174		✗	av_strlcpy(reply->real_challenge, p, sizeof(reply->real_challenge));
1175		✗	} else if (av_stristart(p, "Server:", &p)) {
1176		✗	p += strspn(p, SPACE_CHARS);
1177		✗	av_strlcpy(reply->server, p, sizeof(reply->server));
1178		✗	} else if (av_stristart(p, "Notice:", &p) ||
1179		✗	av_stristart(p, "X-Notice:", &p)) {
1180		✗	reply->notice = strtol(p, NULL, 10);
1181		✗	} else if (av_stristart(p, "Location:", &p)) {
1182		✗	p += strspn(p, SPACE_CHARS);
1183		✗	av_strlcpy(reply->location, p , sizeof(reply->location));
1184		✗	} else if (av_stristart(p, "WWW-Authenticate:", &p) && rt) {
1185		✗	p += strspn(p, SPACE_CHARS);
1186		✗	ff_http_auth_handle_header(&rt->auth_state, "WWW-Authenticate", p);
1187		✗	} else if (av_stristart(p, "Authentication-Info:", &p) && rt) {
1188		✗	p += strspn(p, SPACE_CHARS);
1189		✗	ff_http_auth_handle_header(&rt->auth_state, "Authentication-Info", p);
1190		✗	} else if (av_stristart(p, "Content-Base:", &p) && rt) {
1191		✗	p += strspn(p, SPACE_CHARS);
1192		✗	if (method && !strcmp(method, "DESCRIBE"))
1193		✗	av_strlcpy(rt->control_uri, p , sizeof(rt->control_uri));
1194		✗	} else if (av_stristart(p, "RTP-Info:", &p) && rt) {
1195		✗	p += strspn(p, SPACE_CHARS);
1196		✗	if (method && !strcmp(method, "PLAY"))
1197		✗	rtsp_parse_rtp_info(rt, p);
1198		✗	} else if (av_stristart(p, "Public:", &p) && rt) {
1199		✗	if (strstr(p, "GET_PARAMETER") &&
1200		✗	method && !strcmp(method, "OPTIONS"))
1201		✗	rt->get_parameter_supported = 1;
1202		✗	} else if (av_stristart(p, "x-Accept-Dynamic-Rate:", &p) && rt) {
1203		✗	p += strspn(p, SPACE_CHARS);
1204		✗	rt->accept_dynamic_rate = atoi(p);
1205		✗	} else if (av_stristart(p, "Content-Type:", &p)) {
1206		✗	p += strspn(p, SPACE_CHARS);
1207		✗	av_strlcpy(reply->content_type, p, sizeof(reply->content_type));
1208		✗	} else if (av_stristart(p, "com.ses.streamID:", &p)) {
1209		✗	p += strspn(p, SPACE_CHARS);
1210		✗	av_strlcpy(reply->stream_id, p, sizeof(reply->stream_id));
1211			}
1212		✗	}
1213
1214			/* skip a RTP/TCP interleaved packet */
1215		✗	int ff_rtsp_skip_packet(AVFormatContext *s)
1216			{
1217		✗	RTSPState *rt = s->priv_data;
1218			int ret, len, len1;
1219			uint8_t buf[MAX_URL_SIZE];
1220
1221		✗	rt->pending_packet = 0;
1222		✗	ret = ffurl_read_complete(rt->rtsp_hd, buf, 3);
1223		✗	if (ret != 3)
1224		✗	return ret < 0 ? ret : AVERROR(EIO);
1225		✗	len = AV_RB16(buf + 1);
1226
1227		✗	av_log(s, AV_LOG_TRACE, "skipping RTP packet len=%d\n", len);
1228
1229			/* skip payload */
1230		✗	while (len > 0) {
1231		✗	len1 = len;
1232		✗	if (len1 > sizeof(buf))
1233		✗	len1 = sizeof(buf);
1234		✗	ret = ffurl_read_complete(rt->rtsp_hd, buf, len1);
1235		✗	if (ret != len1)
1236		✗	return ret < 0 ? ret : AVERROR(EIO);
1237		✗	len -= len1;
1238			}
1239
1240		✗	return 0;
1241			}
1242
1243		✗	static int ff_rtsp_read_reply_internal(AVFormatContext *s,
1244			RTSPMessageHeader *reply,
1245			unsigned char **content_ptr,
1246			int return_on_interleaved_data,
1247			const char *method)
1248			{
1249		✗	RTSPState *rt = s->priv_data;
1250			char buf[MAX_URL_SIZE], buf1[MAX_URL_SIZE], *q;
1251			unsigned char ch;
1252			const char *p;
1253			int ret, content_length, line_count, request;
1254			unsigned char *content;
1255
1256		✗	start:
1257		✗	line_count = 0;
1258		✗	request = 0;
1259		✗	content = NULL;
1260		✗	memset(reply, 0, sizeof(*reply));
1261
1262			/* parse reply (XXX: use buffers) */
1263		✗	rt->last_reply[0] = '\0';
1264			for (;;) {
1265		✗	q = buf;
1266			for (;;) {
1267		✗	ret = ffurl_read_complete(rt->rtsp_hd, &ch, 1);
1268		✗	if (ret != 1) {
1269		✗	ret = (ret < 0) ? ret : AVERROR(EIO);
1270		✗	av_log(s, AV_LOG_WARNING, "Failed reading RTSP data: %s\n", av_err2str(ret));
1271		✗	return ret;
1272			}
1273		✗	av_log(s, AV_LOG_TRACE, "ret=%d c=%02x [%c]\n", ret, ch, ch);
1274		✗	if (ch == '\n')
1275		✗	break;
1276		✗	if (ch == '$' && q == buf) {
1277		✗	if (return_on_interleaved_data) {
1278		✗	rt->pending_packet = 1;
1279		✗	return 1;
1280			} else {
1281		✗	ret = ff_rtsp_skip_packet(s);
1282		✗	if (ret < 0)
1283		✗	return ret;
1284			}
1285		✗	} else if (ch != '\r') {
1286		✗	if ((q - buf) < sizeof(buf) - 1)
1287		✗	*q++ = ch;
1288			}
1289			}
1290		✗	*q = '\0';
1291
1292		✗	av_log(s, AV_LOG_TRACE, "line='%s'\n", buf);
1293
1294			/* test if last line */
1295		✗	if (buf[0] == '\0')
1296		✗	break;
1297		✗	p = buf;
1298		✗	if (line_count == 0) {
1299			/* get reply code */
1300		✗	get_word(buf1, sizeof(buf1), &p);
1301		✗	if (!strncmp(buf1, "RTSP/", 5)) {
1302		✗	get_word(buf1, sizeof(buf1), &p);
1303		✗	reply->status_code = atoi(buf1);
1304		✗	p += strspn(p, SPACE_CHARS);
1305		✗	av_strlcpy(reply->reason, p, sizeof(reply->reason));
1306			} else {
1307		✗	av_strlcpy(reply->reason, buf1, sizeof(reply->reason)); // method
1308		✗	get_word(buf1, sizeof(buf1), &p); // object
1309		✗	request = 1;
1310			}
1311			} else {
1312		✗	ff_rtsp_parse_line(s, reply, p, rt, method);
1313		✗	av_strlcat(rt->last_reply, p, sizeof(rt->last_reply));
1314		✗	av_strlcat(rt->last_reply, "\n", sizeof(rt->last_reply));
1315			}
1316		✗	line_count++;
1317			}
1318
1319		✗	if (rt->session_id[0] == '\0' && reply->session_id[0] != '\0' && !request)
1320		✗	av_strlcpy(rt->session_id, reply->session_id, sizeof(rt->session_id));
1321
1322		✗	content_length = reply->content_length;
1323		✗	if (content_length > 0) {
1324			/* leave some room for a trailing '\0' (useful for simple parsing) */
1325		✗	content = av_malloc(content_length + 1);
1326		✗	if (!content)
1327		✗	return AVERROR(ENOMEM);
1328		✗	if ((ret = ffurl_read_complete(rt->rtsp_hd, content, content_length)) != content_length) {
1329		✗	av_freep(&content);
1330		✗	return ret < 0 ? ret : AVERROR(EIO);
1331			}
1332		✗	content[content_length] = '\0';
1333			}
1334		✗	if (content_ptr)
1335		✗	*content_ptr = content;
1336			else
1337		✗	av_freep(&content);
1338
1339		✗	if (request) {
1340			char buf[MAX_URL_SIZE];
1341			char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1342		✗	const char* ptr = buf;
1343
1344		✗	if (!strcmp(reply->reason, "OPTIONS") ||
1345		✗	!strcmp(reply->reason, "GET_PARAMETER")) {
1346		✗	snprintf(buf, sizeof(buf), "RTSP/1.0 200 OK\r\n");
1347		✗	if (reply->seq)
1348		✗	av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", reply->seq);
1349		✗	if (reply->session_id[0])
1350		✗	av_strlcatf(buf, sizeof(buf), "Session: %s\r\n",
1351		✗	reply->session_id);
1352			} else {
1353		✗	snprintf(buf, sizeof(buf), "RTSP/1.0 501 Not Implemented\r\n");
1354			}
1355		✗	av_strlcat(buf, "\r\n", sizeof(buf));
1356
1357		✗	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1358		✗	av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1359		✗	ptr = base64buf;
1360			}
1361		✗	ffurl_write(rt->rtsp_hd_out, ptr, strlen(ptr));
1362
1363		✗	rt->last_cmd_time = av_gettime_relative();
1364			/* Even if the request from the server had data, it is not the data
1365			* that the caller wants or expects. The memory could also be leaked
1366			* if the actual following reply has content data. */
1367		✗	if (content_ptr)
1368		✗	av_freep(content_ptr);
1369			/* If method is set, this is called from ff_rtsp_send_cmd,
1370			* where a reply to exactly this request is awaited. For
1371			* callers from within packet receiving, we just want to
1372			* return to the caller and go back to receiving packets. */
1373		✗	if (method)
1374		✗	goto start;
1375		✗	return 0;
1376			}
1377
1378		✗	if (rt->seq != reply->seq) {
1379		✗	av_log(s, AV_LOG_WARNING, "CSeq %d expected, %d received.\n",
1380			rt->seq, reply->seq);
1381			/* At close time, drain stale async replies - e.g. queued keepalive
1382			* OPTIONS or GET_PARAMETER responses - until the expected CSeq shows
1383			* up. Otherwise ff_rtsp_send_cmd("TEARDOWN") in rtsp_read_close()
1384			* is satisfied by a queued keepalive reply, leaving the TEARDOWN
1385			* 200 OK unread so the server never frees the session. Only done
1386			* while teardown_deadline bounds the wait; every other synchronous
1387			* command keeps accepting a mismatching reply. */
1388		✗	if (rt->teardown_deadline) {
1389		✗	if (content_ptr)
1390		✗	av_freep(content_ptr);
1391		✗	goto start;
1392			}
1393			}
1394
1395			/* EOS */
1396		✗	if (reply->notice == 2101 /* End-of-Stream Reached */ ||
1397		✗	reply->notice == 2104 /* Start-of-Stream Reached */ ||
1398		✗	reply->notice == 2306 /* Continuous Feed Terminated */) {
1399		✗	rt->state = RTSP_STATE_IDLE;
1400		✗	} else if (reply->notice >= 4400 && reply->notice < 5500) {
1401		✗	return AVERROR(EIO); /* data or server error */
1402		✗	} else if (reply->notice == 2401 /* Ticket Expired */ ||
1403		✗	(reply->notice >= 5500 && reply->notice < 5600) /* end of term */ )
1404		✗	return AVERROR(EPERM);
1405
1406		✗	return 0;
1407			}
1408
1409		✗	int ff_rtsp_read_reply(AVFormatContext *s, RTSPMessageHeader *reply,
1410			unsigned char **content_ptr,
1411			int return_on_interleaved_data, const char *method)
1412			{
1413			int ret;
1414		✗	RTSPState *rt = s->priv_data;
1415
1416			// If we returned on pending packet last time,
1417			// do not try to read again, as it would corrupt
1418			// the state due to the already consumed '$'.
1419		✗	if (rt->pending_packet) {
1420		✗	if (return_on_interleaved_data)
1421		✗	return 1;
1422
1423		✗	ret = ff_rtsp_skip_packet(s);
1424		✗	if (ret < 0)
1425		✗	return ret;
1426			}
1427
1428		✗	if (rt->stored_msg.expected_seq != -1) {
1429			RTSPMessageHeader header;
1430
1431		✗	ret = ff_rtsp_read_reply_internal(s, &header,
1432			&rt->stored_msg.body, return_on_interleaved_data, NULL);
1433		✗	if (ret != 0)
1434		✗	return ret;
1435
1436		✗	if (rt->stored_msg.expected_seq == header.seq) {
1437			// Got the expected reply, store it for later
1438		✗	rt->stored_msg.expected_seq = -1;
1439		✗	rt->stored_msg.header = av_calloc(1, sizeof(*rt->stored_msg.header));
1440		✗	if (!rt->stored_msg.header) {
1441		✗	av_freep(&rt->stored_msg.body);
1442		✗	return AVERROR(ENOMEM);
1443			}
1444		✗	memcpy(rt->stored_msg.header, &header, sizeof(header));
1445			} else {
1446		✗	av_log(s, AV_LOG_WARNING, "Unexpected reply with seq %d, expected %d\n",
1447			header.seq, rt->stored_msg.expected_seq);
1448		✗	av_freep(&rt->stored_msg.body);
1449			}
1450
1451			// Do not return here as we still need to read the reply
1452			// the caller was actually wanting to retrieve.
1453			}
1454
1455		✗	return ff_rtsp_read_reply_internal(s, reply, content_ptr,
1456			return_on_interleaved_data, method);
1457			}
1458
1459			/**
1460			* Send a command to the RTSP server without waiting for the reply.
1461			*
1462			* @param s RTSP (de)muxer context
1463			* @param method the method for the request
1464			* @param url the target url for the request
1465			* @param headers extra header lines to include in the request
1466			* @param send_content if non-null, the data to send as request body content
1467			* @param send_content_length the length of the send_content data, or 0 if
1468			* send_content is null
1469			*
1470			* @return zero if success, nonzero otherwise
1471			*/
1472		✗	int ff_rtsp_send_cmd_with_content_async(AVFormatContext *s,
1473			const char *method, const char *url,
1474			const char *headers,
1475			const unsigned char *send_content,
1476			int send_content_length)
1477			{
1478		✗	RTSPState *rt = s->priv_data;
1479			char buf[MAX_URL_SIZE], *out_buf;
1480			char base64buf[AV_BASE64_SIZE(sizeof(buf))];
1481
1482		✗	if (!rt->rtsp_hd_out)
1483		✗	return AVERROR(ENOTCONN);
1484
1485			/* Add in RTSP headers */
1486		✗	out_buf = buf;
1487		✗	rt->seq++;
1488		✗	snprintf(buf, sizeof(buf), "%s %s RTSP/1.0\r\n", method, url);
1489		✗	if (headers)
1490		✗	av_strlcat(buf, headers, sizeof(buf));
1491		✗	av_strlcatf(buf, sizeof(buf), "CSeq: %d\r\n", rt->seq);
1492		✗	av_strlcatf(buf, sizeof(buf), "User-Agent: %s\r\n", rt->user_agent);
1493		✗	if (rt->session_id[0] != '\0' && (!headers ||
1494		✗	!strstr(headers, "\nIf-Match:"))) {
1495		✗	av_strlcatf(buf, sizeof(buf), "Session: %s\r\n", rt->session_id);
1496			}
1497		✗	if (rt->auth[0]) {
1498		✗	char *str = ff_http_auth_create_response(&rt->auth_state,
1499		✗	rt->auth, url, method);
1500		✗	if (str)
1501		✗	av_strlcat(buf, str, sizeof(buf));
1502		✗	av_free(str);
1503			}
1504		✗	if (send_content_length > 0 && send_content)
1505		✗	av_strlcatf(buf, sizeof(buf), "Content-Length: %d\r\n", send_content_length);
1506		✗	av_strlcat(buf, "\r\n", sizeof(buf));
1507
1508			/* base64 encode rtsp if tunneling */
1509		✗	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1510		✗	av_base64_encode(base64buf, sizeof(base64buf), buf, strlen(buf));
1511		✗	out_buf = base64buf;
1512			}
1513
1514		✗	av_log(s, AV_LOG_TRACE, "Sending:\n%s--\n", buf);
1515
1516		✗	ffurl_write(rt->rtsp_hd_out, out_buf, strlen(out_buf));
1517		✗	if (send_content_length > 0 && send_content) {
1518		✗	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1519		✗	avpriv_report_missing_feature(s, "Tunneling of RTSP requests with content data");
1520		✗	return AVERROR_PATCHWELCOME;
1521			}
1522		✗	ffurl_write(rt->rtsp_hd_out, send_content, send_content_length);
1523			}
1524		✗	rt->last_cmd_time = av_gettime_relative();
1525
1526		✗	return 0;
1527			}
1528
1529		✗	int ff_rtsp_send_cmd_with_content_async_stored(AVFormatContext *s,
1530			const char *method, const char *url,
1531			const char *headers,
1532			const unsigned char *send_content,
1533			int send_content_length)
1534			{
1535		✗	RTSPState *rt = s->priv_data;
1536		✗	int ret = ff_rtsp_send_cmd_with_content_async(s, method, url, headers,
1537			send_content, send_content_length);
1538		✗	if (ret < 0)
1539		✗	return ret;
1540
1541		✗	rt->stored_msg.expected_seq = rt->seq;
1542		✗	av_freep(&rt->stored_msg.header);
1543		✗	av_freep(&rt->stored_msg.body);
1544		✗	return 0;
1545			}
1546
1547		✗	int ff_rtsp_send_cmd_async(AVFormatContext *s, const char *method,
1548			const char *url, const char *headers)
1549			{
1550		✗	return ff_rtsp_send_cmd_with_content_async(s, method, url, headers, NULL, 0);
1551			}
1552
1553		✗	int ff_rtsp_send_cmd(AVFormatContext *s, const char *method, const char *url,
1554			const char *headers, RTSPMessageHeader *reply,
1555			unsigned char **content_ptr)
1556			{
1557		✗	return ff_rtsp_send_cmd_with_content(s, method, url, headers, reply,
1558			content_ptr, NULL, 0);
1559			}
1560
1561		✗	int ff_rtsp_send_cmd_with_content(AVFormatContext *s,
1562			const char *method, const char *url,
1563			const char *header,
1564			RTSPMessageHeader *reply,
1565			unsigned char **content_ptr,
1566			const unsigned char *send_content,
1567			int send_content_length)
1568			{
1569		✗	RTSPState *rt = s->priv_data;
1570			HTTPAuthType cur_auth_type;
1571		✗	int ret, attempts = 0;
1572
1573		✗	retry:
1574		✗	cur_auth_type = rt->auth_state.auth_type;
1575		✗	if ((ret = ff_rtsp_send_cmd_with_content_async(s, method, url, header,
1576			send_content,
1577			send_content_length)) < 0)
1578		✗	return ret;
1579
1580		✗	if ((ret = ff_rtsp_read_reply(s, reply, content_ptr, 0, method) ) < 0)
1581		✗	return ret;
1582		✗	attempts++;
1583
1584		✗	if (reply->status_code == 401 &&
1585		✗	(cur_auth_type == HTTP_AUTH_NONE || rt->auth_state.stale) &&
1586		✗	rt->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2)
1587		✗	goto retry;
1588
1589		✗	if (reply->status_code > 400){
1590		✗	av_log(s, AV_LOG_ERROR, "method %s failed: %d (%s)\n",
1591			method,
1592		✗	reply->status_code,
1593		✗	reply->reason);
1594		✗	av_log(s, AV_LOG_DEBUG, "%s\n", rt->last_reply);
1595			}
1596
1597		✗	return 0;
1598			}
1599
1600		✗	int ff_rtsp_read_reply_async_stored(AVFormatContext *s, RTSPMessageHeader **reply,
1601			unsigned char **content_ptr)
1602			{
1603		✗	RTSPState *rt = s->priv_data;
1604		✗	if (rt->stored_msg.header == NULL) {
1605		✗	if (rt->stored_msg.expected_seq == -1)
1606		✗	return AVERROR(EINVAL); // Reply to be stored was never requested
1607
1608			// Reply pending, tell caller to try again later
1609		✗	return AVERROR(EAGAIN);
1610			}
1611
1612		✗	if (reply)
1613		✗	*reply = rt->stored_msg.header;
1614			else
1615		✗	av_free(rt->stored_msg.header);
1616
1617		✗	if (content_ptr)
1618		✗	*content_ptr = rt->stored_msg.body;
1619			else
1620		✗	av_free(rt->stored_msg.body);
1621
1622		✗	rt->stored_msg.header = NULL;
1623		✗	rt->stored_msg.body = NULL;
1624		✗	return 0;
1625			}
1626
1627		✗	int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
1628			int lower_transport, const char *real_challenge)
1629			{
1630		✗	RTSPState *rt = s->priv_data;
1631		✗	int rtx = 0, j, i, err, interleave = 0, port_off = 0;
1632			RTSPStream *rtsp_st;
1633		✗	RTSPMessageHeader reply1, *reply = &reply1;
1634			char cmd[MAX_URL_SIZE];
1635			const char *trans_pref;
1636
1637		✗	memset(&reply1, 0, sizeof(reply1));
1638
1639		✗	if (rt->transport == RTSP_TRANSPORT_RDT)
1640		✗	trans_pref = "x-pn-tng";
1641		✗	else if (rt->transport == RTSP_TRANSPORT_RAW)
1642		✗	trans_pref = "RAW/RAW";
1643			else
1644		✗	trans_pref = "RTP/AVP";
1645
1646			/* default timeout: 1 minute */
1647		✗	rt->timeout = 60;
1648
1649			/* Choose a random starting offset within the first half of the
1650			* port range, to allow for a number of ports to try even if the offset
1651			* happens to be at the end of the random range. */
1652		✗	if (rt->rtp_port_max - rt->rtp_port_min >= 4) {
1653		✗	port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1654			/* even random offset */
1655		✗	port_off -= port_off & 0x01;
1656			}
1657
1658		✗	for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1659			char transport[MAX_URL_SIZE];
1660
1661			/*
1662			* WMS serves all UDP data over a single connection, the RTX, which
1663			* isn't necessarily the first in the SDP but has to be the first
1664			* to be set up, else the second/third SETUP will fail with a 461.
1665			*/
1666		✗	if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1667		✗	rt->server_type == RTSP_SERVER_WMS) {
1668		✗	if (i == 0) {
1669			/* rtx first */
1670		✗	for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1671		✗	int len = strlen(rt->rtsp_streams[rtx]->control_url);
1672		✗	if (len >= 4 &&
1673		✗	!strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1674			"/rtx"))
1675		✗	break;
1676			}
1677		✗	if (rtx == rt->nb_rtsp_streams)
1678		✗	return -1; /* no RTX found */
1679		✗	rtsp_st = rt->rtsp_streams[rtx];
1680			} else
1681		✗	rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1682			} else
1683		✗	rtsp_st = rt->rtsp_streams[i];
1684
1685			/* RTP/UDP */
1686		✗	if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1687			char buf[256];
1688
1689		✗	if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1690		✗	port = reply->transports[0].client_port_min;
1691		✗	goto have_port;
1692			}
1693
1694			/* first try in specified port range */
1695		✗	while (j + 1 <= rt->rtp_port_max) {
1696		✗	AVDictionary *opts = map_to_opts(rt);
1697
1698		✗	ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1699			"?localrtpport=%d", j);
1700			/* we will use two ports per rtp stream (rtp and rtcp) */
1701		✗	j += 2;
1702		✗	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
1703		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1704
1705		✗	av_dict_free(&opts);
1706
1707		✗	if (!err)
1708		✗	goto rtp_opened;
1709			}
1710		✗	av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1711		✗	err = AVERROR(EIO);
1712		✗	goto fail;
1713
1714		✗	rtp_opened:
1715		✗	port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1716		✗	have_port:
1717		✗	av_strlcpy(transport, trans_pref, sizeof(transport));
1718		✗	av_strlcat(transport,
1719		✗	rt->server_type == RTSP_SERVER_SATIP ? ";" : "/UDP;",
1720			sizeof(transport));
1721		✗	if (rt->server_type != RTSP_SERVER_REAL)
1722		✗	av_strlcat(transport, "unicast;", sizeof(transport));
1723		✗	av_strlcatf(transport, sizeof(transport),
1724			"client_port=%d", port);
1725		✗	if (rt->transport == RTSP_TRANSPORT_RTP &&
1726		✗	!(rt->server_type == RTSP_SERVER_WMS && i > 0))
1727		✗	av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1728			}
1729
1730			/* RTP/TCP */
1731		✗	else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1732			/* For WMS streams, the application streams are only used for
1733			* UDP. When trying to set it up for TCP streams, the server
1734			* will return an error. Therefore, we skip those streams. */
1735		✗	if (rt->server_type == RTSP_SERVER_WMS &&
1736		✗	(rtsp_st->stream_index < 0 ||
1737		✗	s->streams[rtsp_st->stream_index]->codecpar->codec_type ==
1738			AVMEDIA_TYPE_DATA))
1739		✗	continue;
1740		✗	snprintf(transport, sizeof(transport) - 1,
1741			"%s/TCP;", trans_pref);
1742		✗	if (rt->transport != RTSP_TRANSPORT_RDT)
1743		✗	av_strlcat(transport, "unicast;", sizeof(transport));
1744		✗	av_strlcatf(transport, sizeof(transport),
1745			"interleaved=%d-%d",
1746			interleave, interleave + 1);
1747		✗	interleave += 2;
1748			}
1749
1750		✗	else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1751		✗	snprintf(transport, sizeof(transport) - 1,
1752			"%s/UDP;multicast", trans_pref);
1753			} else {
1754		✗	err = AVERROR(EINVAL);
1755		✗	goto fail; // transport would be uninitialized
1756			}
1757
1758		✗	if (s->oformat) {
1759		✗	av_strlcat(transport, ";mode=record", sizeof(transport));
1760		✗	} else if (rt->server_type == RTSP_SERVER_REAL ||
1761		✗	rt->server_type == RTSP_SERVER_WMS)
1762		✗	av_strlcat(transport, ";mode=play", sizeof(transport));
1763		✗	snprintf(cmd, sizeof(cmd),
1764			"Transport: %s\r\n",
1765			transport);
1766		✗	if (rt->accept_dynamic_rate)
1767		✗	av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1768		✗	if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1769			char real_res[41], real_csum[9];
1770		✗	ff_rdt_calc_response_and_checksum(real_res, real_csum,
1771			real_challenge);
1772		✗	av_strlcatf(cmd, sizeof(cmd),
1773			"If-Match: %s\r\n"
1774			"RealChallenge2: %s, sd=%s\r\n",
1775		✗	rt->session_id, real_res, real_csum);
1776			}
1777		✗	ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1778		✗	if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1779		✗	err = 1;
1780		✗	goto fail;
1781		✗	} else if (reply->status_code != RTSP_STATUS_OK ||
1782		✗	reply->nb_transports != 1) {
1783		✗	err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1784		✗	goto fail;
1785			}
1786
1787		✗	if (rt->server_type == RTSP_SERVER_SATIP && reply->stream_id[0]) {
1788			char proto[128], host[128], path[512], auth[128];
1789			int port;
1790		✗	av_url_split(proto, sizeof(proto), auth, sizeof(auth), host, sizeof(host),
1791		✗	&port, path, sizeof(path), rt->control_uri);
1792		✗	ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL, host,
1793		✗	port, "/stream=%s", reply->stream_id);
1794			}
1795
1796			/* XXX: same protocol for all streams is required */
1797		✗	if (i > 0) {
1798		✗	if (reply->transports[0].lower_transport != rt->lower_transport ||
1799		✗	reply->transports[0].transport != rt->transport) {
1800		✗	err = AVERROR_INVALIDDATA;
1801		✗	goto fail;
1802			}
1803			} else {
1804		✗	rt->lower_transport = reply->transports[0].lower_transport;
1805		✗	rt->transport = reply->transports[0].transport;
1806			}
1807
1808			/* Fail if the server responded with another lower transport mode
1809			* than what we requested. */
1810		✗	if (reply->transports[0].lower_transport != lower_transport) {
1811		✗	av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1812		✗	err = AVERROR_INVALIDDATA;
1813		✗	goto fail;
1814			}
1815
1816		✗	switch(reply->transports[0].lower_transport) {
1817		✗	case RTSP_LOWER_TRANSPORT_TCP:
1818		✗	rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1819		✗	rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1820		✗	break;
1821
1822		✗	case RTSP_LOWER_TRANSPORT_UDP: {
1823		✗	char url[MAX_URL_SIZE], options[30] = "";
1824		✗	const char *peer = host;
1825
1826		✗	if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1827		✗	av_strlcpy(options, "?connect=1", sizeof(options));
1828			/* Use source address if specified */
1829		✗	if (reply->transports[0].source[0])
1830		✗	peer = reply->transports[0].source;
1831		✗	ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1832			reply->transports[0].server_port_min, "%s", options);
1833		✗	if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1834		✗	ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1835		✗	err = AVERROR_INVALIDDATA;
1836		✗	goto fail;
1837			}
1838		✗	break;
1839			}
1840		✗	case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1841		✗	char url[MAX_URL_SIZE], namebuf[50], optbuf[20] = "";
1842			struct sockaddr_storage addr;
1843			int port, ttl;
1844		✗	AVDictionary *opts = map_to_opts(rt);
1845
1846		✗	if (reply->transports[0].destination.ss_family) {
1847		✗	addr = reply->transports[0].destination;
1848		✗	port = reply->transports[0].port_min;
1849		✗	ttl = reply->transports[0].ttl;
1850			} else {
1851		✗	addr = rtsp_st->sdp_ip;
1852		✗	port = rtsp_st->sdp_port;
1853		✗	ttl = rtsp_st->sdp_ttl;
1854			}
1855		✗	if (ttl > 0)
1856		✗	snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1857		✗	getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1858			namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1859		✗	ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1860			port, "%s", optbuf);
1861		✗	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1862		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1863		✗	av_dict_free(&opts);
1864
1865		✗	if (err < 0) {
1866		✗	err = AVERROR_INVALIDDATA;
1867		✗	goto fail;
1868			}
1869		✗	break;
1870			}
1871			}
1872
1873		✗	if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1874		✗	goto fail;
1875			}
1876
1877		✗	if (rt->nb_rtsp_streams && reply->timeout > 0)
1878		✗	rt->timeout = reply->timeout;
1879
1880		✗	if (rt->server_type == RTSP_SERVER_REAL)
1881		✗	rt->need_subscription = 1;
1882
1883		✗	return 0;
1884
1885		✗	fail:
1886		✗	ff_rtsp_undo_setup(s, 0);
1887		✗	return err;
1888			}
1889
1890		✗	void ff_rtsp_close_connections(AVFormatContext *s)
1891			{
1892		✗	RTSPState *rt = s->priv_data;
1893		✗	if (rt->rtsp_hd_out != rt->rtsp_hd)
1894		✗	ffurl_closep(&rt->rtsp_hd_out);
1895		✗	rt->rtsp_hd_out = NULL;
1896		✗	ffurl_closep(&rt->rtsp_hd);
1897		✗	}
1898
1899		✗	static int rtsp_url_same_origin(const char *url1, const char *url2)
1900			{
1901			char proto1[128], proto2[128];
1902			char host1[1024], host2[1024];
1903			int port1, port2;
1904
1905		✗	av_url_split(proto1, sizeof(proto1), NULL, 0, host1, sizeof(host1),
1906			&port1, NULL, 0, url1);
1907		✗	av_url_split(proto2, sizeof(proto2), NULL, 0, host2, sizeof(host2),
1908			&port2, NULL, 0, url2);
1909
1910		✗	if (!proto1[0] || !proto2[0] || !host1[0] || !host2[0])
1911		✗	return 0;
1912
1913		✗	if (port1 < 0)
1914		✗	port1 = !av_strcasecmp(proto1, "rtsps") ? RTSPS_DEFAULT_PORT
1915		✗	: RTSP_DEFAULT_PORT;
1916		✗	if (port2 < 0)
1917		✗	port2 = !av_strcasecmp(proto2, "rtsps") ? RTSPS_DEFAULT_PORT
1918		✗	: RTSP_DEFAULT_PORT;
1919
1920		✗	return !av_strcasecmp(proto1, proto2) &&
1921		✗	!av_strcasecmp(host1, host2) &&
1922		✗	port1 == port2;
1923			}
1924
1925		✗	static int rtsp_control_interrupt_cb(void *opaque)
1926			{
1927		✗	AVFormatContext *s = opaque;
1928		✗	RTSPState *rt = s->priv_data;
1929
1930			/* While closing, a pending user interrupt must not prevent TEARDOWN from
1931			* being sent and its reply from being read; bound the wait instead. */
1932		✗	if (rt->teardown_deadline)
1933		✗	return av_gettime_relative() >= rt->teardown_deadline;
1934
1935		✗	return ff_check_interrupt(&s->interrupt_callback);
1936			}
1937
1938		✗	int ff_rtsp_connect(AVFormatContext *s)
1939			{
1940		✗	RTSPState *rt = s->priv_data;
1941			char proto[128], host[1024], path[2048];
1942			char tcpname[1024], cmd[MAX_URL_SIZE], auth[128];
1943		✗	const char *lower_rtsp_proto = "tcp";
1944			int port, err, tcp_fd;
1945		✗	RTSPMessageHeader reply1, *reply = &reply1;
1946		✗	int lower_transport_mask = 0;
1947		✗	int redirects = 0;
1948		✗	int default_port = RTSP_DEFAULT_PORT;
1949		✗	int https_tunnel = 0;
1950		✗	char real_challenge[64] = "";
1951			struct sockaddr_storage peer;
1952		✗	socklen_t peer_len = sizeof(peer);
1953
1954		✗	rt->stored_msg.expected_seq = -1;
1955		✗	rt->control_interrupt_cb.callback = rtsp_control_interrupt_cb;
1956		✗	rt->control_interrupt_cb.opaque = s;
1957		✗	if (rt->rtp_port_max < rt->rtp_port_min) {
1958		✗	av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1959			"than min port %d\n", rt->rtp_port_max,
1960			rt->rtp_port_min);
1961		✗	return AVERROR(EINVAL);
1962			}
1963
1964		✗	if ((err = ff_network_init()) < 0)
1965		✗	return err;
1966
1967		✗	if (s->max_delay < 0) /* Not set by the caller */
1968		✗	s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1969
1970		✗	rt->control_transport = RTSP_MODE_PLAIN;
1971		✗	if (rt->lower_transport_mask & ((1 << RTSP_LOWER_TRANSPORT_HTTP) |
1972			(1 << RTSP_LOWER_TRANSPORT_HTTPS))) {
1973		✗	https_tunnel = !!(rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTPS));
1974		✗	rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1975		✗	rt->control_transport = RTSP_MODE_TUNNEL;
1976			}
1977			/* Only pass through valid flags from here */
1978		✗	rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1979
1980		✗	redirect:
1981		✗	memset(&reply1, 0, sizeof(reply1));
1982			/* extract hostname and port */
1983		✗	av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1984		✗	host, sizeof(host), &port, path, sizeof(path), s->url);
1985
1986		✗	if (!strcmp(proto, "rtsps")) {
1987		✗	lower_rtsp_proto = "tls";
1988		✗	default_port = RTSPS_DEFAULT_PORT;
1989		✗	rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1990		✗	} else if (!strcmp(proto, "satip")) {
1991		✗	av_strlcpy(proto, "rtsp", sizeof(proto));
1992		✗	rt->server_type = RTSP_SERVER_SATIP;
1993		✗	} else if (strcmp(proto, "rtsp"))
1994		✗	return AVERROR_INVALIDDATA;
1995
1996		✗	if (*auth) {
1997		✗	av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1998			}
1999		✗	if (port < 0)
2000		✗	port = default_port;
2001
2002		✗	lower_transport_mask = rt->lower_transport_mask;
2003
2004		✗	if (!lower_transport_mask)
2005		✗	lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
2006
2007		✗	if (s->oformat) {
2008			/* Only UDP or TCP - UDP multicast isn't supported. */
2009		✗	lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
2010			(1 << RTSP_LOWER_TRANSPORT_TCP);
2011		✗	if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
2012		✗	av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
2013			"only UDP and TCP are supported for output.\n");
2014		✗	err = AVERROR(EINVAL);
2015		✗	goto fail;
2016			}
2017			}
2018
2019			/* Construct the URI used in request; this is similar to s->url,
2020			* but with authentication credentials removed and RTSP specific options
2021			* stripped out. */
2022		✗	ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
2023			host, port, "%s", path);
2024
2025		✗	if (rt->control_transport == RTSP_MODE_TUNNEL) {
2026			/* set up initial handshake for tunneling */
2027			char httpname[1024];
2028			char sessioncookie[17];
2029			char headers[1024];
2030		✗	AVDictionary *options = NULL;
2031
2032		✗	av_dict_set_int(&options, "timeout", rt->stimeout, 0);
2033		✗	if (https_tunnel) {
2034		✗	int ret = copy_tls_opts_dict(rt, &options);
2035		✗	if (ret < 0) {
2036		✗	av_dict_free(&options);
2037		✗	err = ret;
2038		✗	goto fail;
2039			}
2040			}
2041
2042		✗	ff_url_join(httpname, sizeof(httpname), https_tunnel ? "https" : "http", auth, host, port, "%s", path);
2043		✗	snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
2044			av_get_random_seed(), av_get_random_seed());
2045
2046			/* GET requests */
2047		✗	if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
2048		✗	&rt->control_interrupt_cb) < 0) {
2049		✗	av_dict_free(&options);
2050		✗	err = AVERROR(EIO);
2051		✗	goto fail;
2052			}
2053
2054			/* generate GET headers */
2055		✗	snprintf(headers, sizeof(headers),
2056			"x-sessioncookie: %s\r\n"
2057			"Accept: application/x-rtsp-tunnelled\r\n"
2058			"Pragma: no-cache\r\n"
2059			"Cache-Control: no-cache\r\n",
2060			sessioncookie);
2061		✗	av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
2062
2063		✗	if (!rt->rtsp_hd->protocol_whitelist && s->protocol_whitelist) {
2064		✗	rt->rtsp_hd->protocol_whitelist = av_strdup(s->protocol_whitelist);
2065		✗	if (!rt->rtsp_hd->protocol_whitelist) {
2066		✗	av_dict_free(&options);
2067		✗	err = AVERROR(ENOMEM);
2068		✗	goto fail;
2069			}
2070			}
2071
2072		✗	if (!rt->rtsp_hd->protocol_blacklist && s->protocol_blacklist) {
2073		✗	rt->rtsp_hd->protocol_blacklist = av_strdup(s->protocol_blacklist);
2074		✗	if (!rt->rtsp_hd->protocol_blacklist) {
2075		✗	av_dict_free(&options);
2076		✗	err = AVERROR(ENOMEM);
2077		✗	goto fail;
2078			}
2079			}
2080
2081			/* complete the connection */
2082		✗	if (ffurl_connect(rt->rtsp_hd, &options)) {
2083		✗	av_dict_free(&options);
2084		✗	err = AVERROR(EIO);
2085		✗	goto fail;
2086			}
2087
2088			/* POST requests */
2089		✗	if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
2090		✗	&rt->control_interrupt_cb) < 0 ) {
2091		✗	av_dict_free(&options);
2092		✗	err = AVERROR(EIO);
2093		✗	goto fail;
2094			}
2095
2096			/* generate POST headers */
2097		✗	snprintf(headers, sizeof(headers),
2098			"x-sessioncookie: %s\r\n"
2099			"Content-Type: application/x-rtsp-tunnelled\r\n"
2100			"Pragma: no-cache\r\n"
2101			"Cache-Control: no-cache\r\n"
2102			"Content-Length: 32767\r\n"
2103			"Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
2104			sessioncookie);
2105		✗	av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
2106		✗	av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
2107		✗	av_opt_set(rt->rtsp_hd_out->priv_data, "send_expect_100", "0", 0);
2108
2109			/* Initialize the authentication state for the POST session. The HTTP
2110			* protocol implementation doesn't properly handle multi-pass
2111			* authentication for POST requests, since it would require one of
2112			* the following:
2113			* - implementing Expect: 100-continue, which many HTTP servers
2114			* don't support anyway, even less the RTSP servers that do HTTP
2115			* tunneling
2116			* - sending the whole POST data until getting a 401 reply specifying
2117			* what authentication method to use, then resending all that data
2118			* - waiting for potential 401 replies directly after sending the
2119			* POST header (waiting for some unspecified time)
2120			* Therefore, we copy the full auth state, which works for both basic
2121			* and digest. (For digest, we would have to synchronize the nonce
2122			* count variable between the two sessions, if we'd do more requests
2123			* with the original session, though.)
2124			*/
2125		✗	ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
2126
2127			/* complete the connection */
2128		✗	if (ffurl_connect(rt->rtsp_hd_out, &options)) {
2129		✗	av_dict_free(&options);
2130		✗	err = AVERROR(EIO);
2131		✗	goto fail;
2132			}
2133		✗	av_dict_free(&options);
2134			} else {
2135			int ret;
2136			/* open the tcp connection */
2137		✗	AVDictionary *proto_opts = NULL;
2138		✗	if (strcmp("tls", lower_rtsp_proto) == 0) {
2139		✗	ret = copy_tls_opts_dict(rt, &proto_opts);
2140		✗	if (ret < 0) {
2141		✗	av_dict_free(&proto_opts);
2142		✗	err = ret;
2143		✗	goto fail;
2144			}
2145			}
2146
2147		✗	ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
2148			host, port,
2149			"?timeout=%"PRId64, rt->stimeout);
2150		✗	if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
2151		✗	&rt->control_interrupt_cb, &proto_opts, s->protocol_whitelist, s->protocol_blacklist, NULL)) < 0) {
2152		✗	av_dict_free(&proto_opts);
2153		✗	err = ret;
2154		✗	goto fail;
2155			}
2156		✗	av_dict_free(&proto_opts);
2157		✗	rt->rtsp_hd_out = rt->rtsp_hd;
2158			}
2159		✗	rt->seq = 0;
2160
2161		✗	tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
2162		✗	if (tcp_fd < 0) {
2163		✗	err = tcp_fd;
2164		✗	goto fail;
2165			}
2166		✗	if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
2167		✗	getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
2168			NULL, 0, NI_NUMERICHOST);
2169			}
2170
2171			/* request options supported by the server; this also detects server
2172			* type */
2173		✗	if (rt->server_type != RTSP_SERVER_SATIP)
2174		✗	rt->server_type = RTSP_SERVER_RTP;
2175			for (;;) {
2176		✗	cmd[0] = 0;
2177		✗	if (rt->server_type == RTSP_SERVER_REAL)
2178		✗	av_strlcat(cmd,
2179			/*
2180			* The following entries are required for proper
2181			* streaming from a Realmedia server. They are
2182			* interdependent in some way although we currently
2183			* don't quite understand how. Values were copied
2184			* from mplayer SVN r23589.
2185			* ClientChallenge is a 16-byte ID in hex
2186			* CompanyID is a 16-byte ID in base64
2187			*/
2188			"ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
2189			"PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
2190			"CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
2191			"GUID: 00000000-0000-0000-0000-000000000000\r\n",
2192			sizeof(cmd));
2193		✗	ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
2194		✗	if (reply->status_code != RTSP_STATUS_OK) {
2195		✗	err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
2196		✗	goto fail;
2197			}
2198
2199			/* detect server type if not standard-compliant RTP */
2200		✗	if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
2201		✗	rt->server_type = RTSP_SERVER_REAL;
2202		✗	continue;
2203		✗	} else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
2204		✗	rt->server_type = RTSP_SERVER_WMS;
2205		✗	} else if (rt->server_type == RTSP_SERVER_REAL)
2206		✗	strcpy(real_challenge, reply->real_challenge);
2207		✗	break;
2208			}
2209
2210			#if CONFIG_RTSP_DEMUXER
2211		✗	if (s->iformat) {
2212		✗	if (rt->server_type == RTSP_SERVER_SATIP)
2213		✗	err = init_satip_stream(s);
2214			else
2215		✗	err = ff_rtsp_setup_input_streams(s, reply);
2216			} else
2217			#endif
2218			if (CONFIG_RTSP_MUXER)
2219		✗	err = ff_rtsp_setup_output_streams(s, host);
2220			else
2221			av_unreachable("Either muxer or demuxer must be enabled");
2222		✗	if (err)
2223		✗	goto fail;
2224
2225			do {
2226		✗	int lower_transport = ff_log2_tab[lower_transport_mask &
2227		✗	~(lower_transport_mask - 1)];
2228
2229		✗	if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
2230		✗	&& (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
2231		✗	lower_transport = RTSP_LOWER_TRANSPORT_TCP;
2232
2233		✗	err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
2234		✗	rt->server_type == RTSP_SERVER_REAL ?
2235			real_challenge : NULL);
2236		✗	if (err < 0)
2237		✗	goto fail;
2238		✗	lower_transport_mask &= ~(1 << lower_transport);
2239		✗	if (lower_transport_mask == 0 && err == 1) {
2240		✗	err = AVERROR(EPROTONOSUPPORT);
2241		✗	goto fail;
2242			}
2243		✗	} while (err);
2244
2245		✗	rt->lower_transport_mask = lower_transport_mask;
2246		✗	av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
2247		✗	rt->state = RTSP_STATE_IDLE;
2248		✗	rt->seek_timestamp = 0; /* default is to start stream at position zero */
2249		✗	return 0;
2250		✗	fail:
2251		✗	ff_rtsp_close_streams(s);
2252		✗	ff_rtsp_close_connections(s);
2253		✗	if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
2254			int ret;
2255
2256		✗	if (redirects++ >= 8 /* MAX_RTSP_REDIRECTS */) {
2257		✗	av_log(s, AV_LOG_ERROR, "Too many RTSP redirects\n");
2258		✗	err = AVERROR(EIO);
2259		✗	goto fail2;
2260			}
2261		✗	if (!rtsp_url_same_origin(s->url, reply->location)) {
2262		✗	memset(rt->auth, 0, sizeof(rt->auth));
2263		✗	memset(&rt->auth_state, 0, sizeof(rt->auth_state));
2264			}
2265		✗	ret = ff_format_check_set_url(s, reply->location);
2266		✗	if (ret < 0) {
2267		✗	err = ret;
2268		✗	goto fail2;
2269			}
2270		✗	rt->session_id[0] = '\0';
2271		✗	av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
2272		✗	reply->status_code,
2273			s->url);
2274		✗	goto redirect;
2275			}
2276		✗	fail2:
2277		✗	ff_network_close();
2278		✗	return err;
2279			}
2280			#endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
2281
2282			#if CONFIG_RTPDEC
2283			#if CONFIG_RTSP_DEMUXER
2284		✗	static int parse_rtsp_message(AVFormatContext *s)
2285			{
2286		✗	RTSPState *rt = s->priv_data;
2287			int ret;
2288
2289		✗	if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
2290		✗	if (rt->state == RTSP_STATE_STREAMING) {
2291		✗	return ff_rtsp_parse_streaming_commands(s);
2292			} else
2293		✗	return AVERROR_EOF;
2294			} else {
2295			RTSPMessageHeader reply;
2296		✗	ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
2297		✗	if (ret < 0)
2298		✗	return ret;
2299			/* XXX: parse message */
2300		✗	if (rt->state != RTSP_STATE_STREAMING)
2301		✗	return 0;
2302			}
2303
2304		✗	return 0;
2305			}
2306			#endif
2307
2308		✗	static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
2309			uint8_t *buf, int buf_size, int64_t wait_end)
2310			{
2311		✗	RTSPState *rt = s->priv_data;
2312			RTSPStream *rtsp_st;
2313			int n, i, ret;
2314		✗	struct pollfd *p = rt->p;
2315		✗	int *fds = NULL, fdsnum, fdsidx;
2316		✗	int64_t runs = rt->stimeout / POLLING_TIME / 1000;
2317
2318		✗	if (!p) {
2319		✗	p = rt->p = av_malloc_array(2 * rt->nb_rtsp_streams + 1, sizeof(*p));
2320		✗	if (!p)
2321		✗	return AVERROR(ENOMEM);
2322
2323		✗	if (rt->rtsp_hd) {
2324		✗	p[rt->max_p].fd = ffurl_get_file_handle(rt->rtsp_hd);
2325		✗	p[rt->max_p++].events = POLLIN;
2326			}
2327		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2328		✗	rtsp_st = rt->rtsp_streams[i];
2329		✗	if (rtsp_st->rtp_handle) {
2330		✗	if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
2331			&fds, &fdsnum)) {
2332		✗	av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
2333		✗	return ret;
2334			}
2335		✗	if (fdsnum != 2) {
2336		✗	av_log(s, AV_LOG_ERROR,
2337			"Number of fds %d not supported\n", fdsnum);
2338		✗	av_freep(&fds);
2339		✗	return AVERROR_INVALIDDATA;
2340			}
2341		✗	for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
2342		✗	p[rt->max_p].fd = fds[fdsidx];
2343		✗	p[rt->max_p++].events = POLLIN;
2344			}
2345		✗	av_freep(&fds);
2346			}
2347			}
2348			}
2349
2350			for (;;) {
2351		✗	if (ff_check_interrupt(&s->interrupt_callback))
2352		✗	return AVERROR_EXIT;
2353		✗	if (wait_end && wait_end - av_gettime_relative() < 0)
2354		✗	return AVERROR(EAGAIN);
2355		✗	n = poll(p, rt->max_p, POLLING_TIME);
2356		✗	if (n > 0) {
2357		✗	int j = rt->rtsp_hd ? 1 : 0;
2358		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2359		✗	rtsp_st = rt->rtsp_streams[i];
2360		✗	if (rtsp_st->rtp_handle) {
2361		✗	if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
2362		✗	ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
2363		✗	if (ret > 0) {
2364		✗	*prtsp_st = rtsp_st;
2365		✗	return ret;
2366			}
2367			}
2368		✗	j+=2;
2369			}
2370			}
2371			#if CONFIG_RTSP_DEMUXER
2372		✗	if (rt->rtsp_hd && p[0].revents & POLLIN) {
2373		✗	if ((ret = parse_rtsp_message(s)) < 0) {
2374		✗	return ret;
2375			}
2376			}
2377			#endif
2378		✗	} else if (n == 0 && rt->stimeout > 0 && --runs <= 0) {
2379		✗	return AVERROR(ETIMEDOUT);
2380		✗	} else if (n < 0 && errno != EINTR)
2381		✗	return AVERROR(errno);
2382			}
2383			}
2384
2385		✗	static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
2386			const uint8_t *buf, int len)
2387			{
2388		✗	RTSPState *rt = s->priv_data;
2389			int i;
2390		✗	if (len < 0)
2391		✗	return len;
2392		✗	if (rt->nb_rtsp_streams == 1) {
2393		✗	*rtsp_st = rt->rtsp_streams[0];
2394		✗	return len;
2395			}
2396		✗	if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
2397		✗	if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
2398		✗	int no_ssrc = 0;
2399		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2400		✗	RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2401		✗	if (!rtpctx)
2402		✗	continue;
2403		✗	if (rtpctx->ssrc == AV_RB32(&buf[4])) {
2404		✗	*rtsp_st = rt->rtsp_streams[i];
2405		✗	return len;
2406			}
2407		✗	if (!rtpctx->ssrc)
2408		✗	no_ssrc = 1;
2409			}
2410		✗	if (no_ssrc) {
2411		✗	av_log(s, AV_LOG_WARNING,
2412			"Unable to pick stream for packet - SSRC not known for "
2413			"all streams\n");
2414		✗	return AVERROR(EAGAIN);
2415			}
2416			} else {
2417		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2418		✗	if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2419		✗	*rtsp_st = rt->rtsp_streams[i];
2420		✗	return len;
2421			}
2422			}
2423			}
2424			}
2425		✗	av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2426		✗	return AVERROR(EAGAIN);
2427			}
2428
2429		✗	static int read_packet(AVFormatContext *s,
2430			RTSPStream **rtsp_st, RTSPStream *first_queue_st,
2431			int64_t wait_end)
2432			{
2433		✗	RTSPState *rt = s->priv_data;
2434			int len;
2435
2436		✗	switch(rt->lower_transport) {
2437		✗	default:
2438			#if CONFIG_RTSP_DEMUXER
2439			case RTSP_LOWER_TRANSPORT_TCP:
2440		✗	len = ff_rtsp_tcp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2441		✗	break;
2442			#endif
2443		✗	case RTSP_LOWER_TRANSPORT_UDP:
2444			case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
2445		✗	len = udp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2446		✗	if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2447		✗	ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, (*rtsp_st)->rtp_handle, NULL, len);
2448		✗	break;
2449		✗	case RTSP_LOWER_TRANSPORT_CUSTOM:
2450		✗	if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2451		✗	wait_end && wait_end < av_gettime_relative())
2452		✗	len = AVERROR(EAGAIN);
2453			else
2454		✗	len = avio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2455		✗	len = pick_stream(s, rtsp_st, rt->recvbuf, len);
2456		✗	if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2457		✗	ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, NULL, s->pb, len);
2458		✗	break;
2459			}
2460
2461		✗	if (len == 0)
2462		✗	return AVERROR_EOF;
2463
2464		✗	return len;
2465			}
2466
2467		✗	int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
2468			{
2469		✗	RTSPState *rt = s->priv_data;
2470			int ret, len;
2471		✗	RTSPStream *rtsp_st, *first_queue_st = NULL;
2472		✗	int64_t wait_end = 0;
2473
2474		✗	if (rt->nb_byes == rt->nb_rtsp_streams)
2475		✗	return AVERROR_EOF;
2476
2477			/* get next frames from the same RTP packet */
2478		✗	if (rt->cur_transport_priv) {
2479		✗	if (rt->transport == RTSP_TRANSPORT_RDT) {
2480		✗	ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2481		✗	} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2482		✗	ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2483		✗	} else if (CONFIG_RTPDEC && rt->ts) {
2484		✗	ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
2485		✗	if (ret >= 0) {
2486		✗	rt->recvbuf_pos += ret;
2487		✗	ret = rt->recvbuf_pos < rt->recvbuf_len;
2488			}
2489			} else
2490		✗	ret = -1;
2491		✗	if (ret == 0) {
2492		✗	rt->cur_transport_priv = NULL;
2493		✗	return 0;
2494		✗	} else if (ret == 1) {
2495		✗	return 0;
2496			} else
2497		✗	rt->cur_transport_priv = NULL;
2498			}
2499
2500		✗	redo:
2501		✗	if (rt->transport == RTSP_TRANSPORT_RTP) {
2502			int i;
2503		✗	int64_t first_queue_time = 0;
2504		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2505		✗	RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2506			int64_t queue_time;
2507		✗	if (!rtpctx)
2508		✗	continue;
2509		✗	queue_time = ff_rtp_queued_packet_time(rtpctx);
2510		✗	if (queue_time && (queue_time - first_queue_time < 0 ||
2511			!first_queue_time)) {
2512		✗	first_queue_time = queue_time;
2513		✗	first_queue_st = rt->rtsp_streams[i];
2514			}
2515			}
2516		✗	if (first_queue_time) {
2517		✗	wait_end = first_queue_time + s->max_delay;
2518			} else {
2519		✗	wait_end = 0;
2520		✗	first_queue_st = NULL;
2521			}
2522			}
2523
2524			/* read next RTP packet */
2525		✗	if (!rt->recvbuf) {
2526		✗	rt->recvbuf = av_malloc(RECVBUF_SIZE);
2527		✗	if (!rt->recvbuf)
2528		✗	return AVERROR(ENOMEM);
2529			}
2530
2531		✗	len = read_packet(s, &rtsp_st, first_queue_st, wait_end);
2532		✗	if (len == AVERROR(EAGAIN) && first_queue_st &&
2533		✗	rt->transport == RTSP_TRANSPORT_RTP) {
2534		✗	av_log(s, AV_LOG_WARNING,
2535			"max delay reached. need to consume packet\n");
2536		✗	rtsp_st = first_queue_st;
2537		✗	ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2538		✗	goto end;
2539			}
2540		✗	if (len < 0)
2541		✗	return len;
2542
2543		✗	if (rt->transport == RTSP_TRANSPORT_RDT) {
2544		✗	ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2545		✗	} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2546		✗	ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2547		✗	if (rtsp_st->feedback) {
2548		✗	AVIOContext *pb = NULL;
2549		✗	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
2550		✗	pb = s->pb;
2551		✗	ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2552			}
2553		✗	if (ret < 0) {
2554			/* Either bad packet, or a RTCP packet. Check if the
2555			* first_rtcp_ntp_time field was initialized. */
2556		✗	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2557		✗	if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2558			/* first_rtcp_ntp_time has been initialized for this stream,
2559			* copy the same value to all other uninitialized streams,
2560			* in order to map their timestamp origin to the same ntp time
2561			* as this one. */
2562			int i;
2563		✗	AVStream *st = NULL;
2564		✗	if (rtsp_st->stream_index >= 0)
2565		✗	st = s->streams[rtsp_st->stream_index];
2566		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2567		✗	RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2568		✗	AVStream *st2 = NULL;
2569		✗	if (rt->rtsp_streams[i]->stream_index >= 0)
2570		✗	st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2571		✗	if (rtpctx2 && st && st2 &&
2572		✗	rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2573		✗	rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2574		✗	rtpctx2->rtcp_ts_offset = av_rescale_q(
2575			rtpctx->rtcp_ts_offset, st->time_base,
2576			st2->time_base);
2577			}
2578			}
2579			// Make real NTP start time available in AVFormatContext
2580		✗	if (s->start_time_realtime == AV_NOPTS_VALUE) {
2581		✗	s->start_time_realtime = ff_parse_ntp_time(rtpctx->first_rtcp_ntp_time) - NTP_OFFSET_US;
2582		✗	if (rtpctx->st) {
2583		✗	s->start_time_realtime -=
2584		✗	av_rescale_q (rtpctx->rtcp_ts_offset, rtpctx->st->time_base, AV_TIME_BASE_Q);
2585			}
2586			}
2587			}
2588		✗	if (ret == -RTCP_BYE) {
2589		✗	rt->nb_byes++;
2590
2591		✗	av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2592		✗	rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2593
2594		✗	if (rt->nb_byes == rt->nb_rtsp_streams)
2595		✗	return AVERROR_EOF;
2596			}
2597			}
2598		✗	} else if (CONFIG_RTPDEC && rt->ts) {
2599		✗	ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2600		✗	if (ret >= 0) {
2601		✗	if (ret < len) {
2602		✗	rt->recvbuf_len = len;
2603		✗	rt->recvbuf_pos = ret;
2604		✗	rt->cur_transport_priv = rt->ts;
2605		✗	return 1;
2606			} else {
2607		✗	ret = 0;
2608			}
2609			}
2610			} else {
2611		✗	return AVERROR_INVALIDDATA;
2612			}
2613		✗	end:
2614		✗	if (ret < 0)
2615		✗	goto redo;
2616		✗	if (ret == 1)
2617			/* more packets may follow, so we save the RTP context */
2618		✗	rt->cur_transport_priv = rtsp_st->transport_priv;
2619
2620		✗	return ret;
2621			}
2622			#endif /* CONFIG_RTPDEC */
2623
2624			#if CONFIG_SDP_DEMUXER
2625		8174	static int sdp_probe(const AVProbeData *p1)
2626			{
2627		8174	const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2628
2629			/* we look for a line beginning "c=IN IP" */
2630	3/4 ✓ Branch 0 taken 797701 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 793184 times. ✓ Branch 3 taken 4517 times.	797701	while (p < p_end && *p != '\0') {
2631	3/4 ✓ Branch 0 taken 793019 times. ✓ Branch 1 taken 165 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 793019 times.	1586203	if (sizeof("c=IN IP") - 1 < p_end - p &&
2632		793019	av_strstart(p, "c=IN IP", NULL))
2633		✗	return AVPROBE_SCORE_EXTENSION;
2634
2635	4/4 ✓ Branch 0 taken 127300144 times. ✓ Branch 1 taken 3657 times. ✓ Branch 2 taken 126510617 times. ✓ Branch 3 taken 789527 times.	127303801	while (p < p_end - 1 && *p != '\n') p++;
2636	2/2 ✓ Branch 0 taken 3657 times. ✓ Branch 1 taken 789527 times.	793184	if (++p >= p_end)
2637		3657	break;
2638	2/2 ✓ Branch 0 taken 4562 times. ✓ Branch 1 taken 784965 times.	789527	if (*p == '\r')
2639		4562	p++;
2640			}
2641		8174	return 0;
2642			}
2643
2644		✗	static void append_source_addrs(char *buf, int size, const char *name,
2645			int count, struct RTSPSource **addrs)
2646			{
2647			int i;
2648		✗	if (!count)
2649		✗	return;
2650		✗	av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2651		✗	for (i = 1; i < count; i++)
2652		✗	av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2653			}
2654
2655		✗	static int sdp_read_header(AVFormatContext *s)
2656			{
2657		✗	RTSPState *rt = s->priv_data;
2658			RTSPStream *rtsp_st;
2659			int i, err;
2660			char url[MAX_URL_SIZE];
2661			AVBPrint bp;
2662
2663		✗	if ((err = ff_network_init()) < 0)
2664		✗	return err;
2665
2666		✗	if (s->max_delay < 0) /* Not set by the caller */
2667		✗	s->max_delay = DEFAULT_REORDERING_DELAY;
2668		✗	if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2669		✗	rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
2670
2671			/* read the whole sdp file */
2672		✗	av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
2673		✗	err = avio_read_to_bprint(s->pb, &bp, INT_MAX);
2674		✗	if (err < 0 ) {
2675		✗	ff_network_close();
2676		✗	av_bprint_finalize(&bp, NULL);
2677		✗	return err;
2678			}
2679		✗	err = ff_sdp_parse(s, bp.str);
2680		✗	av_bprint_finalize(&bp, NULL);
2681		✗	if (err) goto fail;
2682
2683			/* open each RTP stream */
2684		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2685			char namebuf[50];
2686		✗	rtsp_st = rt->rtsp_streams[i];
2687
2688		✗	if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2689		✗	AVDictionary *opts = map_to_opts(rt);
2690			char buf[MAX_URL_SIZE];
2691			const char *p;
2692
2693		✗	err = getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip,
2694			sizeof(rtsp_st->sdp_ip),
2695			namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2696		✗	if (err) {
2697		✗	av_log(s, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(err));
2698		✗	err = AVERROR(EIO);
2699		✗	av_dict_free(&opts);
2700		✗	goto fail;
2701			}
2702		✗	ff_url_join(url, sizeof(url), "rtp", NULL,
2703			namebuf, rtsp_st->sdp_port,
2704			"?localrtpport=%d&ttl=%d&connect=%d&write_to_source=%d",
2705			rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2706		✗	rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2707		✗	rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2708
2709		✗	p = strchr(s->url, '?');
2710		✗	if (p && av_find_info_tag(buf, sizeof(buf), "localaddr", p))
2711		✗	av_strlcatf(url, sizeof(url), "&localaddr=%s", buf);
2712		✗	else if (rt->localaddr && rt->localaddr[0])
2713		✗	av_strlcatf(url, sizeof(url), "&localaddr=%s", rt->localaddr);
2714		✗	append_source_addrs(url, sizeof(url), "sources",
2715			rtsp_st->nb_include_source_addrs,
2716			rtsp_st->include_source_addrs);
2717		✗	append_source_addrs(url, sizeof(url), "block",
2718			rtsp_st->nb_exclude_source_addrs,
2719			rtsp_st->exclude_source_addrs);
2720		✗	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ,
2721		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2722
2723		✗	av_dict_free(&opts);
2724
2725		✗	if (err < 0) {
2726		✗	err = AVERROR_INVALIDDATA;
2727		✗	goto fail;
2728			}
2729			}
2730		✗	if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2731		✗	goto fail;
2732			}
2733		✗	return 0;
2734		✗	fail:
2735		✗	ff_rtsp_close_streams(s);
2736		✗	ff_network_close();
2737		✗	return err;
2738			}
2739
2740		✗	static int sdp_read_close(AVFormatContext *s)
2741			{
2742		✗	ff_rtsp_close_streams(s);
2743		✗	ff_network_close();
2744		✗	return 0;
2745			}
2746
2747			static const AVClass sdp_demuxer_class = {
2748			.class_name = "SDP demuxer",
2749			.item_name = av_default_item_name,
2750			.option = sdp_options,
2751			.version = LIBAVUTIL_VERSION_INT,
2752			};
2753
2754			const FFInputFormat ff_sdp_demuxer = {
2755			.p.name = "sdp",
2756			.p.long_name = NULL_IF_CONFIG_SMALL("SDP"),
2757			.p.priv_class = &sdp_demuxer_class,
2758			.priv_data_size = sizeof(RTSPState),
2759			.read_probe = sdp_probe,
2760			.read_header = sdp_read_header,
2761			.read_packet = ff_rtsp_fetch_packet,
2762			.read_close = sdp_read_close,
2763			};
2764			#endif /* CONFIG_SDP_DEMUXER */
2765
2766			#if CONFIG_RTP_DEMUXER
2767		4346	static int rtp_probe(const AVProbeData *p)
2768			{
2769	1/2 ✗ Branch 1 not taken. ✓ Branch 2 taken 4346 times.	4346	if (av_strstart(p->filename, "rtp:", NULL))
2770		✗	return AVPROBE_SCORE_MAX;
2771		4346	return 0;
2772			}
2773
2774		✗	static int rtp_read_header(AVFormatContext *s)
2775			{
2776			uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2777			char host[500], filters_buf[1000];
2778			int ret, port;
2779		✗	URLContext* in = NULL;
2780			int payload_type;
2781		✗	AVCodecParameters *par = NULL;
2782			struct sockaddr_storage addr;
2783			FFIOContext pb;
2784		✗	socklen_t addrlen = sizeof(addr);
2785		✗	RTSPState *rt = s->priv_data;
2786			const char *p;
2787			AVBPrint sdp;
2788		✗	AVDictionary *opts = NULL;
2789
2790		✗	if ((ret = ff_network_init()) < 0)
2791		✗	return ret;
2792
2793		✗	opts = map_to_opts(rt);
2794		✗	ret = ffurl_open_whitelist(&in, s->url, AVIO_FLAG_READ,
2795		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2796		✗	av_dict_free(&opts);
2797		✗	if (ret)
2798		✗	goto fail;
2799
2800			while (1) {
2801		✗	ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2802		✗	if (ret == AVERROR(EAGAIN))
2803		✗	continue;
2804		✗	if (ret < 0)
2805		✗	goto fail;
2806		✗	if (ret < 12) {
2807		✗	av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2808		✗	continue;
2809			}
2810
2811		✗	if ((recvbuf[0] & 0xc0) != 0x80) {
2812		✗	av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2813			"received\n");
2814		✗	continue;
2815			}
2816
2817		✗	if (RTP_PT_IS_RTCP(recvbuf[1]))
2818		✗	continue;
2819
2820		✗	payload_type = recvbuf[1] & 0x7f;
2821		✗	break;
2822			}
2823		✗	getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2824		✗	ffurl_closep(&in);
2825
2826		✗	par = avcodec_parameters_alloc();
2827		✗	if (!par) {
2828		✗	ret = AVERROR(ENOMEM);
2829		✗	goto fail;
2830			}
2831
2832		✗	if (ff_rtp_get_codec_info(par, payload_type)) {
2833		✗	av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2834			"without an SDP file describing it\n",
2835			payload_type);
2836		✗	ret = AVERROR_INVALIDDATA;
2837		✗	goto fail;
2838			}
2839		✗	if (par->codec_type != AVMEDIA_TYPE_DATA) {
2840		✗	av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2841			"properly you need an SDP file "
2842			"describing it\n");
2843			}
2844
2845		✗	av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2846		✗	NULL, 0, s->url);
2847
2848		✗	av_bprint_init(&sdp, 0, AV_BPRINT_SIZE_UNLIMITED);
2849		✗	av_bprintf(&sdp, "v=0\r\nc=IN IP%d %s\r\n",
2850		✗	addr.ss_family == AF_INET ? 4 : 6, host);
2851
2852		✗	p = strchr(s->url, '?');
2853		✗	if (p) {
2854			static const char filters[][2][8] = { { "sources", "incl" },
2855			{ "block", "excl" } };
2856			int i;
2857			char *q;
2858		✗	for (i = 0; i < FF_ARRAY_ELEMS(filters); i++) {
2859		✗	if (av_find_info_tag(filters_buf, sizeof(filters_buf), filters[i][0], p)) {
2860		✗	q = filters_buf;
2861		✗	while ((q = strchr(q, ',')) != NULL)
2862		✗	*q = ' ';
2863		✗	av_bprintf(&sdp, "a=source-filter:%s IN IP%d %s %s\r\n",
2864		✗	filters[i][1],
2865		✗	addr.ss_family == AF_INET ? 4 : 6, host,
2866			filters_buf);
2867			}
2868			}
2869			}
2870
2871		✗	av_bprintf(&sdp, "m=%s %d RTP/AVP %d\r\n",
2872		✗	par->codec_type == AVMEDIA_TYPE_DATA ? "application" :
2873		✗	par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2874			port, payload_type);
2875		✗	av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp.str);
2876		✗	if (!av_bprint_is_complete(&sdp))
2877		✗	goto fail_nobuf;
2878		✗	avcodec_parameters_free(&par);
2879
2880		✗	ffio_init_read_context(&pb, sdp.str, sdp.len);
2881		✗	s->pb = &pb.pub;
2882
2883			/* if sdp_read_header() fails then following ff_network_close() cancels out */
2884			/* ff_network_init() at the start of this function. Otherwise it cancels out */
2885			/* ff_network_init() inside sdp_read_header() */
2886		✗	ff_network_close();
2887
2888		✗	rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2889
2890		✗	ret = sdp_read_header(s);
2891		✗	s->pb = NULL;
2892		✗	av_bprint_finalize(&sdp, NULL);
2893		✗	return ret;
2894
2895		✗	fail_nobuf:
2896		✗	ret = AVERROR(ENOMEM);
2897		✗	av_log(s, AV_LOG_ERROR, "rtp_read_header(): not enough buffer space for sdp-headers\n");
2898		✗	av_bprint_finalize(&sdp, NULL);
2899		✗	fail:
2900		✗	avcodec_parameters_free(&par);
2901		✗	ffurl_closep(&in);
2902		✗	ff_network_close();
2903		✗	return ret;
2904			}
2905
2906			static const AVClass rtp_demuxer_class = {
2907			.class_name = "RTP demuxer",
2908			.item_name = av_default_item_name,
2909			.option = rtp_options,
2910			.version = LIBAVUTIL_VERSION_INT,
2911			};
2912
2913			const FFInputFormat ff_rtp_demuxer = {
2914			.p.name = "rtp",
2915			.p.long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2916			.p.flags = AVFMT_NOFILE,
2917			.p.priv_class = &rtp_demuxer_class,
2918			.priv_data_size = sizeof(RTSPState),
2919			.read_probe = rtp_probe,
2920			.read_header = rtp_read_header,
2921			.read_packet = ff_rtsp_fetch_packet,
2922			.read_close = sdp_read_close,
2923			};
2924			#endif /* CONFIG_RTP_DEMUXER */
2925