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