Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

RTSP.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       RTSP.cpp                                                      *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program 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 General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifndef WINCE
#include <fcntl.h>
#endif
#include <assert.h>

#ifndef WIN32
#include <unistd.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#endif

#ifdef WIN32
#ifndef WINCE
#include <sys/timeb.h>
#else
#include <time.h>
#endif
#else   
#include <sys/time.h>
#endif

#include <time.h>

/* included from common-UCL RTP for IOD parsing */
#ifdef WINCE
#include "3rdparty/commonucl/base64.h"
#else
#include "base64.h"
#endif

#include "RTSP.hpp"
#include "global.hpp"
#include "DataChannel.hpp"
#include "ContainerInfo.hpp"
#include "DataSink.hpp"
#include "AudioESInfo.hpp"
#include "VideoESInfo.hpp"
#include "BifsESInfo.hpp"
#include "Url.hpp"
#include "SDP.hpp"
#include "PacketizationLayer.hpp"

#include "../metadata/TerminalCapabilities.hpp"
#include "../metadata/MP21.hpp"

#include "../adaptors/MP4Decoder.hpp"
#include "../io/Rtp.hpp"

const char *const 
RTSP::allowedCommands =
"OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN, GET_PARAMETER, SET_PARAMETER, REDIRECT";
const int RTSP::SL_PAYLOAD_TYPE = 96;
const int RTSP::TTL = 16;

RTSP::RTSP() {
        seqNr = 1;
        lastStatus=0;
        buffer[0]='\0';
        protoID = PROTO_RTSP;
};

bool RTSP::applyReqToSession(const char *buffer, u32 bytesRead,
                                                                                                                 Session * ses) 
{

        // an RTSP command consists of the following parts:
        // $COMMAND $URL RTSP/1.0
        // followed by other lines, depending on $COMMAND
        // followed by \r\n\r\n
        dprintf_full("RTSP::applyReqToSession: Request of size %i\n",
                                                         bytesRead);
        return handleSingleRequest(ses, buffer, bytesRead);

};

bool RTSP::applyReqToSession(const char *buffer, u32 bytesRead,
                                                                                                                 Session * ses, bool optionsCallback)
{
  this->optionsCallback = optionsCallback;
  return applyReqToSession(buffer, bytesRead, ses);
}

bool RTSP::handleSingleRequest(Session * ses, const char *buffer,
                                                                                                                         int bytesRead) 
{

    
        // parse request: DESCRIBE, SETUP, PLAY, PAUSE, OPTIONS
        MSG_Type msgtype = MSG_OPTIONS;
        Url *filename = NULL;
        int cseq = -1;
        const char *remaining=NULL;
        dprintf_full("RTSP::handleSingleRequest size %i\n",bytesRead);
        if (false == parseRequest(buffer,bytesRead,&msgtype,&filename,&cseq,&remaining)) {
                generateBadCMD();
                dprintf_err("RTSP::handleSingleRequest: parse failed, file %s, CSeq %i\r\n",
                                                                (filename ? filename->getPath() : "NULL"), cseq);
                if(filename)
                        delete filename;                                                
                return false;
        }
        //dprintf_full("RTSP::handleSingleRequest Remaining is XXXX\n%s\nXXXX\n",remaining);
        bool ret = true;
        switch (msgtype) {
        case MSG_DESCRIBE:
                ret=ses->connect(filename,remaining);
                break;
        case MSG_SETUP:
                ret=ses->setup(filename,remaining);
                break;
        case MSG_PLAY:
                ret=ses->play(filename,remaining);

                break;
        case MSG_PAUSE:
                ret=ses->pause(filename,remaining);
                break;
        case MSG_TEARDOWN:
                ret=ses->tearDown(0,true,filename,remaining);
                break;
        case MSG_OPTIONS:
                if (optionsCallback == true) {
                        ret = ses->options(filename, remaining);
                } else {
                        generateCMDOptionsReply();ret=true;
                        incSeqNr();
                }
                break;
        case GET_PARAMETER:
                ret= ses->getOptions(filename,remaining);
                break;
        case SET_PARAMETER:
                ret= ses->setOptions(filename,remaining);
                break;
        case MSG_REDIRECT:
                ;
        default:
                generateCMDnotSupportedReply();
                ret=false;
                break;
        };
        delete filename;
        return ret;
};


// parses DESCRIBE and returns the player id
bool RTSP::parseCMDDescribe(Session * ses, const Url *fileName,
                                                                                                                const char *remaining, char** playerId) 
{
  

        dprintf_full("RTSP::parseCMDDescribe: file %s\r\n", fileName->toString());
        const char* lptr=strstr(remaining,"User-Agent:");
        const char* lptrEnd=NULL;
        if(!lptr) {
                (*playerId)=new char[1];
                (*playerId)[0]='\0';
                return true; // INVALID_HEADER???
        }
        lptr+=strlen("User-Agent:");
        while(*lptr==' ') //skip white space
                lptr++;

        lptrEnd=strstr(lptr,"\n"); // goto end of line
        if(!lptrEnd) {
                (*playerId)=new char[1];
                (*playerId)[0]='\0';
                return true; // INVALID_HEADER???
        }
        lptrEnd--;
        while(*lptrEnd=='\r' ||  *lptrEnd==' ')
                --lptrEnd;
        // lptrEnd now points to the last char of the player ID
        *playerId=new char[lptrEnd-lptr+2];
        strncpy(*playerId,lptr,lptrEnd-lptr+1);
        (*playerId)[lptrEnd-lptr+1]='\0';
        return true;

};

bool RTSP::generateCMDDescribeReply(Session * ses, const Url *fileName, const char *sourceServerName, const char* playerId) {

        assert(ses && sourceServerName && fileName);
  ContainerInfo *sao = ses->getContainerInfo();
  char *result = 0;
        Adaptor* a=ses->getSuggestedAdaptor();
        bool perfectHit=(a==NULL);
        if(a)
                delete a;
        a=NULL;
  if (sao) {
                printf("RSTP::generateCMDDescribeReply: +++++++++++++++SAO OK\n");
                // FIXME: support UserPreferences
                if(ses->getTerminalCapabilities()) {
                        // enable rtx only with our player
                        result=SDP::generate(sao, perfectHit,fileName->getPath(), sourceServerName,
                                                                                                         SL_PAYLOAD_TYPE, 16, 8, ses->getTerminalCapabilities(),
                                                                                                         true, ses->getAllRtxGroups());
                }
                else {
                        // FIXED: correct last two params in SDP!!! -> 16,8 copied from MOH code
                        result = SDP::generate(sao, perfectHit, fileName->getPath(), sourceServerName,
                                                                                                                 SL_PAYLOAD_TYPE, 16, 8);
                }
  }
  if (!sao || !result) {
          this->generateFileNotFound();
                lastStatus=NOTFOUND;
                return false;
  } else {
                char *pTmp = new char[MSG_BUFFER_SIZE];
                char *next = pTmp;
                int cnt = 0;
                pTmp[0] = 0;
                char timeNow[30];

                getTimeString(timeNow, 30);

                cnt =   sprintf(next, "Date: %s\r\nExpires: %s\r\n", timeNow,   timeNow);
                next += cnt;
        
                /*              cnt=sprintf(next,"x-Accept-Retransmit: our-retransmit\r\nx-Accept-Dynamic-Rate: 1\r\n");
                                        next+=cnt; */ 
                cnt = sprintf(next, "Content-Base: %s\r\n\r\n", fileName->toString());
                next += cnt;
                sprintf(buffer,
                                                "RTSP/1.0 200 OK\r\nServer: %s\r\nCSeq: %i\r\n"
                                                "Content-Type: application/sdp\r\n" 
                                                //              "Cache-Control: must-revalidate\r\n"
                                                "Content-Length: %i\r\n" 
                                                "%s" "%s\r\n\r\n", SERVER_ID, seqNr, strlen(result) + 4, pTmp,
                                                result);
                lastStatus=OK;
                delete [] pTmp;
        };
        if (result)
                delete result;
        return true;
};    


void RTSP::generateNotImplemented() 
{
    
        buffer[0]=0;
        sprintf(buffer, "RTSP/1.0 501 Not Implemented\r\n\r\n");
};


