liveMedia/RTSPClient.cpp

Go to the documentation of this file.

/**********
This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the
Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)

This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
more details.

You should have received a copy of the GNU Lesser General Public License
along with this library; if not, write to the Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**********/
// "liveMedia"
// Copyright (c) 1996-2008 Live Networks, Inc.  All rights reserved.
// A generic RTSP client
// Implementation

#include "RTSPClient.hh"
#include "RTSPCommon.hh"
#include "Base64.hh"
#include "Locale.hh"
#include <GroupsockHelper.hh>
#include "our_md5.h"
#ifdef SUPPORT_REAL_RTSP
#include "../RealRTSP/include/RealRTSP.hh"
#endif


RTSPClient* RTSPClient::createNew(UsageEnvironment& env,
                                  int verbosityLevel,
                                  char const* applicationName,
                                  portNumBits tunnelOverHTTPPortNum) {
  return new RTSPClient(env, verbosityLevel,
                        applicationName, tunnelOverHTTPPortNum);
}

Boolean RTSPClient::lookupByName(UsageEnvironment& env,
                                 char const* instanceName,
                                 RTSPClient*& resultClient) {
  resultClient = NULL; // unless we succeed

  Medium* medium;
  if (!Medium::lookupByName(env, instanceName, medium)) return False;

  if (!medium->isRTSPClient()) {
    env.setResultMsg(instanceName, " is not a RTSP client");
    return False;
  }

  resultClient = (RTSPClient*)medium;
  return True;
}

unsigned RTSPClient::fCSeq = 0;

RTSPClient::RTSPClient(UsageEnvironment& env,
                       int verbosityLevel, char const* applicationName,
                       portNumBits tunnelOverHTTPPortNum)
  : Medium(env),
    fVerbosityLevel(verbosityLevel),
    fTunnelOverHTTPPortNum(tunnelOverHTTPPortNum),
    fInputSocketNum(-1), fOutputSocketNum(-1), fServerAddress(0),
    fBaseURL(NULL), fTCPStreamIdCount(0), fLastSessionId(NULL),
    fSessionTimeoutParameter(0),
#ifdef SUPPORT_REAL_RTSP
    fRealChallengeStr(NULL), fRealETagStr(NULL),
#endif
    fServerIsKasenna(False), fKasennaContentType(NULL),
    fServerIsMicrosoft(False)
{
  fResponseBufferSize = 20000;
  fResponseBuffer = new char[fResponseBufferSize+1];

  // Set the "User-Agent:" header to use in each request:
  char const* const libName = "LIVE555 Streaming Media v";
  char const* const libVersionStr = LIVEMEDIA_LIBRARY_VERSION_STRING;
  char const* libPrefix; char const* libSuffix;
  if (applicationName == NULL || applicationName[0] == '\0') {
    applicationName = libPrefix = libSuffix = "";
  } else {
    libPrefix = " (";
    libSuffix = ")";
  }
  char const* const formatStr = "User-Agent: %s%s%s%s%s\r\n";
  unsigned headerSize
    = strlen(formatStr) + strlen(applicationName) + strlen(libPrefix)
    + strlen(libName) + strlen(libVersionStr) + strlen(libSuffix);
  fUserAgentHeaderStr = new char[headerSize];
  sprintf(fUserAgentHeaderStr, formatStr,
          applicationName, libPrefix, libName, libVersionStr, libSuffix);
  fUserAgentHeaderStrSize = strlen(fUserAgentHeaderStr);
}

void RTSPClient::setUserAgentString(char const* userAgentStr) {
  if (userAgentStr == NULL) return;

  // Change the existing user agent header string:
  char const* const formatStr = "User-Agent: %s\r\n";
  unsigned const headerSize = strlen(formatStr) + strlen(userAgentStr) + 1;
  delete[] fUserAgentHeaderStr;
  fUserAgentHeaderStr = new char[headerSize];
  sprintf(fUserAgentHeaderStr, formatStr, userAgentStr);
  fUserAgentHeaderStrSize = strlen(fUserAgentHeaderStr);
}

RTSPClient::~RTSPClient() {
  envir().taskScheduler().turnOffBackgroundReadHandling(fInputSocketNum); // must be called before:
  reset();

  delete[] fResponseBuffer;
  delete[] fUserAgentHeaderStr;
}

Boolean RTSPClient::isRTSPClient() const {
  return True;
}

void RTSPClient::resetTCPSockets() {
  if (fInputSocketNum >= 0) {
    ::closeSocket(fInputSocketNum);
    if (fOutputSocketNum != fInputSocketNum) ::closeSocket(fOutputSocketNum);
  }
  fInputSocketNum = fOutputSocketNum = -1;
}

