RTSPServer::RTSPClientSession Class Reference

#include <RTSPServer.hh>

Inheritance diagram for RTSPServer::RTSPClientSession:

[legend]Collaboration diagram for RTSPServer::RTSPClientSession:

[legend]

Public Member Functions
	RTSPClientSession (RTSPServer &ourServer, unsigned sessionId, int clientSocket, struct sockaddr_in clientAddr)
virtual	~RTSPClientSession ()
Protected Member Functions
virtual void	handleCmd_bad (char const *cseq)
virtual void	handleCmd_notSupported (char const *cseq)
virtual void	handleCmd_notFound (char const *cseq)
virtual void	handleCmd_unsupportedTransport (char const *cseq)
virtual void	handleCmd_OPTIONS (char const *cseq)
virtual void	handleCmd_DESCRIBE (char const *cseq, char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr)
virtual void	handleCmd_SETUP (char const *cseq, char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr)
virtual void	handleCmd_withinSession (char const *cmdName, char const *urlPreSuffix, char const *urlSuffix, char const *cseq, char const *fullRequestStr)
virtual void	handleCmd_TEARDOWN (ServerMediaSubsession *subsession, char const *cseq)
virtual void	handleCmd_PLAY (ServerMediaSubsession *subsession, char const *cseq, char const *fullRequestStr)
virtual void	handleCmd_PAUSE (ServerMediaSubsession *subsession, char const *cseq)
virtual void	handleCmd_GET_PARAMETER (ServerMediaSubsession *subsession, char const *cseq, char const *fullRequestStr)
virtual void	handleCmd_SET_PARAMETER (ServerMediaSubsession *subsession, char const *cseq, char const *fullRequestStr)
virtual Boolean	parseHTTPRequestString (char *resultCmdName, unsigned resultCmdNameMaxSize, char *urlSuffix, unsigned urlSuffixMaxSize, char *sessionCookie, unsigned sessionCookieMaxSize, char *acceptStr, unsigned acceptStrMaxSize)
virtual void	handleHTTPCmd_notSupported ()
virtual void	handleHTTPCmd_notFound ()
virtual void	handleHTTPCmd_TunnelingGET (char const *sessionCookie)
virtual Boolean	handleHTTPCmd_TunnelingPOST (char const *sessionCookie, unsigned char const *extraData, unsigned extraDataSize)
virtual void	handleHTTPCmd_StreamingGET (char const *urlSuffix, char const *fullRequestStr)
UsageEnvironment &	envir ()
void	closeSockets ()
void	reclaimStreamStates ()
void	resetRequestBuffer ()
Boolean	authenticationOK (char const *cmdName, char const *cseq, char const *urlSuffix, char const *fullRequestStr)
Boolean	isMulticast () const
void	incomingRequestHandler1 ()
void	handleAlternativeRequestByte1 (u_int8_t requestByte)
void	handleRequestBytes (int newBytesRead)
void	noteLiveness ()
void	changeClientInputSocket (int newSocketNum, unsigned char const *extraData, unsigned extraDataSize)
Static Protected Member Functions
static void	incomingRequestHandler (void *, int)
static void	handleAlternativeRequestByte (void *, u_int8_t requestByte)
static void	noteClientLiveness (RTSPClientSession *clientSession)
static void	livenessTimeoutTask (RTSPClientSession *clientSession)
Protected Attributes
RTSPServer &	fOurServer
unsigned	fOurSessionId
ServerMediaSession *	fOurServerMediaSession
int	fClientInputSocket
int	fClientOutputSocket
sockaddr_in	fClientAddr
char *	fSessionCookie
TaskToken	fLivenessCheckTask
unsigned char	fRequestBuffer [RTSP_BUFFER_SIZE]
unsigned	fRequestBytesAlreadySeen
unsigned	fRequestBufferBytesLeft
unsigned char *	fLastCRLF
unsigned	fBase64RemainderCount
unsigned char	fResponseBuffer [RTSP_BUFFER_SIZE]
Boolean	fIsMulticast
Boolean	fSessionIsActive
Boolean	fStreamAfterSETUP
Authenticator	fCurrentAuthenticator
unsigned char	fTCPStreamIdCount
unsigned	fNumStreamStates
RTSPServer::RTSPClientSession::streamState *	fStreamStates
unsigned	fRecursionCount
Data Structures
struct	streamState

---

Detailed Description

Definition at line 124 of file RTSPServer.hh.

---

Constructor & Destructor Documentation

RTSPServer::RTSPClientSession::RTSPClientSession	(	RTSPServer &	ourServer,
		unsigned	sessionId,
		int	clientSocket,
		struct sockaddr_in	clientAddr
	)

Definition at line 290 of file RTSPServer.cpp.

References envir(), fClientInputSocket, incomingRequestHandler(), noteLiveness(), resetRequestBuffer(), UsageEnvironment::taskScheduler(), and TaskScheduler::turnOnBackgroundReadHandling().

  : fOurServer(ourServer), fOurSessionId(sessionId),
    fOurServerMediaSession(NULL),
    fClientInputSocket(clientSocket), fClientOutputSocket(clientSocket), fClientAddr(clientAddr),
    fSessionCookie(NULL), fLivenessCheckTask(NULL),
    fIsMulticast(False), fSessionIsActive(True), fStreamAfterSETUP(False),
    fTCPStreamIdCount(0), fNumStreamStates(0), fStreamStates(NULL), fRecursionCount(0) {
  // Arrange to handle incoming requests:
  resetRequestBuffer();
  envir().taskScheduler().turnOnBackgroundReadHandling(fClientInputSocket,
     (TaskScheduler::BackgroundHandlerProc*)&incomingRequestHandler, this);
  noteLiveness();
}

RTSPServer::RTSPClientSession::~RTSPClientSession

(

)

[virtual]

Definition at line 304 of file RTSPServer.cpp.

References closeSockets(), ServerMediaSession::decrementReferenceCount(), ServerMediaSession::deleteWhenUnreferenced(), RTSPServer::fClientSessionsForHTTPTunneling, fOurServer, fOurServerMediaSession, fSessionCookie, NULL, reclaimStreamStates(), ServerMediaSession::referenceCount(), HashTable::Remove(), and RTSPServer::removeServerMediaSession().

                                                {
  closeSockets();

  if (fSessionCookie != NULL) {
    // We were being used for RTSP-over-HTTP tunneling.  Remove ourselves from the 'session cookie' hash table before we go:
    fOurServer.fClientSessionsForHTTPTunneling->Remove(fSessionCookie);
    delete[] fSessionCookie;
  }

  reclaimStreamStates();

  if (fOurServerMediaSession != NULL) {
    fOurServerMediaSession->decrementReferenceCount();
    if (fOurServerMediaSession->referenceCount() == 0
        && fOurServerMediaSession->deleteWhenUnreferenced()) {
      fOurServer.removeServerMediaSession(fOurServerMediaSession);
      fOurServerMediaSession = NULL;
    }
  }
}

---

Member Function Documentation

void RTSPServer::RTSPClientSession::handleCmd_bad

(

char const *

cseq

)

[protected, virtual]

Definition at line 581 of file RTSPServer.cpp.

References allowedCommandNames, dateHeader(), and fResponseBuffer.

Referenced by handleRequestBytes().

                                                                    {
  // Don't do anything with "cseq", because it might be nonsense
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 400 Bad Request\r\n%sAllow: %s\r\n\r\n",
           dateHeader(), allowedCommandNames);
}

void RTSPServer::RTSPClientSession::handleCmd_notSupported

(

char const *

cseq

)

[protected, virtual]

Definition at line 588 of file RTSPServer.cpp.

References allowedCommandNames, dateHeader(), and fResponseBuffer.

Referenced by handleRequestBytes().

                                                                         {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 405 Method Not Allowed\r\nCSeq: %s\r\n%sAllow: %s\r\n\r\n",
           cseq, dateHeader(), allowedCommandNames);
}

void RTSPServer::RTSPClientSession::handleCmd_notFound

(

char const *

cseq

)

[protected, virtual]

Definition at line 594 of file RTSPServer.cpp.

References dateHeader(), False, fResponseBuffer, and fSessionIsActive.

                                                                     {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 404 Stream Not Found\r\nCSeq: %s\r\n%s\r\n",
           cseq, dateHeader());
  fSessionIsActive = False; // triggers deletion of ourself after responding
}

void RTSPServer::RTSPClientSession::handleCmd_unsupportedTransport

(

char const *

cseq

)

[protected, virtual]

Definition at line 601 of file RTSPServer.cpp.

References dateHeader(), False, fResponseBuffer, and fSessionIsActive.

                                                                                 {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 461 Unsupported Transport\r\nCSeq: %s\r\n%s\r\n",
           cseq, dateHeader());
  fSessionIsActive = False; // triggers deletion of ourself after responding
}

void RTSPServer::RTSPClientSession::handleCmd_OPTIONS