void RTSP::generateBadCMD() 
{
    
        buffer[0]=0;
        sprintf(buffer, "RTSP/1.0 400 Bad Request\r\nAllow: %s\r\n\r\n",
                                        RTSP::allowedCommands);
};

void RTSP::generateCMDnotSupportedReply() 
{
        buffer[0]=0;
  sprintf(buffer,
                                        "RTSP/1.0 405 Method Not Allowed\r\nCSeq: %i\r\nAllow: %s\r\n\r\n",
                                        seqNr, allowedCommands);
        lastStatus=UNKNOWNCMD;
};

void RTSP::generateFileNotFound()
{
        buffer[0]='\0';
        sprintf(buffer, "RTSP/1.0 404 Not Found\r\nCSeq: %i\r\n\r\n",
                                        seqNr);
        lastStatus=NOTFOUND;

};

void RTSP::generateCMDOptionsReply() 
{
        buffer[0]=0;
        sprintf(buffer, "RTSP/1.0 200 OK\r\nCSeq: %i\r\nPublic: %s\r\n\r\n",
                                        seqNr, allowedCommands);
        lastStatus=OK;
};

void RTSP::generateOk() 
{
        buffer[0]=0;
        sprintf(buffer, "RTSP/1.0 200 OK\r\nCSeq: %i\r\n\r\n",seqNr);
};

void RTSP::generateSessionNotFound() 
{
        buffer[0]=0;
        sprintf(buffer,
                                        "RTSP/1.0 454 Session Not Found\r\nCSeq: %i\r\n\r\n",
                                        seqNr);
        lastStatus=NOTFOUND;
};

void RTSP::generateInternalServerError()
{
        buffer[0]=0;
        sprintf(buffer, "RTSP/1.0 500 Internal Server Error\r\nCSeq: %i\r\n\r\n",seqNr);
};

void RTSP::generateDestUnreachable()
{
        buffer[0]=0;
        sprintf(buffer, "RTSP/1.0 462 Destination unreachable\r\nCSeq: %i\r\n\r\n",seqNr);
};

bool RTSP::parseCMDPlay(Session * ses, const Url *filename,
                                                                                                const char *remaining, int* sessionId, double* startTime, double* endTime, double* maxPrefetch) 
{
        buffer[0]=0;
        char *tmp=NULL;
        assert(remaining && sessionId && startTime && endTime && maxPrefetch);
        // parse remaining to get session key
        *sessionId=this->extractSessionKeyFromCMD(remaining);
        if((unsigned)*sessionId==INVALID_SESSIONID) {
                dprintf_err("RTSP::parseCMDPlay extracted invalid session key\n");
                return false;
        }
        // search for Range: npt=0.000000-519.960000
        *startTime=0.0;
        if ( (tmp=strstr(remaining, "Range:")) != NULL &&
                         (tmp=strstr(tmp,"npt="))!= NULL) {
                tmp+=4;
                dprintf_full("RTSP::parseCMDPlay PARSE String in PLAY: X%sX\r\n",tmp);
                if(1!=sscanf(tmp, "%lf",startTime)) {
                        *startTime=0.0;
                        dprintf_err("RTSP::parseCMDPlay FAILED to get startTime %lf\r\n",*startTime);
                }
                if((tmp=strstr(tmp,"-"))!=NULL) {
                        tmp++; // point after -
                        if(1!=sscanf(tmp, "%lf",endTime)) {
                                *endTime=-1.0;
                                dprintf_err("RTSP::parseCMDPlay FAILED to get endTime %lf\r\n",*endTime);
                        }
                }

        }
        //      x-prebuffer: maxtime=2.000000

        if( (tmp=strstr(remaining, "x-prebuffer:")) &&
                        (tmp=strstr(tmp,"maxtime="))) {
                sscanf(tmp+strlen("maxtime="),"%lf",maxPrefetch);
        }
        else
                *maxPrefetch=0.0;
        dprintf_full("RTSP::parseCMDPlay Session %i start %lf end %lf prefetch %lf\n",
                                                         *sessionId,*startTime,*endTime,*maxPrefetch);
        return true;
};


bool RTSP::parseRequest(const char *request, int len, MSG_Type * msgtype,
                                                                                                Url **filename, int *cseq, const char **remaining) 
{
        dprintf_full("RTSP::parseRequest\r\n");
        *filename=NULL;
        *remaining=NULL;
        *msgtype=MSG_UNKNOWN;
        const char *lptr = request;
        const char *lptrEnd=request;
        char *cpUrl = new char[MAX_STR_LEN];

        if (0 == strncmp("OPTIONS", request,strlen("OPTIONS"))) {
                *msgtype = MSG_OPTIONS;
                lptr+=strlen("OPTIONS");
        }
        else if (0 == strncmp("DESCRIBE", request,strlen("DESCRIBE"))) {
                *msgtype = MSG_DESCRIBE;
                lptr+=strlen("DESCRIBE");
        }
        else if (0 == strncmp("SETUP", request,strlen("SETUP"))) {
                *msgtype = MSG_SETUP;
                lptr+=strlen("SETUP");          
        }
        else if (0 == strncmp("PLAY", request, strlen("PLAY"))) {
                *msgtype = MSG_PLAY;
                lptr+=strlen("PLAY");
        }
        else if (0 == strncmp("PAUSE", request,strlen("PAUSE"))) {
                *msgtype = MSG_PAUSE;
                lptr+=strlen("PAUSE");
        }
        else if (0 == strncmp("TEARDOWN", request,strlen("TEARDOWN"))) {
                *msgtype = MSG_TEARDOWN;
                lptr+=strlen("TEARDOWN");
        }
        else if (0 == strncmp("GET_PARAMETER", request, strlen("GET_PARAMETER"))) {
                *msgtype = GET_PARAMETER;
                lptr+=strlen("GET_PARAMETER");
        }
        else if (0 == strncmp("SET_PARAMETER", request, strlen("SET_PARAMETER"))) {
                *msgtype = SET_PARAMETER;
                lptr+=strlen("SET_PARAMETER");
        }
        while(*lptr==' ')
                lptr++;
        // lptr now points to first of url      
        lptrEnd=strstr( lptr,"RTSP/1.0\r\n");
        if(!lptrEnd || lptr>(request+len) || lptrEnd>(request+len) ) {
                *msgtype=MSG_UNKNOWN;
                dprintf_err("Rtsp::parseRequest: Malformed request\n"); 
                delete [] cpUrl;
                return false;
        }
  
        // now set urlEnd to point to the last char of the url
        const char* urlEnd=lptrEnd;
        urlEnd--;
        while(*urlEnd==' ')
                urlEnd--;

        if(urlEnd<lptr) {
                dprintf_err("Rtsp::parseRequest: invalid url\n");       
                delete [] cpUrl;
                return false;
        }
        
        // now position lptrEnd to the next line
        while(*lptrEnd!='\n')
                lptrEnd++;
        // point after \n
        lptrEnd++;

        int lenStr=urlEnd-lptr+1;
        if(lenStr>MAX_STR_LEN-1)
                lenStr=MAX_STR_LEN-1;
        strncpy(cpUrl,lptr, lenStr);
        cpUrl[lenStr]='\0';

        dprintf_full("RTSP::parseRequest: url %s\r\n",cpUrl);
        *filename=new Url(cpUrl);

        // FIX: OPTIONS only has IP+Port or just a *, no filename!
        if (*msgtype == MSG_OPTIONS) {
                delete [] cpUrl;
                return true;
        }  

        lptr = lptrEnd;
        if (! (*filename)->getPath()) {
                delete *filename;
                *filename=NULL;
                dprintf_err("Rtsp::parseRequest: failed to detect fileName\n");
                delete [] cpUrl;
                return false;
        }
        
        lptr = strstr(lptr, "CSeq: ");
        if (!lptr) {
                dprintf_err("Rtsp::parseRequest: failed to detect Cseq number\n");
                delete [] cpUrl;
                return false;
        }

        const char *lcseq = (lptr += 6);
        while(*lcseq==' ')
                lcseq++;

        if(1!=sscanf(lcseq,"%i",cseq)) {
                delete [] cpUrl;
                return false;
        }

        
        while (*lptr != '\n')
                lptr++;
        lptr++;
        *remaining = lptr;
        if (*remaining <= (request + len)) {
                delete [] cpUrl;
                return true;
        } else {
                delete [] cpUrl;
                return false;
        }
}


