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