(

char const *

cseq

)

[protected, virtual]

Definition at line 608 of file RTSPServer.cpp.

References allowedCommandNames, dateHeader(), and fResponseBuffer.

Referenced by handleRequestBytes().

                                                                    {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sPublic: %s\r\n\r\n",
           cseq, dateHeader(), allowedCommandNames);
}

void RTSPServer::RTSPClientSession::handleCmd_DESCRIBE	(	char const *	cseq,
		char const *	urlPreSuffix,
		char const *	urlSuffix,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 615 of file RTSPServer.cpp.

References dateHeader(), NULL, RTSP_PARAM_STRING_MAX, RTSPServer::rtspURL(), and session.

Referenced by handleRequestBytes().

                                                 {
  char* sdpDescription = NULL;
  char* rtspURL = NULL;
  do {
    char urlTotalSuffix[RTSP_PARAM_STRING_MAX];
    if (strlen(urlPreSuffix) + strlen(urlSuffix) + 2 > sizeof urlTotalSuffix) {
      handleCmd_bad(cseq);
      break;
    }
    urlTotalSuffix[0] = '\0';
    if (urlPreSuffix[0] != '\0') {
      strcat(urlTotalSuffix, urlPreSuffix);
      strcat(urlTotalSuffix, "/");
    }
    strcat(urlTotalSuffix, urlSuffix);
      
    if (!authenticationOK("DESCRIBE", cseq, urlTotalSuffix, fullRequestStr)) break;
    
    // We should really check that the request contains an "Accept:" #####
    // for "application/sdp", because that's what we're sending back #####
    
    // Begin by looking up the "ServerMediaSession" object for the specified "urlTotalSuffix":
    ServerMediaSession* session = fOurServer.lookupServerMediaSession(urlTotalSuffix);
    if (session == NULL) {
      handleCmd_notFound(cseq);
      break;
    }
    
    // Then, assemble a SDP description for this session:
    sdpDescription = session->generateSDPDescription();
    if (sdpDescription == NULL) {
      // This usually means that a file name that was specified for a
      // "ServerMediaSubsession" does not exist.
      snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
               "RTSP/1.0 404 File Not Found, Or In Incorrect Format\r\n"
               "CSeq: %s\r\n"
               "%s\r\n",
               cseq,
               dateHeader());
      break;
    }
    unsigned sdpDescriptionSize = strlen(sdpDescription);
    
    // Also, generate our RTSP URL, for the "Content-Base:" header
    // (which is necessary to ensure that the correct URL gets used in
    // subsequent "SETUP" requests).
    rtspURL = fOurServer.rtspURL(session, fClientInputSocket);
    
    snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
             "RTSP/1.0 200 OK\r\nCSeq: %s\r\n"
             "%s"
             "Content-Base: %s/\r\n"
             "Content-Type: application/sdp\r\n"
             "Content-Length: %d\r\n\r\n"
             "%s",
             cseq,
             dateHeader(),
             rtspURL,
             sdpDescriptionSize,
             sdpDescription);
  } while (0);

  delete[] sdpDescription;
  delete[] rtspURL;
}

void RTSPServer::RTSPClientSession::handleCmd_SETUP	(	char const *	cseq,
		char const *	urlPreSuffix,
		char const *	urlSuffix,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 764 of file RTSPServer.cpp.

References dateHeader(), handleCmd_withinSession(), iter, MediaSubsessionIterator::next(), NULL, Port::num(), our_inet_addr(), parsePlayNowHeader(), parseRangeHeader(), parseTransportHeader(), RAW_UDP, ReceivingInterfaceAddr, MediaSubsessionIterator::reset(), RTP_TCP, RTP_UDP, SendingInterfaceAddr, SOCKLEN_T, subsession, and AddressString::val().

Referenced by handleRequestBytes().

                                              {
  // Normally, "urlPreSuffix" should be the session (stream) name, and "urlSuffix" should be the subsession (track) name.
  // However (being "liberal in what we accept"), we also handle 'aggregate' SETUP requests (i.e., without a track name),
  // in the special case where we have only a single track.  I.e., in this case, we also handle:
  //    "urlPreSuffix" is empty and "urlSuffix" is the session (stream) name, or
  //    "urlPreSuffix" concatenated with "urlSuffix" (with "/" inbetween) is the session (stream) name.
  char const* streamName = urlPreSuffix; // in the normal case
  char const* trackId = urlSuffix; // in the normal case
  char* concatenatedStreamName = NULL; // in the normal case

  do {
    // First, make sure the specified stream name exists:
    ServerMediaSession* prevSMS = fOurServerMediaSession;
    fOurServerMediaSession = fOurServer.lookupServerMediaSession(streamName);
    if (fOurServerMediaSession == NULL) {
      // Check for the special case (noted above), before we give up:
      if (urlPreSuffix[0] == '\0') {
        streamName = urlSuffix;
      } else {
        concatenatedStreamName = new char[strlen(urlPreSuffix) + strlen(urlSuffix) + 2]; // allow for the "/" and the trailing '\0'
        sprintf(concatenatedStreamName, "%s/%s", urlPreSuffix, urlSuffix);
        streamName = concatenatedStreamName;
      }
      trackId = NULL;

      // Check again:
      fOurServerMediaSession = fOurServer.lookupServerMediaSession(streamName);
    }
    if (fOurServerMediaSession == NULL) {
      handleCmd_notFound(cseq);
      break;
    }

    if (fOurServerMediaSession != prevSMS) {
      // We're accessing the "ServerMediaSession" for the first time.
      fOurServerMediaSession->incrementReferenceCount();
    }

    if (fStreamStates == NULL) {
      // This is the first "SETUP" for this session.  Set up our array of states for all of this session's subsessions (tracks):
      ServerMediaSubsessionIterator iter(*fOurServerMediaSession);
      for (fNumStreamStates = 0; iter.next() != NULL; ++fNumStreamStates) {} // begin by counting the number of subsessions (tracks)

      fStreamStates = new struct streamState[fNumStreamStates];

      iter.reset();
      ServerMediaSubsession* subsession;
      for (unsigned i = 0; i < fNumStreamStates; ++i) {
        subsession = iter.next();
        fStreamStates[i].subsession = subsession;
        fStreamStates[i].streamToken = NULL; // for now; it may be changed by the "getStreamParameters()" call that comes later
      }
    }

    // Look up information for the specified subsession (track):
    ServerMediaSubsession* subsession = NULL;
    unsigned streamNum;
    if (trackId != NULL && trackId[0] != '\0') { // normal case
      for (streamNum = 0; streamNum < fNumStreamStates; ++streamNum) {
        subsession = fStreamStates[streamNum].subsession;
        if (subsession != NULL && strcmp(trackId, subsession->trackId()) == 0) break;
      }
      if (streamNum >= fNumStreamStates) {
        // The specified track id doesn't exist, so this request fails:
        handleCmd_notFound(cseq);
        break;
      }
    } else {
      // Weird case: there was no track id in the URL.
      // This works only if we have only one subsession:
      if (fNumStreamStates != 1) {
        handleCmd_bad(cseq);
        break;
      }
      streamNum = 0;
      subsession = fStreamStates[streamNum].subsession;
    }
    // ASSERT: subsession != NULL

    // Look for a "Transport:" header in the request string, to extract client parameters:
    StreamingMode streamingMode;
    char* streamingModeString = NULL; // set when RAW_UDP streaming is specified
    char* clientsDestinationAddressStr;
    u_int8_t clientsDestinationTTL;
    portNumBits clientRTPPortNum, clientRTCPPortNum;
    unsigned char rtpChannelId, rtcpChannelId;
    parseTransportHeader(fullRequestStr, streamingMode, streamingModeString,
                         clientsDestinationAddressStr, clientsDestinationTTL,
                         clientRTPPortNum, clientRTCPPortNum,
                         rtpChannelId, rtcpChannelId);
    if (streamingMode == RTP_TCP && rtpChannelId == 0xFF ||
        streamingMode != RTP_TCP && fClientOutputSocket != fClientInputSocket) {
      // An anomolous situation, caused by a buggy client.  Either:
      //     1/ TCP streaming was requested, but with no "interleaving=" fields.  (QuickTime Player sometimes does this.), or
      //     2/ TCP streaming was not requested, but we're doing RTSP-over-HTTP tunneling (which implies TCP streaming).
      // In either case, we assume TCP streaming, and set the RTP and RTCP channel ids to proper values:
      streamingMode = RTP_TCP;
      rtpChannelId = fTCPStreamIdCount; rtcpChannelId = fTCPStreamIdCount+1;
    }
    fTCPStreamIdCount += 2;

    Port clientRTPPort(clientRTPPortNum);
    Port clientRTCPPort(clientRTCPPortNum);

    // Next, check whether a "Range:" header is present in the request.
    // This isn't legal, but some clients do this to combine "SETUP" and "PLAY":
    double rangeStart = 0.0, rangeEnd = 0.0;
    fStreamAfterSETUP = parseRangeHeader(fullRequestStr, rangeStart, rangeEnd) || parsePlayNowHeader(fullRequestStr);

    // Then, get server parameters from the 'subsession':
    int tcpSocketNum = streamingMode == RTP_TCP ? fClientOutputSocket : -1;
    netAddressBits destinationAddress = 0;
    u_int8_t destinationTTL = 255;
#ifdef RTSP_ALLOW_CLIENT_DESTINATION_SETTING
    if (clientsDestinationAddressStr != NULL) {
      // Use the client-provided "destination" address.
      // Note: This potentially allows the server to be used in denial-of-service
      // attacks, so don't enable this code unless you're sure that clients are
      // trusted.
      destinationAddress = our_inet_addr(clientsDestinationAddressStr);
    }
    // Also use the client-provided TTL.
    destinationTTL = clientsDestinationTTL;
#endif
    delete[] clientsDestinationAddressStr;
    Port serverRTPPort(0);
    Port serverRTCPPort(0);

    // Make sure that we transmit on the same interface that's used by the client (in case we're a multi-homed server):
    struct sockaddr_in sourceAddr; SOCKLEN_T namelen = sizeof sourceAddr;
    getsockname(fClientInputSocket, (struct sockaddr*)&sourceAddr, &namelen);
    netAddressBits origSendingInterfaceAddr = SendingInterfaceAddr;
    netAddressBits origReceivingInterfaceAddr = ReceivingInterfaceAddr;
    // NOTE: The following might not work properly, so we ifdef it out for now:
#ifdef HACK_FOR_MULTIHOMED_SERVERS
    ReceivingInterfaceAddr = SendingInterfaceAddr = sourceAddr.sin_addr.s_addr;
#endif

    subsession->getStreamParameters(fOurSessionId, fClientAddr.sin_addr.s_addr,
                                    clientRTPPort, clientRTCPPort,
                                    tcpSocketNum, rtpChannelId, rtcpChannelId,
                                    destinationAddress, destinationTTL, fIsMulticast,
                                    serverRTPPort, serverRTCPPort,
                                    fStreamStates[streamNum].streamToken);
    SendingInterfaceAddr = origSendingInterfaceAddr;
    ReceivingInterfaceAddr = origReceivingInterfaceAddr;
    
    AddressString destAddrStr(destinationAddress);
    AddressString sourceAddrStr(sourceAddr);
    if (fIsMulticast) {
      switch (streamingMode) {
        case RTP_UDP:
          snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
                   "RTSP/1.0 200 OK\r\n"
                   "CSeq: %s\r\n"
                   "%s"
                   "Transport: RTP/AVP;multicast;destination=%s;source=%s;port=%d-%d;ttl=%d\r\n"
                   "Session: %08X\r\n\r\n",
                   cseq,
                   dateHeader(),
                   destAddrStr.val(), sourceAddrStr.val(), ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()), destinationTTL,
                   fOurSessionId);
          break;
        case RTP_TCP:
          // multicast streams can't be sent via TCP
          handleCmd_unsupportedTransport(cseq);
          break;
        case RAW_UDP:
          snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
                   "RTSP/1.0 200 OK\r\n"
                   "CSeq: %s\r\n"
                   "%s"
                   "Transport: %s;multicast;destination=%s;source=%s;port=%d;ttl=%d\r\n"
                   "Session: %08X\r\n\r\n",
                   cseq,
                   dateHeader(),
                   streamingModeString, destAddrStr.val(), sourceAddrStr.val(), ntohs(serverRTPPort.num()), destinationTTL,
                   fOurSessionId);
          break;
      }
    } else {
      switch (streamingMode) {
        case RTP_UDP: {
          snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
                   "RTSP/1.0 200 OK\r\n"
                   "CSeq: %s\r\n"
                   "%s"
                   "Transport: RTP/AVP;unicast;destination=%s;source=%s;client_port=%d-%d;server_port=%d-%d\r\n"
                   "Session: %08X\r\n\r\n",
                   cseq,
                   dateHeader(),
                   destAddrStr.val(), sourceAddrStr.val(), ntohs(clientRTPPort.num()), ntohs(clientRTCPPort.num()), ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()),
                   fOurSessionId);
          break;
        }
        case RTP_TCP: {
          snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
                   "RTSP/1.0 200 OK\r\n"
                   "CSeq: %s\r\n"
                   "%s"
                   "Transport: RTP/AVP/TCP;unicast;destination=%s;source=%s;interleaved=%d-%d\r\n"
                   "Session: %08X\r\n\r\n",
                   cseq,
                   dateHeader(),
                   destAddrStr.val(), sourceAddrStr.val(), rtpChannelId, rtcpChannelId,
                   fOurSessionId);
          break;
        }
        case RAW_UDP: {
          snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
                   "RTSP/1.0 200 OK\r\n"
                   "CSeq: %s\r\n"
                   "%s"
                   "Transport: %s;unicast;destination=%s;source=%s;client_port=%d;server_port=%d\r\n"
                   "Session: %08X\r\n\r\n",
                   cseq,
                   dateHeader(),
                   streamingModeString, destAddrStr.val(), sourceAddrStr.val(), ntohs(clientRTPPort.num()), ntohs(serverRTPPort.num()),
                   fOurSessionId);
          break;
        }
      }
    }
    delete[] streamingModeString;
  } while (0);

  delete[] concatenatedStreamName;
}