int RTSP::generateSessionKey()
{
        int next_key=0;
        int sesKey=0;

#if (defined(WIN32) && !defined(WINCE))
        struct timeb tv;
        ftime(&tv);
        srand48(tv.millitm);
  
#else   /*  */
        struct timeval tv;
        gettimeofday(&tv, 0);
        srand48(tv.tv_usec);
#endif  /*  */

        next_key = lrand48() / 2; // can never generate a number larger than 2 ** 31
        sesKey=next_key++;
        return sesKey;
};

bool RTSP::parseCMDSetup(Session * ses, const Url *fileName,
                                                                                                 const char * const remaining, bool* hasSessionKey, int* sesKey,
                                                                                                 char** protocols, char** unicast,int* esId,int* rPort, int* rPort2,
                                                                                                 bool* hasRtxPort, u32* clientRtxPort, char** clientAddress) 
{
  assert(fileName && remaining && hasSessionKey && sesKey && 
                                 protocols && unicast && esId && rPort && rPort2 && hasRtxPort && 
                                 clientRtxPort);

        buffer[0]=0;
  (*protocols)=(*unicast)=NULL;

        // Quicktime sends: Transport: RTP/ADV;unicast;client_port=6970-6971
        // scan for ;
        const char *lptr=NULL;    
        // create a session identifier
        // QT requests audio & video with the same sessionkey
        // check if SETUP contains Session: %l
        dprintf_full("RTSP::parseCMDSetup:Y%sY\r\n",remaining);
        *hasSessionKey=false;
        lptr=strstr(remaining,"Session:");
        if(lptr) {
                dprintf_full("RTSP::parseCMDSetup: Detected Session key in SETUP\r\n");
                lptr+=strlen("Session:");
                if(1!=sscanf(lptr,"%i",sesKey)) {
                        dprintf_err("RTSP::parseCMDSetup failed to extract sessionkey\r\n");
                }
                else {
                        *hasSessionKey=true;
                }
  }
        else {
                dprintf_full("RTSP::handleCMDSetup: No Session key in SETUP request\r\n");
        }

  
  bool error = false;
  const char* filen=fileName->getPath();
  char *l2 = strchr(filen, '=');
  if (l2) {
                l2++;
                error = (1 != sscanf(l2, "%i", esId));
  } else
                error = true;

  if (error)
                dprintf_err("URL didn't trail with \"=esID\"");

        lptr=strstr(remaining,"Transport:");
        if(lptr) {
                lptr+=strlen("Transport:");
                while(*lptr==' ')
                        lptr++;
                const char* lptrend=strchr(lptr,';');
                if(lptrend) {
                        *protocols=new char[lptrend-lptr+1];
                        strncpy(*protocols,lptr,lptrend-lptr);
                        (*protocols)[lptrend-lptr]='\0';
                }
                else {
                        dprintf_full("RTSP::parseCMDSetup: missing keyword \"Transport:\" in string XXX%sXXX",remaining);
                        lptrend=lptr-1;
                        error=true;
                }

                // now get unicast
                if(strstr(lptr,"unicast")) {
                        *unicast=new char[strlen("unicast")+1];
                        strcpy(*unicast,"unicast");
                }
                else if(strstr(lptr,"multicast")) {
                        *unicast=new char[strlen("multicast")+1];
                        strcpy(*unicast,"multicast");
                }
    
                //get destination address
                if (clientAddress != NULL && (lptrend=strstr(lptr, "destination=")) != NULL) {
                        bool destEndFound = true;
                        const char *destptrend = strstr(lptrend,";");
                        if (destptrend == NULL) {
                                destptrend = strstr(lptrend, "\r\n");
                                if (destptrend == NULL) {
                                        destptrend = strstr(lptrend, "\n");
                                        if (destptrend == NULL) {
                                                destEndFound = false;
                                                dprintf_full("RTSP::parseCMDSetup: cannot find end of destination value!");
                                        }
                                }
                        }
                        
                        if (destEndFound) {
                                uint destlen = destptrend - (lptrend + strlen("destination=")) - 1;
                                *clientAddress = new char[destlen + 1];
                                int i = 0;
                                const char *myptr = lptrend + strlen("destination=");
                                while (myptr != NULL && (*myptr) != ';' && (*myptr) != '\r' && (*myptr) != '\n') {
                                        (*clientAddress)[i++] = *(myptr++);
                                }          
                                (*clientAddress)[i] = '\0';
                                dprintf_full("\nclientAddress = %s\r\n", *clientAddress);
                        }
                } else {
                        dprintf_full("destination parameter not found\n");
                }
    
                // now get client port
                lptrend=strstr(lptr,"client_port=");
                if(lptrend && !error) {
                        error = (2 != sscanf(lptrend, "client_port=%i-%i", rPort, rPort2));

                }
                else {
                        *rPort=*rPort2=0;
                        error=true;
                }
                lptrend=strstr(lptrend,"client_rtx_port=");
                if(lptrend) {
                        lptrend+=strlen("client_rtx_port=");
                        // points after the =
                        *hasRtxPort= (1==sscanf(lptrend,"%u",clientRtxPort));
                }
        }

        // end parsing
        dprintf_full 
                ("RTSP::parseCMDSetup: protocols:>%s< unicast:>%s<ports: %i %i rtxport %u\r\n",
                 *protocols, *unicast, *rPort, *rPort2, *clientRtxPort);
        return !error;
};

void RTSP::generateIllegalTransport()
{
        buffer[0]='\0';
        sprintf(buffer,
                                        "RTSP/1.0 461 Unsupported Transport\r\nCSeq: %i\r\n\r\n",
                                        seqNr);
        lastStatus=ILLEGAL;
}

bool RTSP::isSupportedTransport(const char* protocols)
{
        if (strstr(protocols, "TCP") != NULL)
                return false;

        return true;
};

bool RTSP::isCmdOk(const char* buf)
{
        if( strstr(buf,"RTSP/1.0") && 
                        strstr(buf,"200") &&
                        strstr(buf,"OK"))
                return true;
        return false;
};

bool RTSP::generateSetupReply(Session * ses, const Url *fileName,
                                                                                                                        const int sesKey, const char* protocols, const char* unicast, const char* sourceAddress,
                                                                                                                        const int esId, const int rPort, const int rPort2, const int lPort,
                                                                                                                        const u32 clientRtxPort, const u32 serverRtxPort)
{
        dprintf_full("RTSP::generateSetupReply: Session* %p, const Url* %s,\
                           sesKey %i, protocols %s, unicast %s, sourceAddress %s,\
                                 esId %i, rPort %i, rPort2 %i, lPort %i,\
                                 clientRtxPort %u, serverRtxPort %u\n",
                                                         ses,fileName->toString(),sesKey,protocols,unicast,sourceAddress,esId,rPort,rPort2,
                                                         lPort,clientRtxPort,serverRtxPort);
        assert(ses && fileName && protocols && sesKey>0 && unicast &&
                                 rPort>0 && rPort2>0 && lPort>0 && esId>=0);

 
    
        // first check if a setup was already done
        // if yes, we do not allow changing ports on the fly
        DataChannel * dc = ses->getDataChannel(esId);

  if (dc) {
                sprintf(buffer,
                                                "RTSP/1.0 455 Method Not Valid In This State\r\nCSeq: %i\r\n\r\n",
                                                seqNr);
                lastStatus=ILLEGAL;
                // ses->sendResponse(buffer, strlen(buffer));
                return false;
  }

   
        // FIXME: not sure, but it could be that QuickTime tries to establish a connection to the RTCP port
        // immediately? Don't think so but try it
        // prot->open();
  //  char *ssrc = prot->getSSRC();
    
        // build the response
        //      S->C: RTSP/1.0 200 OK
        //          CSeq: 302
        //          Date: 23 Jan 1997 15:35:06 GMT
        //          Session: 47112344
        //          Transport: RTP/AVP;unicast;
        //            client_port=4588-4589;server_port=6256-6257
  char timeStr[30];


  int offset=0;  

  if (getTimeString(timeStr, 30)) {
        
                // delete lt; NOT allowed to do that, statically stored internally in localtime
          dprintf_full("RTSP::handleCMDSetup: timeString: %s\r\n",
                                                                 timeStr);
                offset= sprintf(buffer,
                                                                                "RTSP/1.0 200 OK\r\nCSeq: %i\r\nServer: %s\r\n"  
                                                                                "Last-Modified: %s\r\nCache-Control: must-revalidate\r\n"
                                                                                "Session: %i\r\n" "Date: %s\r\nExpires: %s\r\n" 
                                                                        //      "Transport: %s;%s;client_port=%i-%i;source=%s;server_port=%i-%i",
                                                                                "Transport: %s;%s;client_port=%i-%i;server_port=%i-%i",
                                                                                seqNr, SERVER_ID, timeStr, sesKey, timeStr, timeStr, protocols,
                                                                                unicast, rPort, rPort2, /*sourceAddress,*/ lPort, lPort + 1);

  } else {
                dprintf_small("RTSP::handleCMDSetup: no time set\r\n");
                offset=sprintf(buffer, "RTSP/1.0 200 OK\r\nCSeq: %i\r\n" 
                                                                         "Last-Modified: %s\r\nCache-Control: must-revalidate\r\n"
                                                                         "Session: %i\r\n" 
                                                                //       "Transport: %s;%s;client_port=%i-%i;source=%s;server_port=%i-%i",
                                                                         "Transport: %s;%s;client_port=%i-%i;server_port=%i-%i",
                                                                         seqNr, timeStr, sesKey, protocols, unicast, rPort,
                                                                         rPort2, /*sourceAddress,*/ lPort, lPort + 1);
  }

        if(clientRtxPort>0 && serverRtxPort>0) {
                sprintf( (buffer+offset),
                                                 ";client_rtx_port=%u;server_rtx_port=%u\r\n\r\n",
                                                 clientRtxPort,
                                                 serverRtxPort);
        }
        else {
                sprintf( (buffer+offset), "\r\n\r\n");
        }
        lastStatus=OK;

  return true;
};