void RTSPClient::reset() {
  resetTCPSockets();
  fServerAddress = 0;

  delete[] fBaseURL; fBaseURL = NULL;

  fCurrentAuthenticator.reset();

  delete[] fKasennaContentType; fKasennaContentType = NULL;
#ifdef SUPPORT_REAL_RTSP
  delete[] fRealChallengeStr; fRealChallengeStr = NULL;
  delete[] fRealETagStr; fRealETagStr = NULL;
#endif
  delete[] fLastSessionId; fLastSessionId = NULL;
}

static char* getLine(char* startOfLine) {
  // returns the start of the next line, or NULL if none
  for (char* ptr = startOfLine; *ptr != '\0'; ++ptr) {
    // Check for the end of line: \r\n (but also accept \r or \n by itself):
    if (*ptr == '\r' || *ptr == '\n') {
      // We found the end of the line
      if (*ptr == '\r') {
        *ptr++ = '\0';
        if (*ptr == '\n') ++ptr;
      } else {
        *ptr++ = '\0';
      }
      return ptr;
    }
  }

  return NULL;
}

char* RTSPClient::describeURL(char const* url, Authenticator* authenticator,
                              Boolean allowKasennaProtocol) {
  char* cmd = NULL;
  fDescribeStatusCode = 0;
  do {  
    // First, check whether "url" contains a username:password to be used:
    char* username; char* password;
    if (authenticator == NULL
        && parseRTSPURLUsernamePassword(url, username, password)) {
      char* result = describeWithPassword(url, username, password, allowKasennaProtocol);
      delete[] username; delete[] password; // they were dynamically allocated
      return result;
    }

    if (!openConnectionFromURL(url, authenticator)) break;

    // Send the DESCRIBE command:

    // First, construct an authenticator string:
    fCurrentAuthenticator.reset();
    char* authenticatorStr
      = createAuthenticatorString(authenticator, "DESCRIBE", url);

    char const* acceptStr = allowKasennaProtocol
      ? "Accept: application/x-rtsp-mh, application/sdp\r\n"
      : "Accept: application/sdp\r\n";

    // (Later implement more, as specified in the RTSP spec, sec D.1 #####)
    char* const cmdFmt =
      "DESCRIBE %s RTSP/1.0\r\n"
      "CSeq: %d\r\n"
      "%s"
      "%s"
      "%s"
#ifdef SUPPORT_REAL_RTSP
      REAL_DESCRIBE_HEADERS
#endif
      "\r\n";
    unsigned cmdSize = strlen(cmdFmt)
      + strlen(url)
      + 20 /* max int len */
      + strlen(acceptStr)
      + strlen(authenticatorStr)
      + fUserAgentHeaderStrSize;
    cmd = new char[cmdSize];
    sprintf(cmd, cmdFmt,
            url,
            ++fCSeq,
            acceptStr,
            authenticatorStr,
            fUserAgentHeaderStr);
    delete[] authenticatorStr;

    if (!sendRequest(cmd, "DESCRIBE")) break;

    // Get the response from the server:
    unsigned bytesRead; unsigned responseCode;
    char* firstLine; char* nextLineStart;
    if (!getResponse("DESCRIBE", bytesRead, responseCode, firstLine, nextLineStart,
                     False /*don't check for response code 200*/)) break;

    // Inspect the first line to check whether it's a result code that
    // we can handle.
    Boolean wantRedirection = False;
    char* redirectionURL = NULL;
#ifdef SUPPORT_REAL_RTSP
    delete[] fRealETagStr; fRealETagStr = new char[fResponseBufferSize];
#endif
    if (responseCode == 301 || responseCode == 302) {
      wantRedirection = True;
      redirectionURL = new char[fResponseBufferSize]; // ensures enough space
    } else if (responseCode != 200) {
      checkForAuthenticationFailure(responseCode, nextLineStart, authenticator);
      envir().setResultMsg("cannot handle DESCRIBE response: ", firstLine);
      break;
    }

    // Skip over subsequent header lines, until we see a blank line.
    // The remaining data is assumed to be the SDP descriptor that we want.
    // While skipping over the header lines, we also check for certain headers
    // that we recognize.
    // (We should also check for "Content-type: application/sdp",
    // "Content-location", "CSeq", etc.) #####
    char* serverType = new char[fResponseBufferSize]; // ensures enough space
    int contentLength = -1;
    char* lineStart;
    while (1) {
      lineStart = nextLineStart;
      if (lineStart == NULL) break;

      nextLineStart = getLine(lineStart);
      if (lineStart[0] == '\0') break; // this is a blank line

      if (sscanf(lineStart, "Content-Length: %d", &contentLength) == 1
          || sscanf(lineStart, "Content-length: %d", &contentLength) == 1) {
        if (contentLength < 0) {
          envir().setResultMsg("Bad \"Content-length:\" header: \"",
                               lineStart, "\"");
          break;
        }
      } else if (strncmp(lineStart, "Content-Base:", 13) == 0) {
        int cbIndex = 13;

        while (lineStart[cbIndex] == ' ' || lineStart[cbIndex] == '\t') ++cbIndex; 
        if (lineStart[cbIndex] != '\0'/*sanity check*/) {
          delete[] fBaseURL; fBaseURL = strDup(&lineStart[cbIndex]);
        }
      } else if (sscanf(lineStart, "Server: %s", serverType) == 1) {
        if (strncmp(serverType, "Kasenna", 7) == 0) fServerIsKasenna = True;
        if (strncmp(serverType, "WMServer", 8) == 0) fServerIsMicrosoft = True;
#ifdef SUPPORT_REAL_RTSP
      } else if (sscanf(lineStart, "ETag: %s", fRealETagStr) == 1) {
#endif
      } else if (wantRedirection) { 
        if (sscanf(lineStart, "Location: %s", redirectionURL) == 1) {
          // Try again with this URL
          if (fVerbosityLevel >= 1) {
            envir() << "Redirecting to the new URL \""
                    << redirectionURL << "\"\n";
          }
          reset();
          char* result = describeURL(redirectionURL, authenticator, allowKasennaProtocol);
          delete[] redirectionURL;
          delete[] serverType;
          delete[] cmd;
          return result;
        }
      }
    } 
    delete[] serverType;

    // We're now at the end of the response header lines
    if (wantRedirection) {
      envir().setResultMsg("Saw redirection response code, but not a \"Location:\" header");
      delete[] redirectionURL;
      break;
    }
    if (lineStart == NULL) {
      envir().setResultMsg("no content following header lines: ", fResponseBuffer);
      break;
    }

    // Use the remaining data as the SDP descr, but first, check
    // the "Content-length:" header (if any) that we saw.  We may need to
    // read more data, or we may have extraneous data in the buffer.
    char* bodyStart = nextLineStart;
    if (contentLength >= 0) {
      // We saw a "Content-length:" header
      unsigned numBodyBytes = &firstLine[bytesRead] - bodyStart;
      if (contentLength > (int)numBodyBytes) {
        // We need to read more data.  First, make sure we have enough
        // space for it:
        unsigned numExtraBytesNeeded = contentLength - numBodyBytes;
        unsigned remainingBufferSize
          = fResponseBufferSize - (bytesRead + (firstLine - fResponseBuffer));
        if (numExtraBytesNeeded > remainingBufferSize) {
          char tmpBuf[200];
          sprintf(tmpBuf, "Read buffer size (%d) is too small for \"Content-length:\" %d (need a buffer size of >= %d bytes\n",
                  fResponseBufferSize, contentLength,
                  fResponseBufferSize + numExtraBytesNeeded - remainingBufferSize);
          envir().setResultMsg(tmpBuf);
          break;
        }

        // Keep reading more data until we have enough:
        if (fVerbosityLevel >= 1) {
          envir() << "Need to read " << numExtraBytesNeeded
                  << " extra bytes\n";
        }
        while (numExtraBytesNeeded > 0) {
          struct sockaddr_in fromAddress;
          char* ptr = &firstLine[bytesRead];
          int bytesRead2 = readSocket(envir(), fInputSocketNum, (unsigned char*)ptr,
                                      numExtraBytesNeeded, fromAddress);
          if (bytesRead2 < 0) break;
          ptr[bytesRead2] = '\0';
          if (fVerbosityLevel >= 1) {
            envir() << "Read " << bytesRead2 << " extra bytes: "
                    << ptr << "\n";
          }

          bytesRead += bytesRead2;
          numExtraBytesNeeded -= bytesRead2;
        }
        if (numExtraBytesNeeded > 0) break; // one of the reads failed
      }

      // Remove any '\0' characters from inside the SDP description.
      // Any such characters would violate the SDP specification, but
      // some RTSP servers have been known to include them:
      int from, to = 0;
      for (from = 0; from < contentLength; ++from) {
        if (bodyStart[from] != '\0') {
          if (to != from) bodyStart[to] = bodyStart[from];
          ++to;
        }
      }
      if (from != to && fVerbosityLevel >= 1) {
        envir() << "Warning: " << from-to << " invalid 'NULL' bytes were found in (and removed from) the SDP description.\n";
      }
      bodyStart[to] = '\0'; // trims any extra data
    }

    // If necessary, handle Kasenna's non-standard BS response:
    if (fServerIsKasenna && strncmp(bodyStart, "<MediaDescription>", 18) == 0) {
      // Translate from x-rtsp-mh to sdp
      int videoPid, audioPid;
      u_int64_t mh_duration;
      char* currentWord = new char[fResponseBufferSize]; // ensures enough space
      delete[] fKasennaContentType;
      fKasennaContentType = new char[fResponseBufferSize]; // ensures enough space
      char* currentPos = bodyStart;
      
      while (strcmp(currentWord, "</MediaDescription>") != 0) {
          sscanf(currentPos, "%s", currentWord);
          
          if (strcmp(currentWord, "VideoPid") == 0) {
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%s", currentWord);
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%d", &videoPid);
            currentPos += 3;
          }
          
          if (strcmp(currentWord, "AudioPid") == 0) {
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%s", currentWord);
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%d", &audioPid);
            currentPos += 3;
          }
          
          if (strcmp(currentWord, "Duration") == 0) {
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%s", currentWord);
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%llu", &mh_duration);
            currentPos += 3;
          }
          
          if (strcmp(currentWord, "TypeSpecificData") == 0) {
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%s", currentWord);
            currentPos += strlen(currentWord) + 1;
            sscanf(currentPos, "%s", fKasennaContentType);
            currentPos += 3;
            printf("Kasenna Content Type: %s\n", fKasennaContentType);
          }
          
          currentPos += strlen(currentWord) + 1;
        }
      
      if (fKasennaContentType != NULL
          && strcmp(fKasennaContentType, "PARTNER_41_MPEG-4") == 0) {
          char* describeSDP = describeURL(url, authenticator, True);
          
          delete[] currentWord;
          delete[] cmd;
          return describeSDP;
      }
      
      unsigned char byte1 = fServerAddress & 0x000000ff;
      unsigned char byte2 = (fServerAddress & 0x0000ff00) >>  8;
      unsigned char byte3 = (fServerAddress & 0x00ff0000) >> 16;
      unsigned char byte4 = (fServerAddress & 0xff000000) >> 24;
      
      char const* sdpFmt =
        "v=0\r\n"
        "o=NoSpacesAllowed 1 1 IN IP4 %u.%u.%u.%u\r\n"
        "s=%s\r\n"
        "c=IN IP4 %u.%u.%u.%u\r\n"
        "t=0 0\r\n"
        "a=control:*\r\n"
        "a=range:npt=0-%llu\r\n"
        "m=video 1554 RAW/RAW/UDP 33\r\n"
        "a=control:trackID=%d\r\n";
      unsigned sdpBufSize = strlen(sdpFmt)
        + 4*3 // IP address
        + strlen(url)
        + 20 // max int length
        + 20; // max int length
      char* sdpBuf = new char[sdpBufSize];
      sprintf(sdpBuf, sdpFmt,
              byte1, byte2, byte3, byte4,
              url,
              byte1, byte2, byte3, byte4,
              mh_duration/1000000,
              videoPid);
      
      char* result = strDup(sdpBuf);
      delete[] sdpBuf; delete[] currentWord;
      delete[] cmd;
      return result;
    }
    
    delete[] cmd;
    return strDup(bodyStart);
  } while (0);
  
  delete[] cmd;
  if (fDescribeStatusCode == 0) fDescribeStatusCode = 2;
  return NULL;
}

