RTSPServer::RTSPClientSession Class Reference

#include <RTSPServer.hh>

Collaboration diagram for RTSPServer::RTSPClientSession:

[legend]

Public Member Functions
	RTSPClientSession (RTSPServer &ourServer, u_int32_t sessionId)
virtual	~RTSPClientSession ()
Protected Member Functions
virtual void	handleCmd_SETUP (RTSPClientConnection *ourClientConnection, char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr)
virtual void	handleCmd_withinSession (RTSPClientConnection *ourClientConnection, char const *cmdName, char const *urlPreSuffix, char const *urlSuffix, char const *fullRequestStr)
virtual void	handleCmd_TEARDOWN (RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession)
virtual void	handleCmd_PLAY (RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession, char const *fullRequestStr)
virtual void	handleCmd_PAUSE (RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession)
virtual void	handleCmd_GET_PARAMETER (RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession, char const *fullRequestStr)
virtual void	handleCmd_SET_PARAMETER (RTSPClientConnection *ourClientConnection, ServerMediaSubsession *subsession, char const *fullRequestStr)
UsageEnvironment &	envir ()
void	reclaimStreamStates ()
Boolean	isMulticast () const
void	noteLiveness ()
Boolean	usesTCPTransport () const
Static Protected Member Functions
static void	noteClientLiveness (RTSPClientSession *clientSession)
static void	livenessTimeoutTask (RTSPClientSession *clientSession)
Protected Attributes
RTSPServer &	fOurServer
u_int32_t	fOurSessionId
ServerMediaSession *	fOurServerMediaSession
Boolean	fIsMulticast
Boolean	fStreamAfterSETUP
unsigned char	fTCPStreamIdCount
TaskToken	fLivenessCheckTask
unsigned	fNumStreamStates
RTSPServer::RTSPClientSession::streamState *	fStreamStates
Friends
class	RTSPServer
class	RTSPClientConnection
Data Structures
struct	streamState

---

Detailed Description

Definition at line 214 of file RTSPServer.hh.

---

Constructor & Destructor Documentation

RTSPServer::RTSPClientSession::RTSPClientSession	(	RTSPServer &	ourServer,
		u_int32_t	sessionId
	)

Definition at line 1096 of file RTSPServer.cpp.

References noteLiveness().

  : fOurServer(ourServer), fOurSessionId(sessionId), fOurServerMediaSession(NULL), fIsMulticast(False), fStreamAfterSETUP(False),
    fTCPStreamIdCount(0), fLivenessCheckTask(NULL), fNumStreamStates(0), fStreamStates(NULL) {
  noteLiveness();
}

RTSPServer::RTSPClientSession::~RTSPClientSession

(

)

[virtual]

Definition at line 1102 of file RTSPServer.cpp.

References ServerMediaSession::decrementReferenceCount(), ServerMediaSession::deleteWhenUnreferenced(), envir(), RTSPServer::fClientSessions, fLivenessCheckTask, fOurServer, fOurServerMediaSession, fOurSessionId, NULL, reclaimStreamStates(), ServerMediaSession::referenceCount(), HashTable::Remove(), RTSPServer::removeServerMediaSession(), UsageEnvironment::taskScheduler(), and TaskScheduler::unscheduleDelayedTask().

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

  // Remove ourself from the server's 'client sessions' hash table before we go:
  char sessionIdStr[9];
  sprintf(sessionIdStr, "%08X", fOurSessionId);
  fOurServer.fClientSessions->Remove(sessionIdStr);

  reclaimStreamStates();

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

---

Member Function Documentation

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

Definition at line 1215 of file RTSPServer.cpp.

References dateHeader(), False, RTSPServer::RTSPClientConnection::fClientAddr, RTSPServer::RTSPClientConnection::fClientInputSocket, RTSPServer::RTSPClientConnection::fClientOutputSocket, RTSPServer::RTSPClientConnection::fCurrentCSeq, RTSPServer::RTSPClientConnection::fResponseBuffer, RTSPServer::RTSPClientConnection::handleCmd_bad(), RTSPServer::RTSPClientConnection::handleCmd_notFound(), RTSPServer::RTSPClientConnection::handleCmd_unsupportedTransport(), handleCmd_withinSession(), ServerMediaSession::incrementReferenceCount(), 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, True, and AddressString::val().