void RTSPServer::RTSPClientSession::handleCmd_withinSession	(	char const *	cmdName,
		char const *	urlPreSuffix,
		char const *	urlSuffix,
		char const *	cseq,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 996 of file RTSPServer.cpp.

References iter, MediaSubsessionIterator::next(), NULL, and subsession.

Referenced by handleCmd_SETUP(), and handleRequestBytes().

                                                                        {
  // This will either be:
  // - an operation on the entire server, if "urlPreSuffix" is "", and "urlSuffix" is "*" (i.e., the special "*" URL), or
  // - a non-aggregated operation, if "urlPreSuffix" is the session (stream)
  //   name and "urlSuffix" is the subsession (track) name, or
  // - an aggregated operation, if "urlSuffix" is the session (stream) name,
  //   or "urlPreSuffix" is the session (stream) name, and "urlSuffix" is empty,
  //   or "urlPreSuffix" and "urlSuffix" are both nonempty, but when concatenated, (with "/") form the session (stream) name.
  // Begin by figuring out which of these it is:
  ServerMediaSubsession* subsession;
  if (urlPreSuffix[0] == '\0' && urlSuffix[0] == '*' && urlSuffix[1] == '\0') {
    // An operation on the entire server.  This works only for GET_PARAMETER and SET_PARAMETER:
    if (strcmp(cmdName, "GET_PARAMETER") == 0) {
      handleCmd_GET_PARAMETER(NULL, cseq, fullRequestStr);
    } else if (strcmp(cmdName, "SET_PARAMETER") == 0) {
      handleCmd_SET_PARAMETER(NULL, cseq, fullRequestStr);
    } else {
      handleCmd_notSupported(cseq);
    }
    return;
  } else if (fOurServerMediaSession == NULL) { // There wasn't a previous SETUP!
    handleCmd_notSupported(cseq);
    return;
  } else if (urlSuffix[0] != '\0' && strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0) {
    // Non-aggregated operation.
    // Look up the media subsession whose track id is "urlSuffix":
    ServerMediaSubsessionIterator iter(*fOurServerMediaSession);
    while ((subsession = iter.next()) != NULL) {
      if (strcmp(subsession->trackId(), urlSuffix) == 0) break; // success
    }
    if (subsession == NULL) { // no such track!
      handleCmd_notFound(cseq);
      return;
    }
  } else if (strcmp(fOurServerMediaSession->streamName(), urlSuffix) == 0 ||
             (urlSuffix[0] == '\0' && strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0)) {
    // Aggregated operation
    subsession = NULL;
  } else if (urlPreSuffix[0] != '\0' && urlSuffix[0] != '\0') {
    // Aggregated operation, if <urlPreSuffix>/<urlSuffix> is the session (stream) name:
    unsigned const urlPreSuffixLen = strlen(urlPreSuffix);
    if (strncmp(fOurServerMediaSession->streamName(), urlPreSuffix, urlPreSuffixLen) == 0 &&
        fOurServerMediaSession->streamName()[urlPreSuffixLen] == '/' &&
        strcmp(&(fOurServerMediaSession->streamName())[urlPreSuffixLen+1], urlSuffix) == 0) {
      subsession = NULL;
    } else {
      handleCmd_notFound(cseq);
      return;
    }
  } else { // the request doesn't match a known stream and/or track at all!
    handleCmd_notFound(cseq);
    return;
  }

  if (strcmp(cmdName, "TEARDOWN") == 0) {
    handleCmd_TEARDOWN(subsession, cseq);
  } else if (strcmp(cmdName, "PLAY") == 0) {
    handleCmd_PLAY(subsession, cseq, fullRequestStr);
  } else if (strcmp(cmdName, "PAUSE") == 0) {
    handleCmd_PAUSE(subsession, cseq);
  } else if (strcmp(cmdName, "GET_PARAMETER") == 0) {
    handleCmd_GET_PARAMETER(subsession, cseq, fullRequestStr);
  } else if (strcmp(cmdName, "SET_PARAMETER") == 0) {
    handleCmd_SET_PARAMETER(subsession, cseq, fullRequestStr);
  }
}

void RTSPServer::RTSPClientSession::handleCmd_TEARDOWN	(	ServerMediaSubsession *	subsession,
		char const *	cseq
	)			[protected, virtual]

Definition at line 1066 of file RTSPServer.cpp.

References dateHeader(), and False.

                                                                            {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 200 OK\r\nCSeq: %s\r\n%s\r\n",
           cseq, dateHeader());
  fSessionIsActive = False; // triggers deletion of ourself after responding
}