char* RTSPClient
::describeWithPassword(char const* url,
                       char const* username, char const* password,
                       Boolean allowKasennaProtocol) {
  Authenticator authenticator;
  authenticator.setUsernameAndPassword(username, password);
  char* describeResult = describeURL(url, &authenticator, allowKasennaProtocol);
  if (describeResult != NULL) {
    // We are already authorized
    return describeResult;
  }

  // The "realm" field should have been filled in:
  if (authenticator.realm() == NULL) {
    // We haven't been given enough information to try again, so fail:
    return NULL;
  }

  // Try again:
  describeResult = describeURL(url, &authenticator, allowKasennaProtocol);
  if (describeResult != NULL) {
    // The authenticator worked, so use it in future requests:
    fCurrentAuthenticator = authenticator;
  }

  return describeResult;
}

char* RTSPClient::sendOptionsCmd(char const* url,
                                 char* username, char* password,
                                 Authenticator* authenticator) {
  char* result = NULL;
  char* cmd = NULL;
  Boolean haveAllocatedAuthenticator = False;
  do {
    if (authenticator == NULL) {
      // First, check whether "url" contains a username:password to be used
      // (and no username,password pair was supplied separately):
      if (username == NULL && password == NULL
          && parseRTSPURLUsernamePassword(url, username, password)) {
        Authenticator newAuthenticator;
        newAuthenticator.setUsernameAndPassword(username, password);
        result = sendOptionsCmd(url, username, password, &newAuthenticator);
        delete[] username; delete[] password; // they were dynamically allocated
        break;
      } else if (username != NULL && password != NULL) {
        // Use the separately supplied username and password:
        authenticator = new Authenticator;
        haveAllocatedAuthenticator = True;
        authenticator->setUsernameAndPassword(username, password);

        result = sendOptionsCmd(url, username, password, authenticator);
        if (result != NULL) break; // We are already authorized

        // The "realm" field should have been filled in:
        if (authenticator->realm() == NULL) {
          // We haven't been given enough information to try again, so fail:
          break;
        }
        // Try again:
      }
    }

    if (!openConnectionFromURL(url, authenticator)) break;

    // Send the OPTIONS command:

    // First, construct an authenticator string:
    char* authenticatorStr
      = createAuthenticatorString(authenticator, "OPTIONS", url);

    char* const cmdFmt =
      "OPTIONS %s RTSP/1.0\r\n"
      "CSeq: %d\r\n"
      "%s"
      "%s"
#ifdef SUPPORT_REAL_RTSP
      REAL_OPTIONS_HEADERS
#endif
      "\r\n";
    unsigned cmdSize = strlen(cmdFmt)
      + strlen(url)
      + 20 /* max int len */
      + strlen(authenticatorStr)
      + fUserAgentHeaderStrSize;
    cmd = new char[cmdSize];
    sprintf(cmd, cmdFmt,
            url,
            ++fCSeq,
            authenticatorStr,
            fUserAgentHeaderStr);
    delete[] authenticatorStr;

    if (!sendRequest(cmd, "OPTIONS")) break;

    // Get the response from the server:
    unsigned bytesRead; unsigned responseCode;
    char* firstLine; char* nextLineStart;
    if (!getResponse("OPTIONS", bytesRead, responseCode, firstLine, nextLineStart,
                     False /*don't check for response code 200*/)) break;
    if (responseCode != 200) {
      checkForAuthenticationFailure(responseCode, nextLineStart, authenticator);
      envir().setResultMsg("cannot handle OPTIONS response: ", firstLine);
      break;
    }

    // Look for a "Public:" header (which will contain our result str):
    char* lineStart;
    while (1) {
      lineStart = nextLineStart;
      if (lineStart == NULL) break;

      nextLineStart = getLine(lineStart);

      if (_strncasecmp(lineStart, "Public: ", 8) == 0) {
        delete[] result; result = strDup(&lineStart[8]);
#ifdef SUPPORT_REAL_RTSP
      } else if (_strncasecmp(lineStart, "RealChallenge1: ", 16) == 0) {
        delete[] fRealChallengeStr; fRealChallengeStr = strDup(&lineStart[16]);
#endif
      }
    }
  } while (0);

  delete[] cmd;
  if (haveAllocatedAuthenticator) delete authenticator;
  return result;
}

