rtsp_resp.c

完整的RTP RTSP代码库

/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *              Bill May        [e-mail]
 */
/*
 * rtsp_resp.c - process rtsp response
 */

#include "rtsp_private.h"

static const char *end2 = "\n\r";
static const char *end1 = "\r\n";
static const char *end3 = "\r";
static const char *end4 = "\n";

/*
 * find_end_seperator()
 * Will search through the string pointer to by ptr, and figure out
 * what character is being used as a seperator - either \r \n, \r\n
 * or \n\r.
 *
 * Inputs:
 *    ptr - string to decode
 *    len - pointer to end seperator len
 *
 * Outputs:
 *    pointer to character to use as end seperator.  Dividing the len
 *    by 2, and adding to the return pointer will give the normal
 *    line seperator.
 */
static const char *find_seperator (const char *ptr)
{
  while (*ptr != '\0') {
    if (*ptr == '\r') {
      if (*(ptr + 1) == '\n') {
	return (end1);
      } else {
	return (end3);
      }
    } else if (*ptr == '\n') {
      if (*(ptr + 1) == '\r') {
	return (end2);
      } else {
	return (end4);
      }
    }
    ptr++;
  }
  return (NULL);
}

/************************************************************************
 * Decode rtsp header lines.
 *
 * These routines will decode the various RTSP header lines, setting the
 * correct information in the rtsp_decode_t structure.
 *
 * DEC_DUP_WARN macro will see if the field is already set, and send a warning
 * if it is.  If the cont_line field is set, it will append the next line
 *
 ************************************************************************/
#define RTSP_HEADER_FUNC(a) static void a (const char *lptr, rtsp_decode_t *dec, int cont_line)

static void dec_dup_warn (char **location,
			  const char *lptr,
			  const char *warn,
			  int cont_line)
{
  if (*location == NULL) {
    *location = strdup(lptr);
  } else if (cont_line != 0) {
    uint32_t len = strlen(*location);
    len += strlen(lptr);
    len++;
    *location = realloc(*location, len);
    strcat(*location, lptr);
  } else {
    rtsp_debug(LOG_WARNING, "2nd %s %s", warn, lptr);
  }
}

#define DEC_DUP_WARN(a, b) dec_dup_warn(&dec->a, lptr, b, cont_line)

RTSP_HEADER_FUNC(rtsp_header_allow_public)
{
  DEC_DUP_WARN(allow_public, "allow public");
}

RTSP_HEADER_FUNC(rtsp_header_connection)
{
  if (strncasecmp(lptr, "close", strlen("close")) == 0) {
    dec->close_connection = TRUE;
  }
}

RTSP_HEADER_FUNC(rtsp_header_cookie)
{
  DEC_DUP_WARN(cookie, "cookie");
}

RTSP_HEADER_FUNC(rtsp_header_content_base)
{
  DEC_DUP_WARN(content_base, "Content-Base");
}

RTSP_HEADER_FUNC(rtsp_header_content_length)
{
  dec->content_length = strtoul(lptr, NULL, 10);
}

RTSP_HEADER_FUNC(rtsp_header_content_loc)
{
  DEC_DUP_WARN(content_location, "Content-Location");
}

RTSP_HEADER_FUNC(rtsp_header_content_type)
{
  DEC_DUP_WARN(content_type, "Content-Type");
}

RTSP_HEADER_FUNC(rtsp_header_cseq)
{
  dec->cseq = strtoul(lptr, NULL, 10);
  dec->have_cseq = TRUE;
}

RTSP_HEADER_FUNC(rtsp_header_location)
{
  DEC_DUP_WARN(location, "Location");
}

RTSP_HEADER_FUNC(rtsp_header_range)
{
  DEC_DUP_WARN(range, "Range");
}

RTSP_HEADER_FUNC(rtsp_header_retry_after)
{
  // May try strptime if we need to convert
  DEC_DUP_WARN(retry_after, "Retry-After");
}