int RTSP::extractSessionKeyFromCMD(const char* remaining)
{
        char *tmp=NULL;
        int key;
  if ( ((tmp=strstr(remaining, "Session:")) == NULL) ||
                         (sscanf(tmp,"%*s %i",&key) != 1) ) {
                dprintf_err("Session Tag %i [%s] not found\n",key,tmp);
                key=INVALID_SESSIONID;
        }
        return key;
};

/*
        void RTSP::handleCMDPause(Session * ses, const Url *fileName,
        const char *remaining) 
        {
 

        };
*/

ContainerInfo * RTSP::parseResponseDescribe(const char *response, const char *url, char** serverName,
                                                                                                                                                                                        list<rtx_group*> *groups) 
{
        assert( response && url && serverName);
        // check if it is really an ok message
        if(!strstr(response,"RTSP/1.0 200 OK"))
                return NULL;

        const char* serverBegin=strstr(response,"Server:");
        if(serverBegin) {
                serverBegin+=strlen("Server:");
                while(*serverBegin==' ')
                        serverBegin++;
                const char* serverEnd=strstr(serverBegin,"\r\n");
                if(serverEnd) {
                        *serverName=new char[serverEnd-serverBegin+1];
                        strncpy(*serverName,serverBegin,serverEnd-serverBegin);
                        (*serverName)[serverEnd-serverBegin]='\0';
                        dprintf_full("RTSP::parseResponseDescribe extracted serverName %s\n",*serverName);
                }
                else
                        *serverName=NULL;
        }
        else
                *serverName=NULL;

        ContainerInfo * mp4Info = new ContainerInfo(url, NULL, ContainerInfo::SDP);

        // search rtx_groups
        if(groups) {
                const char* grp=response;
                while( (grp=strstr(grp,"a=group:FID"))!=NULL ) {
                        rtx_group* group=new rtx_group(NACK,0);
                        grp+=strlen("a=group:FID");
                        if(2!=sscanf( grp,
                                                                                "%u %u",
                                                                                &(group->midESInfo), &(group->rtx->mId))) {
                                delete group;
                        }
                        else {
                                dprintf_full("RTSP::parseResponseDescribe found rtx group: mid %u midES %u\n",
                                                                                 group->rtx->mId,group->midESInfo);
                                groups->push_back(group);
                        }
                }
        }
        // we have created the groups

        // extract iod
  const char *iod = strstr(response, "mpeg4-iod:");
  iod = strstr(iod, "base64,");
  if (iod) {
                iod += 7;               // points to first char of iod
                // iod ends with ", there shouldn't be any space within the IOD
                //  but there can be a \n!
                const char *temp2 = strchr(iod, '"');
                int iodSizeEncoded = temp2 - iod;
                u8 iodHandle[MAX_IOD_SIZE];
                
                //decode
                //              int iodenclen = str_base64((char*)iod, iodSizeEncoded, iodHandle, MAX_IOD_SIZE, STR_BASE64_DECODE);
                int iodenclen = base64decode((unsigned char*)iod, iodSizeEncoded, iodHandle, MAX_IOD_SIZE);

                if (iodenclen <= 0) { //wrong or no IOD
                        dprintf_err("RTSP::parseResponseDescribe: there was a wrong/empty IOD given... ignoring...\n");
                } else
                        // set decoded IOD
                        mp4Info->setIODHandle(iodHandle, iodenclen);
  }
        // search for a=range:npt=0-  66.47000
        double durSeconds=0;
        
        const char* temp2=strstr(response,"range:");
        if(temp2) {
                temp2=strstr(temp2,"-");
                if(temp2) {
                        temp2++;
                        sscanf(temp2,"%lf",&durSeconds);
                }
        }
        const char* media=NULL;
        const char* endOfMedia=NULL;
        const char* copy=response;

        // search media blocks
        // media blocks begin with m=
  while ((media = strstr(copy, "\nm=")) != NULL) {

          //media now points to first m=
          media += 3;
                copy = media;
                endOfMedia = strstr(copy, "\nm=");
                if (!endOfMedia) {              
                        // set to end of sdp desc.
                        endOfMedia = media + strlen(media);
                }

                // we can have two different media blocks
                // one normal one which describes the media
                // or one rtx transmission block
                // detect this by searching "rtx"
                const char* pRtx=strstr(media,"rtx");
                if(pRtx > media && pRtx < endOfMedia) {
                        // we have a rtx entry
                        // should we ignore it ?
                        if(groups)
                                parseSDP_RTXBlock(media,endOfMedia,groups);
                }
                else {
                        ESInfo* es=parseSDPMediaBlock(media,endOfMedia,
                                                                                                                                                durSeconds,mp4Info,groups);
                        if(es) {
                                // add es to mp4info
                                es->enableFrameStatistic();
                                mp4Info->addESInfo(es);
                        }
                        else {
                                delete mp4Info;
                                return NULL;
                        }
    }
        }

  return mp4Info;
};

void RTSP::parseSDP_RTXBlock(const char* media,
                                                                                                                 const char* endOfMedia, 
                                                                                                                 list<rtx_group*> *groups) 
{
        //m=video 0 RTP/AVPF 99
        //a=rtpmap:99 rtx/32000
        //a=fmtp:99 apt=98;rtx-time=3000
        //a=mid:4

        if(!groups)
                return;
        if(groups->empty())
                return;

        // we extract mid, rtx_time, ticks and payload
        u32 mid=0;
        u32 rtxDelay=0;
        u32 ticks=0;
        u32 payload=0;

        const char* pMedia=strstr(media,"a=rtpmap:");
        if(pMedia>media && pMedia<endOfMedia) {
                pMedia+=strlen("a=rtpmap:");
                if(2!=sscanf(pMedia,"%u rtx/%u",&payload,&ticks)) {
                        dprintf_err("RTSP::parseSDP_RTXBlock failed (ticks)\r\n");
                        return;
                }
        }
        pMedia=strstr(media,"rtx-time=");
        if(pMedia>media && pMedia<endOfMedia) {
                pMedia+=strlen("rtx-time=");
                if(1!=sscanf(pMedia,"%u",&rtxDelay)) {
                        dprintf_err("RTSP::parseSDP_RTXBlock err in rtxDelay\r\n");
                        return;
                }
        }
        pMedia=strstr(media,"a=mid:");
        if(pMedia>media && pMedia<endOfMedia) {
                pMedia+=strlen("a=mid:");
                if(1!=sscanf(pMedia,"%u",&mid)) {
                        dprintf_err("RTSP::parseSDP_RTXBlock err in mid\r\n");
                        return;
                }
        }
        // got all that is necessary

};