static Boolean isAbsoluteURL(char const* url) {
  // Assumption: "url" is absolute if it contains a ':', before any
  // occurrence of '/'
  while (*url != '\0' && *url != '/') {
    if (*url == ':') return True;
    ++url;
  }

  return False;
}

char const* RTSPClient::sessionURL(MediaSession const& session) const {
  char const* url = session.controlPath();
  if (url == NULL || strcmp(url, "*") == 0) url = fBaseURL;

  return url;
}

void RTSPClient::constructSubsessionURL(MediaSubsession const& subsession,
                                        char const*& prefix,
                                        char const*& separator,
                                        char const*& suffix) {
  // Figure out what the URL describing "subsession" will look like.
  // The URL is returned in three parts: prefix; separator; suffix
  //##### NOTE: This code doesn't really do the right thing if "sessionURL()"
  // doesn't end with a "/", and "subsession.controlPath()" is relative.
  // The right thing would have been to truncate "sessionURL()" back to the
  // rightmost "/", and then add "subsession.controlPath()".
  // In practice, though, each "DESCRIBE" response typically contains
  // a "Content-Base:" header that consists of "sessionURL()" followed by
  // a "/", in which case this code ends up giving the correct result.
  // However, we should really fix this code to do the right thing, and
  // also check for and use the "Content-Base:" header appropriately. #####
  prefix = sessionURL(subsession.parentSession());
  if (prefix == NULL) prefix = "";

  suffix = subsession.controlPath();
  if (suffix == NULL) suffix = "";

  if (isAbsoluteURL(suffix)) {
    prefix = separator = "";
  } else {
    unsigned prefixLen = strlen(prefix);
    separator = (prefix[prefixLen-1] == '/' || suffix[0] == '/') ? "" : "/";
  }
}