RTSP_HEADER_FUNC(rtsp_header_rtp)
{
  DEC_DUP_WARN(rtp_info, "RtpInfo");
}

RTSP_HEADER_FUNC(rtsp_header_session)
{
  DEC_DUP_WARN(session, "Session");
}

RTSP_HEADER_FUNC(rtsp_header_speed)
{
  DEC_DUP_WARN(speed, "Speed");
}

RTSP_HEADER_FUNC(rtsp_header_transport)
{
  DEC_DUP_WARN(transport, "Transport");
}

RTSP_HEADER_FUNC(rtsp_header_www)
{
  DEC_DUP_WARN(www_authenticate, "WWW-Authenticate");
}

RTSP_HEADER_FUNC(rtsp_header_accept)
{
  DEC_DUP_WARN(accept, "Accept");
}

RTSP_HEADER_FUNC(rtsp_header_accept_enc)
{
  DEC_DUP_WARN(accept_encoding, "Accept-Encoding");
}

RTSP_HEADER_FUNC(rtsp_header_accept_lang)
{
  DEC_DUP_WARN(accept_language, "Accept-Language");
}

RTSP_HEADER_FUNC(rtsp_header_auth)
{
  DEC_DUP_WARN(authorization, "Authorization");
}

RTSP_HEADER_FUNC(rtsp_header_bandwidth)
{
  DEC_DUP_WARN(bandwidth, "Bandwidth");
}

RTSP_HEADER_FUNC(rtsp_header_blocksize)
{
  DEC_DUP_WARN(blocksize, "blocksize");
}

RTSP_HEADER_FUNC(rtsp_header_cache_control)
{
  DEC_DUP_WARN(cache_control, "Cache-control");
}

RTSP_HEADER_FUNC(rtsp_header_content_enc)
{
  DEC_DUP_WARN(content_encoding, "Content-Encoding");
}

RTSP_HEADER_FUNC(rtsp_header_content_lang)
{
  DEC_DUP_WARN(content_language, "Content-Language");
}
RTSP_HEADER_FUNC(rtsp_header_date)
{
  DEC_DUP_WARN(date, "Date");
}

RTSP_HEADER_FUNC(rtsp_header_expires)
{
  DEC_DUP_WARN(expires, "Expires");
}

RTSP_HEADER_FUNC(rtsp_header_from)
{
  DEC_DUP_WARN(from, "From");
}

RTSP_HEADER_FUNC(rtsp_header_ifmod)
{
  DEC_DUP_WARN(if_modified_since, "If-Modified-Since");
}

RTSP_HEADER_FUNC(rtsp_header_lastmod)
{
  DEC_DUP_WARN(last_modified, "Last-Modified");
}

RTSP_HEADER_FUNC(rtsp_header_proxyauth)
{
  DEC_DUP_WARN(proxy_authenticate, "Proxy-Authenticate");
}

RTSP_HEADER_FUNC(rtsp_header_proxyreq)
{
  DEC_DUP_WARN(proxy_require, "Proxy-Require");
}

RTSP_HEADER_FUNC(rtsp_header_referer)
{
  DEC_DUP_WARN(referer, "Referer");
}

RTSP_HEADER_FUNC(rtsp_header_scale)
{
  DEC_DUP_WARN(scale, "Scale");
}

RTSP_HEADER_FUNC(rtsp_header_server)
{
  DEC_DUP_WARN(server, "Server");
}

RTSP_HEADER_FUNC(rtsp_header_unsup)
{
  DEC_DUP_WARN(unsupported, "Unsupported");
}

RTSP_HEADER_FUNC(rtsp_header_uagent)
{
  DEC_DUP_WARN(user_agent, "User-Agent");
}

RTSP_HEADER_FUNC(rtsp_header_via)
{
  DEC_DUP_WARN(via, "Via");
}

/*
 * header_types structure will provide a lookup between certain headers
 * in RTSP, and the function routines (above) that deal with actions based
 * on the response
 */