ESInfo* RTSP::parseSDPMediaBlock(       const char* media,
                                                                                                                                        const char* endOfMedia, 
                                                                                                                                        const double durSeconds,
                                                                                                                                        ContainerInfo * mp4Info,
                                                                                                                                        list<rtx_group*> *groups) 
{
        /*
                m=video 0 RTP/AVP 96
                b=AS:1067
                a=rtpmap:96 MP4V-ES/90000
                a=control:trackID=1
                a=cliprect:0,0,352,288
                a=fmtp:96 profile-level-id=1;config=000001010000012000C888800F50B042414183
                a=mpeg4-esid:1
                a=aspect-ratio=1.3333
        */ 

        const char *temp = NULL;
        const char *copy = media;
        // normal media block
        // now determine type of stream
        // Example: m=video 0 RTP/AVP 96
        //          m=audio 0 RTP/AVP 97
        //          m=application 0 RTP/AVP 98
        //          %s %i %s %i
        u32 handlerType = 0;
        char *handlerString = new char[50];
        char *transportString = new char[40];
        int rtpPayload = -1;
        int avg_bw = -1;
        int dummy = -1;;
        int trackId=-1;
        bool err=false;
        handlerString[0] = 0;
        transportString[0] = 0;
        sscanf(copy, "%s %i %s %i", handlerString, &dummy,
                                 transportString, &rtpPayload);
        dprintf_full("RTSP::parseSDPMediaBlock  handler is %s\n",handlerString);
        if (strcmp(handlerString, "video") == 0) {
                handlerType = MP4VisualHandlerType;
        }
        else if (strcmp(handlerString, "audio") == 0) {
                handlerType = MP4AudioHandlerType;
        }       
        else if (strcmp(handlerString, "application") == 0) {                           
                // PROBLEM: SDP doesn't make a difference between BIFS or OD
                // most servers don't even describe these two streams in SDP
                // FIXME:
                handlerType = MP4SceneDescriptionHandlerType;
        }

        const char *pBW = strstr(media,"b=AS:");
        sscanf(pBW+strlen("b=AS:"), "%i",&avg_bw);
        avg_bw *= 1024; // bit/sec

        // we ignore payload & transport for now
        
        // now search for possible rtx feedback
        // a=rtcp-fb:%i nack
        // a=mid:3
        u32 mid=0;
        if(groups && !groups->empty()) {
                const char * pMid=strstr(media,"a=mid:");
                char ackType[20];
                ackType[0]=0;
                
                if(pMid>media && pMid<endOfMedia) {
                        // a valid entry
                        sscanf( (pMid+strlen("a=mid:")),"%u",&mid);
                }
                pMid=strstr(media,"a=rtcp-fb:");
                if(pMid) {
                        pMid+=strlen("a=rtcp-fb:");
                        // skip over the number, read ACK-Type
                        sscanf(pMid,"%*s %s",ackType);
                }
                if(mid>0 && strlen(ackType)>0) {
                        // search the group 
                        list<rtx_group*>::iterator li=groups->begin();
                        bool stop=false;
                        while(li!=groups->end() && !stop) {
                                if( (*li)->midESInfo==mid) {
                                        // found the group, now set the state
                                        for(int r=0;r<(int)LAST_RTX_STATE && !stop;r++) {
                                                if(strcmp(sRTXState[r],ackType)==0) {
                                                        (*li)->rtx->state=(RTXState)r; 
                                                        stop=true;
                                                }
                                        }
                                }
                                ++li;
                        }
                }
        }

        // now get ticks: a=rtpmap:96 MP4V-ES/90000
        u32 ticksPerSec=90000; //default
        temp=strstr(media,"rtpmap:");
        if(temp != NULL && temp<endOfMedia) {
                //search for /
                temp=strstr(temp,"/");
                if(temp) {
                        temp++;
                        if(1!=sscanf(temp,"%ui",&ticksPerSec))
                                ticksPerSec=90000;
                }
        }

        u64 durTicks=(u64) (durSeconds*ticksPerSec);

        //now extract streamid
        // Example:     a=control:trackId=3
        temp = strstr(media, "control:");
        trackId=-1;
        if(temp != NULL && temp<endOfMedia) {
                temp=strstr(temp,"=");
                
                if(temp) {
                        temp++;
                        if(1!=sscanf(temp,"%i",&trackId))
                                trackId=-1;
                }
        }
        if(trackId<0)
                err=true;

        /* Extract Rest:
                 a=cliprect:0,0,352,288 //optional
                 a=fmtp:96 profile-level-id=1;config=000001010000012000C888800F50B042414183
        */
        int width=0;
        int height=0;
        temp=strstr(media,"cliprect:");
        if(temp!=NULL && temp<endOfMedia) {
                temp+=strlen("cliprect:");
                sscanf(temp,"%*i,%*i,%i,%i",&width,&height);
        }
        // now get the config
        u8* encodedDecConf=NULL;
        temp=strstr(media,"config=");
        if(temp!=NULL && temp<endOfMedia) {
                temp+=strlen("config=");
                char* tmp2=strstr(temp,"\r");
                if(tmp2==NULL)
                        tmp2=strstr(temp,"\n");

                encodedDecConf=new u8[(tmp2-temp)+1];
                
                strncpy((char*)encodedDecConf,temp,(tmp2-temp));
                encodedDecConf[(tmp2-temp)]=0;
        }

        if(encodedDecConf==NULL)
                err=true;
        if(err) {
                delete [] handlerString;
                delete [] transportString;
                return NULL;
        }

        // now get the aspect ratio
        float ratio=1.0;
  temp=strstr(media,"aspect-ratio=");
        if(temp!=NULL && temp<endOfMedia) {
                temp+=strlen("aspect-ratio=");
                sscanf(temp,"%f",&ratio);
                dprintf_full("RTSP::parseSDPMediaBlock got aspect ratio %6.4f\n",ratio);
        }
        // get frame pattern
        char fpTemp[32];
        bool staticFramePattern=true;
        u32 gopSize=50;
        u32 numBFrames=0;
        temp=strstr(media,"frame-pattern=");
        if(temp!=NULL && temp<endOfMedia) {
                temp+=strlen("frame-pattern=");
                sscanf(temp,"%31s",fpTemp);
                if(strstr(temp,"dynamic"))
                        staticFramePattern=false;
        }
        float bfrmamount=0.0f;
        temp=strstr(media,"bframesamount=");
        if(temp!=NULL && temp<endOfMedia) {
                temp+=strlen("bframesamount=");
                if(1!=sscanf(temp,"%f",&bfrmamount))
                        bfrmamount=0.2f;

        }
        if(staticFramePattern) {
                // extract num-bframes
                temp=strstr(media,"num-bframes");
                if(temp!=NULL && temp<endOfMedia) {
                        temp+=strlen("num-bframes");
                        sscanf(temp," %u",&numBFrames);
                }

                // extract gop-size
                temp=strstr(media,"gop-size");
                if(temp!=NULL && temp<endOfMedia) {
                        temp+=strlen("gop-size");
                        if(1!=sscanf(temp," %u",&gopSize))
                                gopSize=50;
                }
        }
        dprintf_full("RTSP::parseSDPMediaBlock got %s frame pattern, gopsize: %u, bframes: %u\n",
                                                         staticFramePattern?"STATIC":"DYNAMIC",gopSize,numBFrames);
        /*      VideoESInfo(u32 streamId, u32 streamtype, ContainerInfo * vob, u32 timeIncrement,
                                 u8 * encodeddecconf, u32 objtype, u32 bufsize,
                                 u32 avgBW, u32 maxBW, u32 timeScale,
                                 u64 duration, u32 size,  
                                 u32 w, u32 h, bool colorVideo,
                                 bool complete=true, 
                                 CodecID codec_id = CODEC_ID_MPEG4, float quality = 1.0,
                                 float aspect_ratio = 352/288, u32 GOP_size = 50, 
                                 u32 num_B_frames = 0);
        */
        // FIXME: we hardcode to 3000 ticks!!!!!! we fix that in IO (HACK) 
        // FIXME: we hardcode 100000 as size...
        ESInfo* es=NULL;
        if(avg_bw<=0 && (es->isVisualStream() || es->isAudioStream())) {
                // FIXME: assume 256000 bit
                if(es->isVisualStream())
                        avg_bw=256000;
                else if(es->isAudioStream())
                        avg_bw=128000;
                dprintf_err("RTSP.parseSDPMediaBlock: No avg Bandwidth found\n");
        }
        if(handlerType==MP4VisualHandlerType) {
                es=new VideoESInfo(trackId, 0,
                                                                                         mp4Info,3000, encodedDecConf,0,0,
                                                                                         avg_bw, avg_bw, ticksPerSec,
                                                                                         durTicks,100000,width,height,true,false,
                                                                                         CODEC_ID_MPEG4,1.0, //default values
                                                                                         ratio,staticFramePattern,gopSize,numBFrames,bfrmamount);
        }
        else if(handlerType==MP4AudioHandlerType) {
                // FIXME: we hardcode to 48000hz and 2 channels
                es=new AudioESInfo(trackId, 0,
                                                                        mp4Info,3000, encodedDecConf,0,0,
                                                                        avg_bw, avg_bw, ticksPerSec,
                                                                        durTicks,100000,48000,2,false);
        }
        else if(handlerType==MP4SceneDescriptionHandlerType) {
                es=new BifsESInfo(trackId, 0,
                                                                        mp4Info,3000, encodedDecConf,0,0,
                                                                        avg_bw, avg_bw, ticksPerSec,
                                                                        durTicks,10000,false);
        }

        // now link the ES into the rtx_group
        if(groups && !groups->empty()) {
                list<rtx_group*>::iterator gi=groups->begin();
                while(gi!=groups->end()) {

                        if( (*gi)->midESInfo==mid) {
                                (*gi)->es=es;
                                gi=groups->end();
                        }
                        else
                                ++gi;
                }
        }
        
        delete [] handlerString;
        delete [] transportString;
        return es;
};

