luna - curl/lib/rtsp.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24#include "curl_setup.h"
  25#include "urldata.h"
  26#include "rtsp.h"
  27
  28#ifndef CURL_DISABLE_RTSP
  29
  30#include "transfer.h"
  31#include "sendf.h"
  32#include "curl_trc.h"
  33#include "multiif.h"
  34#include "http.h"
  35#include "url.h"
  36#include "progress.h"
  37#include "strcase.h"
  38#include "select.h"
  39#include "connect.h"
  40#include "cfilters.h"
  41#include "curlx/strdup.h"
  42#include "bufref.h"
  43#include "curlx/strparse.h"
  44
  45/* meta key for storing protocol meta at easy handle */
  46#define CURL_META_RTSP_EASY   "meta:proto:rtsp:easy"
  47/* meta key for storing protocol meta at connection */
  48#define CURL_META_RTSP_CONN   "meta:proto:rtsp:conn"
  49
  50typedef enum {
  51  RTP_PARSE_SKIP,
  52  RTP_PARSE_CHANNEL,
  53  RTP_PARSE_LEN,
  54  RTP_PARSE_DATA
  55} rtp_parse_st;
  56
  57/* RTSP Connection data
  58 * Currently, only used for tracking incomplete RTP data reads */
  59struct rtsp_conn {
  60  struct dynbuf buf;
  61  int rtp_channel;
  62  size_t rtp_len;
  63  rtp_parse_st state;
  64  BIT(in_header);
  65};
  66
  67/* RTSP transfer data */
  68struct RTSP {
  69  uint32_t CSeq_sent; /* CSeq of this request */
  70  uint32_t CSeq_recv; /* CSeq received */
  71};
  72
  73#define RTP_PKT_LENGTH(p) ((((unsigned int)((unsigned char)((p)[2]))) << 8) | \
  74                            ((unsigned int)((unsigned char)((p)[3]))))
  75
  76/* this returns the socket to wait for in the DO and DOING state for the multi
  77   interface and then we are always _sending_ a request and thus we wait for
  78   the single socket to become writable only */
  79static CURLcode rtsp_do_pollset(struct Curl_easy *data,
  80                                struct easy_pollset *ps)
  81{
  82  /* write mode */
  83  return Curl_pollset_add_out(data, ps, data->conn->sock[FIRSTSOCKET]);
  84}
  85
  86#define MAX_RTP_BUFFERSIZE 1000000 /* arbitrary */
  87
  88static void rtsp_easy_dtor(void *key, size_t klen, void *entry)
  89{
  90  struct RTSP *rtsp = entry;
  91  (void)key;
  92  (void)klen;
  93  curlx_free(rtsp);
  94}
  95
  96static void rtsp_conn_dtor(void *key, size_t klen, void *entry)
  97{
  98  struct rtsp_conn *rtspc = entry;
  99  (void)key;
 100  (void)klen;
 101  curlx_dyn_free(&rtspc->buf);
 102  curlx_free(rtspc);
 103}
 104
 105static CURLcode rtsp_setup_connection(struct Curl_easy *data,
 106                                      struct connectdata *conn)
 107{
 108  struct rtsp_conn *rtspc;
 109  struct RTSP *rtsp;
 110
 111  rtspc = curlx_calloc(1, sizeof(*rtspc));
 112  if(!rtspc)
 113    return CURLE_OUT_OF_MEMORY;
 114  curlx_dyn_init(&rtspc->buf, MAX_RTP_BUFFERSIZE);
 115  if(Curl_conn_meta_set(conn, CURL_META_RTSP_CONN, rtspc, rtsp_conn_dtor))
 116    return CURLE_OUT_OF_MEMORY;
 117
 118  rtsp = curlx_calloc(1, sizeof(struct RTSP));
 119  if(!rtsp ||
 120     Curl_meta_set(data, CURL_META_RTSP_EASY, rtsp, rtsp_easy_dtor))
 121    return CURLE_OUT_OF_MEMORY;
 122
 123  return CURLE_OK;
 124}
 125
 126/*
 127 * Function to check on various aspects of a connection.
 128 */
 129static bool rtsp_conn_is_dead(struct Curl_easy *data,
 130                              struct connectdata *conn)
 131{
 132  bool input_pending;
 133  /* Contrary to default handling, this protocol allows pending
 134   * input on an unused connection. */
 135  return !Curl_conn_is_alive(data, conn, &input_pending);
 136}
 137
 138static CURLcode rtsp_connect(struct Curl_easy *data, bool *done)
 139{
 140  struct rtsp_conn *rtspc =
 141    Curl_conn_meta_get(data->conn, CURL_META_RTSP_CONN);
 142
 143  if(!rtspc)
 144    return CURLE_FAILED_INIT;
 145
 146  /* Initialize the CSeq if not already done */
 147  if(data->state.rtsp_next_client_CSeq == 0)
 148    data->state.rtsp_next_client_CSeq = 1;
 149  if(data->state.rtsp_next_server_CSeq == 0)
 150    data->state.rtsp_next_server_CSeq = 1;
 151
 152  rtspc->rtp_channel = -1;
 153  *done = TRUE;
 154  return CURLE_OK;
 155}
 156
 157static CURLcode rtsp_done(struct Curl_easy *data,
 158                          CURLcode status, bool premature)
 159{
 160  struct rtsp_conn *rtspc =
 161    Curl_conn_meta_get(data->conn, CURL_META_RTSP_CONN);
 162  struct RTSP *rtsp = Curl_meta_get(data, CURL_META_RTSP_EASY);
 163  CURLcode result;
 164
 165  if(!rtspc || !rtsp)
 166    return CURLE_FAILED_INIT;
 167
 168  /* Bypass HTTP empty-reply checks on receive */
 169  if(data->set.rtspreq == RTSPREQ_RECEIVE)
 170    premature = TRUE;
 171
 172  result = Curl_http_done(data, status, premature);
 173
 174  if(!status && !result) {
 175    /* Check the sequence numbers */
 176    uint32_t CSeq_sent = rtsp->CSeq_sent;
 177    uint32_t CSeq_recv = rtsp->CSeq_recv;
 178    if((data->set.rtspreq != RTSPREQ_RECEIVE) && (CSeq_sent != CSeq_recv)) {
 179      failf(data,
 180            "The CSeq of this request %u did not match the response %u",
 181            CSeq_sent, CSeq_recv);
 182      return CURLE_RTSP_CSEQ_ERROR;
 183    }
 184    if(data->set.rtspreq == RTSPREQ_RECEIVE && (rtspc->rtp_channel == -1)) {
 185      infof(data, "Got an RTP Receive with a CSeq of %u", CSeq_recv);
 186    }
 187    if(data->set.rtspreq == RTSPREQ_RECEIVE &&
 188       data->req.eos_written) {
 189      failf(data, "Server prematurely closed the RTSP connection.");
 190      return CURLE_RECV_ERROR;
 191    }
 192  }
 193
 194  return result;
 195}
 196
 197static CURLcode rtsp_setup_body(struct Curl_easy *data,
 198                                Curl_RtspReq rtspreq,
 199                                struct dynbuf *reqp)
 200{
 201  CURLcode result;
 202  if(rtspreq == RTSPREQ_ANNOUNCE ||
 203     rtspreq == RTSPREQ_SET_PARAMETER ||
 204     rtspreq == RTSPREQ_GET_PARAMETER) {
 205    curl_off_t req_clen; /* request content length */
 206
 207    if(data->state.upload) {
 208      req_clen = data->state.infilesize;
 209      data->state.httpreq = HTTPREQ_PUT;
 210      result = Curl_creader_set_fread(data, req_clen);
 211      if(result)
 212        return result;
 213    }
 214    else {
 215      if(data->set.postfields) {
 216        size_t plen = (data->set.postfieldsize >= 0) ?
 217          (size_t)data->set.postfieldsize : strlen(data->set.postfields);
 218        req_clen = (curl_off_t)plen;
 219        result = Curl_creader_set_buf(data, data->set.postfields, plen);
 220      }
 221      else if(data->state.infilesize >= 0) {
 222        req_clen = data->state.infilesize;
 223        result = Curl_creader_set_fread(data, req_clen);
 224      }
 225      else {
 226        req_clen = 0;
 227        result = Curl_creader_set_null(data);
 228      }
 229      if(result)
 230        return result;
 231    }
 232
 233    if(req_clen > 0) {
 234      /* As stated in the http comments, it is probably not wise to
 235       * actually set a custom Content-Length in the headers */
 236      if(!Curl_checkheaders(data, STRCONST("Content-Length"))) {
 237        result = curlx_dyn_addf(reqp, "Content-Length: %" FMT_OFF_T "\r\n",
 238                                req_clen);
 239        if(result)
 240          return result;
 241      }
 242
 243      if(rtspreq == RTSPREQ_SET_PARAMETER ||
 244         rtspreq == RTSPREQ_GET_PARAMETER) {
 245        if(!Curl_checkheaders(data, STRCONST("Content-Type"))) {
 246          result = curlx_dyn_addn(reqp, STRCONST("Content-Type: "
 247                                                 "text/parameters\r\n"));
 248          if(result)
 249            return result;
 250        }
 251      }
 252
 253      if(rtspreq == RTSPREQ_ANNOUNCE) {
 254        if(!Curl_checkheaders(data, STRCONST("Content-Type"))) {
 255          result = curlx_dyn_addn(reqp, STRCONST("Content-Type: "
 256                                                 "application/sdp\r\n"));
 257          if(result)
 258            return result;
 259        }
 260      }
 261    }
 262    else if(rtspreq == RTSPREQ_GET_PARAMETER) {
 263      /* Check for an empty GET_PARAMETER (heartbeat) request */
 264      data->state.httpreq = HTTPREQ_HEAD;
 265      data->req.no_body = TRUE;
 266    }
 267  }
 268  else
 269    result = Curl_creader_set_null(data);
 270  return result;
 271}
 272
 273static CURLcode rtsp_do(struct Curl_easy *data, bool *done)
 274{
 275  struct connectdata *conn = data->conn;
 276  CURLcode result = CURLE_OK;
 277  const Curl_RtspReq rtspreq = data->set.rtspreq;
 278  struct RTSP *rtsp = Curl_meta_get(data, CURL_META_RTSP_EASY);
 279  struct dynbuf req_buffer;
 280  const unsigned char httpversion = 11; /* RTSP is close to HTTP/1.1, sort
 281                                           of... */
 282  const char *p_request = NULL;
 283  const char *p_session_id = NULL;
 284  const char *p_accept = NULL;
 285  const char *p_accept_encoding = NULL;
 286  const char *p_range = NULL;
 287  const char *p_referrer = NULL;
 288  const char *p_stream_uri = NULL;
 289  const char *p_transport = NULL;
 290  const char *p_uagent = NULL;
 291  const char *p_hd_proxy_auth = NULL;
 292  const char *p_hd_auth = NULL;
 293
 294  *done = TRUE;
 295  if(!rtsp)
 296    return CURLE_FAILED_INIT;
 297
 298  /* Initialize a dynamic send buffer */
 299  curlx_dyn_init(&req_buffer, DYN_RTSP_REQ_HEADER);
 300
 301  rtsp->CSeq_sent = data->state.rtsp_next_client_CSeq;
 302  rtsp->CSeq_recv = 0;
 303
 304  /* Setup the 'p_request' pointer to the proper p_request string
 305   * Since all RTSP requests are included here, there is no need to
 306   * support custom requests like HTTP.
 307   **/
 308  data->req.no_body = TRUE; /* most requests do not contain a body */
 309  switch(rtspreq) {
 310  default:
 311    failf(data, "Got invalid RTSP request");
 312    return CURLE_BAD_FUNCTION_ARGUMENT;
 313  case RTSPREQ_OPTIONS:
 314    p_request = "OPTIONS";
 315    break;
 316  case RTSPREQ_DESCRIBE:
 317    p_request = "DESCRIBE";
 318    data->req.no_body = FALSE;
 319    break;
 320  case RTSPREQ_ANNOUNCE:
 321    p_request = "ANNOUNCE";
 322    break;
 323  case RTSPREQ_SETUP:
 324    p_request = "SETUP";
 325    break;
 326  case RTSPREQ_PLAY:
 327    p_request = "PLAY";
 328    break;
 329  case RTSPREQ_PAUSE:
 330    p_request = "PAUSE";
 331    break;
 332  case RTSPREQ_TEARDOWN:
 333    p_request = "TEARDOWN";
 334    break;
 335  case RTSPREQ_GET_PARAMETER:
 336    /* GET_PARAMETER's no_body status is determined later */
 337    p_request = "GET_PARAMETER";
 338    data->req.no_body = FALSE;
 339    break;
 340  case RTSPREQ_SET_PARAMETER:
 341    p_request = "SET_PARAMETER";
 342    break;
 343  case RTSPREQ_RECORD:
 344    p_request = "RECORD";
 345    break;
 346  case RTSPREQ_RECEIVE:
 347    p_request = "";
 348    /* Treat interleaved RTP as body */
 349    data->req.no_body = FALSE;
 350    break;
 351  case RTSPREQ_LAST:
 352    failf(data, "Got invalid RTSP request: RTSPREQ_LAST");
 353    return CURLE_BAD_FUNCTION_ARGUMENT;
 354  }
 355
 356  if(rtspreq == RTSPREQ_RECEIVE) {
 357    Curl_xfer_setup_recv(data, FIRSTSOCKET, -1);
 358    goto out;
 359  }
 360
 361  p_session_id = data->set.str[STRING_RTSP_SESSION_ID];
 362  if(!p_session_id &&
 363     (rtspreq & ~(Curl_RtspReq)(RTSPREQ_OPTIONS |
 364                                RTSPREQ_DESCRIBE |
 365                                RTSPREQ_SETUP))) {
 366    failf(data, "Refusing to issue an RTSP request [%s] without a session ID.",
 367          p_request);
 368    result = CURLE_BAD_FUNCTION_ARGUMENT;
 369    goto out;
 370  }
 371
 372  /* Stream URI. Default to server '*' if not specified */
 373  if(data->set.str[STRING_RTSP_STREAM_URI]) {
 374    p_stream_uri = data->set.str[STRING_RTSP_STREAM_URI];
 375  }
 376  else {
 377    p_stream_uri = "*";
 378  }
 379
 380  /* Transport Header for SETUP requests */
 381  p_transport = Curl_checkheaders(data, STRCONST("Transport"));
 382  if(rtspreq == RTSPREQ_SETUP && !p_transport) {
 383    /* New Transport: setting? */
 384    if(data->set.str[STRING_RTSP_TRANSPORT]) {
 385      curlx_free(data->state.aptr.rtsp_transport);
 386      data->state.aptr.rtsp_transport =
 387        curl_maprintf("Transport: %s\r\n",
 388                      data->set.str[STRING_RTSP_TRANSPORT]);
 389      if(!data->state.aptr.rtsp_transport)
 390        return CURLE_OUT_OF_MEMORY;
 391    }
 392    else {
 393      failf(data,
 394            "Refusing to issue an RTSP SETUP without a Transport: header.");
 395      result = CURLE_BAD_FUNCTION_ARGUMENT;
 396      goto out;
 397    }
 398
 399    p_transport = data->state.aptr.rtsp_transport;
 400  }
 401
 402  /* Accept Headers for DESCRIBE requests */
 403  if(rtspreq == RTSPREQ_DESCRIBE) {
 404    /* Accept Header */
 405    p_accept = Curl_checkheaders(data, STRCONST("Accept")) ?
 406      NULL : "Accept: application/sdp\r\n";
 407
 408    /* Accept-Encoding header */
 409    if(!Curl_checkheaders(data, STRCONST("Accept-Encoding")) &&
 410       data->set.str[STRING_ENCODING]) {
 411      curlx_free(data->state.aptr.accept_encoding);
 412      data->state.aptr.accept_encoding =
 413        curl_maprintf("Accept-Encoding: %s\r\n",
 414                      data->set.str[STRING_ENCODING]);
 415
 416      if(!data->state.aptr.accept_encoding) {
 417        result = CURLE_OUT_OF_MEMORY;
 418        goto out;
 419      }
 420      p_accept_encoding = data->state.aptr.accept_encoding;
 421    }
 422  }
 423
 424  /* The User-Agent string might have been allocated already, because
 425     it might have been used in the proxy connect, but if we have got a header
 426     with the user-agent string specified, we erase the previously made string
 427     here. */
 428  if(Curl_checkheaders(data, STRCONST("User-Agent")) &&
 429     data->state.aptr.uagent) {
 430    curlx_safefree(data->state.aptr.uagent);
 431  }
 432  else if(!Curl_checkheaders(data, STRCONST("User-Agent")) &&
 433          data->set.str[STRING_USERAGENT]) {
 434    p_uagent = data->state.aptr.uagent;
 435  }
 436
 437  /* setup the authentication headers */
 438  result = Curl_http_output_auth(data, conn, p_request, HTTPREQ_GET,
 439                                 p_stream_uri, NULL, FALSE);
 440  if(result)
 441    goto out;
 442
 443#ifndef CURL_DISABLE_PROXY
 444  p_hd_proxy_auth = data->req.hd_proxy_auth;
 445#endif
 446  p_hd_auth = data->req.hd_auth;
 447
 448  /* Referrer */
 449  curlx_safefree(data->state.aptr.ref);
 450  if(Curl_bufref_ptr(&data->state.referer) &&
 451     !Curl_checkheaders(data, STRCONST("Referer")))
 452    data->state.aptr.ref =
 453      curl_maprintf("Referer: %s\r\n", Curl_bufref_ptr(&data->state.referer));
 454
 455  p_referrer = data->state.aptr.ref;
 456
 457  /*
 458   * Range Header
 459   * Only applies to PLAY, PAUSE, RECORD
 460   *
 461   * Go ahead and use the Range stuff supplied for HTTP
 462   */
 463  if(data->state.use_range &&
 464     (rtspreq & (RTSPREQ_PLAY | RTSPREQ_PAUSE | RTSPREQ_RECORD))) {
 465
 466    /* Check to see if there is a range set in the custom headers */
 467    if(!Curl_checkheaders(data, STRCONST("Range")) && data->state.range) {
 468      curlx_free(data->state.aptr.rangeline);
 469      data->state.aptr.rangeline = curl_maprintf("Range: %s\r\n",
 470                                                 data->state.range);
 471      p_range = data->state.aptr.rangeline;
 472    }
 473  }
 474
 475  /*
 476   * Sanity check the custom headers
 477   */
 478  if(Curl_checkheaders(data, STRCONST("CSeq"))) {
 479    failf(data, "CSeq cannot be set as a custom header.");
 480    result = CURLE_RTSP_CSEQ_ERROR;
 481    goto out;
 482  }
 483  if(Curl_checkheaders(data, STRCONST("Session"))) {
 484    failf(data, "Session ID cannot be set as a custom header.");
 485    result = CURLE_BAD_FUNCTION_ARGUMENT;
 486    goto out;
 487  }
 488
 489  result =
 490    curlx_dyn_addf(&req_buffer,
 491                   "%s %s RTSP/1.0\r\n" /* Request Stream-URI RTSP/1.0 */
 492                   "CSeq: %u\r\n", /* CSeq */
 493                   p_request, p_stream_uri, rtsp->CSeq_sent);
 494  if(result)
 495    goto out;
 496
 497  /*
 498   * Rather than do a normal alloc line, keep the session_id unformatted
 499   * to make comparison easier
 500   */
 501  if(p_session_id) {
 502    result = curlx_dyn_addf(&req_buffer, "Session: %s\r\n", p_session_id);
 503    if(result)
 504      goto out;
 505  }
 506
 507  /*
 508   * Shared HTTP-like options
 509   */
 510  result = curlx_dyn_addf(&req_buffer,
 511                          "%s" /* transport */
 512                          "%s" /* accept */
 513                          "%s" /* accept-encoding */
 514                          "%s" /* range */
 515                          "%s" /* referrer */
 516                          "%s" /* user-agent */
 517                          "%s" /* hd_proxy_auth */
 518                          "%s" /* hd_auth */
 519                          ,
 520                          p_transport ? p_transport : "",
 521                          p_accept ? p_accept : "",
 522                          p_accept_encoding ? p_accept_encoding : "",
 523                          p_range ? p_range : "",
 524                          p_referrer ? p_referrer : "",
 525                          p_uagent ? p_uagent : "",
 526                          p_hd_proxy_auth ? p_hd_proxy_auth : "",
 527                          p_hd_auth ? p_hd_auth : "");
 528
 529  if(result)
 530    goto out;
 531
 532  if((rtspreq == RTSPREQ_SETUP) || (rtspreq == RTSPREQ_DESCRIBE)) {
 533    result = Curl_add_timecondition(data, &req_buffer);
 534    if(result)
 535      goto out;
 536  }
 537
 538  result = Curl_add_custom_headers(data, FALSE, httpversion, &req_buffer);
 539  if(result)
 540    goto out;
 541
 542  result = rtsp_setup_body(data, rtspreq, &req_buffer);
 543  if(result)
 544    goto out;
 545
 546  /* Finish the request buffer */
 547  result = curlx_dyn_addn(&req_buffer, STRCONST("\r\n"));
 548  if(result)
 549    goto out;
 550
 551  Curl_xfer_setup_sendrecv(data, FIRSTSOCKET, -1);
 552
 553  /* issue the request */
 554  result = Curl_req_send(data, &req_buffer, httpversion);
 555  if(result) {
 556    failf(data, "Failed sending RTSP request");
 557    goto out;
 558  }
 559
 560  /* Increment the CSeq on success */
 561  data->state.rtsp_next_client_CSeq++;
 562
 563  if(data->req.writebytecount) {
 564    /* if a request-body has been sent off, we make sure this progress is
 565       noted properly */
 566    Curl_pgrsSetUploadCounter(data, data->req.writebytecount);
 567    result = Curl_pgrsUpdate(data);
 568  }
 569out:
 570  curlx_dyn_free(&req_buffer);
 571  return result;
 572}
 573
 574/**
 575 * write any BODY bytes missing to the client, ignore the rest.
 576 */
 577static CURLcode rtp_write_body_junk(struct Curl_easy *data,
 578                                    struct rtsp_conn *rtspc,
 579                                    const char *buf,
 580                                    size_t blen)
 581{
 582  curl_off_t body_remain;
 583  bool in_body;
 584
 585  in_body = (data->req.headerline && !rtspc->in_header) &&
 586            (data->req.size >= 0) &&
 587            (data->req.bytecount < data->req.size);
 588  body_remain = in_body ? (data->req.size - data->req.bytecount) : 0;
 589  DEBUGASSERT(body_remain >= 0);
 590  if(body_remain) {
 591    if((curl_off_t)blen > body_remain)
 592      blen = (size_t)body_remain;
 593    return Curl_client_write(data, CLIENTWRITE_BODY, buf, blen);
 594  }
 595  return CURLE_OK;
 596}
 597
 598static CURLcode rtp_client_write(struct Curl_easy *data, const char *ptr,
 599                                 size_t len)
 600{
 601  size_t wrote;
 602  curl_write_callback writeit;
 603  void *user_ptr;
 604
 605  if(len == 0) {
 606    failf(data, "Cannot write a 0 size RTP packet.");
 607    return CURLE_WRITE_ERROR;
 608  }
 609
 610  /* If the user has configured CURLOPT_INTERLEAVEFUNCTION then use that
 611     function and any configured CURLOPT_INTERLEAVEDATA to write out the RTP
 612     data. Otherwise, use the CURLOPT_WRITEFUNCTION with the CURLOPT_WRITEDATA
 613     pointer to write out the RTP data. */
 614  if(data->set.fwrite_rtp) {
 615    writeit = data->set.fwrite_rtp;
 616    user_ptr = data->set.rtp_out;
 617  }
 618  else {
 619    writeit = data->set.fwrite_func;
 620    user_ptr = data->set.out;
 621  }
 622
 623  Curl_set_in_callback(data, TRUE);
 624  wrote = writeit((char *)CURL_UNCONST(ptr), 1, len, user_ptr);
 625  Curl_set_in_callback(data, FALSE);
 626
 627  if(wrote == CURL_WRITEFUNC_PAUSE) {
 628    failf(data, "Cannot pause RTP");
 629    return CURLE_WRITE_ERROR;
 630  }
 631
 632  if(wrote != len) {
 633    failf(data, "Failed writing RTP data");
 634    return CURLE_WRITE_ERROR;
 635  }
 636
 637  return CURLE_OK;
 638}
 639
 640static CURLcode rtsp_filter_rtp(struct Curl_easy *data,
 641                                struct rtsp_conn *rtspc,
 642                                const char *buf,
 643                                size_t blen,
 644                                size_t *pconsumed)
 645{
 646  CURLcode result = CURLE_OK;
 647  size_t skip_len = 0;
 648
 649  *pconsumed = 0;
 650  while(blen) {
 651    bool in_body = (data->req.headerline && !rtspc->in_header) &&
 652                   (data->req.size >= 0) &&
 653                   (data->req.bytecount < data->req.size);
 654    switch(rtspc->state) {
 655
 656    case RTP_PARSE_SKIP: {
 657      DEBUGASSERT(curlx_dyn_len(&rtspc->buf) == 0);
 658      while(blen && buf[0] != '$') {
 659        if(!in_body && buf[0] == 'R' &&
 660           data->set.rtspreq != RTSPREQ_RECEIVE) {
 661          if(strncmp(buf, "RTSP/", (blen < 5) ? blen : 5) == 0) {
 662            /* This could be the next response, no consume and return */
 663            if(*pconsumed) {
 664              DEBUGF(infof(data, "RTP rtsp_filter_rtp[SKIP] RTSP/ prefix, "
 665                           "skipping %zu bytes of junk", *pconsumed));
 666            }
 667            rtspc->state = RTP_PARSE_SKIP;
 668            rtspc->in_header = TRUE;
 669            goto out;
 670          }
 671        }
 672        /* junk/BODY, consume without buffering */
 673        *pconsumed += 1;
 674        ++buf;
 675        --blen;
 676        ++skip_len;
 677      }
 678      if(blen && buf[0] == '$') {
 679        /* possible start of an RTP message, buffer */
 680        if(skip_len) {
 681          /* end of junk/BODY bytes, flush */
 682          result = rtp_write_body_junk(data, rtspc, buf - skip_len, skip_len);
 683          skip_len = 0;
 684          if(result)
 685            goto out;
 686        }
 687        if(curlx_dyn_addn(&rtspc->buf, buf, 1)) {
 688          result = CURLE_OUT_OF_MEMORY;
 689          goto out;
 690        }
 691        *pconsumed += 1;
 692        ++buf;
 693        --blen;
 694        rtspc->state = RTP_PARSE_CHANNEL;
 695      }
 696      break;
 697    }
 698
 699    case RTP_PARSE_CHANNEL: {
 700      int idx = ((unsigned char)buf[0]) / 8;
 701      int off = ((unsigned char)buf[0]) % 8;
 702      DEBUGASSERT(curlx_dyn_len(&rtspc->buf) == 1);
 703      if(!(data->state.rtp_channel_mask[idx] & (1 << off))) {
 704        /* invalid channel number, junk or BODY data */
 705        rtspc->state = RTP_PARSE_SKIP;
 706        DEBUGASSERT(skip_len == 0);
 707        /* we do not consume this byte, it is BODY data */
 708        DEBUGF(infof(data, "RTSP: invalid RTP channel %d, skipping", idx));
 709        if(*pconsumed == 0) {
 710          /* We did not consume the initial '$' in our buffer, but had
 711           * it from an earlier call. We cannot un-consume it and have
 712           * to write it directly as BODY data */
 713          result = rtp_write_body_junk(data, rtspc,
 714                                       curlx_dyn_ptr(&rtspc->buf), 1);
 715          if(result)
 716            goto out;
 717        }
 718        else {
 719          /* count the '$' as skip and continue */
 720          skip_len = 1;
 721        }
 722        curlx_dyn_free(&rtspc->buf);
 723        break;
 724      }
 725      /* a valid channel, so we expect this to be a real RTP message */
 726      rtspc->rtp_channel = (unsigned char)buf[0];
 727      if(curlx_dyn_addn(&rtspc->buf, buf, 1)) {
 728        result = CURLE_OUT_OF_MEMORY;
 729        goto out;
 730      }
 731      *pconsumed += 1;
 732      ++buf;
 733      --blen;
 734      rtspc->state = RTP_PARSE_LEN;
 735      break;
 736    }
 737
 738    case RTP_PARSE_LEN: {
 739      size_t rtp_len = curlx_dyn_len(&rtspc->buf);
 740      const char *rtp_buf;
 741      DEBUGASSERT(rtp_len >= 2 && rtp_len < 4);
 742      if(curlx_dyn_addn(&rtspc->buf, buf, 1)) {
 743        result = CURLE_OUT_OF_MEMORY;
 744        goto out;
 745      }
 746      *pconsumed += 1;
 747      ++buf;
 748      --blen;
 749      if(rtp_len == 2)
 750        break;
 751      rtp_buf = curlx_dyn_ptr(&rtspc->buf);
 752      rtspc->rtp_len = RTP_PKT_LENGTH(rtp_buf) + 4;
 753      if(rtspc->rtp_len == 4) {
 754        /* zero-length payload, the 4-byte header is the complete RTP
 755           message. Dispatch immediately without entering RTP_PARSE_DATA. */
 756        DEBUGF(infof(data, "RTP write channel %d rtp_len %zu (no payload)",
 757                     rtspc->rtp_channel, rtspc->rtp_len));
 758        result = rtp_client_write(data, rtp_buf, rtspc->rtp_len);
 759        curlx_dyn_free(&rtspc->buf);
 760        rtspc->state = RTP_PARSE_SKIP;
 761        if(result)
 762          goto out;
 763        break;
 764      }
 765      rtspc->state = RTP_PARSE_DATA;
 766      break;
 767    }
 768
 769    case RTP_PARSE_DATA: {
 770      size_t rtp_len = curlx_dyn_len(&rtspc->buf);
 771      size_t needed;
 772      DEBUGASSERT(rtp_len < rtspc->rtp_len);
 773      needed = rtspc->rtp_len - rtp_len;
 774      if(needed <= blen) {
 775        if(curlx_dyn_addn(&rtspc->buf, buf, needed)) {
 776          result = CURLE_OUT_OF_MEMORY;
 777          goto out;
 778        }
 779        *pconsumed += needed;
 780        buf += needed;
 781        blen -= needed;
 782        /* complete RTP message in buffer */
 783        DEBUGF(infof(data, "RTP write channel %d rtp_len %zu",
 784                     rtspc->rtp_channel, rtspc->rtp_len));
 785        result = rtp_client_write(data, curlx_dyn_ptr(&rtspc->buf),
 786                                  rtspc->rtp_len);
 787        curlx_dyn_free(&rtspc->buf);
 788        rtspc->state = RTP_PARSE_SKIP;
 789        if(result)
 790          goto out;
 791      }
 792      else {
 793        if(curlx_dyn_addn(&rtspc->buf, buf, blen)) {
 794          result = CURLE_OUT_OF_MEMORY;
 795          goto out;
 796        }
 797        *pconsumed += blen;
 798        buf += blen;
 799        blen = 0;
 800      }
 801      break;
 802    }
 803
 804    default:
 805      DEBUGASSERT(0);
 806      return CURLE_RECV_ERROR;
 807    }
 808  }
 809out:
 810  if(!result && skip_len)
 811    result = rtp_write_body_junk(data, rtspc, buf - skip_len, skip_len);
 812  return result;
 813}
 814
 815/*
 816 * Parse and write out an RTSP response.
 817 * @param data     the transfer
 818 * @param conn     the connection
 819 * @param buf      data read from connection
 820 * @param blen     amount of data in buf
 821 * @param is_eos   TRUE iff this is the last write
 822 * @param readmore out, TRUE iff complete buf was consumed and more data
 823 *                 is needed
 824 */
 825static CURLcode rtsp_rtp_write_resp(struct Curl_easy *data,
 826                                    const char *buf,
 827                                    size_t blen,
 828                                    bool is_eos)
 829{
 830  struct rtsp_conn *rtspc =
 831    Curl_conn_meta_get(data->conn, CURL_META_RTSP_CONN);
 832  CURLcode result = CURLE_OK;
 833  size_t consumed = 0;
 834
 835  if(!rtspc)
 836    return CURLE_FAILED_INIT;
 837
 838  if(!data->req.header)
 839    rtspc->in_header = FALSE;
 840  if(!blen) {
 841    goto out;
 842  }
 843
 844  DEBUGF(infof(data, "rtsp_rtp_write_resp(len=%zu, in_header=%d, eos=%d)",
 845               blen, rtspc->in_header, is_eos));
 846
 847  /* If header parsing is not ongoing, extract RTP messages */
 848  if(!rtspc->in_header) {
 849    result = rtsp_filter_rtp(data, rtspc, buf, blen, &consumed);
 850    if(result)
 851      goto out;
 852    buf += consumed;
 853    blen -= consumed;
 854    /* either we consumed all or are at the start of header parsing */
 855    if(blen && !data->req.header)
 856      DEBUGF(infof(data, "RTSP: %zu bytes, possibly excess in response body",
 857                   blen));
 858  }
 859
 860  /* we want to parse headers, do so */
 861  if(data->req.header && blen) {
 862    rtspc->in_header = TRUE;
 863    result = Curl_http_write_resp_hds(data, buf, blen, &consumed);
 864    if(result)
 865      goto out;
 866
 867    buf += consumed;
 868    blen -= consumed;
 869
 870    if(!data->req.header)
 871      rtspc->in_header = FALSE;
 872
 873    if(!rtspc->in_header) {
 874      /* If header parsing is done, extract interleaved RTP messages */
 875      if(data->req.size <= -1) {
 876        /* Respect section 4.4 of rfc2326: If the Content-Length header is
 877           absent, a length 0 must be assumed. */
 878        data->req.size = 0;
 879        data->req.download_done = TRUE;
 880      }
 881      result = rtsp_filter_rtp(data, rtspc, buf, blen, &consumed);
 882      if(result)
 883        goto out;
 884      buf += consumed;
 885      blen -= consumed;
 886    }
 887  }
 888
 889  if(rtspc->state != RTP_PARSE_SKIP)
 890    data->req.done = FALSE;
 891  /* we SHOULD have consumed all bytes, unless the response is borked.
 892   * In which case we write out the left over bytes, letting the client
 893   * writer deal with it (it will report EXCESS and fail the transfer). */
 894  DEBUGF(infof(data, "rtsp_rtp_write_resp(len=%zu, in_header=%d, done=%d, "
 895               "rtspc->state=%d, req.size=%" FMT_OFF_T ")",
 896               blen, rtspc->in_header, data->req.done, rtspc->state,
 897               data->req.size));
 898  if(!result && (is_eos || blen)) {
 899    result = Curl_client_write(data, CLIENTWRITE_BODY |
 900                               (is_eos ? CLIENTWRITE_EOS : 0), buf, blen);
 901  }
 902
 903out:
 904  if((data->set.rtspreq == RTSPREQ_RECEIVE) &&
 905     (rtspc->state == RTP_PARSE_SKIP)) {
 906    /* In special mode RECEIVE, we process one chunk of network
 907     * data, so we stop the transfer here, if we have no incomplete
 908     * RTP message pending. */
 909    data->req.download_done = TRUE;
 910  }
 911  return result;
 912}
 913
 914static CURLcode rtsp_rtp_write_resp_hd(struct Curl_easy *data,
 915                                       const char *buf,
 916                                       size_t blen,
 917                                       bool is_eos)
 918{
 919  return rtsp_rtp_write_resp(data, buf, blen, is_eos);
 920}
 921
 922static CURLcode rtsp_parse_transport(struct Curl_easy *data,
 923                                     const char *transport)
 924{
 925  /* If we receive multiple Transport response-headers, the interleaved
 926     channels of each response header is recorded and used together for
 927     subsequent data validity checks.*/
 928  /* e.g.: ' RTP/AVP/TCP;unicast;interleaved=5-6' */
 929  const char *start, *end;
 930  start = transport;
 931  while(start && *start) {
 932    curlx_str_passblanks(&start);
 933    end = strchr(start, ';');
 934    if(checkprefix("interleaved=", start)) {
 935      curl_off_t chan1, chan2, chan;
 936      const char *p = start + 12;
 937      if(!curlx_str_number(&p, &chan1, 255)) {
 938        unsigned char *rtp_channel_mask = data->state.rtp_channel_mask;
 939        chan2 = chan1;
 940        if(!curlx_str_single(&p, '-')) {
 941          if(curlx_str_number(&p, &chan2, 255)) {
 942            infof(data, "Unable to read the interleaved parameter from "
 943                  "Transport header: [%s]", transport);
 944            chan2 = chan1;
 945          }
 946        }
 947        for(chan = chan1; chan <= chan2; chan++) {
 948          int idx = (int)chan / 8;
 949          int off = (int)chan % 8;
 950          rtp_channel_mask[idx] |= (unsigned char)(1 << off);
 951        }
 952      }
 953      else {
 954        infof(data, "Unable to read the interleaved parameter from "
 955              "Transport header: [%s]", transport);
 956      }
 957      break;
 958    }
 959    /* skip to next parameter */
 960    start = (!end) ? end : (end + 1);
 961  }
 962  return CURLE_OK;
 963}
 964
 965CURLcode Curl_rtsp_parseheader(struct Curl_easy *data, const char *header)
 966{
 967  if(checkprefix("CSeq:", header)) {
 968    curl_off_t CSeq = 0;
 969    struct RTSP *rtsp = Curl_meta_get(data, CURL_META_RTSP_EASY);
 970    const char *p = &header[5];
 971    if(!rtsp)
 972      return CURLE_FAILED_INIT;
 973    curlx_str_passblanks(&p);
 974    if(curlx_str_number(&p, &CSeq, UINT_MAX)) {
 975      failf(data, "Unable to read the CSeq header: [%s]", header);
 976      return CURLE_RTSP_CSEQ_ERROR;
 977    }
 978    data->state.rtsp_CSeq_recv = rtsp->CSeq_recv = (uint32_t)CSeq;
 979  }
 980  else if(checkprefix("Session:", header)) {
 981    const char *start, *end;
 982    size_t idlen;
 983
 984    /* Find the first non-space letter */
 985    start = header + 8;
 986    curlx_str_passblanks(&start);
 987
 988    if(!*start) {
 989      failf(data, "Got a blank Session ID");
 990      return CURLE_RTSP_SESSION_ERROR;
 991    }
 992
 993    /* Find the end of Session ID
 994     *
 995     * Allow any non whitespace content, up to the field separator or end of
 996     * line. RFC 2326 is not 100% clear on the session ID and for example
 997     * gstreamer does URL-encoded session ID's not covered by the standard.
 998     */
 999    end = start;
1000    while((*end > ' ') && (*end != ';'))
1001      end++;
1002    idlen = end - start;
1003
1004    if(data->set.str[STRING_RTSP_SESSION_ID]) {
1005
1006      /* If the Session ID is set, then compare */
1007      if(strlen(data->set.str[STRING_RTSP_SESSION_ID]) != idlen ||
1008         strncmp(start, data->set.str[STRING_RTSP_SESSION_ID], idlen)) {
1009        failf(data, "Got RTSP Session ID Line [%s], but wanted ID [%s]",
1010              start, data->set.str[STRING_RTSP_SESSION_ID]);
1011        return CURLE_RTSP_SESSION_ERROR;
1012      }
1013    }
1014    else {
1015      /* If the Session ID is not set, and we find it in a response, then set
1016       * it.
1017       */
1018
1019      /* Copy the id substring into a new buffer */
1020      data->set.str[STRING_RTSP_SESSION_ID] = curlx_memdup0(start, idlen);
1021      if(!data->set.str[STRING_RTSP_SESSION_ID])
1022        return CURLE_OUT_OF_MEMORY;
1023    }
1024  }
1025  else if(checkprefix("Transport:", header)) {
1026    CURLcode result;
1027    result = rtsp_parse_transport(data, header + 10);
1028    if(result)
1029      return result;
1030  }
1031  return CURLE_OK;
1032}
1033
1034/*
1035 * RTSP handler interface.
1036 */
1037const struct Curl_protocol Curl_protocol_rtsp = {
1038  rtsp_setup_connection,                /* setup_connection */
1039  rtsp_do,                              /* do_it */
1040  rtsp_done,                            /* done */
1041  ZERO_NULL,                            /* do_more */
1042  rtsp_connect,                         /* connect_it */
1043  ZERO_NULL,                            /* connecting */
1044  ZERO_NULL,                            /* doing */
1045  ZERO_NULL,                            /* proto_pollset */
1046  rtsp_do_pollset,                      /* doing_pollset */
1047  ZERO_NULL,                            /* domore_pollset */
1048  Curl_http_perform_pollset,            /* perform_pollset */
1049  ZERO_NULL,                            /* disconnect */
1050  rtsp_rtp_write_resp,                  /* write_resp */
1051  rtsp_rtp_write_resp_hd,               /* write_resp_hd */
1052  rtsp_conn_is_dead,                    /* connection_is_dead */
1053  ZERO_NULL,                            /* attach connection */
1054  Curl_http_follow,                     /* follow */
1055};
1056
1057#endif /* CURL_DISABLE_RTSP */