Referenced by RTSPServer::RTSPClientConnection::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

  noteLiveness();
  do {
    // First, make sure the specified stream name exists:
    ServerMediaSession* sms = fOurServer.lookupServerMediaSession(streamName);
    if (sms == 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:
      sms = fOurServer.lookupServerMediaSession(streamName);
    }
    if (sms == NULL) {
      if (fOurServerMediaSession == NULL) {
        // The client asked for a stream that doesn't exist (and this session descriptor has not been used before):
        ourClientConnection->handleCmd_notFound();
      } else {
        // The client asked for a stream that doesn't exist, but using a stream id for a stream that does exist. Bad request:
        ourClientConnection->handleCmd_bad();
      }
      break;
    } else {
      if (fOurServerMediaSession == NULL) {
        // We're accessing the "ServerMediaSession" for the first time.
        fOurServerMediaSession = sms;
        fOurServerMediaSession->incrementReferenceCount();
      } else if (sms != fOurServerMediaSession) {
        // The client asked for a stream that's different from the one originally requested for this stream id.  Bad request:
        ourClientConnection->handleCmd_bad();
        break;
      }
    }

    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:
        ourClientConnection->handleCmd_notFound();
        break;
      }
    } else {
      // Weird case: there was no track id in the URL.
      // This works only if we have only one subsession:
      if (fNumStreamStates != 1 || fStreamStates[0].subsession == NULL) {
        ourClientConnection->handleCmd_bad();
        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 && ourClientConnection->fClientOutputSocket != ourClientConnection->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;
    }
    if (streamingMode == RTP_TCP) fTCPStreamIdCount += 2;

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

    // Next, check whether a "Range:" or "x-playNow:" 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;
    char* absStart = NULL; char* absEnd = NULL;
    if (parseRangeHeader(fullRequestStr, rangeStart, rangeEnd, absStart, absEnd)) {
      delete[] absStart; delete[] absEnd;
      fStreamAfterSETUP = True;
    } else if (parsePlayNowHeader(fullRequestStr)) {
      fStreamAfterSETUP = True;
    } else {
      fStreamAfterSETUP = False;
    }

    // Then, get server parameters from the 'subsession':
    int tcpSocketNum = streamingMode == RTP_TCP ? ourClientConnection->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(ourClientConnection->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, ourClientConnection->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*)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->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",
                   ourClientConnection->fCurrentCSeq,
                   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
          ourClientConnection->handleCmd_unsupportedTransport();
          break;
        case RAW_UDP:
          snprintf((char*)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->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",
                   ourClientConnection->fCurrentCSeq,
                   dateHeader(),
                   streamingModeString, destAddrStr.val(), sourceAddrStr.val(), ntohs(serverRTPPort.num()), destinationTTL,
                   fOurSessionId);
          break;
      }
    } else {
      switch (streamingMode) {
        case RTP_UDP: {
          snprintf((char*)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->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",
                   ourClientConnection->fCurrentCSeq,
                   dateHeader(),
                   destAddrStr.val(), sourceAddrStr.val(), ntohs(clientRTPPort.num()), ntohs(clientRTCPPort.num()), ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()),
                   fOurSessionId);
          break;
        }
        case RTP_TCP: {
          snprintf((char*)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->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",
                   ourClientConnection->fCurrentCSeq,
                   dateHeader(),
                   destAddrStr.val(), sourceAddrStr.val(), rtpChannelId, rtcpChannelId,
                   fOurSessionId);
          break;
        }
        case RAW_UDP: {
          snprintf((char*)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->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",
                   ourClientConnection->fCurrentCSeq,
                   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	(	RTSPClientConnection *	ourClientConnection,
		char const *	cmdName,
		char const *	urlPreSuffix,
		char const *	urlSuffix,
		char const *	fullRequestStr
	)			[protected, virtual]

Definition at line 1465 of file RTSPServer.cpp.

References RTSPServer::RTSPClientConnection::handleCmd_notFound(), RTSPServer::RTSPClientConnection::handleCmd_notSupported(), iter, MediaSubsessionIterator::next(), NULL, and subsession.

Referenced by handleCmd_SETUP(), and RTSPServer::RTSPClientConnection::handleRequestBytes().

                                                      {
  // This will either be:
  // - 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;

  noteLiveness();
  if (fOurServerMediaSession == NULL) { // There wasn't a previous SETUP!
    ourClientConnection->handleCmd_notSupported();
    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!
      ourClientConnection->handleCmd_notFound();
      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 {
      ourClientConnection->handleCmd_notFound();
      return;
    }
  } else { // the request doesn't match a known stream and/or track at all!
    ourClientConnection->handleCmd_notFound();
    return;
  }

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

void RTSPServer::RTSPClientSession::handleCmd_TEARDOWN	(	RTSPClientConnection *	ourClientConnection,
		ServerMediaSubsession *	subsession
	)			[protected, virtual]

Definition at line 1527 of file RTSPServer.cpp.

References False, NULL, RTSPServer::RTSPClientConnection::setRTSPResponse(), subsession, and True.

                                                        {
  unsigned i;
  for (i = 0; i < fNumStreamStates; ++i) {
    if (subsession == NULL /* means: aggregated operation */
        || subsession == fStreamStates[i].subsession) {
      if (fStreamStates[i].subsession != NULL) {
        fStreamStates[i].subsession->deleteStream(fOurSessionId, fStreamStates[i].streamToken);
        fStreamStates[i].subsession = NULL;
      }
    }
  }

  ourClientConnection->setRTSPResponse("200 OK");

  // Optimization: If all subsessions have now been torn down, then we know that we can reclaim our object now.
  // (Without this optimization, however, this object would still get reclaimed later, as a result of a 'liveness' timeout.)
  Boolean noSubsessionsRemain = True;
  for (i = 0; i < fNumStreamStates; ++i) {
    if (fStreamStates[i].subsession != NULL) {
      noSubsessionsRemain = False;
      break;
    }
  }
  if (noSubsessionsRemain) delete this;
}

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

Definition at line 1579 of file RTSPServer.cpp.

References dateHeader(), duration, RTSPServer::RTSPClientConnection::fClientInputSocket, RTSPServer::RTSPClientConnection::fCurrentCSeq, RTSPServer::RTSPClientConnection::fResponseBuffer, RTSPServer::RTSPClientConnection::handleAlternativeRequestByte(), NULL, parseRangeHeader(), parseScaleHeader(), RTSPServer::rtspURL(), scale, strDup(), and subsession.

                                                                                {
  char* rtspURL = fOurServer.rtspURL(fOurServerMediaSession, ourClientConnection->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:
  float duration = 0.0;
  double rangeStart = 0.0, rangeEnd = 0.0;
  char* absStart = NULL; char* absEnd = NULL;
  Boolean sawRangeHeader = parseRangeHeader(fullRequestStr, rangeStart, rangeEnd, absStart, absEnd);

  if (sawRangeHeader && absStart == NULL/*not seeking by 'absolute' time*/) {
    // Use this information, plus the stream's duration (if known), to create our own "Range:" header, for the response:
    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) {
        if (fStreamStates[i].subsession != NULL) {
          fStreamStates[i].subsession->setStreamScale(fOurSessionId, fStreamStates[i].streamToken, scale);
        }
      }
      if (sawRangeHeader) {
        if (absStart != NULL) {
          // Special case handling for seeking by 'absolute' time:

          if (fStreamStates[i].subsession != NULL) {
            fStreamStates[i].subsession->seekStream(fOurSessionId, fStreamStates[i].streamToken, absStart, absEnd);
          }
        } else {
          // Seeking by relative (NPT) time:

          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
          }
          if (fStreamStates[i].subsession != NULL) {
            u_int64_t numBytes;
            fStreamStates[i].subsession->seekStream(fOurSessionId, fStreamStates[i].streamToken,
                                                    rangeStart, streamDuration, numBytes);
          }
        }
      } else {
        // No "Range:" header was specified in the "PLAY", so we do a 'null' seek (i.e., we don't seek at all):
        if (fStreamStates[i].subsession != NULL) {
          fStreamStates[i].subsession->nullSeekStream(fOurSessionId, fStreamStates[i].streamToken);
        }
      }
    }
  }

  // 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) {
    // There wasn't a "Range:" header in the request, so, in our response, begin the range with the current NPT (normal play time):
    float curNPT = 0.0;
    for (i = 0; i < fNumStreamStates; ++i) {
      if (subsession == NULL /* means: aggregated operation */
          || subsession == fStreamStates[i].subsession) {
        if (fStreamStates[i].subsession == NULL) continue;
        float npt = fStreamStates[i].subsession->getCurrentNPT(fStreamStates[i].streamToken);
        if (npt > curNPT) curNPT = npt;
        // Note: If this is an aggregate "PLAY" on a multi-subsession stream, then it's conceivable that the NPTs of each subsession
        // may differ (if there has been a previous seek on just one subsession).  In this (unusual) case, we just return the
        // largest NPT; I hope that turns out OK...
      }
    }

    sprintf(buf, "Range: npt=%.3f-\r\n", curNPT);
  } else if (absStart != NULL) {
    // We're seeking by 'absolute' time:
    if (absEnd == NULL) {
      sprintf(buf, "Range: clock=%s-\r\n", absStart);
    } else {
      sprintf(buf, "Range: clock=%s-%s\r\n", absStart, absEnd);
    }
    delete[] absStart; delete[] absEnd;
  } else {
    // We're seeking by relative (NPT) time:
    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;
      if (fStreamStates[i].subsession == NULL) continue;
      fStreamStates[i].subsession->startStream(fOurSessionId,
                                               fStreamStates[i].streamToken,
                                               (TaskFunc*)noteClientLiveness, this,
                                               rtpSeqNum, rtpTimestamp,
                                               RTSPServer::RTSPClientConnection::handleAlternativeRequestByte, ourClientConnection);
      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*)ourClientConnection->fResponseBuffer, sizeof ourClientConnection->fResponseBuffer,
           "RTSP/1.0 200 OK\r\n"
           "CSeq: %s\r\n"
           "%s"
           "%s"
           "%s"
           "Session: %08X\r\n"
           "%s\r\n",
           ourClientConnection->fCurrentCSeq,
           dateHeader(),
           scaleHeader,
           rangeHeader,
           fOurSessionId,
           rtpInfo);
  delete[] rtpInfo; delete[] rangeHeader;
  delete[] scaleHeader; delete[] rtspURL;
}