void RTSPServer::RTSPClientSession::handleCmd_PLAY	(	ServerMediaSubsession *	subsession,
		char const *	cseq,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 1098 of file RTSPServer.cpp.

References dateHeader(), duration, NULL, parseRangeHeader(), parseScaleHeader(), RTSPServer::rtspURL(), scale, strDup(), and subsession.

                                               {
  char* rtspURL = fOurServer.rtspURL(fOurServerMediaSession, fClientInputSocket);
  unsigned rtspURLSize = strlen(rtspURL);

  // Parse the client's "Scale:" header, if any:
  float scale;
  Boolean sawScaleHeader = parseScaleHeader(fullRequestStr, scale);

  // Try to set the stream's scale factor to this value:
  if (subsession == NULL /*aggregate op*/) {
    fOurServerMediaSession->testScaleFactor(scale);
  } else {
    subsession->testScaleFactor(scale);
  }

  char buf[100];
  char* scaleHeader;
  if (!sawScaleHeader) {
    buf[0] = '\0'; // Because we didn't see a Scale: header, don't send one back
  } else {
    sprintf(buf, "Scale: %f\r\n", scale);
  }
  scaleHeader = strDup(buf);

  // Parse the client's "Range:" header, if any:
  double rangeStart = 0.0, rangeEnd = 0.0;
  Boolean sawRangeHeader = parseRangeHeader(fullRequestStr, rangeStart, rangeEnd);

  // Use this information, plus the stream's duration (if known), to create
  // our own "Range:" header, for the response:
  float duration = subsession == NULL /*aggregate op*/
    ? fOurServerMediaSession->duration() : subsession->duration();
  if (duration < 0.0) {
    // We're an aggregate PLAY, but the subsessions have different durations.
    // Use the largest of these durations in our header
    duration = -duration;
  }

  // Make sure that "rangeStart" and "rangeEnd" (from the client's "Range:" header) have sane values
  // before we send back our own "Range:" header in our response:
  if (rangeStart < 0.0) rangeStart = 0.0;
  else if (rangeStart > duration) rangeStart = duration;
  if (rangeEnd < 0.0) rangeEnd = 0.0;
  else if (rangeEnd > duration) rangeEnd = duration;
  if ((scale > 0.0 && rangeStart > rangeEnd && rangeEnd > 0.0) ||
      (scale < 0.0 && rangeStart < rangeEnd)) {
    // "rangeStart" and "rangeEnd" were the wrong way around; swap them:
    double tmp = rangeStart;
    rangeStart = rangeEnd;
    rangeEnd = tmp;
  }

  // Create a "RTP-Info:" line.  It will get filled in from each subsession's state:
  char const* rtpInfoFmt =
    "%s" // "RTP-Info:", plus any preceding rtpInfo items
    "%s" // comma separator, if needed
    "url=%s/%s"
    ";seq=%d"
    ";rtptime=%u"
    ;
  unsigned rtpInfoFmtSize = strlen(rtpInfoFmt);
  char* rtpInfo = strDup("RTP-Info: ");
  unsigned i, numRTPInfoItems = 0;

  // Do any required seeking/scaling on each subsession, before starting streaming.
  // (However, we don't do this if the "PLAY" request was for just a single subsession of a multiple-subsession stream;
  //  for such streams, seeking/scaling can be done only with an aggregate "PLAY".)
  for (i = 0; i < fNumStreamStates; ++i) {
    if (subsession == NULL /* means: aggregated operation */ || fNumStreamStates == 1) {
      if (sawScaleHeader) {
        fStreamStates[i].subsession->setStreamScale(fOurSessionId,
                                                    fStreamStates[i].streamToken,
                                                    scale);
      }
      if (sawRangeHeader) {
        double streamDuration = 0.0; // by default; means: stream until the end of the media
        if (rangeEnd > 0.0 && (rangeEnd+0.001) < duration) { // the 0.001 is because we limited the values to 3 decimal places
          // We want the stream to end early.  Set the duration we want:
          streamDuration = rangeEnd - rangeStart;
          if (streamDuration < 0.0) streamDuration = -streamDuration; // should happen only if scale < 0.0
        }
        u_int64_t numBytes;
        fStreamStates[i].subsession->seekStream(fOurSessionId,
                                                fStreamStates[i].streamToken,
                                                rangeStart, streamDuration, numBytes);
      }
    }
  }

  // Create the "Range:" header that we'll send back in our response.
  // (Note that we do this after seeking, in case the seeking operation changed the range start time.)
  char* rangeHeader;
  if (!sawRangeHeader) {
    buf[0] = '\0'; // Because we didn't see a Range: header, don't send one back
  } else if (rangeEnd == 0.0 && scale >= 0.0) {
    sprintf(buf, "Range: npt=%.3f-\r\n", rangeStart);
  } else {
    sprintf(buf, "Range: npt=%.3f-%.3f\r\n", rangeStart, rangeEnd);
  }
  rangeHeader = strDup(buf);

  // Now, start streaming:
  for (i = 0; i < fNumStreamStates; ++i) {
    if (subsession == NULL /* means: aggregated operation */
        || subsession == fStreamStates[i].subsession) {
      unsigned short rtpSeqNum = 0;
      unsigned rtpTimestamp = 0;
      fStreamStates[i].subsession->startStream(fOurSessionId,
                                               fStreamStates[i].streamToken,
                                               (TaskFunc*)noteClientLiveness, this,
                                               rtpSeqNum, rtpTimestamp,
                                               handleAlternativeRequestByte, this);
      const char *urlSuffix = fStreamStates[i].subsession->trackId();
      char* prevRTPInfo = rtpInfo;
      unsigned rtpInfoSize = rtpInfoFmtSize
        + strlen(prevRTPInfo)
        + 1
        + rtspURLSize + strlen(urlSuffix)
        + 5 /*max unsigned short len*/
        + 10 /*max unsigned (32-bit) len*/
        + 2 /*allows for trailing \r\n at final end of string*/;
      rtpInfo = new char[rtpInfoSize];
      sprintf(rtpInfo, rtpInfoFmt,
              prevRTPInfo,
              numRTPInfoItems++ == 0 ? "" : ",",
              rtspURL, urlSuffix,
              rtpSeqNum,
              rtpTimestamp
              );
      delete[] prevRTPInfo;
    }
  }
  if (numRTPInfoItems == 0) {
    rtpInfo[0] = '\0';
  } else {
    unsigned rtpInfoLen = strlen(rtpInfo);
    rtpInfo[rtpInfoLen] = '\r';
    rtpInfo[rtpInfoLen+1] = '\n';
    rtpInfo[rtpInfoLen+2] = '\0';
  }

  // Fill in the response:
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 200 OK\r\n"
           "CSeq: %s\r\n"
           "%s"
           "%s"
           "%s"
           "Session: %08X\r\n"
           "%s\r\n",
           cseq,
           dateHeader(),
           scaleHeader,
           rangeHeader,
           fOurSessionId,
           rtpInfo);
  delete[] rtpInfo; delete[] rangeHeader;
  delete[] scaleHeader; delete[] rtspURL;
}

void RTSPServer::RTSPClientSession::handleCmd_PAUSE	(	ServerMediaSubsession *	subsession,
		char const *	cseq
	)			[protected, virtual]

Definition at line 1260 of file RTSPServer.cpp.

References dateHeader(), NULL, and subsession.

                                                                       {
  for (unsigned i = 0; i < fNumStreamStates; ++i) {
    if (subsession == NULL /* means: aggregated operation */
        || subsession == fStreamStates[i].subsession) {
      fStreamStates[i].subsession->pauseStream(fOurSessionId,
                                               fStreamStates[i].streamToken);
    }
  }
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sSession: %08X\r\n\r\n",
           cseq, dateHeader(), fOurSessionId);
}