Boolean RTSPClient::announceSDPDescription(char const* url,
                                           char const* sdpDescription,
                                           Authenticator* authenticator) {
  char* cmd = NULL;
  do {
    if (!openConnectionFromURL(url, authenticator)) break;

    // Send the ANNOUNCE command:

    // First, construct an authenticator string:
    fCurrentAuthenticator.reset();
    char* authenticatorStr
      = createAuthenticatorString(authenticator, "ANNOUNCE", url);

    char* const cmdFmt =
      "ANNOUNCE %s RTSP/1.0\r\n"
      "CSeq: %d\r\n"
      "Content-Type: application/sdp\r\n"
      "%s"
      "Content-length: %d\r\n\r\n"
      "%s";
            // Note: QTSS hangs if an "ANNOUNCE" contains a "User-Agent:" field (go figure), so don't include one here
    unsigned sdpSize = strlen(sdpDescription);
    unsigned cmdSize = strlen(cmdFmt)
      + strlen(url)
      + 20 /* max int len */
      + strlen(authenticatorStr)
      + 20 /* max int len */
      + sdpSize;
    cmd = new char[cmdSize];
    sprintf(cmd, cmdFmt,
            url,
            ++fCSeq,
            authenticatorStr,
            sdpSize,
            sdpDescription);
    delete[] authenticatorStr;

    if (!sendRequest(cmd, "ANNOUNCE")) break;

    // Get the response from the server:
    unsigned bytesRead; unsigned responseCode;
    char* firstLine; char* nextLineStart;
    if (!getResponse("ANNOUNCE", bytesRead, responseCode, firstLine, nextLineStart,
                     False /*don't check for response code 200*/)) break;

    // Inspect the first line to check whether it's a result code 200
    if (responseCode != 200) {
      checkForAuthenticationFailure(responseCode, nextLineStart, authenticator);
      envir().setResultMsg("cannot handle ANNOUNCE response: ", firstLine);
      break;
    }

    delete[] cmd;
    return True;
  } while (0);

  delete[] cmd;
  return False;
}