static struct {
  const char *val;
  uint32_t val_length;
  void (*parse_routine)(const char *lptr, rtsp_decode_t *decode, int cont_line);
} header_types[] =
{
#define HEAD_TYPE(a, b) { a, sizeof(a) - 1, b }
  HEAD_TYPE("AlLow", rtsp_header_allow_public),
  HEAD_TYPE("Public", rtsp_header_allow_public),
  HEAD_TYPE("Connection", rtsp_header_connection),
  HEAD_TYPE("Content-Base", rtsp_header_content_base),
  HEAD_TYPE("Content-Length", rtsp_header_content_length),
  HEAD_TYPE("Content-Location", rtsp_header_content_loc),
  HEAD_TYPE("Content-Type", rtsp_header_content_type),
  HEAD_TYPE("CSeq", rtsp_header_cseq),
  HEAD_TYPE("Location", rtsp_header_location),
  HEAD_TYPE("Range", rtsp_header_range),
  HEAD_TYPE("Retry-After", rtsp_header_retry_after),
  HEAD_TYPE("RTP-Info", rtsp_header_rtp),
  HEAD_TYPE("Session", rtsp_header_session),
  HEAD_TYPE("Set-Cookie", rtsp_header_cookie),
  HEAD_TYPE("Speed", rtsp_header_speed),
  HEAD_TYPE("Transport", rtsp_header_transport),
  HEAD_TYPE("WWW-Authenticate", rtsp_header_www),
  // None of these are needed for client, but are included for completion
  HEAD_TYPE("Accept", rtsp_header_accept),
  HEAD_TYPE("Accept-Encoding", rtsp_header_accept_enc),
  HEAD_TYPE("Accept-Language", rtsp_header_accept_lang),
  HEAD_TYPE("Authorization", rtsp_header_auth),
  HEAD_TYPE("Bandwidth", rtsp_header_bandwidth),
  HEAD_TYPE("Blocksize", rtsp_header_blocksize),
  HEAD_TYPE("Cache-Control", rtsp_header_cache_control),
  HEAD_TYPE("Content-Encoding", rtsp_header_content_enc),
  HEAD_TYPE("Content-Language", rtsp_header_content_lang),
  HEAD_TYPE("Date", rtsp_header_date),
  HEAD_TYPE("Expires", rtsp_header_expires),
  HEAD_TYPE("From", rtsp_header_from),
  HEAD_TYPE("If-Modified-Since", rtsp_header_ifmod),
  HEAD_TYPE("Last-Modified", rtsp_header_lastmod),
  HEAD_TYPE("Proxy-Authenticate", rtsp_header_proxyauth),
  HEAD_TYPE("Proxy-Require", rtsp_header_proxyreq),
  HEAD_TYPE("Referer", rtsp_header_referer),
  HEAD_TYPE("Scale", rtsp_header_scale),
  HEAD_TYPE("Server", rtsp_header_server),
  HEAD_TYPE("Unsupported", rtsp_header_unsup),
  HEAD_TYPE("User-Agent", rtsp_header_uagent),
  HEAD_TYPE("Via", rtsp_header_via),
  { NULL, 0, NULL },
};

// We don't care about the following: Cache-control, date, expires,
// Last-modified, Server, Unsupported, Via

/*
 * rtsp_decode_header - header line pointed to by lptr.  will be \0 terminated
 * Decode using above table
 */
static void rtsp_decode_header (const char *lptr,
				rtsp_client_t *info,
				int *last_number)
{
  int ix;
  const char *after;

  ix = 0;
  /*
   * go through above array, looking for a complete match
   */
  while (header_types[ix].val != NULL) {
    if (strncasecmp(lptr,
		    header_types[ix].val,
		    header_types[ix].val_length) == 0) {
      after = lptr + header_types[ix].val_length;
      ADV_SPACE(after);
      if (*after == ':') {
	after++;
	ADV_SPACE(after);