liveMedia/include/RTSPCommon.hh File Reference

#include "Boolean.hh"

Include dependency graph for RTSPCommon.hh:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	_strncasecmp   strncasecmp
#define	RTSP_PARAM_STRING_MAX   100
Functions
Boolean	parseRTSPRequestString (char const *reqStr, unsigned reqStrSize, char *resultCmdName, unsigned resultCmdNameMaxSize, char *resultURLPreSuffix, unsigned resultURLPreSuffixMaxSize, char *resultURLSuffix, unsigned resultURLSuffixMaxSize, char *resultCSeq, unsigned resultCSeqMaxSize)
Boolean	parseRangeHeader (char const *buf, float &rangeStart, float &rangeEnd)

---

Define Documentation

#define _strncasecmp   strncasecmp

Definition at line 32 of file RTSPCommon.hh.

Referenced by parseAuthorizationHeader(), RTSPClient::parseGetParameterHeader(), parsePlayNowHeader(), parseRangeHeader(), RTSPClient::parseRTPInfoHeader(), RTSPClient::parseRTSPURL(), RTSPClient::parseRTSPURLUsernamePassword(), parseScaleHeader(), RTSPClient::parseScaleHeader(), SIPClient::parseSIPURL(), SIPClient::parseSIPURLUsernamePassword(), parseTransportHeader(), RTSPClient::parseTransportResponse(), and RTSPClient::sendOptionsCmd().

#define RTSP_PARAM_STRING_MAX   100

Definition at line 35 of file RTSPCommon.hh.

Referenced by RTSPServer::RTSPClientSession::incomingRequestHandler1(), and RTSPClient::incomingRequestHandler1().

---

Function Documentation

Boolean parseRangeHeader	(	char const *	buf,
		float &	rangeStart,
		float &	rangeEnd
	)

Definition at line 137 of file RTSPCommon.cpp.

References _strncasecmp, False, and True.

Referenced by RTSPServer::RTSPClientSession::handleCmd_PLAY(), RTSPServer::RTSPClientSession::handleCmd_SETUP(), RTSPClient::playMediaSession(), and RTSPClient::playMediaSubsession().

                                                                              {
  // First, find "Range:"
  while (1) {
    if (*buf == '\0') return False; // not found
    if (_strncasecmp(buf, "Range: ", 7) == 0) break;
    ++buf;
  }

  // Then, run through each of the fields, looking for ones we handle:
  char const* fields = buf + 7;
  while (*fields == ' ') ++fields;
  float start, end;
  Locale("C", LC_NUMERIC);
  if (sscanf(fields, "npt = %f - %f", &start, &end) == 2) {
    rangeStart = start;
    rangeEnd = end;
  } else if (sscanf(fields, "npt = %f -", &start) == 1) {
    rangeStart = start;
    rangeEnd = 0.0;
  } else {
    return False; // The header is malformed
  }

  return True;
}

Boolean parseRTSPRequestString	(	char const *	reqStr,
		unsigned	reqStrSize,
		char *	resultCmdName,
		unsigned	resultCmdNameMaxSize,
		char *	resultURLPreSuffix,
		unsigned	resultURLPreSuffixMaxSize,
		char *	resultURLSuffix,
		unsigned	resultURLSuffixMaxSize,
		char *	resultCSeq,
		unsigned	resultCSeqMaxSize
	)

Definition at line 26 of file RTSPCommon.cpp.

References False, and True.