/*
        DESCRIBE rtsp://143.205.122.43:80/sample_300kbit.mp4 RTSP/1.0
        CSeq: 1
        Accept: application/sdp
        User-Agent: QTS (qtver=6.0;os=Windows NT 5.0Service Pack 2)
*/
void RTSP::generateDescribeForUrl(const char* url, const char* playerID, const TerminalCapabilities* tc,const UserPreferences* up) {
        assert(url);
        int bufferOffset=0;
        buffer[0]=0;
        bufferOffset = sprintf(buffer,"DESCRIBE %s RTSP/1.0\r\nCSeq: %i\r\n"
                                                                                                 "Accept: application/sdp\r\n"
                                                                                                 "User-Agent: %s\r\n"
                                                                                                 ,url,seqNr,playerID);

        char* tcd=NULL;
        if(up) {
                char* upd=MP21::generateUserPreferencesDescription(up);
                int updlength=strlen(upd)+4;
                bufferOffset += sprintf(buffer+bufferOffset,
                                                                                                                "Content-Type: application/mpeg21_dia\r\n"
                                                                                                                "Content-Length: %i\r\n%s\r\n\r\n",updlength,upd);
        }
        else if(tc) {
                tcd=MP21::generateTerminalCapabilityDescription(tc);
                int tcdLength=strlen(tcd)+4;
                bufferOffset += sprintf(buffer+bufferOffset,
                                                                                                                "Content-Type: application/mpeg21_dia\r\n"
                                                                                                                "Content-Length: %i\r\n%s\r\n\r\n",tcdLength,tcd);
        }
        else
                sprintf(buffer+bufferOffset,"\r\n");
};

/*      
        SETUP rtsp://143.205.122.43:80/sample_300kbit.mp4/trackID=3 RTSP/1.0
        CSeq: 2
        Transport: RTP/AVP;unicast;client_port=6970-6971;client_rtx_port=6972
*/
void RTSP::generateSetup(const char* url, int trackId, int clientPort,bool unicast,u32 rtxPort,int sessionId) 
{
        assert(url && trackId>=0 && clientPort>0);
        buffer[0]=0;
        char* mcast[]={"multicast","unicast"};

        if(rtxPort==0) {
                if(sessionId<=0) {
                        sprintf(buffer,"SETUP %s/trackID=%i RTSP/1.0\r\n"
                                                "CSeq: %i\r\n"
                                                "Transport: RTP/UDP;%s;client_port=%i-%i\r\n\r\n",
                                                url,trackId,
                                                seqNr,
                                                mcast[unicast ? 1 :0],clientPort,clientPort+1);
                }
                else {
                        sprintf(buffer,"SETUP %s/trackID=%i RTSP/1.0\r\n"
                                                "CSeq: %i\r\n"
                                                "Session: %i\r\n"
                                                "Transport: RTP/UDP;%s;client_port=%i-%i\r\n\r\n",
                                                url,trackId,
                                                sessionId,
                                                seqNr,
                                                mcast[unicast ? 1 :0],clientPort,clientPort+1);
                }
        }
        else {
                if(sessionId<=0) {
                        sprintf(buffer,"SETUP %s/trackID=%i RTSP/1.0\r\n"
                                                "CSeq: %i\r\n"
                                                "Transport: RTP/UDP;%s;client_port=%i-%i;client_rtx_port=%u\r\n\r\n",
                                                url,trackId,
                                                seqNr,
                                                mcast[unicast ? 1 :0],clientPort,clientPort+1,rtxPort);
                }
                else {
                        sprintf(buffer,"SETUP %s/trackID=%i RTSP/1.0\r\n"
                                                "CSeq: %i\r\n"
                                                "Session: %i\r\n"
                                                "Transport: RTP/UDP;%s;client_port=%i-%i;client_rtx_port=%u\r\n\r\n",
                                                url,trackId,
                                                sessionId,
                                                seqNr,
                                                mcast[unicast ? 1 :0],clientPort,clientPort+1,rtxPort);
                }
        }
};

void RTSP::generatePlay(const char* url, u32 session, double start, double nptEnd, double maxPrefetch) {
        assert(url);
        buffer[0]=0;

        sprintf(buffer, "PLAY %s RTSP/1.0\r\n"
                                        "CSeq: %i\r\n"
                                        "Session: %i\r\n"
                                        "x-prebuffer: maxtime=%lf\r\n"
                                        "Range: npt=%lf-%lf\r\n\r\n",
                                        url,seqNr,session,maxPrefetch,start,nptEnd);
        dprintf_full("RTSP::generatePlay: %s\n",buffer);
};

/*
        PAUSE rtsp://143.205.122.43:80/sample_300kbit.mp4 RTSP/1.0
        CSeq: 4
        Session: 12345678
*/
void RTSP::generatePause(const char* url, u32 session) {
        assert(url);
        buffer[0]=0;
        sprintf(buffer, "PAUSE %s RTSP/1.0\r\n"
                                        "CSeq: %i\r\n"
                                        "Session: %u\r\n\r\n",
                                        url,seqNr,session);
};

/*
        TEARDOWN rtsp://143.205.122.43:80/sample_300kbit.mp4 RTSP/1.0
        CSeq: 5
        Session: 12345678
*/
void RTSP::generateTeardown(const char* url, u32 session) {
        assert(url);
        buffer[0]=0;
        sprintf(buffer, "TEARDOWN %s RTSP/1.0\r\n"
                                        "CSeq: %i\r\n"
                                        "Session: %u\r\n\r\n",
                                        url,seqNr,session);
};