void RTSPServer::RTSPClientSession::handleCmd_GET_PARAMETER	(	ServerMediaSubsession *	subsession,
		char const *	cseq,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 1274 of file RTSPServer.cpp.

References dateHeader().

                                                          {
  // By default, we implement "GET_PARAMETER" just as a 'keep alive', and send back an empty response.
  // (If you want to handle "GET_PARAMETER" properly, you can do so by defining a subclass of "RTSPServer"
  // and "RTSPServer::RTSPClientSession", and then reimplement this virtual function in your subclass.)
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sSession: %08X\r\n\r\n",
           cseq, dateHeader(), fOurSessionId);
}

void RTSPServer::RTSPClientSession::handleCmd_SET_PARAMETER	(	ServerMediaSubsession *	subsession,
		char const *	cseq,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 1285 of file RTSPServer.cpp.

References dateHeader().

                                                          {
  // By default, we implement "SET_PARAMETER" just as a 'keep alive', and send back an empty response.
  // (If you want to handle "SET_PARAMETER" properly, you can do so by defining a subclass of "RTSPServer"
  // and "RTSPServer::RTSPClientSession", and then reimplement this virtual function in your subclass.)
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sSession: %08X\r\n\r\n",
           cseq, dateHeader(), fOurSessionId);
}

Boolean RTSPServer::RTSPClientSession::parseHTTPRequestString	(	char *	resultCmdName,
		unsigned	resultCmdNameMaxSize,
		char *	urlSuffix,
		unsigned	urlSuffixMaxSize,
		char *	sessionCookie,
		unsigned	sessionCookieMaxSize,
		char *	acceptStr,
		unsigned	acceptStrMaxSize
	)			[protected, virtual]

Definition at line 1317 of file RTSPServer.cpp.

References False, fRequestBuffer, fRequestBytesAlreadySeen, lookForHeader(), and True.

Referenced by handleRequestBytes().

                                                                                                          {
  // Check for the limited HTTP requests that we expect for specifying RTSP-over-HTTP tunneling.
  // This parser is currently rather dumb; it should be made smarter #####
  char const* reqStr = (char const*)fRequestBuffer;
  unsigned const reqStrSize = fRequestBytesAlreadySeen;

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

  // Look for the string "HTTP/", before the first \r or \n:
  parseSucceeded = False;
  for (; i < reqStrSize-5 && reqStr[i] != '\r' && reqStr[i] != '\n'; ++i) {
    if (reqStr[i] == 'H' && reqStr[i+1] == 'T' && reqStr[i+2]== 'T' && reqStr[i+3]== 'P' && reqStr[i+4]== '/') {
      i += 5; // to advance past the "HTTP/"
      parseSucceeded = True;
      break;
    }
  }
  if (!parseSucceeded) return False;

  // Get the 'URL suffix' that occurred before this:
  unsigned k = i-6;
  while (k > 0 && reqStr[k] == ' ') --k; // back up over white space
  unsigned j = k;
  while (j > 0 && reqStr[j] != ' ' && reqStr[j] != '/') --j;
  // The URL suffix is in position (j,k]:
  if (k - j + 1 > urlSuffixMaxSize) return False; // there's no room> 
  unsigned n = 0;
  while (++j <= k) urlSuffix[n++] = reqStr[j];
  urlSuffix[n] = '\0';

  // Look for various headers that we're interested in:
  lookForHeader("x-sessioncookie", &reqStr[i], reqStrSize-i, sessionCookie, sessionCookieMaxSize);
  lookForHeader("Accept", &reqStr[i], reqStrSize-i, acceptStr, acceptStrMaxSize);

  return True;
}

void RTSPServer::RTSPClientSession::handleHTTPCmd_notSupported

(

)

[protected, virtual]

Definition at line 1370 of file RTSPServer.cpp.

References dateHeader(), and fResponseBuffer.

Referenced by handleHTTPCmd_StreamingGET(), and handleRequestBytes().

                                                             {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "HTTP/1.0 405 Method Not Allowed\r\n%s\r\n\r\n",
           dateHeader());
}

void RTSPServer::RTSPClientSession::handleHTTPCmd_notFound

(

)

[protected, virtual]

Definition at line 1376 of file RTSPServer.cpp.

References dateHeader(), and fResponseBuffer.

                                                         {
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "HTTP/1.0 404 Not Found\r\n%s\r\n\r\n",
           dateHeader());
}

void RTSPServer::RTSPClientSession::handleHTTPCmd_TunnelingGET

(

char const *

sessionCookie

)

[protected, virtual]

Definition at line 1382 of file RTSPServer.cpp.

References HashTable::Add(), HashTable::create(), fClientOutputSocket, RTSPServer::fClientSessionsForHTTPTunneling, fOurServer, fResponseBuffer, NULL, and STRING_HASH_KEYS.

Referenced by handleRequestBytes().

                                                                                      {
  // Record ourself as having this 'session cookie', so that a subsequent HTTP "POST" command (with the same 'session cookie')
  // can find us:
  if (fOurServer.fClientSessionsForHTTPTunneling == NULL) {
    fOurServer.fClientSessionsForHTTPTunneling = HashTable::create(STRING_HASH_KEYS);
  }
  fOurServer.fClientSessionsForHTTPTunneling->Add(sessionCookie, (void*)this);
#ifdef DEBUG
  fprintf(stderr, "Handled HTTP \"GET\" request (client output socket: %d)\n", fClientOutputSocket);
#endif

  // Construct our response:
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "HTTP/1.0 200 OK\r\n"
           "Date: Thu, 19 Aug 1982 18:30:00 GMT\r\n"
           "Cache-Control: no-cache\r\n"
           "Pragma: no-cache\r\n"
           "Content-Type: application/x-rtsp-tunnelled\r\n"
           "\r\n");
}

Boolean RTSPServer::RTSPClientSession::handleHTTPCmd_TunnelingPOST	(	char const *	sessionCookie,
		unsigned char const *	extraData,
		unsigned	extraDataSize
	)			[protected, virtual]

Definition at line 1404 of file RTSPServer.cpp.

References changeClientInputSocket(), False, NULL, and True.

Referenced by handleRequestBytes().

                                                                                                               {
  // Use the "sessionCookie" string to look up the separate "RTSPClientSession" object that should have been used to handle
  // an earlier HTTP "GET" request:
  RTSPServer::RTSPClientSession* prevClientSession
    = (RTSPServer::RTSPClientSession*)(fOurServer.fClientSessionsForHTTPTunneling->Lookup(sessionCookie));
  if (prevClientSession == NULL) {
    // There was no previous HTTP "GET" request; treat this "POST" request as bad:
    handleHTTPCmd_notSupported();
    fSessionIsActive = False; // triggers deletion of ourself
    return False;
  }
#ifdef DEBUG
  fprintf(stderr, "Handled HTTP \"POST\" request (client input socket: %d)\n", fClientInputSocket);
#endif

  // Change the previous "RTSPClientSession" object's input socket to ours.  It will be used for subsequent requests:
  prevClientSession->changeClientInputSocket(fClientInputSocket, extraData, extraDataSize);
  fClientInputSocket = fClientOutputSocket = -1; // so the socket doesn't get closed when we get deleted
  return True;
}

void RTSPServer::RTSPClientSession::handleHTTPCmd_StreamingGET	(	char const *	urlSuffix,
		char const *	fullRequestStr
	)			[protected, virtual]

Reimplemented in RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming.

Definition at line 1425 of file RTSPServer.cpp.

References handleHTTPCmd_notSupported().

Referenced by handleRequestBytes().

                                                                                                                      {
  // By default, we don't support requests to access streams via HTTP:
  handleHTTPCmd_notSupported();
}

UsageEnvironment& RTSPServer::RTSPClientSession::envir

(

)

[inline, protected]

Definition at line 166 of file RTSPServer.hh.

References Medium::envir(), and fOurServer.

Referenced by closeSockets(), incomingRequestHandler1(), noteLiveness(), and RTSPClientSession().

{ return fOurServer.envir(); }

void RTSPServer::RTSPClientSession::closeSockets

(

)

[protected]

Definition at line 325 of file RTSPServer.cpp.

References closeSocket, envir(), fClientInputSocket, fClientOutputSocket, fLivenessCheckTask, UsageEnvironment::taskScheduler(), TaskScheduler::turnOffBackgroundReadHandling(), and TaskScheduler::unscheduleDelayedTask().

Referenced by handleRequestBytes(), and ~RTSPClientSession().

                                               {
  // Turn off any liveness checking:
  envir().taskScheduler().unscheduleDelayedTask(fLivenessCheckTask);

  // Turn off background read handling:
  envir().taskScheduler().turnOffBackgroundReadHandling(fClientInputSocket);

  if (fClientOutputSocket != fClientInputSocket) ::closeSocket(fClientOutputSocket);
  ::closeSocket(fClientInputSocket);

  fClientInputSocket = fClientOutputSocket = -1;
}