Referenced by RTSPServer::RTSPClientSession::incomingRequestHandler1(), and RTSPClient::incomingRequestHandler1().

                                                           {
  // This parser is currently rather dumb; it should be made smarter #####

  // Read everything up to the first space as the command name:
  Boolean parseSucceeded = False;
  unsigned i;
  for (i = 0; i < resultCmdNameMaxSize-1 && i < reqStrSize; ++i) {
    char c = reqStr[i];
    if (c == ' ' || c == '\t') {
      parseSucceeded = True;
      break;
    }

    resultCmdName[i] = c;
  }
  resultCmdName[i] = '\0';
  if (!parseSucceeded) return False;

  // Skip over the prefix of any "rtsp://" or "rtsp:/" URL that follows:
  unsigned j = i+1;
  while (j < reqStrSize && (reqStr[j] == ' ' || reqStr[j] == '\t')) ++j; // skip over any additional white space
  for (j = i+1; (int)j < (int)(reqStrSize-8); ++j) {
    if ((reqStr[j] == 'r' || reqStr[j] == 'R')
        && (reqStr[j+1] == 't' || reqStr[j+1] == 'T')
        && (reqStr[j+2] == 's' || reqStr[j+2] == 'S')
        && (reqStr[j+3] == 'p' || reqStr[j+3] == 'P')
        && reqStr[j+4] == ':' && reqStr[j+5] == '/') {
      j += 6;
      if (reqStr[j] == '/') {
        // This is a "rtsp://" URL; skip over the host:port part that follows:
        ++j;
        while (j < reqStrSize && reqStr[j] != '/' && reqStr[j] != ' ') ++j;
      } else {
        // This is a "rtsp:/" URL; back up to the "/":
        --j;
      }
      i = j;
      break;
    }
  }

  // Look for the URL suffix (before the following "RTSP/"):
  parseSucceeded = False;
  for (unsigned k = i+1; (int)k < (int)(reqStrSize-5); ++k) {
    if (reqStr[k] == 'R' && reqStr[k+1] == 'T' &&
        reqStr[k+2] == 'S' && reqStr[k+3] == 'P' && reqStr[k+4] == '/') {
      while (--k >= i && reqStr[k] == ' ') {} // go back over all spaces before "RTSP/"
      unsigned k1 = k;
      while (k1 > i && reqStr[k1] != '/') --k1;
      // the URL suffix comes from [k1+1,k]

      // Copy "resultURLSuffix":
      if (k - k1 + 1 > resultURLSuffixMaxSize) return False; // there's no room
      unsigned n = 0, k2 = k1+1;
      while (k2 <= k) resultURLSuffix[n++] = reqStr[k2++];
      resultURLSuffix[n] = '\0';

      // Also look for the URL 'pre-suffix' before this:
      unsigned k3 = --k1;
      while (k3 > i && reqStr[k3] != '/') --k3;
      // the URL pre-suffix comes from [k3+1,k1]

      // Copy "resultURLPreSuffix":
      if (k1 - k3 + 1 > resultURLPreSuffixMaxSize) return False; // there's no room
      n = 0; k2 = k3+1;
      while (k2 <= k1) resultURLPreSuffix[n++] = reqStr[k2++];
      resultURLPreSuffix[n] = '\0';

      i = k + 7; // to go past " RTSP/"
      parseSucceeded = True;
      break;
    }
  }
  if (!parseSucceeded) return False;

  // Look for "CSeq:", skip whitespace,
  // then read everything up to the next \r or \n as 'CSeq':
  parseSucceeded = False;
  for (j = i; (int)j < (int)(reqStrSize-5); ++j) {
    if (reqStr[j] == 'C' && reqStr[j+1] == 'S' && reqStr[j+2] == 'e' &&
        reqStr[j+3] == 'q' && reqStr[j+4] == ':') {
      j += 5;
      unsigned n;
      while (j < reqStrSize && (reqStr[j] ==  ' ' || reqStr[j] == '\t')) ++j;
      for (n = 0; n < resultCSeqMaxSize-1 && j < reqStrSize; ++n,++j) {
        char c = reqStr[j];
        if (c == '\r' || c == '\n') {
          parseSucceeded = True;
          break;
        }

        resultCSeq[n] = c;
      }
      resultCSeq[n] = '\0';
      break;
    }
  }
  if (!parseSucceeded) return False;

  return True;
}

---