/*
        RTSP/1.0 200 OK
        Server: DSS/4.1.1 (Build/412.36; Platform/Win32)
        CSeq: 2
        Last-Modified: Fri, 05 Jul 2002 15:20:14 GMT
        Cache-Control: must-revalidate
        Session: 53034256198111
        Date: Mon, 09 Sep 2002 13:04:48 GMT
        Expires: Mon, 09 Sep 2002 13:04:48 GMT
        Transport: RTP/AVP;unicast;client_port=6970-6971;source=143.205.122.43;server_port=6970-6971;ssrc=00002908
*/
int RTSP::parseResponseSetup(const char* buffer, int *sessionID, int *clientPort,
                                                                                                                 int *serverPort,bool *unicast, char** ssrc,
                                                                                                                 rtx_info* info) {

        if(!strstr(buffer,"RTSP/1.0 200 OK"))
                return 0;
        *ssrc=NULL;
        const char* pBuffer=NULL;
        int retVal=5;
        if(strstr(buffer,"multicast"))
                *unicast=false;
        else
                *unicast=true;

        pBuffer=strstr(buffer,"Session: ");
        if(pBuffer)
                sscanf(pBuffer,"%*s %i",sessionID);
        else {
                dprintf_err("RTSP.parseResponseSetup: no sessionID found???\n");
                return 0;
        }
        pBuffer=strstr(buffer,"client_port=");
        if(pBuffer) {
                pBuffer+=strlen("client_port=");
                if(1!=sscanf(pBuffer,"%i",clientPort))
                        return 0;
        }
        pBuffer=strstr(buffer,"server_port=");
        if(pBuffer) {
                pBuffer+=strlen("server_port=");
                if(1!=sscanf(pBuffer,"%i",serverPort))
                        return 0;
        }
        // scan for ssrc
        pBuffer=strstr(buffer,"ssrc=");
        if(pBuffer) {
                pBuffer+=strlen("ssrc=");
                *ssrc=new char[9];
                strncpy(*ssrc,pBuffer,8);
                (*ssrc)[8]='\0';
        }
        else
                retVal--;
        
        // check for rtx, rtx is not a must-param, so exclude it from retval
        if(info) {
                u32 rtxSPort=0;
                u32 rtxCPort=0;
                pBuffer=strstr(buffer,"server_rtx_port=");
                if(pBuffer) {
                        sscanf( (pBuffer+strlen("server_rtx_port=")),
                                                        "%u",&rtxSPort);
                }
                pBuffer=strstr(buffer,"client_rtx_port=");
                if(pBuffer) {
                        sscanf( (pBuffer+strlen("client_rtx_port=")),
                                                        "%u",&rtxCPort);
                }
                info->localPort=rtxCPort;
                info->remotePort=rtxSPort;
        }
        return retVal;

};


/* parses @param buffer for a sessionid returns INVALID_SESSIONID
 * if none is found 
 */
u32 RTSP::extractSessionId(const char* buffer)
{
        u32 sesKey=INVALID_SESSIONID;
        if(buffer==NULL)
                return sesKey;

        const char* lptr=strstr(buffer,"Session:");             
        if(lptr) {
                dprintf_full("RTSP::extractSessionId: Detected Session key in SETUP\r\n");
                lptr+=strlen("Session:");
                if(1!=sscanf(lptr,"%u",&sesKey)) {
                        dprintf_small("RTSP::extractSessionId: malformed RTSP request\n%s\r\n",buffer);
                }
  }
        return sesKey;
};

/* searches for the sessionId in @param buffer
 * if none is found @param return is NULL, otherwise a new string
 * is created with the new sessionid 
 */
char* RTSP::replaceSessionIdWith(u32 newId,const char* buffer) 
{
        if(newId==INVALID_SESSIONID || buffer==NULL)
                return NULL;
        int newSize=strlen(buffer)+10; // approx. ;-)

        const char* lptr=strstr(buffer,"Session:");     
        if(lptr==NULL)
                return NULL;

        char* result=new char[newSize];
        lptr+=strlen("Session:");
        // copies till (+incl.) Session:
        strncpy(result,buffer,lptr-buffer); 
        // now add the new SessionId
        sprintf(result+(lptr-buffer)," %u\r\n",newId);
        lptr=strstr(lptr,"\n");
        if(!lptr) {
                // should never happen
                dprintf_small("RTSP::replaceSessionIdWith: malformed RTSP request\n%s\r\n",buffer);
                delete result;
                return NULL;
        }
        lptr++; // point after \n
        // just add the rest of the command
        strcat(result,lptr);
        return result;
};

/*
        SET_PARAMETER rtsp://example.com/fizzle/foo RTSP/1.0
        CSeq: 421
        Content-length: 20
        Session: 12345678 // Fixme: missing in standard??? no session???
        Content-type: text/parameters

        barparam: barstuff
*/
void RTSP::generateSetParameter(const char* url, u32 session,
                                                                                                                                std::map<char*, char*, struct stringCompare>* params)
{
        assert(url && session>0 && params && params->size()>0);
        char *tmp = new char[MSG_BUFFER_SIZE];
        int offset=0;
        buffer[0]='\0';
        tmp[0]='\0';

        std::map<char*, char*, struct stringCompare>::iterator li;
        for(li=params->begin();li!=params->end();++li) {
                offset+=sprintf(tmp+offset,"%s: %s\r\n",(*li).first, (*li).second);
        }
        
        offset+=sprintf(tmp+offset,"\r\n");
        offset+=2;
        sprintf(buffer+strlen(buffer),  "SET_PARAMETER %s RTSP/1.0\r\n"
                                        "CSeq: %i\r\n"
                                        "Session: %u\r\n"
                                        "Content-length: %i\r\n"
                                        "Content-type: text/parameters\r\n\r\n",
                                        url,seqNr,session,offset);
        strcat(buffer,tmp);
        delete [] tmp;
};

/* GET_PARAMETER rtsp://example.com/fizzle/foo RTSP/1.0
         CSeq: 431
         Content-Type: text/parameters
         Session: 12345678
         Content-Length: 15

         packets_received
         jitter
*/
void RTSP::generateGetParameter(const char* url, const u32 session,
                                                                                                                                const int numParams, const char** params)
{
        // zero params are legal
        assert(url && numParams>=0 && session>0);
        buffer[0]=0;
        if(numParams==0) {
                sprintf(buffer,"GET_PARAMETER %s RTSP/1.0\r\nCSeq: %i\r\nSession: %u\r\n\r\n",
                                                url,seqNr,session);
                return;
        }

        // calc content-length
        u32 length=0;
        int i=0;
        for(i=0;i<numParams;i++)
                length+=(strlen(params[i])+2); //add \r\n
        if(length>0)
                length+=strlen("\r\n\r\n");
        
        int sz=sprintf(buffer,"GET_PARAMETER %s RTSP/1.0\r\n"
                                                                 "CSeq: %i\r\n"
                                                                 "Content-Type: text/parameters\r\n"
                                                                 "Session: %u\r\n",
                                                                 url,seqNr,session);
        if(length>0 && sz>0) {
                sz+=sprintf(buffer+sz,"Content-Length: %u\r\n\r\n",length);
                for(i=0;i<numParams;i++)
                        sz+=sprintf(buffer+sz,"%s\r\n",params[i]);
        }
        strcat(buffer,"\r\n");
        
};