void RTSPServer::RTSPClientSession::handleCmd_PAUSE	(	RTSPClientConnection *	ourClientConnection,
		ServerMediaSubsession *	subsession
	)			[protected, virtual]

Definition at line 1786 of file RTSPServer.cpp.

References NULL, RTSPServer::RTSPClientConnection::setRTSPResponse(), and subsession.

                                                     {
  for (unsigned i = 0; i < fNumStreamStates; ++i) {
    if (subsession == NULL /* means: aggregated operation */
        || subsession == fStreamStates[i].subsession) {
      if (fStreamStates[i].subsession != NULL) {
        fStreamStates[i].subsession->pauseStream(fOurSessionId, fStreamStates[i].streamToken);
      }
    }
  }

  ourClientConnection->setRTSPResponse("200 OK", fOurSessionId);
}

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

Definition at line 1801 of file RTSPServer.cpp.

References LIVEMEDIA_LIBRARY_VERSION_STRING, and RTSPServer::RTSPClientConnection::setRTSPResponse().

                                                                                                 {
  // By default, we implement "GET_PARAMETER" just as a 'keep alive', and send back a dummy 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.)
  ourClientConnection->setRTSPResponse("200 OK", fOurSessionId, LIVEMEDIA_LIBRARY_VERSION_STRING);
}

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

