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)))
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		✗	if (rt->transport == RTSP_TRANSPORT_RDT)
1466		✗	trans_pref = "x-pn-tng";
1467		✗	else if (rt->transport == RTSP_TRANSPORT_RAW)
1468		✗	trans_pref = "RAW/RAW";
1469			else
1470		✗	trans_pref = "RTP/AVP";
1471
1472			/* default timeout: 1 minute */
1473		✗	rt->timeout = 60;
1474
1475			/* Choose a random starting offset within the first half of the
1476			* port range, to allow for a number of ports to try even if the offset
1477			* happens to be at the end of the random range. */
1478		✗	if (rt->rtp_port_max - rt->rtp_port_min >= 4) {
1479		✗	port_off = av_get_random_seed() % ((rt->rtp_port_max - rt->rtp_port_min)/2);
1480			/* even random offset */
1481		✗	port_off -= port_off & 0x01;
1482			}
1483
1484		✗	for (j = rt->rtp_port_min + port_off, i = 0; i < rt->nb_rtsp_streams; ++i) {
1485			char transport[MAX_URL_SIZE];
1486
1487			/*
1488			* WMS serves all UDP data over a single connection, the RTX, which
1489			* isn't necessarily the first in the SDP but has to be the first
1490			* to be set up, else the second/third SETUP will fail with a 461.
1491			*/
1492		✗	if (lower_transport == RTSP_LOWER_TRANSPORT_UDP &&
1493		✗	rt->server_type == RTSP_SERVER_WMS) {
1494		✗	if (i == 0) {
1495			/* rtx first */
1496		✗	for (rtx = 0; rtx < rt->nb_rtsp_streams; rtx++) {
1497		✗	int len = strlen(rt->rtsp_streams[rtx]->control_url);
1498		✗	if (len >= 4 &&
1499		✗	!strcmp(rt->rtsp_streams[rtx]->control_url + len - 4,
1500			"/rtx"))
1501		✗	break;
1502			}
1503		✗	if (rtx == rt->nb_rtsp_streams)
1504		✗	return -1; /* no RTX found */
1505		✗	rtsp_st = rt->rtsp_streams[rtx];
1506			} else
1507		✗	rtsp_st = rt->rtsp_streams[i > rtx ? i : i - 1];
1508			} else
1509		✗	rtsp_st = rt->rtsp_streams[i];
1510
1511			/* RTP/UDP */
1512		✗	if (lower_transport == RTSP_LOWER_TRANSPORT_UDP) {
1513			char buf[256];
1514
1515		✗	if (rt->server_type == RTSP_SERVER_WMS && i > 1) {
1516		✗	port = reply->transports[0].client_port_min;
1517		✗	goto have_port;
1518			}
1519
1520			/* first try in specified port range */
1521		✗	while (j + 1 <= rt->rtp_port_max) {
1522		✗	AVDictionary *opts = map_to_opts(rt);
1523
1524		✗	ff_url_join(buf, sizeof(buf), "rtp", NULL, host, -1,
1525			"?localport=%d", j);
1526			/* we will use two ports per rtp stream (rtp and rtcp) */
1527		✗	j += 2;
1528		✗	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, buf, AVIO_FLAG_READ_WRITE,
1529		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1530
1531		✗	av_dict_free(&opts);
1532
1533		✗	if (!err)
1534		✗	goto rtp_opened;
1535			}
1536		✗	av_log(s, AV_LOG_ERROR, "Unable to open an input RTP port\n");
1537		✗	err = AVERROR(EIO);
1538		✗	goto fail;
1539
1540		✗	rtp_opened:
1541		✗	port = ff_rtp_get_local_rtp_port(rtsp_st->rtp_handle);
1542		✗	have_port:
1543		✗	av_strlcpy(transport, trans_pref, sizeof(transport));
1544		✗	av_strlcat(transport,
1545		✗	rt->server_type == RTSP_SERVER_SATIP ? ";" : "/UDP;",
1546			sizeof(transport));
1547		✗	if (rt->server_type != RTSP_SERVER_REAL)
1548		✗	av_strlcat(transport, "unicast;", sizeof(transport));
1549		✗	av_strlcatf(transport, sizeof(transport),
1550			"client_port=%d", port);
1551		✗	if (rt->transport == RTSP_TRANSPORT_RTP &&
1552		✗	!(rt->server_type == RTSP_SERVER_WMS && i > 0))
1553		✗	av_strlcatf(transport, sizeof(transport), "-%d", port + 1);
1554			}
1555
1556			/* RTP/TCP */
1557		✗	else if (lower_transport == RTSP_LOWER_TRANSPORT_TCP) {
1558			/* For WMS streams, the application streams are only used for
1559			* UDP. When trying to set it up for TCP streams, the server
1560			* will return an error. Therefore, we skip those streams. */
1561		✗	if (rt->server_type == RTSP_SERVER_WMS &&
1562		✗	(rtsp_st->stream_index < 0 ||
1563		✗	s->streams[rtsp_st->stream_index]->codecpar->codec_type ==
1564			AVMEDIA_TYPE_DATA))
1565		✗	continue;
1566		✗	snprintf(transport, sizeof(transport) - 1,
1567			"%s/TCP;", trans_pref);
1568		✗	if (rt->transport != RTSP_TRANSPORT_RDT)
1569		✗	av_strlcat(transport, "unicast;", sizeof(transport));
1570		✗	av_strlcatf(transport, sizeof(transport),
1571			"interleaved=%d-%d",
1572			interleave, interleave + 1);
1573		✗	interleave += 2;
1574			}
1575
1576		✗	else if (lower_transport == RTSP_LOWER_TRANSPORT_UDP_MULTICAST) {
1577		✗	snprintf(transport, sizeof(transport) - 1,
1578			"%s/UDP;multicast", trans_pref);
1579			}
1580		✗	if (s->oformat) {
1581		✗	av_strlcat(transport, ";mode=record", sizeof(transport));
1582		✗	} else if (rt->server_type == RTSP_SERVER_REAL ||
1583		✗	rt->server_type == RTSP_SERVER_WMS)
1584		✗	av_strlcat(transport, ";mode=play", sizeof(transport));
1585		✗	snprintf(cmd, sizeof(cmd),
1586			"Transport: %s\r\n",
1587			transport);
1588		✗	if (rt->accept_dynamic_rate)
1589		✗	av_strlcat(cmd, "x-Dynamic-Rate: 0\r\n", sizeof(cmd));
1590		✗	if (CONFIG_RTPDEC && i == 0 && rt->server_type == RTSP_SERVER_REAL) {
1591			char real_res[41], real_csum[9];
1592		✗	ff_rdt_calc_response_and_checksum(real_res, real_csum,
1593			real_challenge);
1594		✗	av_strlcatf(cmd, sizeof(cmd),
1595			"If-Match: %s\r\n"
1596			"RealChallenge2: %s, sd=%s\r\n",
1597		✗	rt->session_id, real_res, real_csum);
1598			}
1599		✗	ff_rtsp_send_cmd(s, "SETUP", rtsp_st->control_url, cmd, reply, NULL);
1600		✗	if (reply->status_code == 461 /* Unsupported protocol */ && i == 0) {
1601		✗	err = 1;
1602		✗	goto fail;
1603		✗	} else if (reply->status_code != RTSP_STATUS_OK ||
1604		✗	reply->nb_transports != 1) {
1605		✗	err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1606		✗	goto fail;
1607			}
1608
1609		✗	if (rt->server_type == RTSP_SERVER_SATIP && reply->stream_id[0]) {
1610			char proto[128], host[128], path[512], auth[128];
1611			int port;
1612		✗	av_url_split(proto, sizeof(proto), auth, sizeof(auth), host, sizeof(host),
1613		✗	&port, path, sizeof(path), rt->control_uri);
1614		✗	ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL, host,
1615		✗	port, "/stream=%s", reply->stream_id);
1616			}
1617
1618			/* XXX: same protocol for all streams is required */
1619		✗	if (i > 0) {
1620		✗	if (reply->transports[0].lower_transport != rt->lower_transport ||
1621		✗	reply->transports[0].transport != rt->transport) {
1622		✗	err = AVERROR_INVALIDDATA;
1623		✗	goto fail;
1624			}
1625			} else {
1626		✗	rt->lower_transport = reply->transports[0].lower_transport;
1627		✗	rt->transport = reply->transports[0].transport;
1628			}
1629
1630			/* Fail if the server responded with another lower transport mode
1631			* than what we requested. */
1632		✗	if (reply->transports[0].lower_transport != lower_transport) {
1633		✗	av_log(s, AV_LOG_ERROR, "Nonmatching transport in server reply\n");
1634		✗	err = AVERROR_INVALIDDATA;
1635		✗	goto fail;
1636			}
1637
1638		✗	switch(reply->transports[0].lower_transport) {
1639		✗	case RTSP_LOWER_TRANSPORT_TCP:
1640		✗	rtsp_st->interleaved_min = reply->transports[0].interleaved_min;
1641		✗	rtsp_st->interleaved_max = reply->transports[0].interleaved_max;
1642		✗	break;
1643
1644		✗	case RTSP_LOWER_TRANSPORT_UDP: {
1645		✗	char url[MAX_URL_SIZE], options[30] = "";
1646		✗	const char *peer = host;
1647
1648		✗	if (rt->rtsp_flags & RTSP_FLAG_FILTER_SRC)
1649		✗	av_strlcpy(options, "?connect=1", sizeof(options));
1650			/* Use source address if specified */
1651		✗	if (reply->transports[0].source[0])
1652		✗	peer = reply->transports[0].source;
1653		✗	ff_url_join(url, sizeof(url), "rtp", NULL, peer,
1654			reply->transports[0].server_port_min, "%s", options);
1655		✗	if (!(rt->server_type == RTSP_SERVER_WMS && i > 1) &&
1656		✗	ff_rtp_set_remote_url(rtsp_st->rtp_handle, url) < 0) {
1657		✗	err = AVERROR_INVALIDDATA;
1658		✗	goto fail;
1659			}
1660		✗	break;
1661			}
1662		✗	case RTSP_LOWER_TRANSPORT_UDP_MULTICAST: {
1663		✗	char url[MAX_URL_SIZE], namebuf[50], optbuf[20] = "";
1664			struct sockaddr_storage addr;
1665			int port, ttl;
1666		✗	AVDictionary *opts = map_to_opts(rt);
1667
1668		✗	if (reply->transports[0].destination.ss_family) {
1669		✗	addr = reply->transports[0].destination;
1670		✗	port = reply->transports[0].port_min;
1671		✗	ttl = reply->transports[0].ttl;
1672			} else {
1673		✗	addr = rtsp_st->sdp_ip;
1674		✗	port = rtsp_st->sdp_port;
1675		✗	ttl = rtsp_st->sdp_ttl;
1676			}
1677		✗	if (ttl > 0)
1678		✗	snprintf(optbuf, sizeof(optbuf), "?ttl=%d", ttl);
1679		✗	getnameinfo((struct sockaddr*) &addr, sizeof(addr),
1680			namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
1681		✗	ff_url_join(url, sizeof(url), "rtp", NULL, namebuf,
1682			port, "%s", optbuf);
1683		✗	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ_WRITE,
1684		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
1685		✗	av_dict_free(&opts);
1686
1687		✗	if (err < 0) {
1688		✗	err = AVERROR_INVALIDDATA;
1689		✗	goto fail;
1690			}
1691		✗	break;
1692			}
1693			}
1694
1695		✗	if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
1696		✗	goto fail;
1697			}
1698
1699		✗	if (rt->nb_rtsp_streams && reply->timeout > 0)
1700		✗	rt->timeout = reply->timeout;
1701
1702		✗	if (rt->server_type == RTSP_SERVER_REAL)
1703		✗	rt->need_subscription = 1;
1704
1705		✗	return 0;
1706
1707		✗	fail:
1708		✗	ff_rtsp_undo_setup(s, 0);
1709		✗	return err;
1710			}
1711
1712		✗	void ff_rtsp_close_connections(AVFormatContext *s)
1713			{
1714		✗	RTSPState *rt = s->priv_data;
1715		✗	if (rt->rtsp_hd_out != rt->rtsp_hd)
1716		✗	ffurl_closep(&rt->rtsp_hd_out);
1717		✗	rt->rtsp_hd_out = NULL;
1718		✗	ffurl_closep(&rt->rtsp_hd);
1719		✗	}
1720
1721		✗	int ff_rtsp_connect(AVFormatContext *s)
1722			{
1723		✗	RTSPState *rt = s->priv_data;
1724			char proto[128], host[1024], path[1024];
1725			char tcpname[1024], cmd[MAX_URL_SIZE], auth[128];
1726		✗	const char *lower_rtsp_proto = "tcp";
1727			int port, err, tcp_fd;
1728		✗	RTSPMessageHeader reply1, *reply = &reply1;
1729		✗	int lower_transport_mask = 0;
1730		✗	int default_port = RTSP_DEFAULT_PORT;
1731		✗	int https_tunnel = 0;
1732		✗	char real_challenge[64] = "";
1733			struct sockaddr_storage peer;
1734		✗	socklen_t peer_len = sizeof(peer);
1735
1736		✗	if (rt->rtp_port_max < rt->rtp_port_min) {
1737		✗	av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
1738			"than min port %d\n", rt->rtp_port_max,
1739			rt->rtp_port_min);
1740		✗	return AVERROR(EINVAL);
1741			}
1742
1743		✗	if (!ff_network_init())
1744		✗	return AVERROR(EIO);
1745
1746		✗	if (s->max_delay < 0) /* Not set by the caller */
1747		✗	s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
1748
1749		✗	rt->control_transport = RTSP_MODE_PLAIN;
1750		✗	if (rt->lower_transport_mask & ((1 << RTSP_LOWER_TRANSPORT_HTTP) |
1751			(1 << RTSP_LOWER_TRANSPORT_HTTPS))) {
1752		✗	https_tunnel = !!(rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTPS));
1753		✗	rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1754		✗	rt->control_transport = RTSP_MODE_TUNNEL;
1755			}
1756			/* Only pass through valid flags from here */
1757		✗	rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1758
1759		✗	redirect:
1760		✗	memset(&reply1, 0, sizeof(reply1));
1761			/* extract hostname and port */
1762		✗	av_url_split(proto, sizeof(proto), auth, sizeof(auth),
1763		✗	host, sizeof(host), &port, path, sizeof(path), s->url);
1764
1765		✗	if (!strcmp(proto, "rtsps")) {
1766		✗	lower_rtsp_proto = "tls";
1767		✗	default_port = RTSPS_DEFAULT_PORT;
1768		✗	rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
1769		✗	} else if (!strcmp(proto, "satip")) {
1770		✗	av_strlcpy(proto, "rtsp", sizeof(proto));
1771		✗	rt->server_type = RTSP_SERVER_SATIP;
1772			}
1773
1774		✗	if (*auth) {
1775		✗	av_strlcpy(rt->auth, auth, sizeof(rt->auth));
1776			}
1777		✗	if (port < 0)
1778		✗	port = default_port;
1779
1780		✗	lower_transport_mask = rt->lower_transport_mask;
1781
1782		✗	if (!lower_transport_mask)
1783		✗	lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
1784
1785		✗	if (s->oformat) {
1786			/* Only UDP or TCP - UDP multicast isn't supported. */
1787		✗	lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
1788			(1 << RTSP_LOWER_TRANSPORT_TCP);
1789		✗	if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) {
1790		✗	av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
1791			"only UDP and TCP are supported for output.\n");
1792		✗	err = AVERROR(EINVAL);
1793		✗	goto fail;
1794			}
1795			}
1796
1797			/* Construct the URI used in request; this is similar to s->url,
1798			* but with authentication credentials removed and RTSP specific options
1799			* stripped out. */
1800		✗	ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
1801			host, port, "%s", path);
1802
1803		✗	if (rt->control_transport == RTSP_MODE_TUNNEL) {
1804			/* set up initial handshake for tunneling */
1805			char httpname[1024];
1806			char sessioncookie[17];
1807			char headers[1024];
1808		✗	AVDictionary *options = NULL;
1809
1810		✗	av_dict_set_int(&options, "timeout", rt->stimeout, 0);
1811
1812		✗	ff_url_join(httpname, sizeof(httpname), https_tunnel ? "https" : "http", auth, host, port, "%s", path);
1813		✗	snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
1814			av_get_random_seed(), av_get_random_seed());
1815
1816			/* GET requests */
1817		✗	if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
1818		✗	&s->interrupt_callback) < 0) {
1819		✗	err = AVERROR(EIO);
1820		✗	goto fail;
1821			}
1822
1823			/* generate GET headers */
1824		✗	snprintf(headers, sizeof(headers),
1825			"x-sessioncookie: %s\r\n"
1826			"Accept: application/x-rtsp-tunnelled\r\n"
1827			"Pragma: no-cache\r\n"
1828			"Cache-Control: no-cache\r\n",
1829			sessioncookie);
1830		✗	av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
1831
1832		✗	if (!rt->rtsp_hd->protocol_whitelist && s->protocol_whitelist) {
1833		✗	rt->rtsp_hd->protocol_whitelist = av_strdup(s->protocol_whitelist);
1834		✗	if (!rt->rtsp_hd->protocol_whitelist) {
1835		✗	err = AVERROR(ENOMEM);
1836		✗	goto fail;
1837			}
1838			}
1839
1840			/* complete the connection */
1841		✗	if (ffurl_connect(rt->rtsp_hd, &options)) {
1842		✗	av_dict_free(&options);
1843		✗	err = AVERROR(EIO);
1844		✗	goto fail;
1845			}
1846
1847			/* POST requests */
1848		✗	if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
1849		✗	&s->interrupt_callback) < 0 ) {
1850		✗	err = AVERROR(EIO);
1851		✗	goto fail;
1852			}
1853
1854			/* generate POST headers */
1855		✗	snprintf(headers, sizeof(headers),
1856			"x-sessioncookie: %s\r\n"
1857			"Content-Type: application/x-rtsp-tunnelled\r\n"
1858			"Pragma: no-cache\r\n"
1859			"Cache-Control: no-cache\r\n"
1860			"Content-Length: 32767\r\n"
1861			"Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
1862			sessioncookie);
1863		✗	av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
1864		✗	av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
1865		✗	av_opt_set(rt->rtsp_hd_out->priv_data, "send_expect_100", "0", 0);
1866
1867			/* Initialize the authentication state for the POST session. The HTTP
1868			* protocol implementation doesn't properly handle multi-pass
1869			* authentication for POST requests, since it would require one of
1870			* the following:
1871			* - implementing Expect: 100-continue, which many HTTP servers
1872			* don't support anyway, even less the RTSP servers that do HTTP
1873			* tunneling
1874			* - sending the whole POST data until getting a 401 reply specifying
1875			* what authentication method to use, then resending all that data
1876			* - waiting for potential 401 replies directly after sending the
1877			* POST header (waiting for some unspecified time)
1878			* Therefore, we copy the full auth state, which works for both basic
1879			* and digest. (For digest, we would have to synchronize the nonce
1880			* count variable between the two sessions, if we'd do more requests
1881			* with the original session, though.)
1882			*/
1883		✗	ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
1884
1885			/* complete the connection */
1886		✗	if (ffurl_connect(rt->rtsp_hd_out, &options)) {
1887		✗	av_dict_free(&options);
1888		✗	err = AVERROR(EIO);
1889		✗	goto fail;
1890			}
1891		✗	av_dict_free(&options);
1892			} else {
1893			int ret;
1894			/* open the tcp connection */
1895		✗	ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
1896			host, port,
1897			"?timeout=%"PRId64, rt->stimeout);
1898		✗	if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
1899		✗	&s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL)) < 0) {
1900		✗	err = ret;
1901		✗	goto fail;
1902			}
1903		✗	rt->rtsp_hd_out = rt->rtsp_hd;
1904			}
1905		✗	rt->seq = 0;
1906
1907		✗	tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
1908		✗	if (tcp_fd < 0) {
1909		✗	err = tcp_fd;
1910		✗	goto fail;
1911			}
1912		✗	if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) {
1913		✗	getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
1914			NULL, 0, NI_NUMERICHOST);
1915			}
1916
1917			/* request options supported by the server; this also detects server
1918			* type */
1919		✗	if (rt->server_type != RTSP_SERVER_SATIP)
1920		✗	rt->server_type = RTSP_SERVER_RTP;
1921			for (;;) {
1922		✗	cmd[0] = 0;
1923		✗	if (rt->server_type == RTSP_SERVER_REAL)
1924		✗	av_strlcat(cmd,
1925			/*
1926			* The following entries are required for proper
1927			* streaming from a Realmedia server. They are
1928			* interdependent in some way although we currently
1929			* don't quite understand how. Values were copied
1930			* from mplayer SVN r23589.
1931			* ClientChallenge is a 16-byte ID in hex
1932			* CompanyID is a 16-byte ID in base64
1933			*/
1934			"ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
1935			"PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
1936			"CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
1937			"GUID: 00000000-0000-0000-0000-000000000000\r\n",
1938			sizeof(cmd));
1939		✗	ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
1940		✗	if (reply->status_code != RTSP_STATUS_OK) {
1941		✗	err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
1942		✗	goto fail;
1943			}
1944
1945			/* detect server type if not standard-compliant RTP */
1946		✗	if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) {
1947		✗	rt->server_type = RTSP_SERVER_REAL;
1948		✗	continue;
1949		✗	} else if (!av_strncasecmp(reply->server, "WMServer/", 9)) {
1950		✗	rt->server_type = RTSP_SERVER_WMS;
1951		✗	} else if (rt->server_type == RTSP_SERVER_REAL)
1952		✗	strcpy(real_challenge, reply->real_challenge);
1953		✗	break;
1954			}
1955
1956			#if CONFIG_RTSP_DEMUXER
1957		✗	if (s->iformat) {
1958		✗	if (rt->server_type == RTSP_SERVER_SATIP)
1959		✗	err = init_satip_stream(s);
1960			else
1961		✗	err = ff_rtsp_setup_input_streams(s, reply);
1962			} else
1963			#endif
1964			if (CONFIG_RTSP_MUXER)
1965		✗	err = ff_rtsp_setup_output_streams(s, host);
1966			else
1967			av_assert0(0);
1968		✗	if (err)
1969		✗	goto fail;
1970
1971			do {
1972		✗	int lower_transport = ff_log2_tab[lower_transport_mask &
1973		✗	~(lower_transport_mask - 1)];
1974
1975		✗	if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
1976		✗	&& (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
1977		✗	lower_transport = RTSP_LOWER_TRANSPORT_TCP;
1978
1979		✗	err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
1980		✗	rt->server_type == RTSP_SERVER_REAL ?
1981			real_challenge : NULL);
1982		✗	if (err < 0)
1983		✗	goto fail;
1984		✗	lower_transport_mask &= ~(1 << lower_transport);
1985		✗	if (lower_transport_mask == 0 && err == 1) {
1986		✗	err = AVERROR(EPROTONOSUPPORT);
1987		✗	goto fail;
1988			}
1989		✗	} while (err);
1990
1991		✗	rt->lower_transport_mask = lower_transport_mask;
1992		✗	av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
1993		✗	rt->state = RTSP_STATE_IDLE;
1994		✗	rt->seek_timestamp = 0; /* default is to start stream at position zero */
1995		✗	return 0;
1996		✗	fail:
1997		✗	ff_rtsp_close_streams(s);
1998		✗	ff_rtsp_close_connections(s);
1999		✗	if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) {
2000		✗	char *new_url = av_strdup(reply->location);
2001		✗	if (!new_url) {
2002		✗	err = AVERROR(ENOMEM);
2003		✗	goto fail2;
2004			}
2005		✗	ff_format_set_url(s, new_url);
2006		✗	rt->session_id[0] = '\0';
2007		✗	av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
2008		✗	reply->status_code,
2009			s->url);
2010		✗	goto redirect;
2011			}
2012		✗	fail2:
2013		✗	ff_network_close();
2014		✗	return err;
2015			}
2016			#endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
2017
2018			#if CONFIG_RTPDEC
2019			#if CONFIG_RTSP_DEMUXER
2020		✗	static int parse_rtsp_message(AVFormatContext *s)
2021			{
2022		✗	RTSPState *rt = s->priv_data;
2023			int ret;
2024
2025		✗	if (rt->rtsp_flags & RTSP_FLAG_LISTEN) {
2026		✗	if (rt->state == RTSP_STATE_STREAMING) {
2027		✗	return ff_rtsp_parse_streaming_commands(s);
2028			} else
2029		✗	return AVERROR_EOF;
2030			} else {
2031			RTSPMessageHeader reply;
2032		✗	ret = ff_rtsp_read_reply(s, &reply, NULL, 0, NULL);
2033		✗	if (ret < 0)
2034		✗	return ret;
2035			/* XXX: parse message */
2036		✗	if (rt->state != RTSP_STATE_STREAMING)
2037		✗	return 0;
2038			}
2039
2040		✗	return 0;
2041			}
2042			#endif
2043
2044		✗	static int udp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
2045			uint8_t *buf, int buf_size, int64_t wait_end)
2046			{
2047		✗	RTSPState *rt = s->priv_data;
2048			RTSPStream *rtsp_st;
2049			int n, i, ret;
2050		✗	struct pollfd *p = rt->p;
2051		✗	int *fds = NULL, fdsnum, fdsidx;
2052		✗	int64_t runs = rt->stimeout / POLLING_TIME / 1000;
2053
2054		✗	if (!p) {
2055		✗	p = rt->p = av_malloc_array(2 * rt->nb_rtsp_streams + 1, sizeof(*p));
2056		✗	if (!p)
2057		✗	return AVERROR(ENOMEM);
2058
2059		✗	if (rt->rtsp_hd) {
2060		✗	p[rt->max_p].fd = ffurl_get_file_handle(rt->rtsp_hd);
2061		✗	p[rt->max_p++].events = POLLIN;
2062			}
2063		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2064		✗	rtsp_st = rt->rtsp_streams[i];
2065		✗	if (rtsp_st->rtp_handle) {
2066		✗	if (ret = ffurl_get_multi_file_handle(rtsp_st->rtp_handle,
2067			&fds, &fdsnum)) {
2068		✗	av_log(s, AV_LOG_ERROR, "Unable to recover rtp ports\n");
2069		✗	return ret;
2070			}
2071		✗	if (fdsnum != 2) {
2072		✗	av_log(s, AV_LOG_ERROR,
2073			"Number of fds %d not supported\n", fdsnum);
2074		✗	return AVERROR_INVALIDDATA;
2075			}
2076		✗	for (fdsidx = 0; fdsidx < fdsnum; fdsidx++) {
2077		✗	p[rt->max_p].fd = fds[fdsidx];
2078		✗	p[rt->max_p++].events = POLLIN;
2079			}
2080		✗	av_freep(&fds);
2081			}
2082			}
2083			}
2084
2085			for (;;) {
2086		✗	if (ff_check_interrupt(&s->interrupt_callback))
2087		✗	return AVERROR_EXIT;
2088		✗	if (wait_end && wait_end - av_gettime_relative() < 0)
2089		✗	return AVERROR(EAGAIN);
2090		✗	n = poll(p, rt->max_p, POLLING_TIME);
2091		✗	if (n > 0) {
2092		✗	int j = rt->rtsp_hd ? 1 : 0;
2093		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2094		✗	rtsp_st = rt->rtsp_streams[i];
2095		✗	if (rtsp_st->rtp_handle) {
2096		✗	if (p[j].revents & POLLIN || p[j+1].revents & POLLIN) {
2097		✗	ret = ffurl_read(rtsp_st->rtp_handle, buf, buf_size);
2098		✗	if (ret > 0) {
2099		✗	*prtsp_st = rtsp_st;
2100		✗	return ret;
2101			}
2102			}
2103		✗	j+=2;
2104			}
2105			}
2106			#if CONFIG_RTSP_DEMUXER
2107		✗	if (rt->rtsp_hd && p[0].revents & POLLIN) {
2108		✗	if ((ret = parse_rtsp_message(s)) < 0) {
2109		✗	return ret;
2110			}
2111			}
2112			#endif
2113		✗	} else if (n == 0 && rt->stimeout > 0 && --runs <= 0) {
2114		✗	return AVERROR(ETIMEDOUT);
2115		✗	} else if (n < 0 && errno != EINTR)
2116		✗	return AVERROR(errno);
2117			}
2118			}
2119
2120		✗	static int pick_stream(AVFormatContext *s, RTSPStream **rtsp_st,
2121			const uint8_t *buf, int len)
2122			{
2123		✗	RTSPState *rt = s->priv_data;
2124			int i;
2125		✗	if (len < 0)
2126		✗	return len;
2127		✗	if (rt->nb_rtsp_streams == 1) {
2128		✗	*rtsp_st = rt->rtsp_streams[0];
2129		✗	return len;
2130			}
2131		✗	if (len >= 8 && rt->transport == RTSP_TRANSPORT_RTP) {
2132		✗	if (RTP_PT_IS_RTCP(rt->recvbuf[1])) {
2133		✗	int no_ssrc = 0;
2134		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2135		✗	RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2136		✗	if (!rtpctx)
2137		✗	continue;
2138		✗	if (rtpctx->ssrc == AV_RB32(&buf[4])) {
2139		✗	*rtsp_st = rt->rtsp_streams[i];
2140		✗	return len;
2141			}
2142		✗	if (!rtpctx->ssrc)
2143		✗	no_ssrc = 1;
2144			}
2145		✗	if (no_ssrc) {
2146		✗	av_log(s, AV_LOG_WARNING,
2147			"Unable to pick stream for packet - SSRC not known for "
2148			"all streams\n");
2149		✗	return AVERROR(EAGAIN);
2150			}
2151			} else {
2152		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2153		✗	if ((buf[1] & 0x7f) == rt->rtsp_streams[i]->sdp_payload_type) {
2154		✗	*rtsp_st = rt->rtsp_streams[i];
2155		✗	return len;
2156			}
2157			}
2158			}
2159			}
2160		✗	av_log(s, AV_LOG_WARNING, "Unable to pick stream for packet\n");
2161		✗	return AVERROR(EAGAIN);
2162			}
2163
2164		✗	static int read_packet(AVFormatContext *s,
2165			RTSPStream **rtsp_st, RTSPStream *first_queue_st,
2166			int64_t wait_end)
2167			{
2168		✗	RTSPState *rt = s->priv_data;
2169			int len;
2170
2171		✗	switch(rt->lower_transport) {
2172		✗	default:
2173			#if CONFIG_RTSP_DEMUXER
2174			case RTSP_LOWER_TRANSPORT_TCP:
2175		✗	len = ff_rtsp_tcp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE);
2176		✗	break;
2177			#endif
2178		✗	case RTSP_LOWER_TRANSPORT_UDP:
2179			case RTSP_LOWER_TRANSPORT_UDP_MULTICAST:
2180		✗	len = udp_read_packet(s, rtsp_st, rt->recvbuf, RECVBUF_SIZE, wait_end);
2181		✗	if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2182		✗	ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, (*rtsp_st)->rtp_handle, NULL, len);
2183		✗	break;
2184		✗	case RTSP_LOWER_TRANSPORT_CUSTOM:
2185		✗	if (first_queue_st && rt->transport == RTSP_TRANSPORT_RTP &&
2186		✗	wait_end && wait_end < av_gettime_relative())
2187		✗	len = AVERROR(EAGAIN);
2188			else
2189		✗	len = avio_read_partial(s->pb, rt->recvbuf, RECVBUF_SIZE);
2190		✗	len = pick_stream(s, rtsp_st, rt->recvbuf, len);
2191		✗	if (len > 0 && (*rtsp_st)->transport_priv && rt->transport == RTSP_TRANSPORT_RTP)
2192		✗	ff_rtp_check_and_send_back_rr((*rtsp_st)->transport_priv, NULL, s->pb, len);
2193		✗	break;
2194			}
2195
2196		✗	if (len == 0)
2197		✗	return AVERROR_EOF;
2198
2199		✗	return len;
2200			}
2201
2202		✗	int ff_rtsp_fetch_packet(AVFormatContext *s, AVPacket *pkt)
2203			{
2204		✗	RTSPState *rt = s->priv_data;
2205			int ret, len;
2206		✗	RTSPStream *rtsp_st, *first_queue_st = NULL;
2207		✗	int64_t wait_end = 0;
2208
2209		✗	if (rt->nb_byes == rt->nb_rtsp_streams)
2210		✗	return AVERROR_EOF;
2211
2212			/* get next frames from the same RTP packet */
2213		✗	if (rt->cur_transport_priv) {
2214		✗	if (rt->transport == RTSP_TRANSPORT_RDT) {
2215		✗	ret = ff_rdt_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2216		✗	} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2217		✗	ret = ff_rtp_parse_packet(rt->cur_transport_priv, pkt, NULL, 0);
2218		✗	} else if (CONFIG_RTPDEC && rt->ts) {
2219		✗	ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf + rt->recvbuf_pos, rt->recvbuf_len - rt->recvbuf_pos);
2220		✗	if (ret >= 0) {
2221		✗	rt->recvbuf_pos += ret;
2222		✗	ret = rt->recvbuf_pos < rt->recvbuf_len;
2223			}
2224			} else
2225		✗	ret = -1;
2226		✗	if (ret == 0) {
2227		✗	rt->cur_transport_priv = NULL;
2228		✗	return 0;
2229		✗	} else if (ret == 1) {
2230		✗	return 0;
2231			} else
2232		✗	rt->cur_transport_priv = NULL;
2233			}
2234
2235		✗	redo:
2236		✗	if (rt->transport == RTSP_TRANSPORT_RTP) {
2237			int i;
2238		✗	int64_t first_queue_time = 0;
2239		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2240		✗	RTPDemuxContext *rtpctx = rt->rtsp_streams[i]->transport_priv;
2241			int64_t queue_time;
2242		✗	if (!rtpctx)
2243		✗	continue;
2244		✗	queue_time = ff_rtp_queued_packet_time(rtpctx);
2245		✗	if (queue_time && (queue_time - first_queue_time < 0 ||
2246			!first_queue_time)) {
2247		✗	first_queue_time = queue_time;
2248		✗	first_queue_st = rt->rtsp_streams[i];
2249			}
2250			}
2251		✗	if (first_queue_time) {
2252		✗	wait_end = first_queue_time + s->max_delay;
2253			} else {
2254		✗	wait_end = 0;
2255		✗	first_queue_st = NULL;
2256			}
2257			}
2258
2259			/* read next RTP packet */
2260		✗	if (!rt->recvbuf) {
2261		✗	rt->recvbuf = av_malloc(RECVBUF_SIZE);
2262		✗	if (!rt->recvbuf)
2263		✗	return AVERROR(ENOMEM);
2264			}
2265
2266		✗	len = read_packet(s, &rtsp_st, first_queue_st, wait_end);
2267		✗	if (len == AVERROR(EAGAIN) && first_queue_st &&
2268		✗	rt->transport == RTSP_TRANSPORT_RTP) {
2269		✗	av_log(s, AV_LOG_WARNING,
2270			"max delay reached. need to consume packet\n");
2271		✗	rtsp_st = first_queue_st;
2272		✗	ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, NULL, 0);
2273		✗	goto end;
2274			}
2275		✗	if (len < 0)
2276		✗	return len;
2277
2278		✗	if (rt->transport == RTSP_TRANSPORT_RDT) {
2279		✗	ret = ff_rdt_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2280		✗	} else if (rt->transport == RTSP_TRANSPORT_RTP) {
2281		✗	ret = ff_rtp_parse_packet(rtsp_st->transport_priv, pkt, &rt->recvbuf, len);
2282		✗	if (rtsp_st->feedback) {
2283		✗	AVIOContext *pb = NULL;
2284		✗	if (rt->lower_transport == RTSP_LOWER_TRANSPORT_CUSTOM)
2285		✗	pb = s->pb;
2286		✗	ff_rtp_send_rtcp_feedback(rtsp_st->transport_priv, rtsp_st->rtp_handle, pb);
2287			}
2288		✗	if (ret < 0) {
2289			/* Either bad packet, or a RTCP packet. Check if the
2290			* first_rtcp_ntp_time field was initialized. */
2291		✗	RTPDemuxContext *rtpctx = rtsp_st->transport_priv;
2292		✗	if (rtpctx->first_rtcp_ntp_time != AV_NOPTS_VALUE) {
2293			/* first_rtcp_ntp_time has been initialized for this stream,
2294			* copy the same value to all other uninitialized streams,
2295			* in order to map their timestamp origin to the same ntp time
2296			* as this one. */
2297			int i;
2298		✗	AVStream *st = NULL;
2299		✗	if (rtsp_st->stream_index >= 0)
2300		✗	st = s->streams[rtsp_st->stream_index];
2301		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2302		✗	RTPDemuxContext *rtpctx2 = rt->rtsp_streams[i]->transport_priv;
2303		✗	AVStream *st2 = NULL;
2304		✗	if (rt->rtsp_streams[i]->stream_index >= 0)
2305		✗	st2 = s->streams[rt->rtsp_streams[i]->stream_index];
2306		✗	if (rtpctx2 && st && st2 &&
2307		✗	rtpctx2->first_rtcp_ntp_time == AV_NOPTS_VALUE) {
2308		✗	rtpctx2->first_rtcp_ntp_time = rtpctx->first_rtcp_ntp_time;
2309		✗	rtpctx2->rtcp_ts_offset = av_rescale_q(
2310			rtpctx->rtcp_ts_offset, st->time_base,
2311			st2->time_base);
2312			}
2313			}
2314			// Make real NTP start time available in AVFormatContext
2315		✗	if (s->start_time_realtime == AV_NOPTS_VALUE) {
2316		✗	s->start_time_realtime = av_rescale (rtpctx->first_rtcp_ntp_time - (NTP_OFFSET << 32), 1000000, 1LL << 32);
2317		✗	if (rtpctx->st) {
2318		✗	s->start_time_realtime -=
2319		✗	av_rescale_q (rtpctx->rtcp_ts_offset, rtpctx->st->time_base, AV_TIME_BASE_Q);
2320			}
2321			}
2322			}
2323		✗	if (ret == -RTCP_BYE) {
2324		✗	rt->nb_byes++;
2325
2326		✗	av_log(s, AV_LOG_DEBUG, "Received BYE for stream %d (%d/%d)\n",
2327		✗	rtsp_st->stream_index, rt->nb_byes, rt->nb_rtsp_streams);
2328
2329		✗	if (rt->nb_byes == rt->nb_rtsp_streams)
2330		✗	return AVERROR_EOF;
2331			}
2332			}
2333		✗	} else if (CONFIG_RTPDEC && rt->ts) {
2334		✗	ret = avpriv_mpegts_parse_packet(rt->ts, pkt, rt->recvbuf, len);
2335		✗	if (ret >= 0) {
2336		✗	if (ret < len) {
2337		✗	rt->recvbuf_len = len;
2338		✗	rt->recvbuf_pos = ret;
2339		✗	rt->cur_transport_priv = rt->ts;
2340		✗	return 1;
2341			} else {
2342		✗	ret = 0;
2343			}
2344			}
2345			} else {
2346		✗	return AVERROR_INVALIDDATA;
2347			}
2348		✗	end:
2349		✗	if (ret < 0)
2350		✗	goto redo;
2351		✗	if (ret == 1)
2352			/* more packets may follow, so we save the RTP context */
2353		✗	rt->cur_transport_priv = rtsp_st->transport_priv;
2354
2355		✗	return ret;
2356			}
2357			#endif /* CONFIG_RTPDEC */
2358
2359			#if CONFIG_SDP_DEMUXER
2360		7128	static int sdp_probe(const AVProbeData *p1)
2361			{
2362		7128	const char *p = p1->buf, *p_end = p1->buf + p1->buf_size;
2363
2364			/* we look for a line beginning "c=IN IP" */
2365	3/4 ✓ Branch 0 taken 518080 times. ✗ Branch 1 not taken. ✓ Branch 2 taken 514072 times. ✓ Branch 3 taken 4008 times.	518080	while (p < p_end && *p != '\0') {
2366	3/4 ✓ Branch 0 taken 513933 times. ✓ Branch 1 taken 139 times. ✗ Branch 2 not taken. ✓ Branch 3 taken 513933 times.	1028005	if (sizeof("c=IN IP") - 1 < p_end - p &&
2367		513933	av_strstart(p, "c=IN IP", NULL))
2368		✗	return AVPROBE_SCORE_EXTENSION;
2369
2370	4/4 ✓ Branch 0 taken 84755173 times. ✓ Branch 1 taken 3120 times. ✓ Branch 2 taken 84244221 times. ✓ Branch 3 taken 510952 times.	84758293	while (p < p_end - 1 && *p != '\n') p++;
2371	2/2 ✓ Branch 0 taken 3120 times. ✓ Branch 1 taken 510952 times.	514072	if (++p >= p_end)
2372		3120	break;
2373	2/2 ✓ Branch 0 taken 3094 times. ✓ Branch 1 taken 507858 times.	510952	if (*p == '\r')
2374		3094	p++;
2375			}
2376		7128	return 0;
2377			}
2378
2379		✗	static void append_source_addrs(char *buf, int size, const char *name,
2380			int count, struct RTSPSource **addrs)
2381			{
2382			int i;
2383		✗	if (!count)
2384		✗	return;
2385		✗	av_strlcatf(buf, size, "&%s=%s", name, addrs[0]->addr);
2386		✗	for (i = 1; i < count; i++)
2387		✗	av_strlcatf(buf, size, ",%s", addrs[i]->addr);
2388			}
2389
2390		✗	static int sdp_read_header(AVFormatContext *s)
2391			{
2392		✗	RTSPState *rt = s->priv_data;
2393			RTSPStream *rtsp_st;
2394			int i, err;
2395			char url[MAX_URL_SIZE];
2396			AVBPrint bp;
2397
2398		✗	if (!ff_network_init())
2399		✗	return AVERROR(EIO);
2400
2401		✗	if (s->max_delay < 0) /* Not set by the caller */
2402		✗	s->max_delay = DEFAULT_REORDERING_DELAY;
2403		✗	if (rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)
2404		✗	rt->lower_transport = RTSP_LOWER_TRANSPORT_CUSTOM;
2405
2406			/* read the whole sdp file */
2407		✗	av_bprint_init(&bp, 0, AV_BPRINT_SIZE_UNLIMITED);
2408		✗	err = avio_read_to_bprint(s->pb, &bp, INT_MAX);
2409		✗	if (err < 0 ) {
2410		✗	ff_network_close();
2411		✗	av_bprint_finalize(&bp, NULL);
2412		✗	return err;
2413			}
2414		✗	err = ff_sdp_parse(s, bp.str);
2415		✗	av_bprint_finalize(&bp, NULL);
2416		✗	if (err) goto fail;
2417
2418			/* open each RTP stream */
2419		✗	for (i = 0; i < rt->nb_rtsp_streams; i++) {
2420			char namebuf[50];
2421		✗	rtsp_st = rt->rtsp_streams[i];
2422
2423		✗	if (!(rt->rtsp_flags & RTSP_FLAG_CUSTOM_IO)) {
2424		✗	AVDictionary *opts = map_to_opts(rt);
2425			char buf[MAX_URL_SIZE];
2426			const char *p;
2427
2428		✗	err = getnameinfo((struct sockaddr*) &rtsp_st->sdp_ip,
2429			sizeof(rtsp_st->sdp_ip),
2430			namebuf, sizeof(namebuf), NULL, 0, NI_NUMERICHOST);
2431		✗	if (err) {
2432		✗	av_log(s, AV_LOG_ERROR, "getnameinfo: %s\n", gai_strerror(err));
2433		✗	err = AVERROR(EIO);
2434		✗	av_dict_free(&opts);
2435		✗	goto fail;
2436			}
2437		✗	ff_url_join(url, sizeof(url), "rtp", NULL,
2438			namebuf, rtsp_st->sdp_port,
2439			"?localport=%d&ttl=%d&connect=%d&write_to_source=%d",
2440			rtsp_st->sdp_port, rtsp_st->sdp_ttl,
2441		✗	rt->rtsp_flags & RTSP_FLAG_FILTER_SRC ? 1 : 0,
2442		✗	rt->rtsp_flags & RTSP_FLAG_RTCP_TO_SOURCE ? 1 : 0);
2443
2444		✗	p = strchr(s->url, '?');
2445		✗	if (p && av_find_info_tag(buf, sizeof(buf), "localaddr", p))
2446		✗	av_strlcatf(url, sizeof(url), "&localaddr=%s", buf);
2447		✗	else if (rt->localaddr && rt->localaddr[0])
2448		✗	av_strlcatf(url, sizeof(url), "&localaddr=%s", rt->localaddr);
2449		✗	append_source_addrs(url, sizeof(url), "sources",
2450			rtsp_st->nb_include_source_addrs,
2451			rtsp_st->include_source_addrs);
2452		✗	append_source_addrs(url, sizeof(url), "block",
2453			rtsp_st->nb_exclude_source_addrs,
2454			rtsp_st->exclude_source_addrs);
2455		✗	err = ffurl_open_whitelist(&rtsp_st->rtp_handle, url, AVIO_FLAG_READ,
2456		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2457
2458		✗	av_dict_free(&opts);
2459
2460		✗	if (err < 0) {
2461		✗	err = AVERROR_INVALIDDATA;
2462		✗	goto fail;
2463			}
2464			}
2465		✗	if ((err = ff_rtsp_open_transport_ctx(s, rtsp_st)))
2466		✗	goto fail;
2467			}
2468		✗	return 0;
2469		✗	fail:
2470		✗	ff_rtsp_close_streams(s);
2471		✗	ff_network_close();
2472		✗	return err;
2473			}
2474
2475		✗	static int sdp_read_close(AVFormatContext *s)
2476			{
2477		✗	ff_rtsp_close_streams(s);
2478		✗	ff_network_close();
2479		✗	return 0;
2480			}
2481
2482			static const AVClass sdp_demuxer_class = {
2483			.class_name = "SDP demuxer",
2484			.item_name = av_default_item_name,
2485			.option = sdp_options,
2486			.version = LIBAVUTIL_VERSION_INT,
2487			};
2488
2489			const FFInputFormat ff_sdp_demuxer = {
2490			.p.name = "sdp",
2491			.p.long_name = NULL_IF_CONFIG_SMALL("SDP"),
2492			.p.priv_class = &sdp_demuxer_class,
2493			.priv_data_size = sizeof(RTSPState),
2494			.read_probe = sdp_probe,
2495			.read_header = sdp_read_header,
2496			.read_packet = ff_rtsp_fetch_packet,
2497			.read_close = sdp_read_close,
2498			};
2499			#endif /* CONFIG_SDP_DEMUXER */
2500
2501			#if CONFIG_RTP_DEMUXER
2502		3795	static int rtp_probe(const AVProbeData *p)
2503			{
2504	1/2 ✗ Branch 1 not taken. ✓ Branch 2 taken 3795 times.	3795	if (av_strstart(p->filename, "rtp:", NULL))
2505		✗	return AVPROBE_SCORE_MAX;
2506		3795	return 0;
2507			}
2508
2509		✗	static int rtp_read_header(AVFormatContext *s)
2510			{
2511			uint8_t recvbuf[RTP_MAX_PACKET_LENGTH];
2512			char host[500], filters_buf[1000];
2513			int ret, port;
2514		✗	URLContext* in = NULL;
2515			int payload_type;
2516		✗	AVCodecParameters *par = NULL;
2517			struct sockaddr_storage addr;
2518			FFIOContext pb;
2519		✗	socklen_t addrlen = sizeof(addr);
2520		✗	RTSPState *rt = s->priv_data;
2521			const char *p;
2522			AVBPrint sdp;
2523		✗	AVDictionary *opts = NULL;
2524
2525		✗	if (!ff_network_init())
2526		✗	return AVERROR(EIO);
2527
2528		✗	opts = map_to_opts(rt);
2529		✗	ret = ffurl_open_whitelist(&in, s->url, AVIO_FLAG_READ,
2530		✗	&s->interrupt_callback, &opts, s->protocol_whitelist, s->protocol_blacklist, NULL);
2531		✗	av_dict_free(&opts);
2532		✗	if (ret)
2533		✗	goto fail;
2534
2535			while (1) {
2536		✗	ret = ffurl_read(in, recvbuf, sizeof(recvbuf));
2537		✗	if (ret == AVERROR(EAGAIN))
2538		✗	continue;
2539		✗	if (ret < 0)
2540		✗	goto fail;
2541		✗	if (ret < 12) {
2542		✗	av_log(s, AV_LOG_WARNING, "Received too short packet\n");
2543		✗	continue;
2544			}
2545
2546		✗	if ((recvbuf[0] & 0xc0) != 0x80) {
2547		✗	av_log(s, AV_LOG_WARNING, "Unsupported RTP version packet "
2548			"received\n");
2549		✗	continue;
2550			}
2551
2552		✗	if (RTP_PT_IS_RTCP(recvbuf[1]))
2553		✗	continue;
2554
2555		✗	payload_type = recvbuf[1] & 0x7f;
2556		✗	break;
2557			}
2558		✗	getsockname(ffurl_get_file_handle(in), (struct sockaddr*) &addr, &addrlen);
2559		✗	ffurl_closep(&in);
2560
2561		✗	par = avcodec_parameters_alloc();
2562		✗	if (!par) {
2563		✗	ret = AVERROR(ENOMEM);
2564		✗	goto fail;
2565			}
2566
2567		✗	if (ff_rtp_get_codec_info(par, payload_type)) {
2568		✗	av_log(s, AV_LOG_ERROR, "Unable to receive RTP payload type %d "
2569			"without an SDP file describing it\n",
2570			payload_type);
2571		✗	ret = AVERROR_INVALIDDATA;
2572		✗	goto fail;
2573			}
2574		✗	if (par->codec_type != AVMEDIA_TYPE_DATA) {
2575		✗	av_log(s, AV_LOG_WARNING, "Guessing on RTP content - if not received "
2576			"properly you need an SDP file "
2577			"describing it\n");
2578			}
2579
2580		✗	av_url_split(NULL, 0, NULL, 0, host, sizeof(host), &port,
2581		✗	NULL, 0, s->url);
2582
2583		✗	av_bprint_init(&sdp, 0, AV_BPRINT_SIZE_UNLIMITED);
2584		✗	av_bprintf(&sdp, "v=0\r\nc=IN IP%d %s\r\n",
2585		✗	addr.ss_family == AF_INET ? 4 : 6, host);
2586
2587		✗	p = strchr(s->url, '?');
2588		✗	if (p) {
2589			static const char filters[][2][8] = { { "sources", "incl" },
2590			{ "block", "excl" } };
2591			int i;
2592			char *q;
2593		✗	for (i = 0; i < FF_ARRAY_ELEMS(filters); i++) {
2594		✗	if (av_find_info_tag(filters_buf, sizeof(filters_buf), filters[i][0], p)) {
2595		✗	q = filters_buf;
2596		✗	while ((q = strchr(q, ',')) != NULL)
2597		✗	*q = ' ';
2598		✗	av_bprintf(&sdp, "a=source-filter:%s IN IP%d %s %s\r\n",
2599		✗	filters[i][1],
2600		✗	addr.ss_family == AF_INET ? 4 : 6, host,
2601			filters_buf);
2602			}
2603			}
2604			}
2605
2606		✗	av_bprintf(&sdp, "m=%s %d RTP/AVP %d\r\n",
2607		✗	par->codec_type == AVMEDIA_TYPE_DATA ? "application" :
2608		✗	par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio",
2609			port, payload_type);
2610		✗	av_log(s, AV_LOG_VERBOSE, "SDP:\n%s\n", sdp.str);
2611		✗	if (!av_bprint_is_complete(&sdp))
2612		✗	goto fail_nobuf;
2613		✗	avcodec_parameters_free(&par);
2614
2615		✗	ffio_init_read_context(&pb, sdp.str, sdp.len);
2616		✗	s->pb = &pb.pub;
2617
2618			/* if sdp_read_header() fails then following ff_network_close() cancels out */
2619			/* ff_network_init() at the start of this function. Otherwise it cancels out */
2620			/* ff_network_init() inside sdp_read_header() */
2621		✗	ff_network_close();
2622
2623		✗	rt->media_type_mask = (1 << (AVMEDIA_TYPE_SUBTITLE+1)) - 1;
2624
2625		✗	ret = sdp_read_header(s);
2626		✗	s->pb = NULL;
2627		✗	av_bprint_finalize(&sdp, NULL);
2628		✗	return ret;
2629
2630		✗	fail_nobuf:
2631		✗	ret = AVERROR(ENOMEM);
2632		✗	av_log(s, AV_LOG_ERROR, "rtp_read_header(): not enough buffer space for sdp-headers\n");
2633		✗	av_bprint_finalize(&sdp, NULL);
2634		✗	fail:
2635		✗	avcodec_parameters_free(&par);
2636		✗	ffurl_closep(&in);
2637		✗	ff_network_close();
2638		✗	return ret;
2639			}
2640
2641			static const AVClass rtp_demuxer_class = {
2642			.class_name = "RTP demuxer",
2643			.item_name = av_default_item_name,
2644			.option = rtp_options,
2645			.version = LIBAVUTIL_VERSION_INT,
2646			};
2647
2648			const FFInputFormat ff_rtp_demuxer = {
2649			.p.name = "rtp",
2650			.p.long_name = NULL_IF_CONFIG_SMALL("RTP input"),
2651			.p.flags = AVFMT_NOFILE,
2652			.p.priv_class = &rtp_demuxer_class,
2653			.priv_data_size = sizeof(RTSPState),
2654			.read_probe = rtp_probe,
2655			.read_header = rtp_read_header,
2656			.read_packet = ff_rtsp_fetch_packet,
2657			.read_close = sdp_read_close,
2658			};
2659			#endif /* CONFIG_RTP_DEMUXER */
2660