void RTSPServer::RTSPClientSession::reclaimStreamStates

(

)

[protected]

Definition at line 338 of file RTSPServer.cpp.

References fNumStreamStates, fOurSessionId, fStreamStates, NULL, RTSPServer::RTSPClientSession::streamState::streamToken, and subsession.

Referenced by ~RTSPClientSession().

                                                      {
  for (unsigned i = 0; i < fNumStreamStates; ++i) {
    if (fStreamStates[i].subsession != NULL) {
      fStreamStates[i].subsession->deleteStream(fOurSessionId,
                                                fStreamStates[i].streamToken);
    }
  }
  delete[] fStreamStates; fStreamStates = NULL;
  fNumStreamStates = 0;
}

void RTSPServer::RTSPClientSession::resetRequestBuffer

(

)

[protected]

Definition at line 349 of file RTSPServer.cpp.

References fBase64RemainderCount, fLastCRLF, fRequestBuffer, fRequestBufferBytesLeft, and fRequestBytesAlreadySeen.

Referenced by handleRequestBytes(), and RTSPClientSession().

                                                     {
  fRequestBytesAlreadySeen = 0;
  fRequestBufferBytesLeft = sizeof fRequestBuffer;
  fLastCRLF = &fRequestBuffer[-3]; // hack: Ensures that we don't think we have end-of-msg if the data starts with <CR><LF>
  fBase64RemainderCount = 0;
}

Boolean RTSPServer::RTSPClientSession::authenticationOK	(	char const *	cmdName,
		char const *	cseq,
		char const *	urlSuffix,
		char const *	fullRequestStr
	)			[protected]

Definition at line 1478 of file RTSPServer.cpp.

References dateHeader(), False, NULL, parseAuthorizationHeader(), password, True, and username.

                                                                      {

  if (!fOurServer.specialClientAccessCheck(fClientInputSocket, fClientAddr, urlSuffix)) {
    snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
             "RTSP/1.0 401 Unauthorized\r\n"
             "CSeq: %s\r\n"
             "%s"
             "\r\n",
             cseq, dateHeader());
    return False;
  }

  // If we weren't set up with an authentication database, we're OK:
  if (fOurServer.fAuthDB == NULL) return True;

  char const* username = NULL; char const* realm = NULL; char const* nonce = NULL;
  char const* uri = NULL; char const* response = NULL;
  Boolean success = False;

  do {
    // To authenticate, we first need to have a nonce set up
    // from a previous attempt:
    if (fCurrentAuthenticator.nonce() == NULL) break;

    // Next, the request needs to contain an "Authorization:" header,
    // containing a username, (our) realm, (our) nonce, uri,
    // and response string:
    if (!parseAuthorizationHeader(fullRequestStr,
                                  username, realm, nonce, uri, response)
        || username == NULL
        || realm == NULL || strcmp(realm, fCurrentAuthenticator.realm()) != 0
        || nonce == NULL || strcmp(nonce, fCurrentAuthenticator.nonce()) != 0
        || uri == NULL || response == NULL) {
      break;
    }

    // Next, the username has to be known to us:
    char const* password = fOurServer.fAuthDB->lookupPassword(username);
#ifdef DEBUG
    fprintf(stderr, "lookupPassword(%s) returned password %s\n", username, password);
#endif
    if (password == NULL) break;
    fCurrentAuthenticator.
      setUsernameAndPassword(username, password,
                             fOurServer.fAuthDB->passwordsAreMD5());

    // Finally, compute a digest response from the information that we have,
    // and compare it to the one that we were given:
    char const* ourResponse
      = fCurrentAuthenticator.computeDigestResponse(cmdName, uri);
    success = (strcmp(ourResponse, response) == 0);
    fCurrentAuthenticator.reclaimDigestResponse(ourResponse);
  } while (0);

  delete[] (char*)username; delete[] (char*)realm; delete[] (char*)nonce;
  delete[] (char*)uri; delete[] (char*)response;
  if (success) return True;

  // If we get here, there was some kind of authentication failure.
  // Send back a "401 Unauthorized" response, with a new random nonce:
  fCurrentAuthenticator.setRealmAndRandomNonce(fOurServer.fAuthDB->realm());
  snprintf((char*)fResponseBuffer, sizeof fResponseBuffer,
           "RTSP/1.0 401 Unauthorized\r\n"
           "CSeq: %s\r\n"
           "%s"
           "WWW-Authenticate: Digest realm=\"%s\", nonce=\"%s\"\r\n\r\n",
           cseq,
           dateHeader(),
           fCurrentAuthenticator.realm(), fCurrentAuthenticator.nonce());
  return False;
}

Boolean RTSPServer::RTSPClientSession::isMulticast

(

)

const [inline, protected]

Definition at line 173 of file RTSPServer.hh.

References fIsMulticast.

{ return fIsMulticast; }

void RTSPServer::RTSPClientSession::incomingRequestHandler	(	void *	,
		int
	)			[static, protected]

Definition at line 356 of file RTSPServer.cpp.

References session.

Referenced by RTSPClientSession().

                                                                                     {
  RTSPClientSession* session = (RTSPClientSession*)instance;
  session->incomingRequestHandler1();
}

void RTSPServer::RTSPClientSession::incomingRequestHandler1

(

)

[protected]

Definition at line 361 of file RTSPServer.cpp.

References envir(), fClientInputSocket, fRequestBuffer, fRequestBufferBytesLeft, fRequestBytesAlreadySeen, handleRequestBytes(), and readSocket().

                                                          {
  struct sockaddr_in dummy; // 'from' address, meaningless in this case

  int bytesRead = readSocket(envir(), fClientInputSocket, &fRequestBuffer[fRequestBytesAlreadySeen], fRequestBufferBytesLeft, dummy);
  handleRequestBytes(bytesRead);
}

void RTSPServer::RTSPClientSession::handleAlternativeRequestByte	(	void *	,
		u_int8_t	requestByte
	)			[static, protected]

Definition at line 368 of file RTSPServer.cpp.

References session.

                                                                                                   {
  RTSPClientSession* session = (RTSPClientSession*)instance;
  session->handleAlternativeRequestByte1(requestByte);
}

void RTSPServer::RTSPClientSession::handleAlternativeRequestByte1

(

u_int8_t

requestByte

)

[protected]

Definition at line 373 of file RTSPServer.cpp.

References fRequestBuffer, fRequestBufferBytesLeft, fRequestBytesAlreadySeen, handleRequestBytes(), and RTSP_BUFFER_SIZE.

                                                                                    {
  // Add this character to our buffer; then try to handle the data that we have buffered so far:
  if (fRequestBufferBytesLeft == 0 || fRequestBytesAlreadySeen >= RTSP_BUFFER_SIZE) return;
  fRequestBuffer[fRequestBytesAlreadySeen] = requestByte;
  handleRequestBytes(1);
}

void RTSPServer::RTSPClientSession::handleRequestBytes

(

int

newBytesRead

)

[protected]

Definition at line 380 of file RTSPServer.cpp.

References base64Decode(), closeSockets(), False, fBase64RemainderCount, fClientInputSocket, fClientOutputSocket, fLastCRLF, fRecursionCount, fRequestBuffer, fRequestBufferBytesLeft, fRequestBytesAlreadySeen, fResponseBuffer, fSessionIsActive, fStreamAfterSETUP, handleCmd_bad(), handleCmd_DESCRIBE(), handleCmd_notSupported(), handleCmd_OPTIONS(), handleCmd_SETUP(), handleCmd_withinSession(), handleHTTPCmd_notSupported(), handleHTTPCmd_StreamingGET(), handleHTTPCmd_TunnelingGET(), handleHTTPCmd_TunnelingPOST(), noteLiveness(), numBytesRemaining, parseHTTPRequestString(), parseRTSPRequestString(), resetRequestBuffer(), RTSP_PARAM_STRING_MAX, and True.