Definition at line 1810 of file RTSPServer.cpp.

References RTSPServer::RTSPClientConnection::setRTSPResponse().

                                                                                                 {
  // 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.)
  ourClientConnection->setRTSPResponse("200 OK", fOurSessionId);
}

UsageEnvironment& RTSPServer::RTSPClientSession::envir

(

)

[inline, protected]

Definition at line 239 of file RTSPServer.hh.

References Medium::envir(), and fOurServer.

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

{ return fOurServer.envir(); }

void RTSPServer::RTSPClientSession::reclaimStreamStates

(

)

[protected]

Definition at line 1123 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;
}

Boolean RTSPServer::RTSPClientSession::isMulticast

(

)

const [inline, protected]

Definition at line 241 of file RTSPServer.hh.

References fIsMulticast.

{ return fIsMulticast; }

void RTSPServer::RTSPClientSession::noteLiveness

(

)

[protected]

Definition at line 1828 of file RTSPServer.cpp.

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

Referenced by noteClientLiveness(), and RTSPClientSession().

                                               {
  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 1838 of file RTSPServer.cpp.

References fOurServerMediaSession, fOurSessionId, noteLiveness(), NULL, and ServerMediaSession::streamName().

                                                     {
#ifdef DEBUG
  char const* streamName
    = (clientSession->fOurServerMediaSession == NULL) ? "???" : clientSession->fOurServerMediaSession->streamName();
  fprintf(stderr, "RTSP client session (id \"%08X\", stream name \"%s\"): Liveness indication\n",
          clientSession->fOurSessionId, streamName);
#endif
  clientSession->noteLiveness();
}

void RTSPServer::RTSPClientSession::livenessTimeoutTask

(

RTSPClientSession *

clientSession

)

[static, protected]

Definition at line 1849 of file RTSPServer.cpp.

References fOurServerMediaSession, fOurSessionId, NULL, and ServerMediaSession::streamName().

Referenced by noteLiveness().

                                                      {
  // If this gets called, the client session is assumed to have timed out,
  // so delete it:
#ifdef DEBUG
  char const* streamName
    = (clientSession->fOurServerMediaSession == NULL) ? "???" : clientSession->fOurServerMediaSession->streamName();
  fprintf(stderr, "RTSP client session (id \"%08X\", stream name \"%s\") has timed out (due to inactivity)\n",
          clientSession->fOurSessionId, streamName);
#endif
  delete clientSession;
}

Boolean RTSPServer::RTSPClientSession::usesTCPTransport

(

)

const [inline, protected]

Definition at line 251 of file RTSPServer.hh.

References fTCPStreamIdCount.

{ return fTCPStreamIdCount > 0; }

---

Friends And Related Function Documentation

friend class RTSPServer [friend]

Definition at line 219 of file RTSPServer.hh.

friend class RTSPClientConnection [friend]

Definition at line 220 of file RTSPServer.hh.

---

Field Documentation

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

Definition at line 246 of file RTSPServer.hh.

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

u_int32_t RTSPServer::RTSPClientSession::fOurSessionId [protected]

Definition at line 247 of file RTSPServer.hh.

Referenced by livenessTimeoutTask(), noteClientLiveness(), reclaimStreamStates(), and ~RTSPClientSession().

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

Definition at line 248 of file RTSPServer.hh.

Referenced by RTSPServer::closeAllClientSessionsForServerMediaSession(), livenessTimeoutTask(), noteClientLiveness(), and ~RTSPClientSession().

Boolean RTSPServer::RTSPClientSession::fIsMulticast [protected]

Definition at line 249 of file RTSPServer.hh.

Referenced by isMulticast().

Boolean RTSPServer::RTSPClientSession::fStreamAfterSETUP [protected]

Definition at line 249 of file RTSPServer.hh.

Referenced by RTSPServer::RTSPClientConnection::handleRequestBytes().

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

Definition at line 250 of file RTSPServer.hh.

Referenced by usesTCPTransport().

TaskToken RTSPServer::RTSPClientSession::fLivenessCheckTask [protected]

Definition at line 252 of file RTSPServer.hh.

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

unsigned RTSPServer::RTSPClientSession::fNumStreamStates [protected]

Definition at line 253 of file RTSPServer.hh.

Referenced by reclaimStreamStates().

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

Referenced by reclaimStreamStates().

---

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

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

---