git.sesse.net Git - ffmpeg/blob - 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 */