Referenced by handleAlternativeRequestByte1(), and incomingRequestHandler1().

                                                                     {
  int numBytesRemaining = 0;
  ++fRecursionCount;

  do {
    noteLiveness();
    
    if (newBytesRead <= 0 || (unsigned)newBytesRead >= fRequestBufferBytesLeft) {
      // Either the client socket has died, or the request was too big for us.
      // Terminate this connection:
#ifdef DEBUG
      fprintf(stderr, "RTSPClientSession[%p]::handleRequestBytes() read %d new bytes (of %d); terminating connection!\n", this, newBytesRead, fRequestBufferBytesLeft);
#endif
      fSessionIsActive = False;
      break;
    }
    
    Boolean endOfMsg = False;
    unsigned char* ptr = &fRequestBuffer[fRequestBytesAlreadySeen];
#ifdef DEBUG
    ptr[newBytesRead] = '\0';
    fprintf(stderr, "RTSPClientSession[%p]::handleRequestBytes() %s %d new bytes:%s\n",
            this, numBytesRemaining > 0 ? "processing" : "read", newBytesRead, ptr);
#endif
    
    if (fClientOutputSocket != fClientInputSocket) {
      // We're doing RTSP-over-HTTP tunneling, and input commands are assumed to have been Base64-encoded.
      // We therefore Base64-decode as much of this new data as we can (i.e., up to a multiple of 4 bytes):
      unsigned numBytesToDecode = fBase64RemainderCount + newBytesRead;
      unsigned newBase64RemainderCount = numBytesToDecode%4;
      numBytesToDecode -= newBase64RemainderCount;
      if (numBytesToDecode > 0) {
        ptr[newBytesRead] = '\0';
        unsigned decodedSize;
        unsigned char* decodedBytes = base64Decode((char const*)(ptr-fBase64RemainderCount), decodedSize);
#ifdef DEBUG
        fprintf(stderr, "Base64-decoded %d input bytes into %d new bytes:", numBytesToDecode, decodedSize);
        for (unsigned k = 0; k < decodedSize; ++k) fprintf(stderr, "%c", decodedBytes[k]);
        fprintf(stderr, "\n");
#endif
        
        // Copy the new decoded bytes in place of the old ones (we can do this because there are fewer decoded bytes than original):
        unsigned char* to = ptr-fBase64RemainderCount;
        for (unsigned i = 0; i < decodedSize; ++i) *to++ = decodedBytes[i];
        
        // Then copy any remaining (undecoded) bytes to the end:
        for (unsigned j = 0; j < newBase64RemainderCount; ++j) *to++ = (ptr-fBase64RemainderCount+numBytesToDecode)[j];
        
        newBytesRead = decodedSize + newBase64RemainderCount; // adjust to allow for the size of the new decoded data (+ remainder)
        delete[] decodedBytes;
      }
      fBase64RemainderCount = newBase64RemainderCount;
      if (fBase64RemainderCount > 0) break; // because we know that we have more input bytes still to receive
    }
    
    // Look for the end of the message: <CR><LF><CR><LF>
    unsigned char *tmpPtr = fLastCRLF + 2;
    if (tmpPtr < fRequestBuffer) tmpPtr = fRequestBuffer;
    while (tmpPtr < &ptr[newBytesRead-1]) {
      if (*tmpPtr == '\r' && *(tmpPtr+1) == '\n') {
        if (tmpPtr - fLastCRLF == 2) { // This is it:
          endOfMsg = True;
          break;
        }
        fLastCRLF = tmpPtr;
      }
      ++tmpPtr;
    }
    
    fRequestBufferBytesLeft -= newBytesRead;
    fRequestBytesAlreadySeen += newBytesRead;
    
    if (!endOfMsg) break; // subsequent reads will be needed to complete the request
    
    // Parse the request string into command name and 'CSeq', then handle the command:
    fRequestBuffer[fRequestBytesAlreadySeen] = '\0';
    char cmdName[RTSP_PARAM_STRING_MAX];
    char urlPreSuffix[RTSP_PARAM_STRING_MAX];
    char urlSuffix[RTSP_PARAM_STRING_MAX];
    char cseq[RTSP_PARAM_STRING_MAX];
    unsigned contentLength;
    *fLastCRLF = '\0'; // temporarily, for parsing
    Boolean parseSucceeded = parseRTSPRequestString((char*)fRequestBuffer, fRequestBytesAlreadySeen,
                                                    cmdName, sizeof cmdName,
                                                    urlPreSuffix, sizeof urlPreSuffix,
                                                    urlSuffix, sizeof urlSuffix,
                                                    cseq, sizeof cseq,
                                                    contentLength);
    *fLastCRLF = '\r';
    if (parseSucceeded) {
#ifdef DEBUG
      fprintf(stderr, "parseRTSPRequestString() succeeded, returning cmdName \"%s\", urlPreSuffix \"%s\", urlSuffix \"%s\", CSeq \"%s\", Content-Length %u, with %d bytes following the message.\n", cmdName, urlPreSuffix, urlSuffix, cseq, contentLength, ptr + newBytesRead - (tmpPtr + 2));
#endif
      // If there was a "Content-Length:" header, then make sure we've received all of the data that it specified:
      if (ptr + newBytesRead < tmpPtr + 2 + contentLength) break; // we still need more data; subsequent reads will give it to us 
      
      if (strcmp(cmdName, "OPTIONS") == 0) {
        handleCmd_OPTIONS(cseq);
      } else if (strcmp(cmdName, "DESCRIBE") == 0) {
        handleCmd_DESCRIBE(cseq, urlPreSuffix, urlSuffix, (char const*)fRequestBuffer);
      } else if (strcmp(cmdName, "SETUP") == 0) {
        handleCmd_SETUP(cseq, urlPreSuffix, urlSuffix, (char const*)fRequestBuffer);
      } else if (strcmp(cmdName, "TEARDOWN") == 0
                 || strcmp(cmdName, "PLAY") == 0
                 || strcmp(cmdName, "PAUSE") == 0
                 || strcmp(cmdName, "GET_PARAMETER") == 0
                 || strcmp(cmdName, "SET_PARAMETER") == 0) {
        handleCmd_withinSession(cmdName, urlPreSuffix, urlSuffix, cseq, (char const*)fRequestBuffer);
      } else {
        handleCmd_notSupported(cseq);
      }
    } else {
#ifdef DEBUG
      fprintf(stderr, "parseRTSPRequestString() failed\n");
#endif
      // The request was not (valid) RTSP, but check for a special case: HTTP commands (for setting up RTSP-over-HTTP tunneling):
      char sessionCookie[RTSP_PARAM_STRING_MAX];
      char acceptStr[RTSP_PARAM_STRING_MAX];
      *fLastCRLF = '\0'; // temporarily, for parsing
      parseSucceeded = parseHTTPRequestString(cmdName, sizeof cmdName,
                                              urlSuffix, sizeof urlPreSuffix,
                                              sessionCookie, sizeof sessionCookie,
                                              acceptStr, sizeof acceptStr);
      *fLastCRLF = '\r';
      if (parseSucceeded) {
#ifdef DEBUG
        fprintf(stderr, "parseHTTPRequestString() succeeded, returning cmdName \"%s\", urlSuffix \"%s\", sessionCookie \"%s\", acceptStr \"%s\"\n", cmdName, urlSuffix, sessionCookie, acceptStr);
#endif
        // Check that the HTTP command is valid for RTSP-over-HTTP tunneling: There must be a 'session cookie'.
        Boolean isValidHTTPCmd = True;
        if (sessionCookie[0] == '\0') {
          // There was no "x-sessionCookie:" header.  If there was an "Accept: application/x-rtsp-tunnelled" header,
          // then this is a bad tunneling request.  Otherwise, assume that it's an attempt to access the stream via HTTP.
          if (strcmp(acceptStr, "application/x-rtsp-tunnelled") == 0) {
            isValidHTTPCmd = False;
          } else {
            handleHTTPCmd_StreamingGET(urlSuffix, (char const*)fRequestBuffer);
          }
        } else if (strcmp(cmdName, "GET") == 0) {
          handleHTTPCmd_TunnelingGET(sessionCookie);
        } else if (strcmp(cmdName, "POST") == 0) {
          // We might have received additional data following the HTTP "POST" command - i.e., the first Base64-encoded RTSP command.
          // Check for this, and handle it if it exists:
          unsigned char const* extraData = fLastCRLF+4;
          unsigned extraDataSize = &fRequestBuffer[fRequestBytesAlreadySeen] - extraData;
          if (handleHTTPCmd_TunnelingPOST(sessionCookie, extraData, extraDataSize)) {
            // We don't respond to the "POST" command, and we go away:
            fSessionIsActive = False;
            break;
          }
        } else {
          isValidHTTPCmd = False;
        }
        if (!isValidHTTPCmd) {
          handleHTTPCmd_notSupported();
        }
      } else {
#ifdef DEBUG
        fprintf(stderr, "parseHTTPRequestString() failed!\n");
#endif
        handleCmd_bad(cseq);
      }
    }
    
#ifdef DEBUG
    fprintf(stderr, "sending response: %s", fResponseBuffer);
#endif
    send(fClientOutputSocket, (char const*)fResponseBuffer, strlen((char*)fResponseBuffer), 0);
    
    if (strcmp(cmdName, "SETUP") == 0 && fStreamAfterSETUP) {
      // The client has asked for streaming to commence now, rather than after a
      // subsequent "PLAY" command.  So, simulate the effect of a "PLAY" command:
      handleCmd_withinSession("PLAY", urlPreSuffix, urlSuffix, cseq,
                              (char const*)fRequestBuffer);
    }
    
    // Check whether there are extra bytes remaining in the buffer, after the end of the request (a rare case).
    // If so, move them to the front of our buffer, and keep processing it, because it might be a following, pipelined request.
    unsigned requestSize = (fLastCRLF+4-fRequestBuffer) + contentLength;
    numBytesRemaining = fRequestBytesAlreadySeen - requestSize;
    resetRequestBuffer(); // to prepare for any subsequent request

    if (numBytesRemaining > 0) {
      memmove(fRequestBuffer, &fRequestBuffer[requestSize], numBytesRemaining);
      newBytesRead = numBytesRemaining;
    }
  } while (numBytesRemaining > 0);

  --fRecursionCount;
  if (!fSessionIsActive) {
    if (fRecursionCount > 0) closeSockets(); else delete this;
    // Note: The "fRecursionCount" test is for a pathological situation where we got called recursively while handling a command.
    // In such a case we don't want to actually delete ourself until we leave the outermost call.
  }
}

