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