liveMedia/RTSPCommon.cpp File Reference

#include "RTSPCommon.hh"
#include "Locale.hh"
#include <string.h>
#include <stdio.h>
#include <time.h>

Include dependency graph for RTSPCommon.cpp:

Go to the source code of this file.

Functions
Boolean	parseRTSPRequestString (char const *reqStr, unsigned reqStrSize, char *resultCmdName, unsigned resultCmdNameMaxSize, char *resultURLPreSuffix, unsigned resultURLPreSuffixMaxSize, char *resultURLSuffix, unsigned resultURLSuffixMaxSize, char *resultCSeq, unsigned resultCSeqMaxSize, unsigned &contentLength)
Boolean	parseRangeParam (char const *paramStr, double &rangeStart, double &rangeEnd)
Boolean	parseRangeHeader (char const *buf, double &rangeStart, double &rangeEnd)
char const *	dateHeader ()

---

Function Documentation

char const* dateHeader

(

)

Definition at line 188 of file RTSPCommon.cpp.

References DWORD, and NULL.

Referenced by RTSPServer::RTSPClientSession::authenticationOK(), RTSPServer::RTSPClientSession::handleCmd_bad(), RTSPServer::RTSPClientSession::handleCmd_DESCRIBE(), RTSPServer::RTSPClientSession::handleCmd_GET_PARAMETER(), RTSPServer::RTSPClientSession::handleCmd_notFound(), RTSPServer::RTSPClientSession::handleCmd_notSupported(), RTSPServer::RTSPClientSession::handleCmd_OPTIONS(), RTSPServer::RTSPClientSession::handleCmd_PAUSE(), RTSPServer::RTSPClientSession::handleCmd_PLAY(), RTSPServer::RTSPClientSession::handleCmd_SET_PARAMETER(), RTSPServer::RTSPClientSession::handleCmd_SETUP(), RTSPServer::RTSPClientSession::handleCmd_TEARDOWN(), RTSPServer::RTSPClientSession::handleCmd_unsupportedTransport(), RTSPServer::RTSPClientSession::handleHTTPCmd_notFound(), RTSPServer::RTSPClientSession::handleHTTPCmd_notSupported(), and RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming::handleHTTPCmd_StreamingGET().

                         {
  static char buf[200];
#if !defined(_WIN32_WCE)
  time_t tt = time(NULL);
  strftime(buf, sizeof buf, "Date: %a, %b %d %Y %H:%M:%S GMT\r\n", gmtime(&tt));
#else
  // WinCE apparently doesn't have "time()", "strftime()", or "gmtime()",
  // so generate the "Date:" header a different, WinCE-specific way.
  // (Thanks to Pierre l'Hussiez for this code)
  // RSF: But where is the "Date: " string?  This code doesn't look quite right...
  SYSTEMTIME SystemTime;
  GetSystemTime(&SystemTime);
  WCHAR dateFormat[] = L"ddd, MMM dd yyyy";
  WCHAR timeFormat[] = L"HH:mm:ss GMT\r\n";
  WCHAR inBuf[200];
  DWORD locale = LOCALE_NEUTRAL;

  int ret = GetDateFormat(locale, 0, &SystemTime,
                          (LPTSTR)dateFormat, (LPTSTR)inBuf, sizeof inBuf);
  inBuf[ret - 1] = ' ';
  ret = GetTimeFormat(locale, 0, &SystemTime,
                      (LPTSTR)timeFormat,
                      (LPTSTR)inBuf + ret, (sizeof inBuf) - ret);
  wcstombs(buf, inBuf, wcslen(inBuf));
#endif
  return buf;
}

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

Definition at line 174 of file RTSPCommon.cpp.

References _strncasecmp, False, and parseRangeParam().

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

                                                                                {
  // 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;
  return parseRangeParam(fields, rangeStart, rangeEnd);
}

Boolean parseRangeParam	(	char const *	paramStr,
		double &	rangeStart,
		double &	rangeEnd
	)

Definition at line 150 of file RTSPCommon.cpp.

References False, Numeric, and True.

Referenced by RTSPClient::handlePLAYResponse(), and parseRangeHeader().

                                                                                    {
  double start, end;
  int numCharsMatched = 0;
  Locale l("C", Numeric);
  if (sscanf(paramStr, "npt = %lf - %lf", &start, &end) == 2) {
    rangeStart = start;
    rangeEnd = end;
  } else if (sscanf(paramStr, "npt = %lf -", &start) == 1) {
    rangeStart = start;
    rangeEnd = 0.0;
  } else if (strcmp(paramStr, "npt=now-") == 0) {
    rangeStart = 0.0;
    rangeEnd = 0.0;
  } else if (sscanf(paramStr, "clock = %*s%n", &numCharsMatched) == 0 && numCharsMatched > 0) {
    // We accept "clock=" parameters, but currently do no interpret them.
  } else if (sscanf(paramStr, "smtpe = %*s%n", &numCharsMatched) == 0 && numCharsMatched > 0) {
    // We accept "smtpe=" parameters, but currently do no interpret them.
  } 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,
		unsigned &	contentLength
	)

Definition at line 27 of file RTSPCommon.cpp.

References False, and True.

Referenced by RTSPClient::handleIncomingRequest(), and RTSPServer::RTSPClientSession::handleRequestBytes().

                                                        {
  // This parser is currently rather dumb; it should be made smarter #####
  contentLength = 0; // default value

  // 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 (; (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';

      // The URL 'pre-suffix' comes from [i+1,k1-1]
      // Copy "resultURLPreSuffix":
      if (k1 - i > resultURLPreSuffixMaxSize) return False; // there's no room
      n = 0; k2 = i + 1;
      while (k2 <= k1 - 1) 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;
      while (j < reqStrSize && (reqStr[j] ==  ' ' || reqStr[j] == '\t')) ++j;
      unsigned n;
      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;

  // Also: Look for "Content-Length:" (optional)
  for (j = i; (int)j < (int)(reqStrSize-15); ++j) {
    if (reqStr[j] == 'C' && reqStr[j+1] == 'o' && reqStr[j+2] == 'n' && reqStr[j+3] == 't' && reqStr[j+4] == 'e' &&
        reqStr[j+5] == 'n' && reqStr[j+6] == 't' && reqStr[j+7] == '-' && (reqStr[j+8] == 'L' || reqStr[j+8] == 'l') &&
        reqStr[j+9] == 'e' && reqStr[j+10] == 'n' && reqStr[j+11] == 'g' && reqStr[j+12] == 't' && reqStr[j+13] == 'h' &&
        reqStr[j+14] == ':') {
      j += 15;
      while (j < reqStrSize && (reqStr[j] ==  ' ' || reqStr[j] == '\t')) ++j;
      unsigned num;
      if (sscanf(&reqStr[j], "%u", &num) == 1) {
        contentLength = num;
      }
    }
  }
  return True;
}

---