void RTSP::parseGetParameter(const char* request, u32* session,int* numParams, char*** params)
{
        assert(session && numParams && params);
        *session=0;
        *numParams=0;
        *params=NULL;
        const char* lptr=NULL;
        u32 length=0;
        lptr=strstr(request,"Session:");
        if(lptr) {
                lptr+=strlen("Session:");
                while(*lptr==' ')
                        lptr++;
                sscanf(lptr,"%u",session);
        }
        lptr=strstr(request,"Content-Length:");
        if(lptr) {
                lptr+=strlen("Content-Length:");
                while(*lptr==' ')
                        lptr++;
                sscanf(lptr,"%u",&length);
        }
        if(lptr && length>0) {
                // count \r\n to determine numParams
                const char* tptr=lptr;
                int p=0;
                while((tptr=strstr(tptr,"\r\n"))!=NULL) {
                        p++;
                        tptr+=2;
                }
                p-=3; // one \r\n from prev line, one empty line before + one after
                *numParams=p;
                *params=new char*[p];
                // now extract single params
                tptr=lptr;
                p=0;
                while((tptr=strstr(tptr,"\r\n"))!=NULL) {
                        if((tptr-lptr)>2) {
                                // not an empty line
                                (*params)[p]=new char[tptr-lptr+1];
                                strncpy((*params)[p],lptr,tptr-lptr);
                                (*params)[p][tptr-lptr]='\0';
                                dprintf_full("RTSP::parseGetParameter found param %s\n",(*params)[p]);
                                p++;
                        }
                        lptr=(tptr+=2); // next line
                }
        }
};
/*
        SET_PARAMETER rtsp://example.com/fizzle/foo RTSP/1.0
        CSeq: 421
        Content-length: 20
        Session: 12345678 // Fixme: missing in standard??? no session???
        Content-type: text/parameters

        barparam: barstuff
*/
void RTSP::parseSetParameter(const char* remaining, u32* session,std::map<char*, char*, struct stringCompare>* params)
{
        assert(remaining && session && params);
        *session=0;
        const char* lptr=strstr(remaining,"Session:");
        if(lptr) {
                lptr+=strlen("Session:");
                while(*lptr==' ')
                        ++lptr;
                sscanf(lptr,"%u",session);
        }
        // no session could be valid, so continue always
        lptr=strstr(remaining,"Content-type:");
        if( !(lptr && (lptr=strstr(lptr,"text/parameters")))) {
                dprintf_full("RTSP::parseSetParameter illegal content: X%sX\n",remaining);
                return;
        }
        // lptr points to text/..
        lptr=strstr(lptr,"\r\n");
        if(lptr)
                lptr+=2;
        else
                return;

        remaining=lptr;
        while((lptr=strstr(lptr,"\r\n")) != NULL) {
                if(lptr-remaining>2) {
                        // we have a line starting with remaining
                        // ending at pos lptr
                        // we have two strings in this line "a: b"
                        const char* sepToken=strstr(remaining,":");
                        if(!sepToken)
                                return;
                        char* param1=new char[sepToken-remaining+1];
                        strncpy(param1,remaining,sepToken-remaining);
                        param1[sepToken-remaining]='\0';
                        sepToken++; //skip after :
                        while(*sepToken == ' ')
                                ++sepToken;
                        char* param2=new char[lptr-sepToken+1];
                        strncpy(param2,sepToken,lptr-sepToken);
                        param2[lptr-sepToken]='\0';
                        (*params)[param1]=param2;
                }
                remaining=(lptr+=2);
        }
};
/*
        RTSP/1.0 200 OK
        CSeq: 431
        Content-Length: 46
        Content-Type: text/parameters

        packets_received: 10
        jitter: 0.3838
*/
void RTSP::generateResponseGetParameter(std::map<char*, char*, struct stringCompare>* params)
{
        assert(params);
        if(!params || (params && params->size()==0)) {
                this->generateOk();
        }
        else {
                // calculate content length
                char *tmp = new char[MSG_BUFFER_SIZE];
                int offset=0;
                std::map<char*, char*, struct stringCompare>::iterator li;
                for(li=params->begin();li!=params->end();++li) {
                        offset+=sprintf(tmp+offset,"%s: %s\r\n",(*li).first, (*li).second);
                }
                strcat(tmp+offset,"\r\n");
                offset+=4;
                sprintf(buffer,"RTSP/1.0 200 OK\r\nCSeq: %i\r\n"
                                                "Content-Length: %i\r\n"
                                                "Content-Type: text/parameters\r\n\r\n",
                                                seqNr,offset);
                strcat(buffer,tmp);
                delete [] tmp;
        }
};

/* 
         RTSP/1.0 451 Invalid Parameter
         CSeq: 421
         Content-length: 10
         Content-type: text/parameters

         barparam
*/
void RTSP::generateInvalidParameter(const int numParams,  const char* const * const param)
{
        buffer[0]='\0';
        if(numParams<=0) {
                sprintf(buffer,"RTSP/1.0 451 Invalid Parameter\r\nCSeq: %i\r\n\r\n",seqNr);
                return;
        }
        int length=4;
        int i=0;
        for(i=0;i<numParams;i++)
                length+=(strlen(param[i])+2);

        length=sprintf(buffer,"RTSP/1.0 451 Invalid Parameter\r\n"
                                                                 "CSeq: %i\r\n"
                                                                 "Content-length: %i\r\n"
                                                                 "Content-type: text/parameters\r\n\r\n",seqNr,length);

        for(i=0;i<numParams;i++) 
                length+=sprintf(buffer+length,"%s\r\n",param[i]);

        strcpy(buffer+length,"\r\n");
};

void RTSP::generateNotEnoughBandwidth()
{
        sprintf(buffer,"RTSP/1.0 453 Not Enough Bandwidth\r\nCSeq: %i\r\n\r\n",seqNr);
};

#ifndef WINCE

/* REDIRECT rtsp://example.com/fizzle/foo RTSP/1.0
           CSeq: 732
           Location: rtsp://bigserver.com:8001
           Range: clock=19960213T143205Z-
*/
void RTSP::generateRedirect(const char* url, const char* newUrl, 
                                                                                                                const time_t* redirectAllowedAtTimePoint)
{
        int offset=sprintf(buffer,"REDIRECT %s RTSP/1.0\r\n"
                        "CSeq: %i\r\n"
                        "Location: %s\r\n",url,seqNr,newUrl);
        if(redirectAllowedAtTimePoint) {
                struct tm* tl=localtime(redirectAllowedAtTimePoint);
                char timeStr[30];
                strftime(timeStr, 30, "%Y%m%dT%H%M%SZ-", tl);
                sprintf(offset+buffer,"Range: clock=%s\r\n\r\n",timeStr);
        }
        else
                sprintf(buffer+offset,"\r\n");
}

void RTSP::parseCMDRedirect(Session* ses, const Url *fileName, const char* remaining, 
                char** newUrl, time_t* redirectAllowedAtTimePoint)
{
        assert(remaining);
        assert(*newUrl==NULL); // otherwise mem leak created
        assert(redirectAllowedAtTimePoint);
        
        time(redirectAllowedAtTimePoint);
        *newUrl=NULL; 

        const char* pStr=strstr(remaining,"Location:");
        if(!pStr)
                return;

        while(pStr[0]==' ')
                pStr++;
        // points to first char of url
        const char* pStrEnd=strstr(pStr,"\r\n");
        if(!pStrEnd) // invalid request
                return;
        pStrEnd--;
        if(pStr>=pStrEnd)
                return;
        while(pStrEnd[0]==' ')
                pStrEnd--;
        //pStrEnd points to the last Char of the Url
        *newUrl=new char[pStrEnd-pStr+2];
        strncpy(*newUrl,pStr,pStrEnd-pStr+1);
        (*newUrl)[pStrEnd-pStr+1]='\0';

        // now search for timepoint
        pStr=strstr(remaining,"Range:");
        if(!pStr)
                return;
        pStr=strstr(pStr,"clock=");
        if(!pStr)
                return;
        pStr+=strlen("clock=");

        //we now point to the first char of the timestring
        struct tm val;
        if(6==sscanf(pStr,"%4i%2i%2iT%2i%2i%2i",
                &val.tm_year,&val.tm_mon,&val.tm_mday,&val.tm_hour,&val.tm_min,&val.tm_sec)) {
                time_t t=mktime(&val);
                *redirectAllowedAtTimePoint=t;
        }

};
#endif

void RTSP::freeMapMemory(std::map<char*,char*,struct stringCompare>* params)
{
        std::map<char*,char*,struct stringCompare>::iterator p2It;
        for(p2It=params->begin();p2It!=params->end();++p2It) {
                if( (*p2It).first)
                        delete (*p2It).first; 
                if( (*p2It).second)
                        delete (*p2It).second;
        }
}

void RTSP::doTest()
{
        RTSP r;
        std::map<char*,char*,struct stringCompare> params;
        std::map<char*,char*,struct stringCompare> params2;
        params["MINBANDWIDTH"]="128000";
        params["BESTBANDWIDTH"]="512000";
        params["MAXBANDWIDTH"]="";
        r.generateSetParameter("rtsp://server/dummy.mp4",12345,&params);
        const char* tmp=r.getBuffer();
        fprintf(stderr,"%s",tmp);
        u32 session;
        r.parseSetParameter(tmp,&session,&params2);

        assert(strcmp(params["MINBANDWIDTH"],params2["MINBANDWIDTH"])==0);
        assert(strcmp(params["BESTBANDWIDTH"],params2["BESTBANDWIDTH"])==0);
        assert(strlen(params2["MAXBANDWIDTH"])==0);

        //free params2 mem
        std::map<char*,char*,struct stringCompare>::iterator p2It;
        RTSP::freeMapMemory(&params2);
};

© ViTooKi 2003 :: [Lite version] Created with Doxygen