Boolean RTSPClient
::announceWithPassword(char const* url, char const* sdpDescription,
                       char const* username, char const* password) {
  Authenticator authenticator;
  authenticator.setUsernameAndPassword(username, password);
  if (announceSDPDescription(url, sdpDescription, &authenticator)) {
    // We are already authorized
    return True;
  }

  // The "realm" field should have been filled in:
  if (authenticator.realm() == NULL) {
    // We haven't been given enough information to try again, so fail:
    return False;
  }

  // Try again:
  Boolean secondTrySuccess
    = announceSDPDescription(url, sdpDescription, &authenticator);

  if (secondTrySuccess) {
    // The authenticator worked, so use it in future requests:
    fCurrentAuthenticator = authenticator;
  }

  return secondTrySuccess;
}

Boolean RTSPClient::setupMediaSubsession(MediaSubsession& subsession,
                                         Boolean streamOutgoing,
                                         Boolean streamUsingTCP,
                                         Boolean forceMulticastOnUnspecified) {
  char* cmd = NULL;
  char* setupStr = NULL;

  if (fServerIsMicrosoft) {
    // Microsoft doesn't send the right endTime on live streams.  Correct this:
    char *tmpStr = subsession.parentSession().mediaSessionType();
    if (tmpStr != NULL && strncmp(tmpStr, "broadcast", 9) == 0) {
      subsession.parentSession().playEndTime() = 0.0;
    }
  }

  do {
    // Construct the SETUP command:

    // First, construct an authenticator string:
    char* authenticatorStr
      = createAuthenticatorString(&fCurrentAuthenticator,
                                  "SETUP", fBaseURL);

    // When sending more than one "SETUP" request, include a "Session:"
    // header in the 2nd and later "SETUP"s.
    char* sessionStr;
    if (fLastSessionId != NULL) {
      sessionStr = new char[20+strlen(fLastSessionId)];
      sprintf(sessionStr, "Session: %s\r\n", fLastSessionId);
    } else {
      sessionStr = strDup("");
    }

    char* transportStr = NULL;
#ifdef SUPPORT_REAL_RTSP
    if (usingRealNetworksChallengeResponse()) {
      // Use a special "Transport:" header, and also add a 'challenge response'.
      char challenge2[64];
      char checksum[34];
      RealCalculateChallengeResponse(fRealChallengeStr, challenge2, checksum);

      char const* etag = fRealETagStr == NULL ? "" : fRealETagStr;

      char* transportHeader;
      if (subsession.parentSession().isRealNetworksRDT) {
        transportHeader = strDup("Transport: x-pn-tng/tcp;mode=play,rtp/avp/unicast;mode=play\r\n");
      } else {
        // Use a regular "Transport:" header:
        char const* transportHeaderFmt
          = "Transport: RTP/AVP%s%s=%d-%d\r\n";
        char const* transportTypeStr;
        char const* portTypeStr;
        unsigned short rtpNumber, rtcpNumber;
        if (streamUsingTCP) { // streaming over the RTSP connection
          transportTypeStr = "/TCP;unicast";
          portTypeStr = ";interleaved";
          rtpNumber = fTCPStreamIdCount++;
          rtcpNumber = fTCPStreamIdCount++;
        } else { // normal RTP streaming
          unsigned connectionAddress = subsession.connectionEndpointAddress();
          Boolean requestMulticastStreaming = IsMulticastAddress(connectionAddress)
            || (connectionAddress == 0 && forceMulticastOnUnspecified);
          transportTypeStr = requestMulticastStreaming ? ";multicast" : ";unicast";
          portTypeStr = ";client_port";
          rtpNumber = subsession.clientPortNum();
          if (rtpNumber == 0) {
            envir().setResultMsg("Client port number unknown\n");
            break;
          }
          rtcpNumber = rtpNumber + 1;
        }

        unsigned transportHeaderSize = strlen(transportHeaderFmt)
          + strlen(transportTypeStr) + strlen(portTypeStr) + 2*5 /* max port len */;
        transportHeader = new char[transportHeaderSize];
        sprintf(transportHeader, transportHeaderFmt,
                transportTypeStr, portTypeStr, rtpNumber, rtcpNumber);
      }
      char const* transportFmt =
        "%s"
        "RealChallenge2: %s, sd=%s\r\n"
        "If-Match: %s\r\n";
      unsigned transportSize = strlen(transportFmt)
        + strlen(transportHeader)
        + sizeof challenge2 + sizeof checksum
        + strlen(etag);
      transportStr = new char[transportSize];
      sprintf(transportStr, transportFmt,
              transportHeader,
              challenge2, checksum,
              etag);
      delete[] transportHeader;

      if (subsession.parentSession().isRealNetworksRDT) {
        // Also, tell the RDT source to use the RTSP TCP socket:
        RealRDTSource* rdtSource
          = (RealRDTSource*)(subsession.readSource());
        rdtSource->setInputSocket(fInputSocketNum);
      }
    }
#endif

    char const *prefix, *separator, *suffix;
    constructSubsessionURL(subsession, prefix, separator, suffix);
    char* transportFmt;

    if (strcmp(subsession.protocolName(), "UDP") == 0) {
      char const* setupFmt = "SETUP %s%s RTSP/1.0\r\n";
      unsigned setupSize = strlen(setupFmt)
        + strlen(prefix) + strlen (separator);
      setupStr = new char[setupSize];
      sprintf(setupStr, setupFmt, prefix, separator);

      transportFmt = "Transport: RAW/RAW/UDP%s%s%s=%d-%d\r\n";
    } else {
      char const* setupFmt = "SETUP %s%s%s RTSP/1.0\r\n";
      unsigned setupSize = strlen(setupFmt)
        + strlen(prefix) + strlen (separator) + strlen(suffix);
      setupStr = new char[setupSize];
      sprintf(setupStr, setupFmt, prefix, separator, suffix);

      transportFmt = "Transport: RTP/AVP%s%s%s=%d-%d\r\n";
    }

    if (transportStr == NULL) {
      // Construct a "Transport:" header.
      char const* transportTypeStr;
      char const* modeStr = streamOutgoing ? ";mode=receive" : "";
          // Note: I think the above is nonstandard, but DSS wants it this way
      char const* portTypeStr;
      unsigned short rtpNumber, rtcpNumber;
      if (streamUsingTCP) { // streaming over the RTSP connection
        transportTypeStr = "/TCP;unicast";
        portTypeStr = ";interleaved";
        rtpNumber = fTCPStreamIdCount++;
        rtcpNumber = fTCPStreamIdCount++;
      } else { // normal RTP streaming      
        unsigned connectionAddress = subsession.connectionEndpointAddress();
        Boolean requestMulticastStreaming = IsMulticastAddress(connectionAddress)
          || (connectionAddress == 0 && forceMulticastOnUnspecified);
        transportTypeStr = requestMulticastStreaming ? ";multicast" : ";unicast";
        portTypeStr = ";client_port";
        rtpNumber = subsession.clientPortNum();
        if (rtpNumber == 0) {
          envir().setResultMsg("Client port number unknown\n");
          delete[] authenticatorStr; delete[] sessionStr; delete[] setupStr;
          break;
        }
        rtcpNumber = rtpNumber + 1;
      }

      unsigned transportSize = strlen(transportFmt)
        + strlen(transportTypeStr) + strlen(modeStr) + strlen(portTypeStr) + 2*5 /* max port len */;
      transportStr = new char[transportSize];
      sprintf(transportStr, transportFmt,
              transportTypeStr, modeStr, portTypeStr, rtpNumber, rtcpNumber);
    }

    // (Later implement more, as specified in the RTSP spec, sec D.1 #####)
    char* const cmdFmt =
      "%s"
      "CSeq: %d\r\n"
      "%s"
      "%s"
      "%s"
      "%s"
      "\r\n";

    unsigned cmdSize = strlen(cmdFmt)
      + strlen(setupStr)
      + 20 /* max int len */
      + strlen(transportStr)
      + strlen(sessionStr)
      + strlen(authenticatorStr)
      + fUserAgentHeaderStrSize;
    cmd = new char[cmdSize];
    sprintf(cmd, cmdFmt,
            setupStr,
            ++fCSeq,
            transportStr,
            sessionStr,
            authenticatorStr,
            fUserAgentHeaderStr);
    delete[] authenticatorStr; delete[] sessionStr; delete[] setupStr; delete[] transportStr;

    // And then send it:
    if (!sendRequest(cmd, "SETUP")) break;

    // Get the response from the server:
    unsigned bytesRead; unsigned responseCode;
    char* firstLine; char* nextLineStart;
    if (!getResponse("SETUP", bytesRead, responseCode, firstLine, nextLineStart)) break;

    // Look for a "Session:" header (to set our session id), and
    // a "Transport: " header (to set the server address/port)
    // For now, ignore other headers.
    char* lineStart;
    char* sessionId = new char[fResponseBufferSize]; // ensures we have enough space
    unsigned cLength = 0;
    while (1) {
      lineStart = nextLineStart;
      if (lineStart == NULL) break;

      nextLineStart = getLine(lineStart);

      if (sscanf(lineStart, "Session: %[^;]", sessionId) == 1) {
        subsession.sessionId = strDup(sessionId);
        delete[] fLastSessionId; fLastSessionId = strDup(sessionId);

        // Also look for an optional "; timeout = " parameter following this:
        char* afterSessionId
          = lineStart + strlen(sessionId) + strlen ("Session: ");;
        int timeoutVal;
        if (sscanf(afterSessionId, "; timeout = %d", &timeoutVal) == 1) {
          fSessionTimeoutParameter = timeoutVal;
        }
        continue;
      }

      char* serverAddressStr;
      portNumBits serverPortNum;
      unsigned char rtpChannelId, rtcpChannelId;
      if (parseTransportResponse(lineStart,
                                 serverAddressStr, serverPortNum,
                                 rtpChannelId, rtcpChannelId)) {
        delete[] subsession.connectionEndpointName();
        subsession.connectionEndpointName() = serverAddressStr;
        subsession.serverPortNum = serverPortNum;
        subsession.rtpChannelId = rtpChannelId;
        subsession.rtcpChannelId = rtcpChannelId;
        continue;
      }

      // Also check for a "Content-Length:" header.  Some weird servers include this
      // in the RTSP "SETUP" response.
      if (sscanf(lineStart, "Content-Length: %d", &cLength) == 1) continue;
    } 
    delete[] sessionId;

    if (subsession.sessionId == NULL) {
      envir().setResultMsg("\"Session:\" header is missing in the response");
      break;
    }

    // If we saw a "Content-Length:" header in the response, then discard whatever
    // included data it refers to:
    if (cLength > 0) {
      char* dummyBuf = new char[cLength];
      getResponse1(dummyBuf, cLength);
      delete[] dummyBuf;
    }

    if (streamUsingTCP) {
      // Tell the subsession to receive RTP (and send/receive RTCP)
      // over the RTSP stream:
      if (subsession.rtpSource() != NULL)
        subsession.rtpSource()->setStreamSocket(fInputSocketNum,
                                                subsession.rtpChannelId);
      if (subsession.rtcpInstance() != NULL)
        subsession.rtcpInstance()->setStreamSocket(fInputSocketNum,
                                                   subsession.rtcpChannelId);
    } else {
      // Normal case.
      // Set the RTP and RTCP sockets' destination address and port
      // from the information in the SETUP response (if present): 
      netAddressBits destAddress = subsession.connectionEndpointAddress();
      if (destAddress == 0) destAddress = fServerAddress;
      subsession.setDestinations(destAddress);
    }

    delete[] cmd;
    return True;
  } while (0);

  delete[] cmd;
  return False;
}

static char* createScaleString(float scale, float currentScale) {
  char buf[100];
  if (scale == 1.0f && currentScale == 1.0f) {
    // This is the default value; we don't need a "Scale:" header:
    buf[0] = '\0';
  } else {
    Locale("C", LC_NUMERIC);
    sprintf(buf, "Scale: %f\r\n", scale);
  }

  return strDup(buf);
}
      
static char* createRangeString(float start, float end) {
  char buf[100];
  if (start < 0) {
    // We're resuming from a PAUSE; there's no "Range:" header at all
    buf[0] = '\0';
  } else if (end < 0) {
    // There's no end time:
    Locale("C", LC_NUMERIC);
    sprintf(buf, "Range: npt=%.3f-\r\n", start);
  } else {
    // There's both a start and an end time; in