Annotation of embedaddon/curl/lib/rtsp.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2019, 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.haxx.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: ***************************************************************************/
! 22:
! 23: #include "curl_setup.h"
! 24:
! 25: #ifndef CURL_DISABLE_RTSP
! 26:
! 27: #include "urldata.h"
! 28: #include <curl/curl.h>
! 29: #include "transfer.h"
! 30: #include "sendf.h"
! 31: #include "multiif.h"
! 32: #include "http.h"
! 33: #include "url.h"
! 34: #include "progress.h"
! 35: #include "rtsp.h"
! 36: #include "strcase.h"
! 37: #include "select.h"
! 38: #include "connect.h"
! 39: #include "strdup.h"
! 40: /* The last 3 #include files should be in this order */
! 41: #include "curl_printf.h"
! 42: #include "curl_memory.h"
! 43: #include "memdebug.h"
! 44:
! 45: #define RTP_PKT_CHANNEL(p) ((int)((unsigned char)((p)[1])))
! 46:
! 47: #define RTP_PKT_LENGTH(p) ((((int)((unsigned char)((p)[2]))) << 8) | \
! 48: ((int)((unsigned char)((p)[3]))))
! 49:
! 50: /* protocol-specific functions set up to be called by the main engine */
! 51: static CURLcode rtsp_do(struct connectdata *conn, bool *done);
! 52: static CURLcode rtsp_done(struct connectdata *conn, CURLcode, bool premature);
! 53: static CURLcode rtsp_connect(struct connectdata *conn, bool *done);
! 54: static CURLcode rtsp_disconnect(struct connectdata *conn, bool dead);
! 55: static int rtsp_getsock_do(struct connectdata *conn, curl_socket_t *socks);
! 56:
! 57: /*
! 58: * Parse and write out any available RTP data.
! 59: *
! 60: * nread: amount of data left after k->str. will be modified if RTP
! 61: * data is parsed and k->str is moved up
! 62: * readmore: whether or not the RTP parser needs more data right away
! 63: */
! 64: static CURLcode rtsp_rtp_readwrite(struct Curl_easy *data,
! 65: struct connectdata *conn,
! 66: ssize_t *nread,
! 67: bool *readmore);
! 68:
! 69: static CURLcode rtsp_setup_connection(struct connectdata *conn);
! 70: static unsigned int rtsp_conncheck(struct connectdata *check,
! 71: unsigned int checks_to_perform);
! 72:
! 73: /* this returns the socket to wait for in the DO and DOING state for the multi
! 74: interface and then we're always _sending_ a request and thus we wait for
! 75: the single socket to become writable only */
! 76: static int rtsp_getsock_do(struct connectdata *conn,
! 77: curl_socket_t *socks)
! 78: {
! 79: /* write mode */
! 80: socks[0] = conn->sock[FIRSTSOCKET];
! 81: return GETSOCK_WRITESOCK(0);
! 82: }
! 83:
! 84: static
! 85: CURLcode rtp_client_write(struct connectdata *conn, char *ptr, size_t len);
! 86:
! 87:
! 88: /*
! 89: * RTSP handler interface.
! 90: */
! 91: const struct Curl_handler Curl_handler_rtsp = {
! 92: "RTSP", /* scheme */
! 93: rtsp_setup_connection, /* setup_connection */
! 94: rtsp_do, /* do_it */
! 95: rtsp_done, /* done */
! 96: ZERO_NULL, /* do_more */
! 97: rtsp_connect, /* connect_it */
! 98: ZERO_NULL, /* connecting */
! 99: ZERO_NULL, /* doing */
! 100: ZERO_NULL, /* proto_getsock */
! 101: rtsp_getsock_do, /* doing_getsock */
! 102: ZERO_NULL, /* domore_getsock */
! 103: ZERO_NULL, /* perform_getsock */
! 104: rtsp_disconnect, /* disconnect */
! 105: rtsp_rtp_readwrite, /* readwrite */
! 106: rtsp_conncheck, /* connection_check */
! 107: PORT_RTSP, /* defport */
! 108: CURLPROTO_RTSP, /* protocol */
! 109: PROTOPT_NONE /* flags */
! 110: };
! 111:
! 112:
! 113: static CURLcode rtsp_setup_connection(struct connectdata *conn)
! 114: {
! 115: struct RTSP *rtsp;
! 116:
! 117: conn->data->req.protop = rtsp = calloc(1, sizeof(struct RTSP));
! 118: if(!rtsp)
! 119: return CURLE_OUT_OF_MEMORY;
! 120:
! 121: return CURLE_OK;
! 122: }
! 123:
! 124:
! 125: /*
! 126: * The server may send us RTP data at any point, and RTSPREQ_RECEIVE does not
! 127: * want to block the application forever while receiving a stream. Therefore,
! 128: * we cannot assume that an RTSP socket is dead just because it is readable.
! 129: *
! 130: * Instead, if it is readable, run Curl_connalive() to peek at the socket
! 131: * and distinguish between closed and data.
! 132: */
! 133: static bool rtsp_connisdead(struct connectdata *check)
! 134: {
! 135: int sval;
! 136: bool ret_val = TRUE;
! 137:
! 138: sval = SOCKET_READABLE(check->sock[FIRSTSOCKET], 0);
! 139: if(sval == 0) {
! 140: /* timeout */
! 141: ret_val = FALSE;
! 142: }
! 143: else if(sval & CURL_CSELECT_ERR) {
! 144: /* socket is in an error state */
! 145: ret_val = TRUE;
! 146: }
! 147: else if(sval & CURL_CSELECT_IN) {
! 148: /* readable with no error. could still be closed */
! 149: ret_val = !Curl_connalive(check);
! 150: }
! 151:
! 152: return ret_val;
! 153: }
! 154:
! 155: /*
! 156: * Function to check on various aspects of a connection.
! 157: */
! 158: static unsigned int rtsp_conncheck(struct connectdata *check,
! 159: unsigned int checks_to_perform)
! 160: {
! 161: unsigned int ret_val = CONNRESULT_NONE;
! 162:
! 163: if(checks_to_perform & CONNCHECK_ISDEAD) {
! 164: if(rtsp_connisdead(check))
! 165: ret_val |= CONNRESULT_DEAD;
! 166: }
! 167:
! 168: return ret_val;
! 169: }
! 170:
! 171:
! 172: static CURLcode rtsp_connect(struct connectdata *conn, bool *done)
! 173: {
! 174: CURLcode httpStatus;
! 175: struct Curl_easy *data = conn->data;
! 176:
! 177: httpStatus = Curl_http_connect(conn, done);
! 178:
! 179: /* Initialize the CSeq if not already done */
! 180: if(data->state.rtsp_next_client_CSeq == 0)
! 181: data->state.rtsp_next_client_CSeq = 1;
! 182: if(data->state.rtsp_next_server_CSeq == 0)
! 183: data->state.rtsp_next_server_CSeq = 1;
! 184:
! 185: conn->proto.rtspc.rtp_channel = -1;
! 186:
! 187: return httpStatus;
! 188: }
! 189:
! 190: static CURLcode rtsp_disconnect(struct connectdata *conn, bool dead)
! 191: {
! 192: (void) dead;
! 193: Curl_safefree(conn->proto.rtspc.rtp_buf);
! 194: return CURLE_OK;
! 195: }
! 196:
! 197:
! 198: static CURLcode rtsp_done(struct connectdata *conn,
! 199: CURLcode status, bool premature)
! 200: {
! 201: struct Curl_easy *data = conn->data;
! 202: struct RTSP *rtsp = data->req.protop;
! 203: CURLcode httpStatus;
! 204:
! 205: /* Bypass HTTP empty-reply checks on receive */
! 206: if(data->set.rtspreq == RTSPREQ_RECEIVE)
! 207: premature = TRUE;
! 208:
! 209: httpStatus = Curl_http_done(conn, status, premature);
! 210:
! 211: if(rtsp) {
! 212: /* Check the sequence numbers */
! 213: long CSeq_sent = rtsp->CSeq_sent;
! 214: long CSeq_recv = rtsp->CSeq_recv;
! 215: if((data->set.rtspreq != RTSPREQ_RECEIVE) && (CSeq_sent != CSeq_recv)) {
! 216: failf(data,
! 217: "The CSeq of this request %ld did not match the response %ld",
! 218: CSeq_sent, CSeq_recv);
! 219: return CURLE_RTSP_CSEQ_ERROR;
! 220: }
! 221: if(data->set.rtspreq == RTSPREQ_RECEIVE &&
! 222: (conn->proto.rtspc.rtp_channel == -1)) {
! 223: infof(data, "Got an RTP Receive with a CSeq of %ld\n", CSeq_recv);
! 224: }
! 225: }
! 226:
! 227: return httpStatus;
! 228: }
! 229:
! 230: static CURLcode rtsp_do(struct connectdata *conn, bool *done)
! 231: {
! 232: struct Curl_easy *data = conn->data;
! 233: CURLcode result = CURLE_OK;
! 234: Curl_RtspReq rtspreq = data->set.rtspreq;
! 235: struct RTSP *rtsp = data->req.protop;
! 236: Curl_send_buffer *req_buffer;
! 237: curl_off_t postsize = 0; /* for ANNOUNCE and SET_PARAMETER */
! 238: curl_off_t putsize = 0; /* for ANNOUNCE and SET_PARAMETER */
! 239:
! 240: const char *p_request = NULL;
! 241: const char *p_session_id = NULL;
! 242: const char *p_accept = NULL;
! 243: const char *p_accept_encoding = NULL;
! 244: const char *p_range = NULL;
! 245: const char *p_referrer = NULL;
! 246: const char *p_stream_uri = NULL;
! 247: const char *p_transport = NULL;
! 248: const char *p_uagent = NULL;
! 249: const char *p_proxyuserpwd = NULL;
! 250: const char *p_userpwd = NULL;
! 251:
! 252: *done = TRUE;
! 253:
! 254: rtsp->CSeq_sent = data->state.rtsp_next_client_CSeq;
! 255: rtsp->CSeq_recv = 0;
! 256:
! 257: /* Setup the 'p_request' pointer to the proper p_request string
! 258: * Since all RTSP requests are included here, there is no need to
! 259: * support custom requests like HTTP.
! 260: **/
! 261: data->set.opt_no_body = TRUE; /* most requests don't contain a body */
! 262: switch(rtspreq) {
! 263: default:
! 264: failf(data, "Got invalid RTSP request");
! 265: return CURLE_BAD_FUNCTION_ARGUMENT;
! 266: case RTSPREQ_OPTIONS:
! 267: p_request = "OPTIONS";
! 268: break;
! 269: case RTSPREQ_DESCRIBE:
! 270: p_request = "DESCRIBE";
! 271: data->set.opt_no_body = FALSE;
! 272: break;
! 273: case RTSPREQ_ANNOUNCE:
! 274: p_request = "ANNOUNCE";
! 275: break;
! 276: case RTSPREQ_SETUP:
! 277: p_request = "SETUP";
! 278: break;
! 279: case RTSPREQ_PLAY:
! 280: p_request = "PLAY";
! 281: break;
! 282: case RTSPREQ_PAUSE:
! 283: p_request = "PAUSE";
! 284: break;
! 285: case RTSPREQ_TEARDOWN:
! 286: p_request = "TEARDOWN";
! 287: break;
! 288: case RTSPREQ_GET_PARAMETER:
! 289: /* GET_PARAMETER's no_body status is determined later */
! 290: p_request = "GET_PARAMETER";
! 291: data->set.opt_no_body = FALSE;
! 292: break;
! 293: case RTSPREQ_SET_PARAMETER:
! 294: p_request = "SET_PARAMETER";
! 295: break;
! 296: case RTSPREQ_RECORD:
! 297: p_request = "RECORD";
! 298: break;
! 299: case RTSPREQ_RECEIVE:
! 300: p_request = "";
! 301: /* Treat interleaved RTP as body*/
! 302: data->set.opt_no_body = FALSE;
! 303: break;
! 304: case RTSPREQ_LAST:
! 305: failf(data, "Got invalid RTSP request: RTSPREQ_LAST");
! 306: return CURLE_BAD_FUNCTION_ARGUMENT;
! 307: }
! 308:
! 309: if(rtspreq == RTSPREQ_RECEIVE) {
! 310: Curl_setup_transfer(data, FIRSTSOCKET, -1, TRUE, -1);
! 311:
! 312: return result;
! 313: }
! 314:
! 315: p_session_id = data->set.str[STRING_RTSP_SESSION_ID];
! 316: if(!p_session_id &&
! 317: (rtspreq & ~(RTSPREQ_OPTIONS | RTSPREQ_DESCRIBE | RTSPREQ_SETUP))) {
! 318: failf(data, "Refusing to issue an RTSP request [%s] without a session ID.",
! 319: p_request);
! 320: return CURLE_BAD_FUNCTION_ARGUMENT;
! 321: }
! 322:
! 323: /* Stream URI. Default to server '*' if not specified */
! 324: if(data->set.str[STRING_RTSP_STREAM_URI]) {
! 325: p_stream_uri = data->set.str[STRING_RTSP_STREAM_URI];
! 326: }
! 327: else {
! 328: p_stream_uri = "*";
! 329: }
! 330:
! 331: /* Transport Header for SETUP requests */
! 332: p_transport = Curl_checkheaders(conn, "Transport");
! 333: if(rtspreq == RTSPREQ_SETUP && !p_transport) {
! 334: /* New Transport: setting? */
! 335: if(data->set.str[STRING_RTSP_TRANSPORT]) {
! 336: Curl_safefree(conn->allocptr.rtsp_transport);
! 337:
! 338: conn->allocptr.rtsp_transport =
! 339: aprintf("Transport: %s\r\n",
! 340: data->set.str[STRING_RTSP_TRANSPORT]);
! 341: if(!conn->allocptr.rtsp_transport)
! 342: return CURLE_OUT_OF_MEMORY;
! 343: }
! 344: else {
! 345: failf(data,
! 346: "Refusing to issue an RTSP SETUP without a Transport: header.");
! 347: return CURLE_BAD_FUNCTION_ARGUMENT;
! 348: }
! 349:
! 350: p_transport = conn->allocptr.rtsp_transport;
! 351: }
! 352:
! 353: /* Accept Headers for DESCRIBE requests */
! 354: if(rtspreq == RTSPREQ_DESCRIBE) {
! 355: /* Accept Header */
! 356: p_accept = Curl_checkheaders(conn, "Accept")?
! 357: NULL:"Accept: application/sdp\r\n";
! 358:
! 359: /* Accept-Encoding header */
! 360: if(!Curl_checkheaders(conn, "Accept-Encoding") &&
! 361: data->set.str[STRING_ENCODING]) {
! 362: Curl_safefree(conn->allocptr.accept_encoding);
! 363: conn->allocptr.accept_encoding =
! 364: aprintf("Accept-Encoding: %s\r\n", data->set.str[STRING_ENCODING]);
! 365:
! 366: if(!conn->allocptr.accept_encoding)
! 367: return CURLE_OUT_OF_MEMORY;
! 368:
! 369: p_accept_encoding = conn->allocptr.accept_encoding;
! 370: }
! 371: }
! 372:
! 373: /* The User-Agent string might have been allocated in url.c already, because
! 374: it might have been used in the proxy connect, but if we have got a header
! 375: with the user-agent string specified, we erase the previously made string
! 376: here. */
! 377: if(Curl_checkheaders(conn, "User-Agent") && conn->allocptr.uagent) {
! 378: Curl_safefree(conn->allocptr.uagent);
! 379: conn->allocptr.uagent = NULL;
! 380: }
! 381: else if(!Curl_checkheaders(conn, "User-Agent") &&
! 382: data->set.str[STRING_USERAGENT]) {
! 383: p_uagent = conn->allocptr.uagent;
! 384: }
! 385:
! 386: /* setup the authentication headers */
! 387: result = Curl_http_output_auth(conn, p_request, p_stream_uri, FALSE);
! 388: if(result)
! 389: return result;
! 390:
! 391: p_proxyuserpwd = conn->allocptr.proxyuserpwd;
! 392: p_userpwd = conn->allocptr.userpwd;
! 393:
! 394: /* Referrer */
! 395: Curl_safefree(conn->allocptr.ref);
! 396: if(data->change.referer && !Curl_checkheaders(conn, "Referer"))
! 397: conn->allocptr.ref = aprintf("Referer: %s\r\n", data->change.referer);
! 398: else
! 399: conn->allocptr.ref = NULL;
! 400:
! 401: p_referrer = conn->allocptr.ref;
! 402:
! 403: /*
! 404: * Range Header
! 405: * Only applies to PLAY, PAUSE, RECORD
! 406: *
! 407: * Go ahead and use the Range stuff supplied for HTTP
! 408: */
! 409: if(data->state.use_range &&
! 410: (rtspreq & (RTSPREQ_PLAY | RTSPREQ_PAUSE | RTSPREQ_RECORD))) {
! 411:
! 412: /* Check to see if there is a range set in the custom headers */
! 413: if(!Curl_checkheaders(conn, "Range") && data->state.range) {
! 414: Curl_safefree(conn->allocptr.rangeline);
! 415: conn->allocptr.rangeline = aprintf("Range: %s\r\n", data->state.range);
! 416: p_range = conn->allocptr.rangeline;
! 417: }
! 418: }
! 419:
! 420: /*
! 421: * Sanity check the custom headers
! 422: */
! 423: if(Curl_checkheaders(conn, "CSeq")) {
! 424: failf(data, "CSeq cannot be set as a custom header.");
! 425: return CURLE_RTSP_CSEQ_ERROR;
! 426: }
! 427: if(Curl_checkheaders(conn, "Session")) {
! 428: failf(data, "Session ID cannot be set as a custom header.");
! 429: return CURLE_BAD_FUNCTION_ARGUMENT;
! 430: }
! 431:
! 432: /* Initialize a dynamic send buffer */
! 433: req_buffer = Curl_add_buffer_init();
! 434:
! 435: if(!req_buffer)
! 436: return CURLE_OUT_OF_MEMORY;
! 437:
! 438: result =
! 439: Curl_add_bufferf(&req_buffer,
! 440: "%s %s RTSP/1.0\r\n" /* Request Stream-URI RTSP/1.0 */
! 441: "CSeq: %ld\r\n", /* CSeq */
! 442: p_request, p_stream_uri, rtsp->CSeq_sent);
! 443: if(result)
! 444: return result;
! 445:
! 446: /*
! 447: * Rather than do a normal alloc line, keep the session_id unformatted
! 448: * to make comparison easier
! 449: */
! 450: if(p_session_id) {
! 451: result = Curl_add_bufferf(&req_buffer, "Session: %s\r\n", p_session_id);
! 452: if(result)
! 453: return result;
! 454: }
! 455:
! 456: /*
! 457: * Shared HTTP-like options
! 458: */
! 459: result = Curl_add_bufferf(&req_buffer,
! 460: "%s" /* transport */
! 461: "%s" /* accept */
! 462: "%s" /* accept-encoding */
! 463: "%s" /* range */
! 464: "%s" /* referrer */
! 465: "%s" /* user-agent */
! 466: "%s" /* proxyuserpwd */
! 467: "%s" /* userpwd */
! 468: ,
! 469: p_transport ? p_transport : "",
! 470: p_accept ? p_accept : "",
! 471: p_accept_encoding ? p_accept_encoding : "",
! 472: p_range ? p_range : "",
! 473: p_referrer ? p_referrer : "",
! 474: p_uagent ? p_uagent : "",
! 475: p_proxyuserpwd ? p_proxyuserpwd : "",
! 476: p_userpwd ? p_userpwd : "");
! 477:
! 478: /*
! 479: * Free userpwd now --- cannot reuse this for Negotiate and possibly NTLM
! 480: * with basic and digest, it will be freed anyway by the next request
! 481: */
! 482: Curl_safefree(conn->allocptr.userpwd);
! 483: conn->allocptr.userpwd = NULL;
! 484:
! 485: if(result)
! 486: return result;
! 487:
! 488: if((rtspreq == RTSPREQ_SETUP) || (rtspreq == RTSPREQ_DESCRIBE)) {
! 489: result = Curl_add_timecondition(conn, req_buffer);
! 490: if(result)
! 491: return result;
! 492: }
! 493:
! 494: result = Curl_add_custom_headers(conn, FALSE, req_buffer);
! 495: if(result)
! 496: return result;
! 497:
! 498: if(rtspreq == RTSPREQ_ANNOUNCE ||
! 499: rtspreq == RTSPREQ_SET_PARAMETER ||
! 500: rtspreq == RTSPREQ_GET_PARAMETER) {
! 501:
! 502: if(data->set.upload) {
! 503: putsize = data->state.infilesize;
! 504: data->set.httpreq = HTTPREQ_PUT;
! 505:
! 506: }
! 507: else {
! 508: postsize = (data->state.infilesize != -1)?
! 509: data->state.infilesize:
! 510: (data->set.postfields? (curl_off_t)strlen(data->set.postfields):0);
! 511: data->set.httpreq = HTTPREQ_POST;
! 512: }
! 513:
! 514: if(putsize > 0 || postsize > 0) {
! 515: /* As stated in the http comments, it is probably not wise to
! 516: * actually set a custom Content-Length in the headers */
! 517: if(!Curl_checkheaders(conn, "Content-Length")) {
! 518: result =
! 519: Curl_add_bufferf(&req_buffer,
! 520: "Content-Length: %" CURL_FORMAT_CURL_OFF_T"\r\n",
! 521: (data->set.upload ? putsize : postsize));
! 522: if(result)
! 523: return result;
! 524: }
! 525:
! 526: if(rtspreq == RTSPREQ_SET_PARAMETER ||
! 527: rtspreq == RTSPREQ_GET_PARAMETER) {
! 528: if(!Curl_checkheaders(conn, "Content-Type")) {
! 529: result = Curl_add_bufferf(&req_buffer,
! 530: "Content-Type: text/parameters\r\n");
! 531: if(result)
! 532: return result;
! 533: }
! 534: }
! 535:
! 536: if(rtspreq == RTSPREQ_ANNOUNCE) {
! 537: if(!Curl_checkheaders(conn, "Content-Type")) {
! 538: result = Curl_add_bufferf(&req_buffer,
! 539: "Content-Type: application/sdp\r\n");
! 540: if(result)
! 541: return result;
! 542: }
! 543: }
! 544:
! 545: data->state.expect100header = FALSE; /* RTSP posts are simple/small */
! 546: }
! 547: else if(rtspreq == RTSPREQ_GET_PARAMETER) {
! 548: /* Check for an empty GET_PARAMETER (heartbeat) request */
! 549: data->set.httpreq = HTTPREQ_HEAD;
! 550: data->set.opt_no_body = TRUE;
! 551: }
! 552: }
! 553:
! 554: /* RTSP never allows chunked transfer */
! 555: data->req.forbidchunk = TRUE;
! 556: /* Finish the request buffer */
! 557: result = Curl_add_buffer(&req_buffer, "\r\n", 2);
! 558: if(result)
! 559: return result;
! 560:
! 561: if(postsize > 0) {
! 562: result = Curl_add_buffer(&req_buffer, data->set.postfields,
! 563: (size_t)postsize);
! 564: if(result)
! 565: return result;
! 566: }
! 567:
! 568: /* issue the request */
! 569: result = Curl_add_buffer_send(&req_buffer, conn,
! 570: &data->info.request_size, 0, FIRSTSOCKET);
! 571: if(result) {
! 572: failf(data, "Failed sending RTSP request");
! 573: return result;
! 574: }
! 575:
! 576: Curl_setup_transfer(data, FIRSTSOCKET, -1, TRUE, putsize?FIRSTSOCKET:-1);
! 577:
! 578: /* Increment the CSeq on success */
! 579: data->state.rtsp_next_client_CSeq++;
! 580:
! 581: if(data->req.writebytecount) {
! 582: /* if a request-body has been sent off, we make sure this progress is
! 583: noted properly */
! 584: Curl_pgrsSetUploadCounter(data, data->req.writebytecount);
! 585: if(Curl_pgrsUpdate(conn))
! 586: result = CURLE_ABORTED_BY_CALLBACK;
! 587: }
! 588:
! 589: return result;
! 590: }
! 591:
! 592:
! 593: static CURLcode rtsp_rtp_readwrite(struct Curl_easy *data,
! 594: struct connectdata *conn,
! 595: ssize_t *nread,
! 596: bool *readmore) {
! 597: struct SingleRequest *k = &data->req;
! 598: struct rtsp_conn *rtspc = &(conn->proto.rtspc);
! 599:
! 600: char *rtp; /* moving pointer to rtp data */
! 601: ssize_t rtp_dataleft; /* how much data left to parse in this round */
! 602: char *scratch;
! 603: CURLcode result;
! 604:
! 605: if(rtspc->rtp_buf) {
! 606: /* There was some leftover data the last time. Merge buffers */
! 607: char *newptr = Curl_saferealloc(rtspc->rtp_buf,
! 608: rtspc->rtp_bufsize + *nread);
! 609: if(!newptr) {
! 610: rtspc->rtp_buf = NULL;
! 611: rtspc->rtp_bufsize = 0;
! 612: return CURLE_OUT_OF_MEMORY;
! 613: }
! 614: rtspc->rtp_buf = newptr;
! 615: memcpy(rtspc->rtp_buf + rtspc->rtp_bufsize, k->str, *nread);
! 616: rtspc->rtp_bufsize += *nread;
! 617: rtp = rtspc->rtp_buf;
! 618: rtp_dataleft = rtspc->rtp_bufsize;
! 619: }
! 620: else {
! 621: /* Just parse the request buffer directly */
! 622: rtp = k->str;
! 623: rtp_dataleft = *nread;
! 624: }
! 625:
! 626: while((rtp_dataleft > 0) &&
! 627: (rtp[0] == '$')) {
! 628: if(rtp_dataleft > 4) {
! 629: int rtp_length;
! 630:
! 631: /* Parse the header */
! 632: /* The channel identifier immediately follows and is 1 byte */
! 633: rtspc->rtp_channel = RTP_PKT_CHANNEL(rtp);
! 634:
! 635: /* The length is two bytes */
! 636: rtp_length = RTP_PKT_LENGTH(rtp);
! 637:
! 638: if(rtp_dataleft < rtp_length + 4) {
! 639: /* Need more - incomplete payload*/
! 640: *readmore = TRUE;
! 641: break;
! 642: }
! 643: /* We have the full RTP interleaved packet
! 644: * Write out the header including the leading '$' */
! 645: DEBUGF(infof(data, "RTP write channel %d rtp_length %d\n",
! 646: rtspc->rtp_channel, rtp_length));
! 647: result = rtp_client_write(conn, &rtp[0], rtp_length + 4);
! 648: if(result) {
! 649: failf(data, "Got an error writing an RTP packet");
! 650: *readmore = FALSE;
! 651: Curl_safefree(rtspc->rtp_buf);
! 652: rtspc->rtp_buf = NULL;
! 653: rtspc->rtp_bufsize = 0;
! 654: return result;
! 655: }
! 656:
! 657: /* Move forward in the buffer */
! 658: rtp_dataleft -= rtp_length + 4;
! 659: rtp += rtp_length + 4;
! 660:
! 661: if(data->set.rtspreq == RTSPREQ_RECEIVE) {
! 662: /* If we are in a passive receive, give control back
! 663: * to the app as often as we can.
! 664: */
! 665: k->keepon &= ~KEEP_RECV;
! 666: }
! 667: }
! 668: else {
! 669: /* Need more - incomplete header */
! 670: *readmore = TRUE;
! 671: break;
! 672: }
! 673: }
! 674:
! 675: if(rtp_dataleft != 0 && rtp[0] == '$') {
! 676: DEBUGF(infof(data, "RTP Rewinding %zd %s\n", rtp_dataleft,
! 677: *readmore ? "(READMORE)" : ""));
! 678:
! 679: /* Store the incomplete RTP packet for a "rewind" */
! 680: scratch = malloc(rtp_dataleft);
! 681: if(!scratch) {
! 682: Curl_safefree(rtspc->rtp_buf);
! 683: rtspc->rtp_buf = NULL;
! 684: rtspc->rtp_bufsize = 0;
! 685: return CURLE_OUT_OF_MEMORY;
! 686: }
! 687: memcpy(scratch, rtp, rtp_dataleft);
! 688: Curl_safefree(rtspc->rtp_buf);
! 689: rtspc->rtp_buf = scratch;
! 690: rtspc->rtp_bufsize = rtp_dataleft;
! 691:
! 692: /* As far as the transfer is concerned, this data is consumed */
! 693: *nread = 0;
! 694: return CURLE_OK;
! 695: }
! 696: /* Fix up k->str to point just after the last RTP packet */
! 697: k->str += *nread - rtp_dataleft;
! 698:
! 699: /* either all of the data has been read or...
! 700: * rtp now points at the next byte to parse
! 701: */
! 702: if(rtp_dataleft > 0)
! 703: DEBUGASSERT(k->str[0] == rtp[0]);
! 704:
! 705: DEBUGASSERT(rtp_dataleft <= *nread); /* sanity check */
! 706:
! 707: *nread = rtp_dataleft;
! 708:
! 709: /* If we get here, we have finished with the leftover/merge buffer */
! 710: Curl_safefree(rtspc->rtp_buf);
! 711: rtspc->rtp_buf = NULL;
! 712: rtspc->rtp_bufsize = 0;
! 713:
! 714: return CURLE_OK;
! 715: }
! 716:
! 717: static
! 718: CURLcode rtp_client_write(struct connectdata *conn, char *ptr, size_t len)
! 719: {
! 720: struct Curl_easy *data = conn->data;
! 721: size_t wrote;
! 722: curl_write_callback writeit;
! 723: void *user_ptr;
! 724:
! 725: if(len == 0) {
! 726: failf(data, "Cannot write a 0 size RTP packet.");
! 727: return CURLE_WRITE_ERROR;
! 728: }
! 729:
! 730: /* If the user has configured CURLOPT_INTERLEAVEFUNCTION then use that
! 731: function and any configured CURLOPT_INTERLEAVEDATA to write out the RTP
! 732: data. Otherwise, use the CURLOPT_WRITEFUNCTION with the CURLOPT_WRITEDATA
! 733: pointer to write out the RTP data. */
! 734: if(data->set.fwrite_rtp) {
! 735: writeit = data->set.fwrite_rtp;
! 736: user_ptr = data->set.rtp_out;
! 737: }
! 738: else {
! 739: writeit = data->set.fwrite_func;
! 740: user_ptr = data->set.out;
! 741: }
! 742:
! 743: Curl_set_in_callback(data, true);
! 744: wrote = writeit(ptr, 1, len, user_ptr);
! 745: Curl_set_in_callback(data, false);
! 746:
! 747: if(CURL_WRITEFUNC_PAUSE == wrote) {
! 748: failf(data, "Cannot pause RTP");
! 749: return CURLE_WRITE_ERROR;
! 750: }
! 751:
! 752: if(wrote != len) {
! 753: failf(data, "Failed writing RTP data");
! 754: return CURLE_WRITE_ERROR;
! 755: }
! 756:
! 757: return CURLE_OK;
! 758: }
! 759:
! 760: CURLcode Curl_rtsp_parseheader(struct connectdata *conn,
! 761: char *header)
! 762: {
! 763: struct Curl_easy *data = conn->data;
! 764: long CSeq = 0;
! 765:
! 766: if(checkprefix("CSeq:", header)) {
! 767: /* Store the received CSeq. Match is verified in rtsp_done */
! 768: int nc = sscanf(&header[4], ": %ld", &CSeq);
! 769: if(nc == 1) {
! 770: struct RTSP *rtsp = data->req.protop;
! 771: rtsp->CSeq_recv = CSeq; /* mark the request */
! 772: data->state.rtsp_CSeq_recv = CSeq; /* update the handle */
! 773: }
! 774: else {
! 775: failf(data, "Unable to read the CSeq header: [%s]", header);
! 776: return CURLE_RTSP_CSEQ_ERROR;
! 777: }
! 778: }
! 779: else if(checkprefix("Session:", header)) {
! 780: char *start;
! 781:
! 782: /* Find the first non-space letter */
! 783: start = header + 8;
! 784: while(*start && ISSPACE(*start))
! 785: start++;
! 786:
! 787: if(!*start) {
! 788: failf(data, "Got a blank Session ID");
! 789: }
! 790: else if(data->set.str[STRING_RTSP_SESSION_ID]) {
! 791: /* If the Session ID is set, then compare */
! 792: if(strncmp(start, data->set.str[STRING_RTSP_SESSION_ID],
! 793: strlen(data->set.str[STRING_RTSP_SESSION_ID])) != 0) {
! 794: failf(data, "Got RTSP Session ID Line [%s], but wanted ID [%s]",
! 795: start, data->set.str[STRING_RTSP_SESSION_ID]);
! 796: return CURLE_RTSP_SESSION_ERROR;
! 797: }
! 798: }
! 799: else {
! 800: /* If the Session ID is not set, and we find it in a response, then set
! 801: * it.
! 802: *
! 803: * Allow any non whitespace content, up to the field separator or end of
! 804: * line. RFC 2326 isn't 100% clear on the session ID and for example
! 805: * gstreamer does url-encoded session ID's not covered by the standard.
! 806: */
! 807: char *end = start;
! 808: while(*end && *end != ';' && !ISSPACE(*end))
! 809: end++;
! 810:
! 811: /* Copy the id substring into a new buffer */
! 812: data->set.str[STRING_RTSP_SESSION_ID] = malloc(end - start + 1);
! 813: if(data->set.str[STRING_RTSP_SESSION_ID] == NULL)
! 814: return CURLE_OUT_OF_MEMORY;
! 815: memcpy(data->set.str[STRING_RTSP_SESSION_ID], start, end - start);
! 816: (data->set.str[STRING_RTSP_SESSION_ID])[end - start] = '\0';
! 817: }
! 818: }
! 819: return CURLE_OK;
! 820: }
! 821:
! 822: #endif /* CURL_DISABLE_RTSP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rtsp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib