RTSPServer::RTSPClientSession Class Reference

Collaboration diagram for RTSPServer::RTSPClientSession:

[legend]

Public Member Functions
	RTSPClientSession (RTSPServer &ourServer, unsigned sessionId, int clientSocket, struct sockaddr_in clientAddr)
virtual	~RTSPClientSession ()
Private Member Functions
UsageEnvironment &	envir ()
void	reclaimStreamStates ()
void	resetRequestBuffer ()
void	incomingRequestHandler1 ()
void	handleCmd_bad (char const *cseq)
void	handleCmd_notSupported (char const *cseq)
void	handleCmd_notFound (char const *cseq)
void	handleCmd_unsupportedTransport (char const *cseq)
void	handleCmd_OPTIONS (char const *cseq)
void	handleCmd_DESCRIBE (char const *cseq, char const *urlSuffix, char const *fullRequestStr)
void	handleCmd_SETUP (char const *cseq, char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr)
void	handleCmd_withinSession (char const *cmdName, char const *urlPreSuffix, char const *urlSuffix, char const *cseq, char const *fullRequestStr)
void	handleCmd_TEARDOWN (ServerMediaSubsession *subsession, char const *cseq)
void	handleCmd_PLAY (ServerMediaSubsession *subsession, char const *cseq, char const *fullRequestStr)
void	handleCmd_PAUSE (ServerMediaSubsession *subsession, char const *cseq)
void	handleCmd_GET_PARAMETER (ServerMediaSubsession *subsession, char const *cseq, char const *fullRequestStr)
Boolean	authenticationOK (char const *cmdName, char const *cseq, char const *urlSuffix, char const *fullRequestStr)
void	noteLiveness ()
Boolean	isMulticast () const
Static Private Member Functions
static void	incomingRequestHandler (void *, int)
static void	noteClientLiveness (RTSPClientSession *clientSession)
static void	livenessTimeoutTask (RTSPClientSession *clientSession)
Private Attributes
RTSPServer &	fOurServer
unsigned	fOurSessionId
ServerMediaSession *	fOurServerMediaSession
int	fClientSocket
sockaddr_in	fClientAddr
TaskToken	fLivenessCheckTask
unsigned char	fRequestBuffer [RTSP_BUFFER_SIZE]
unsigned	fRequestBytesAlreadySeen
unsigned	fRequestBufferBytesLeft
unsigned char *	fLastCRLF
unsigned char	fResponseBuffer [RTSP_BUFFER_SIZE]
Boolean	fIsMulticast
Boolean	fSessionIsActive
Boolean	fStreamAfterSETUP
Authenticator	fCurrentAuthenticator
unsigned char	fTCPStreamIdCount
unsigned	fNumStreamStates
RTSPServer::RTSPClientSession::streamState *	fStreamStates
Data Structures
struct	streamState

---

Detailed Description

Definition at line 117 of file RTSPServer.hh.

---

Constructor & Destructor Documentation

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

Definition at line 251 of file RTSPServer.cpp.

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

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

RTSPServer::RTSPClientSession::~RTSPClientSession

(

)

[virtual]

Definition at line 266 of file RTSPServer.cpp.

References closeSocket, ServerMediaSession::decrementReferenceCount(), ServerMediaSession::deleteWhenUnreferenced(), envir(), fClientSocket, fLivenessCheckTask, fOurServer, fOurServerMediaSession, NULL, reclaimStreamStates(), ServerMediaSession::referenceCount(), RTSPServer::removeServerMediaSession(), UsageEnvironment::taskScheduler(), TaskScheduler::turnOffBackgroundReadHandling(), and TaskScheduler::unscheduleDelayedTask().

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

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

  ::closeSocket(fClientSocket);

  reclaimStreamStates();

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

---

Member Function Documentation

UsageEnvironment& RTSPServer::RTSPClientSession::envir

(

)

[inline, private]

Definition at line 123 of file RTSPServer.hh.

References Medium::envir(), and fOurServer.

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

{ return fOurServer.envir(); }

void RTSPServer::RTSPClientSession::reclaimStreamStates

(

)

[private]

Definition at line 286 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

(

)

[private]

Definition at line 297 of file RTSPServer.cpp.

References fLastCRLF, fRequestBuffer, fRequestBufferBytesLeft, and fRequestBytesAlreadySeen.

Referenced by incomingRequestHandler1(), and RTSPClientSession().

                                                     {
  fRequestBytesAlreadySeen = 0;
  fRequestBufferBytesLeft = sizeof fRequestBuffer;
  fLastCRLF = &fRequestBuffer[-3]; // hack
}

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

Definition at line 304 of file RTSPServer.cpp.

References session.

Referenced by RTSPClientSession().

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

void RTSPServer::RTSPClientSession::incomingRequestHandler1

(

)

[private]

Definition at line 309 of file RTSPServer.cpp.

References envir(), False, fClientSocket, fLastCRLF, fRequestBuffer, fRequestBufferBytesLeft, fRequestBytesAlreadySeen, fResponseBuffer, fSessionIsActive, fStreamAfterSETUP, handleCmd_bad(), handleCmd_DESCRIBE(), handleCmd_notSupported(), handleCmd_OPTIONS(), handleCmd_SETUP(), handleCmd_withinSession(), noteLiveness(), parseRTSPRequestString(), readSocket(), resetRequestBuffer(), and RTSP_PARAM_STRING_MAX.

                                                          {
  noteLiveness();

  struct sockaddr_in dummy; // 'from' address, meaningless in this case
  Boolean endOfMsg = False;
  unsigned char* ptr = &fRequestBuffer[fRequestBytesAlreadySeen];

  int bytesRead = readSocket(envir(), fClientSocket,
                             ptr, fRequestBufferBytesLeft, dummy);
  if (bytesRead <= 0 || (unsigned)bytesRead >= fRequestBufferBytesLeft) {
    // Either the client socket has died, or the request was too big for us.
    // Terminate this connection:
#ifdef DEBUG
    fprintf(stderr, "RTSPClientSession[%p]::incomingRequestHandler1() read %d bytes (of %d); terminating connection!\n", this, bytesRead, fRequestBufferBytesLeft);
#endif
    delete this;
    return;
  }
#ifdef DEBUG
  ptr[bytesRead] = '\0';
  fprintf(stderr, "RTSPClientSession[%p]::incomingRequestHandler1() read %d bytes:%s\n", this, bytesRead, ptr);
#endif

  // Look for the end of the message: <CR><LF><CR><LF>
  unsigned char *tmpPtr = ptr;
  if (fRequestBytesAlreadySeen > 0) --tmpPtr;
      // in case the last read ended with a <CR>
  while (tmpPtr < &ptr[bytesRead-1]) {
    if (*tmpPtr == '\r' && *(tmpPtr+1) == '\n') {
      if (tmpPtr - fLastCRLF == 2) { // This is it:
        endOfMsg = 1;
        break;
      }
      fLastCRLF = tmpPtr;
    }
    ++tmpPtr;
  }

  fRequestBufferBytesLeft -= bytesRead;
  fRequestBytesAlreadySeen += bytesRead;

  if (!endOfMsg) return; // 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];
  if (!parseRTSPRequestString((char*)fRequestBuffer, fRequestBytesAlreadySeen,
                              cmdName, sizeof cmdName,
                              urlPreSuffix, sizeof urlPreSuffix,
                              urlSuffix, sizeof urlSuffix,
                              cseq, sizeof cseq)) {
#ifdef DEBUG
    fprintf(stderr, "parseRTSPRequestString() failed!\n");
#endif
    handleCmd_bad(cseq);
  } else {
#ifdef DEBUG
    fprintf(stderr, "parseRTSPRequestString() returned cmdName \"%s\", urlPreSuffix \"%s\", urlSuffix \"%s\"\n", cmdName, urlPreSuffix, urlSuffix);
#endif
    if (strcmp(cmdName, "OPTIONS") == 0) {
      handleCmd_OPTIONS(cseq);
    } else if (strcmp(cmdName, "DESCRIBE") == 0) {
      handleCmd_DESCRIBE(cseq, 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) {
      handleCmd_withinSession(cmdName, urlPreSuffix, urlSuffix, cseq,
                              (char const*)fRequestBuffer);
    } else {
      handleCmd_notSupported(cseq);
    }
  }

#ifdef DEBUG
  fprintf(stderr, "sending response: %s", fResponseBuffer);
#endif
  send(fClientSocket, (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);
  }

  resetRequestBuffer(); // to prepare for any subsequent request
  if (!fSessionIsActive) delete this;
}

void RTSPServer::RTSPClientSession::handleCmd_bad

(

char const *

cseq

)

[private]

Definition at line 438 of file RTSPServer.cpp.

References allowedCommandNames, dateHeader(), and fResponseBuffer.

Referenced by incomingRequestHandler1().

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

)

[private]

Definition at line 445 of file RTSPServer.cpp.

References allowedCommandNames, dateHeader(), and fResponseBuffer.

Referenced by incomingRequestHandler1().

                                                                         {
  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

)

[private]

Definition at line 451 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

)

[private]

Definition at line 458 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

)

[private]

Definition at line 465 of file RTSPServer.cpp.

References allowedCommandNames, dateHeader(), and fResponseBuffer.

Referenced by incomingRequestHandler1().

                                                                    {
  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 *	urlSuffix,
		char const *	fullRequestStr
	)			[private]

Definition at line 472 of file RTSPServer.cpp.

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

Referenced by incomingRequestHandler1().

                                                 {
  char* sdpDescription = NULL;
  char* rtspURL = NULL;
  do {
      if (!authenticationOK("DESCRIBE", cseq, urlSuffix, 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 "urlSuffix":
    ServerMediaSession* session = fOurServer.lookupServerMediaSession(urlSuffix);
    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, fClientSocket);

    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
	)			[private]

Definition at line 609 of file RTSPServer.cpp.

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

Referenced by incomingRequestHandler1().

                                              {
  // "urlPreSuffix" should be the session (stream) name, and
  // "urlSuffix" should be the subsession (track) name.
  char const* streamName = urlPreSuffix;
  char const* trackId = urlSuffix;

  // Check whether we have existing session state, and, if so, whether it's
  // for the session that's named in "streamName".  (Note that we don't
  // support more than one concurrent session on the same client connection.) #####
  if (fOurServerMediaSession != NULL
      && strcmp(streamName, fOurServerMediaSession->streamName()) != 0) {
    fOurServerMediaSession = NULL;
  }
  if (fOurServerMediaSession == NULL) {
    // Set up this session's state.

    // Look up the "ServerMediaSession" object for the specified stream:
    if (streamName[0] != '\0' ||
        fOurServer.lookupServerMediaSession("") != NULL) { // normal case
    } else { // weird case: there was no track id in the URL
      streamName = urlSuffix;
      trackId = NULL;
    }
    fOurServerMediaSession = fOurServer.lookupServerMediaSession(streamName);
    if (fOurServerMediaSession == NULL) {
      handleCmd_notFound(cseq);
      return;
    }

    fOurServerMediaSession->incrementReferenceCount();

    // Set up our array of states for this session's subsessions (tracks):
    reclaimStreamStates();
    ServerMediaSubsessionIterator iter(*fOurServerMediaSession);
    for (fNumStreamStates = 0; iter.next() != NULL; ++fNumStreamStates) {}
    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; reset by SETUP 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);
      return;
    }
  } 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);
      return;
    }
    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) {
    // TCP streaming was requested, but with no "interleaving=" fields.
    // (QuickTime Player sometimes does this.)  Set the RTP and RTCP channel ids to
    // proper values:
    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":
  float 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 ? fClientSocket : -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);
  subsession->getStreamParameters(fOurSessionId, fClientAddr.sin_addr.s_addr,
                                  clientRTPPort, clientRTCPPort,
                                  tcpSocketNum, rtpChannelId, rtcpChannelId,
                                  destinationAddress, destinationTTL, fIsMulticast,
                                  serverRTPPort, serverRTCPPort,
                                  fStreamStates[streamNum].streamToken);
  struct in_addr destinationAddr; destinationAddr.s_addr = destinationAddress;
  char* destAddrStr = strDup(our_inet_ntoa(destinationAddr));
  struct sockaddr_in sourceAddr; SOCKLEN_T namelen = sizeof sourceAddr;
  getsockname(fClientSocket, (struct sockaddr*)&sourceAddr, &namelen);
  char* sourceAddrStr = strDup(our_inet_ntoa(sourceAddr.sin_addr));
  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: %d\r\n\r\n",
                 cseq,
                 dateHeader(),
                 destAddrStr, sourceAddrStr, 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: %d\r\n\r\n",
                 cseq,
                 dateHeader(),
                 streamingModeString, destAddrStr, sourceAddrStr, 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: %d\r\n\r\n",
               cseq,
               dateHeader(),
               destAddrStr, sourceAddrStr, 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: %d\r\n\r\n",
               cseq,
               dateHeader(),
               destAddrStr, sourceAddrStr, 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: %d\r\n\r\n",
               cseq,
               dateHeader(),
               streamingModeString, destAddrStr, sourceAddrStr, ntohs(clientRTPPort.num()), ntohs(serverRTPPort.num()),
               fOurSessionId);
      break;
    }
    }
  }
  delete[] destAddrStr; delete[] sourceAddrStr; delete[] streamingModeString;
}

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