void RTSPServer::RTSPClientSession::noteLiveness

(

)

[protected]

Definition at line 1551 of file RTSPServer.cpp.

References envir(), fClientAddr, fLivenessCheckTask, fOurServer, RTSPServer::fReclamationTestSeconds, livenessTimeoutTask(), TaskScheduler::rescheduleDelayedTask(), and UsageEnvironment::taskScheduler().

Referenced by handleRequestBytes(), noteClientLiveness(), and RTSPClientSession().

                                               {
#ifdef DEBUG
  fprintf(stderr, "Liveness indication from client at %s\n", AddressString(fClientAddr).val());
#endif
  if (fOurServer.fReclamationTestSeconds > 0) {
    envir().taskScheduler()
      .rescheduleDelayedTask(fLivenessCheckTask,
                             fOurServer.fReclamationTestSeconds*1000000,
                             (TaskFunc*)livenessTimeoutTask, this);
  }
}

void RTSPServer::RTSPClientSession::noteClientLiveness

(

RTSPClientSession *

clientSession

)

[static, protected]

Definition at line 1564 of file RTSPServer.cpp.

References noteLiveness().

                                                     {
  clientSession->noteLiveness();
}

void RTSPServer::RTSPClientSession::livenessTimeoutTask

(

RTSPClientSession *

clientSession

)

[static, protected]

Definition at line 1569 of file RTSPServer.cpp.

References fClientAddr.

Referenced by noteLiveness().

                                                      {
  // If this gets called, the client session is assumed to have timed out,
  // so delete it:
#ifdef DEBUG
  fprintf(stderr, "RTSP client session from %s has timed out (due to inactivity)\n", AddressString(clientSession->fClientAddr).val());
#endif
  delete clientSession;
}

void RTSPServer::RTSPClientSession::changeClientInputSocket	(	int	newSocketNum,
		unsigned char const *	extraData,
		unsigned	extraDataSize
	)			[protected]

Definition at line 1584 of file RTSPServer.cpp.

References Medium::envir(), UsageEnvironment::taskScheduler(), TaskScheduler::turnOffBackgroundReadHandling(), and TaskScheduler::turnOnBackgroundReadHandling().

Referenced by handleHTTPCmd_TunnelingPOST().

                                                                                                  {
  envir().taskScheduler().turnOffBackgroundReadHandling(fClientInputSocket);
  fClientInputSocket = newSocketNum;
  envir().taskScheduler().turnOnBackgroundReadHandling(fClientInputSocket,
     (TaskScheduler::BackgroundHandlerProc*)&incomingRequestHandler, this);

  // Also write any extra data to our buffer, and handle it:
  if (extraDataSize > 0 && extraDataSize <= fRequestBufferBytesLeft/*sanity check; should always be true*/) {
    unsigned char* ptr = &fRequestBuffer[fRequestBytesAlreadySeen];
    for (unsigned i = 0; i < extraDataSize; ++i) {
      ptr[i] = extraData[i];
    }
    handleRequestBytes(extraDataSize);
  }
}

---

Field Documentation

RTSPServer& RTSPServer::RTSPClientSession::fOurServer [protected]

Definition at line 184 of file RTSPServer.hh.

Referenced by envir(), handleHTTPCmd_TunnelingGET(), noteLiveness(), and ~RTSPClientSession().

unsigned RTSPServer::RTSPClientSession::fOurSessionId [protected]

Definition at line 185 of file RTSPServer.hh.

Referenced by reclaimStreamStates().

ServerMediaSession* RTSPServer::RTSPClientSession::fOurServerMediaSession [protected]

Definition at line 186 of file RTSPServer.hh.

Referenced by ~RTSPClientSession().

int RTSPServer::RTSPClientSession::fClientInputSocket [protected]

Definition at line 187 of file RTSPServer.hh.

Referenced by closeSockets(), handleRequestBytes(), incomingRequestHandler1(), and RTSPClientSession().

int RTSPServer::RTSPClientSession::fClientOutputSocket [protected]

Definition at line 187 of file RTSPServer.hh.

Referenced by closeSockets(), handleHTTPCmd_TunnelingGET(), and handleRequestBytes().

struct sockaddr_in RTSPServer::RTSPClientSession::fClientAddr [read, protected]

Definition at line 188 of file RTSPServer.hh.

Referenced by livenessTimeoutTask(), and noteLiveness().

char* RTSPServer::RTSPClientSession::fSessionCookie [protected]

Definition at line 189 of file RTSPServer.hh.

Referenced by ~RTSPClientSession().

TaskToken RTSPServer::RTSPClientSession::fLivenessCheckTask [protected]

Definition at line 190 of file RTSPServer.hh.

Referenced by closeSockets(), and noteLiveness().

unsigned char RTSPServer::RTSPClientSession::fRequestBuffer[RTSP_BUFFER_SIZE] [protected]

Definition at line 191 of file RTSPServer.hh.

Referenced by handleAlternativeRequestByte1(), handleRequestBytes(), incomingRequestHandler1(), parseHTTPRequestString(), and resetRequestBuffer().

unsigned RTSPServer::RTSPClientSession::fRequestBytesAlreadySeen [protected]

Definition at line 192 of file RTSPServer.hh.

Referenced by handleAlternativeRequestByte1(), handleRequestBytes(), incomingRequestHandler1(), parseHTTPRequestString(), and resetRequestBuffer().

unsigned RTSPServer::RTSPClientSession::fRequestBufferBytesLeft [protected]

Definition at line 192 of file RTSPServer.hh.

Referenced by handleAlternativeRequestByte1(), handleRequestBytes(), incomingRequestHandler1(), and resetRequestBuffer().

unsigned char* RTSPServer::RTSPClientSession::fLastCRLF [protected]

Definition at line 193 of file RTSPServer.hh.

Referenced by handleRequestBytes(), and resetRequestBuffer().

unsigned RTSPServer::RTSPClientSession::fBase64RemainderCount [protected]

Definition at line 194 of file RTSPServer.hh.

Referenced by handleRequestBytes(), and resetRequestBuffer().

unsigned char RTSPServer::RTSPClientSession::fResponseBuffer[RTSP_BUFFER_SIZE] [protected]

Definition at line 195 of file RTSPServer.hh.

Referenced by handleCmd_bad(), handleCmd_notFound(), handleCmd_notSupported(), handleCmd_OPTIONS(), handleCmd_unsupportedTransport(), handleHTTPCmd_notFound(), handleHTTPCmd_notSupported(), handleHTTPCmd_TunnelingGET(), and handleRequestBytes().

Boolean RTSPServer::RTSPClientSession::fIsMulticast [protected]

Definition at line 196 of file RTSPServer.hh.

Referenced by isMulticast().

Boolean RTSPServer::RTSPClientSession::fSessionIsActive [protected]

Definition at line 196 of file RTSPServer.hh.

Referenced by handleCmd_notFound(), handleCmd_unsupportedTransport(), and handleRequestBytes().

Boolean RTSPServer::RTSPClientSession::fStreamAfterSETUP [protected]

Definition at line 196 of file RTSPServer.hh.

Referenced by handleRequestBytes().

Authenticator RTSPServer::RTSPClientSession::fCurrentAuthenticator [protected]

Definition at line 197 of file RTSPServer.hh.

unsigned char RTSPServer::RTSPClientSession::fTCPStreamIdCount [protected]

Definition at line 198 of file RTSPServer.hh.

unsigned RTSPServer::RTSPClientSession::fNumStreamStates [protected]

Definition at line 199 of file RTSPServer.hh.

Referenced by reclaimStreamStates().

struct RTSPServer::RTSPClientSession::streamState * RTSPServer::RTSPClientSession::fStreamStates [protected]

Referenced by reclaimStreamStates().

unsigned RTSPServer::RTSPClientSession::fRecursionCount [protected]

Definition at line 204 of file RTSPServer.hh.

Referenced by handleRequestBytes().

---

The documentation for this class was generated from the following files:

• liveMedia/include/RTSPServer.hh
• liveMedia/RTSPServer.cpp

---