Definition at line 817 of file RTSPServer.cpp.

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

Referenced by handleCmd_SETUP(), and incomingRequestHandler1().

                                                                        {
  // This will either be:
  // - a non-aggregated operation, if "urlPreSuffix" is the session (stream)
  //   name and "urlSuffix" is the subsession (track) name, or
  // - a aggregated operation, if "urlSuffix" is the session (stream) name,
  //   or "urlPreSuffix" is the session (stream) name, and "urlSuffix"
  //   is empty.
  // First, figure out which of these it is:
  if (fOurServerMediaSession == NULL) { // There wasn't a previous SETUP!
    handleCmd_notSupported(cseq);
    return;
  }
  ServerMediaSubsession* subsession;
  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 ||
             strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0) {
    // Aggregated operation
    subsession = NULL;
  } 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);
  }
}

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

Definition at line 865 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
	)			[private]

Definition at line 897 of file RTSPServer.cpp.

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

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

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

  float 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;
  }

  if (rangeEnd < 0.0 || rangeEnd > duration) rangeEnd = duration;
  if (rangeStart < 0.0) {
    rangeStart = 0.0;
  } else if (rangeEnd > 0.0 && scale > 0.0 && rangeStart > rangeEnd) {
    rangeStart = rangeEnd;
  }

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

  // 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"
#ifdef RTPINFO_INCLUDE_RTPTIME
    ";rtptime=%u"
#endif
    ;
  unsigned rtpInfoFmtSize = strlen(rtpInfoFmt);
  char* rtpInfo = strDup("RTP-Info: ");
  unsigned i, numRTPInfoItems = 0;

  // Do any required seeking/scaling on each subsession, before starting streaming:
  for (i = 0; i < fNumStreamStates; ++i) {
    if (subsession == NULL /* means: aggregated operation */
        || subsession == fStreamStates[i].subsession) {
      if (sawScaleHeader) {
        fStreamStates[i].subsession->setStreamScale(fOurSessionId,
                                                    fStreamStates[i].streamToken,
                                                    scale);
      }
      if (sawRangeHeader) {
        fStreamStates[i].subsession->seekStream(fOurSessionId,