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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

SemiProxySession.cpp

/***********************************************************************
*                                                                      *
* ViTooKi                                                              *
*                                                                      *
* title: SemiProxySession.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:                                                   *
*                                                                      *
*                                                                      *
*                                                                      *
***********************************************************************/

/***********************************************************************
* Video Session Migration System, 2005                                 *
* Author: Klaus Schoeffmann                                            *
************************************************************************/


#include "SemiProxySession.hpp"

vector<SemiProxySession*> SemiProxySession::sessionList;


/***********************************************************************/
SemiProxySession::SemiProxySession(int fdclient, struct sockaddr_in* clientsock, SemiProxy *sp) : Session()
{

  fdserver = 0;
  this->fdclient = sessionControlChannel = fdclient;
  this->sp = sp;
  this->clientsock = clientsock;
  this->buffer = new char[MSG_BUFFER_SIZE];
  initSemiProxySession();

  sessionList.push_back(this);
}

/***********************************************************************/
SemiProxySession::~SemiProxySession()
{
  Globals::sdebug << "\nSemiProxySession::cleanup() " << RtspSessionID << " ...";
  if (buffer != NULL) delete buffer;
  //do not delete asess, because this object is deleted by SessionMgmt.cpp
  //if (asess != NULL) delete asess;
  if (timemsmnt != NULL) delete timemsmnt;
  if (SessionURI != NULL) delete SessionURI;
  Globals::sdebug << "\nSemiProxySession::cleanup() done!";
}

/***********************************************************************/
void SemiProxySession::initSemiProxySession()
{
  bytesRead = 0;
  lastClientCSeq = 0;
  lastServerCSeq = 0;
  prevDuration = 0;
  noTermCapsFound = false;
  lastClientRtspMsg = RTSP_NONE;
  RtspSessionID = 0;
  lastCRtspSessionID = 0;
  SessionURI = NULL;
  asess = NULL;
  timemsmnt = NULL;
  requestedHostname = NULL;
  receivedServerPosition = 0;
  receivedClientPosition = 0;
  sendServerPositionRequest = false;
  sendClientPositionRequest = false;
  sessionHasBeenPaused = false;
  playerInfo = PI_UNKOWN;

  //init variables of super-class
  state =  SESSION_NEW;
  termCap = NULL;
  userPref = NULL;
  client = NULL;
  clientId = 0;
  prot = NULL;
  url = NULL;
  serverID = NULL;
  canAdmitRequest = false;
  globalTimer = NULL;
  gtRefCount = NULL;
  gtSharedAdapt = NULL;
  //resUsage = 0;
  sessionControlChannel = 0;
  mp4Stream = NULL;
  suggestedAdaptor = NULL;
}

/***********************************************************************/
void SemiProxySession::resetFlags()
{
  prevDuration = 0;
  noTermCapsFound = false;
  lastClientRtspMsg = RTSP_NONE;
  RtspSessionID = 0;
  lastCRtspSessionID = 0;
  receivedServerPosition = 0;
  receivedClientPosition = 0;
  sendServerPositionRequest = false;
  sendClientPositionRequest = false;
  sessionHasBeenPaused = false;
}


/***********************************************************************/
void SemiProxySession::removeSession()
{
  closeSession();
  sp->removeSession(asess);
}

/***********************************************************************/
void SemiProxySession::closeSession()
{
  state=SESSION_CLOSED;

  if (asess != NULL && !asess->isClosed()) asess->setClosed();

  if (this->fdclient != 0)
  {
#ifndef WIN32
    close(this->fdclient);
#else
        closesocket(this->fdclient);
#endif
    Globals::sdebug << "\n::closeSession(): client-socket CLOSED !";
  }

  if (this->fdserver != 0)
  {
#ifndef WIN32
    close(this->fdserver);
#else
        closesocket(this->fdserver);
#endif
    Globals::sdebug << "\n::closeSession(): server-socket CLOSED !";
  }
}

/***********************************************************************/
SemiProxySession* SemiProxySession::getSemiProxySession(uint RtspSessionId)
{
  Globals::sdebug << "\n:getSemiProxySession(): starts";

  vector<SemiProxySession*>::const_iterator iter = sessionList.begin();
  while (iter != sessionList.end())
  {
    SemiProxySession *sess = *iter;
    bool contained = sess->containsSessionID(RtspSessionId);

    Globals::sdebug << "\n::getSemiProxySession(): " << RtspSessionId << " contained?: " << contained;
    if (contained == true) return sess;

    iter++;
  }

  //not found
  return NULL;

}

/***********************************************************************/
bool SemiProxySession::checkServerConnection(const Url* fileName)
{
  assert(fileName);
  //if not already connected to server: try to connect
  if (this->fdserver == 0)
  {
    //if url contains a port: connect to this port
    //otherwise: use defaultport (554)
    uint port = DEFAULT_RTSPSERVER_PORT;
    if (fileName->getPort() > 0) {
      port = fileName->getPort();
      Globals::sdebug << "\n::checkServerConnection: port of fileName used: " << port;
    }
    Globals::sdebug << "\ncheckServerConnection:";
    if (params.getHost() != NULL) {
      requestedHostname = params.getHost();
      Globals::sdebug << " host=" << params.getHost();
    }
    if (params.getPort() > 0) {
      port = params.getPort();
      Globals::sdebug << " port=" << params.getPort();
    }

    //connect to servername, specified in url
    //dont use servername from URL, because it is not correctly resolved sometimes
    //(e.g. try for "rtsp://rm1.warpnet.jet-stream.nl:554/jet-stream/mpeg4.mp4/")
    //this->fdserver = sp->createRtspServerSocket(fileName->getServerName(), port);
    this->fdserver = sp->createRtspServerSocket(requestedHostname, port);
    if (this->fdserver == 0)
    {
      removeSession();
      return false;
    }
  }
  return true;
}



/***********************************************************************/
char *SemiProxySession::extractStrParameter(string &strbuf, char *pname, bool removeIt)
{
  assert(pname);
  Globals::sdebug << "\n::extractStrParameter(): looking for " << pname;

  uint pstart, pend, pend1, pend2, pend3;
  //first look, if specified parameter is in passed string
  if ((pstart = strbuf.find(pname)) != string::npos)
  {
    //find end of parameter
    //pend1 = strbuf.find("&", pstart+strlen(pname)); //next parameter separated by '&'
    pend1 = strbuf.find("/", pstart+strlen(pname)); //next parameter separated by '&'
    pend2 = strbuf.find("/", pstart+strlen(pname)); //on setup, trackid separated by '/'
    pend3 = strbuf.find(" ", pstart+strlen(pname)); //last parameter
    if (pend1 == string::npos && pend2 == string::npos && pend3 == string::npos)
    {
      Globals::sdebug << "\nParamEndProblem";
      throw ParamEndProblem();
    }

    //take lowest one
    pend = (pend1 <= pend2) ? pend1 : pend2;
    pend = (pend <= pend3) ? pend : pend3;

    string tmp = strbuf.substr(pstart + strlen(pname), pend - (pstart + strlen(pname)));
    Globals::sdebug << "...= " << pname << tmp;

    //remove parameter from string (if should remove)
    if (removeIt)
    {
      //move this param from all positions in the string
      //(this is necessary, if there are more than one messages on one received-buffer -
      //e.g. SET_PARAMETER and PLAY)
      char *tmpparam = semifunc::newStrCpy((char*)strbuf.c_str() + pstart, pend-pstart);
      //strbuf.erase(pstart, pend - pstart);
      semifunc::replaceStr(strbuf, tmpparam, "", true);
    }

    return (char*)tmp.c_str();
  }
  else
  {
    //Param NOT FOUND
    Globals::sdebug << " NOT FOUND!";
    return NULL;
  }
}

/***********************************************************************/
int SemiProxySession::extractParameter(string &strbuf, char *pname, bool removeIt)
{
  //Globals::sdebug << "\n::extractParameter(): looking for " << pname;

  char *par = extractStrParameter(strbuf, pname, removeIt);
  if (par != NULL)
  {
    return atoi(par);
  }
  else
  {
    return -1;
  }
}

/***********************************************************************/
ulong SemiProxySession::extractDuration(string &strbuf)
{
  ulong dur = 0;

  uint rpos1, rpos2;
  if ((rpos1 = strbuf.find("a=range:npt=")) != string::npos)
  {
    if ((rpos2 = strbuf.find("-", rpos1)) != string::npos)
    {
      double ddur = atof(strbuf.c_str() + rpos2 + 1);
      ddur *= 1000;
      dur = (ulong)ddur;
      Globals::sdebug << "\n::extractDuration(): =" << dur;
    }
  }

  return dur;
}

/***********************************************************************/
ulong SemiProxySession::extractRangeFrom(string &strbuf)
{
  ulong from = 0;

  uint rpos1;
  if ((rpos1 = strbuf.find("Range: npt=")) != string::npos)
  {
    double dfrom = atof(strbuf.c_str() + rpos1 + 11);
    dfrom *= 1000;
    from = (ulong)dfrom;
    Globals::sdebug << "\n::extractRangeFrom(): =" << from;
  }

  return from;
}

/***********************************************************************/
ulong SemiProxySession::extractPrebuffer(string &strbuf)
{
  ulong prebuffer = 0;

  uint bpos1;
  if ((bpos1 = strbuf.find("x-prebuffer: maxtime=")) != string::npos)
  {
    double dprebuffer = atof(strbuf.c_str() + bpos1 + 21);
    dprebuffer *= 1000;
    prebuffer = (ulong)dprebuffer;
    Globals::sdebug << "\n::extractPrebuffer(): =" << prebuffer;
  }

  return prebuffer;
}

/**********************************************************************/
uint SemiProxySession::getContentLength(string strbuf)
{
  uint clpos1, clpos2;
  if ((clpos1 = strbuf.find("Content-Length: ")) != string::npos)
  {
    clpos2 = strbuf.find("\r\n", clpos1);
    return atoi(strbuf.c_str() + clpos1 + 16);
  }
  else
  {
    cerr << "\n::getContentLength(): Content-Length not found (cannot change)!" << endl;
    return 0;
  }
}

/**********************************************************************/
void SemiProxySession::changeContentLength(string &strbuf, uint newVal)
{
  uint clpos1, clpos2;
  if ((clpos1 = strbuf.find("Content-Length: ")) != string::npos)
  {
    clpos2 = strbuf.find("\r\n", clpos1);
    strbuf.replace(strbuf.begin() + clpos1 + 16, strbuf.begin() + clpos2, semifunc::toString(newVal));
  }
  else
  {
    cerr << "\n::changeContentLength(): Content-Length not found (cannot change)!" << endl;
  }
}

/**********************************************************************/
void SemiProxySession::extractCSeq(char *tmpbuffer, uint &lastCSeq)
{
  assert(tmpbuffer);
  char *cseqpos;
  Globals::sdebug << "\n::extractCSeq(): ";

  if ((cseqpos = strstr(tmpbuffer, "CSeq: ")) != NULL)
  {
    uint i = 0;
    while (cseqpos[i+5] != 0 && cseqpos[i+5] != '\r' && cseqpos[i+5] != '\n') i++;
    Globals::sdebug << "\n::extractCSeq(): i = " << i;
    char *strCSeq = new char[i+1];
    strncpy(strCSeq, cseqpos+5, i);
    strCSeq[i] = 0;
    lastCSeq = atoi(strCSeq);
    delete strCSeq;
    Globals::sdebug << "\n::extractCSeq(): lastCSeq = " << lastCSeq;
  }
}

/**********************************************************************/
void SemiProxySession::replaceCSeq(string &str, uint newCSeq)
{
  //replace CSeq
  uint pos1 = str.find("CSeq: ");
  if (pos1 != string::npos)
  {
    pos1 += 6;
    uint pos2 = str.find("\r\n", pos1);
    if (pos2 != string::npos)
    {
      str.replace(pos1, pos2-pos1, semifunc::toString(newCSeq));
      Globals::sdebug << "\n::replaceCSeq(): replaced CSeq to " << newCSeq;
    }
    else
    {
      cerr << "\n::replaceCSeq(): found CSeq without end!" << endl;
    }
  }
}

/***********************************************************************/
void SemiProxySession::replaceRange(string &strbuf, char *newVal, bool replaceOnlyFromValue)
{
  //search content of msg for range in npt-format
  unsigned int rastart, raend;
  if ((rastart = strbuf.find("Range: npt=")) != string::npos)
  {
    assert(newVal);
    if (replaceOnlyFromValue)
      raend = strbuf.find("-", rastart + 11);
    else
      raend = strbuf.find("\r\n", rastart + 11);
    strbuf.replace(rastart + 11, raend-(rastart + 11), newVal);
  }
  else
  {
    cerr << "\n::replaceRange(): Range-Parameter not found! (cannot change)" << endl;
  }

}


/***********************************************************************/
string SemiProxySession::createTerminalCapabilities(Profile *profile)
{

  if (profile == NULL)
  {
    return "";
  }
  else
  {

    TerminalCapabilities *tc = new TerminalCapabilities();
    tc->setColorDisplay(profile->isColorCapable());
    tc->setDisplayWidth(profile->getWidth());
    tc->setDisplayHeight(profile->getHeight());
    tc->setDisplayBitsPerPixel(profile->getBitsPerPixel());
    tc->setDisplayRefreshRate(profile->getRefreshRate());
    tc->setNetworkCapacityInByte(profile->getNetkBps() * 1000);
    //audio properties
    tc->setAudioSamplingFrequency(44000);
    tc->setAudioBitsPerSample(16);
    tc->setNumAudioChannels(2);


    string termCaps (MP21::generateTerminalCapabilityDescription(tc));

    delete tc;

    return termCaps;
  }
}

/***********************************************************************/
void SemiProxySession::forwardToServer(char *buffer, int len)
{
  Globals::sdebug << "\n::forwardToServer(): starts";
  if (buffer == NULL)
  {
    Globals::sdebug << "\n::forwardToServer(): detected buffer=NULL!!!";
  }
  else
  {

    //first store CSeq received from client
    Globals::sdebug << "\n::forwardToServer(): before call to extractCSeq()";
    extractCSeq(buffer, lastClientCSeq);
    Globals::sdebug << "\n::forwardToServer(): lastClientCSeq=" << lastClientCSeq;

    //additional newlines, needed for pvplayer
    string strbuf(buffer);
    if (params.getPort() > 0 || params.getHost() != NULL) {
      strbuf.append("\r\n\r\n");
    }


    //add/change terminal capabilites?
    if (sp->shouldAddTermCaps())
    {

      //check terminal capabilities (only if profile specified)
      if (lastClientRtspMsg == RTSP_DESCRIBE && params.getProfileId() != 0)
      {
        uint tcBegin, tcEnd;

        Profile *profile = sp->getProfileList()->getProfileById(params.getProfileId());
        assert(profile != NULL);
        string termCaps = createTerminalCapabilities(profile);

        tcBegin = strbuf.find("<xml ");
        tcEnd = strbuf.find("</DIDL>");

        if (strbuf.find("Content-Type: application/mpeg21_dia") != string::npos &&
            tcBegin != string::npos && tcEnd != string::npos)
        {

          //termcaps found
          strbuf.replace(tcBegin, (tcEnd + 7) - tcBegin, termCaps);
          uint currentLength = getContentLength(strbuf);
          currentLength -= (tcEnd + 7) - tcBegin;
          currentLength += termCaps.length();
          //correct content-length
          changeContentLength(strbuf, currentLength);

        }
        else
        {

          noTermCapsFound = true;

          Globals::sdebug << "\n::forwardToServer(): No Terminalcapabilities found... will add!";

          if (strbuf.find("Content-Length:") != string::npos)
          {
            cerr << "\n::forwardToServer(): cannot handle existing DESCRIBE content!" << endl;
          }
          else
          {

            ostringstream ctinfo, content;
            ctinfo << "Content-Type: application/mpeg21_dia\r\n"
            << "Content-Length: " << termCaps.length() << "\r\n\r\n"
            << termCaps << "\r\n";

            uint uapos1, uapos2;
            if ((uapos1 = strbuf.find("User-Agent:")) != string::npos)
            {
              uapos2 = strbuf.find("\r\n", uapos1);
              strbuf.insert(uapos2+2, ctinfo.str());

              //append tercaps to end
              strbuf.insert(strbuf.rend()-strbuf.rbegin(), content.str());
            }
            else
            {
              cerr << "\n::forwardToServer(): User-Agent not found in message!" << endl;
            }

          }

        }
      }
    }


    //replace CSeq value
    replaceCSeq(strbuf, lastServerCSeq+1);

    //debugging output
    string tmpstr(strbuf);
    Globals::sdebug << "\n::forwardToServer(): Forwarding to SERVER:\n" << tmpstr;

    send(this->fdserver, strbuf.c_str(), strbuf.length(), 0);

    Globals::sdebug << "\n::forwardToServer(): success";
  }
}


/***********************************************************************/
void SemiProxySession::forwardToClient(char *buffer, int len)
{
  Globals::sdebug << "\n::forwardToClient(): starts";
  if (buffer == NULL)
  {
    Globals::sdebug << "\n::forwardToClient(): detected buffer=NULL!!!";
  }
  else
  {

    //first store CSeq received from server
    extractCSeq(buffer, lastServerCSeq);
    Globals::sdebug << "\n::forwardToClient(): lastServerCSeq=" << lastServerCSeq;

    string str(buffer);

    //if the client uses a host/port parameter (because it doesn't support a proxy),
    //replace the content-base to the original filename
    if ((params.getFullURI() != NULL) && ((params.getHost() != NULL) || (params.getPort() != 0)) )
    {
      uint cbstart = str.find("Content-Base: ");
      if (cbstart != string::npos)
      {
        uint cbend = str.find("\r\n", cbstart);
        std::ostringstream newContentBase;
        newContentBase << "Content-Base: " << params.getFullURI();
        semifunc::replaceStr(str, cbstart, cbend, (char*)newContentBase.str().c_str());
      }
    }

    //replace CSeq value
    replaceCSeq(str, lastClientCSeq);

    //debugging output
    string tmpstr (str);
    semifunc::replaceStr(tmpstr, "\r\n", "\r \n\t", true);
    Globals::sdebug << "\n::forwardToClient(): Forwarding to CLIENT:\n" << tmpstr;

    send(this->fdclient, str.c_str(), str.length(), 0);

    //if last client message was PLAY, start time-measurement for current time-section
    //but only for the _first_ PLAY message (session-state not ACTIVE)
    if (this->lastClientRtspMsg == RTSP_PLAY && state != SESSION_ACTIVE)
    {
      Globals::sdebug << "\n::forwardToClient(): _time measurement started_";
      timemsmnt->startTS();
    } else {
      Globals::sdebug << "\n::forwardToClient(): _time measureemnt not started (" << lastClientRtspMsg << "==" << RTSP_PLAY << ", " << state << "!=" << SESSION_ACTIVE << ")";
    }

    //request current media time from media player
    //but only for the _first_ PAUSE message (if there are more than on track)
    if (this->lastClientRtspMsg == RTSP_PAUSE && sp->shouldRequestClientPosition() && state != SESSION_PAUSED
    && SemiProxySession::getSemiProxySession(this->RtspSessionID)->getPlayerInfo() != PI_PVPLAYER)
    {
      ulong cplayout = SemiProxySession::getSemiProxySession(this->RtspSessionID)->getClientTimeMs();
      timemsmnt->setTSclientPlayout(cplayout);
    }

    Globals::sdebug << "\n::forwardToClient(): success";
  }
}


/***********************************************************************/
void SemiProxySession::handleOptionsResponse(string &buf, int &bytesRead)
{
  forwardToClient((char*)buf.c_str(), bytesRead);
}

/***********************************************************************/
void SemiProxySession::handleDescribeResponse(string &buf, int &bytesRead)
{
  if (timemsmnt != NULL)
  {
    delete timemsmnt;
    timemsmnt = NULL;
  }

  //create TimeMeasurement object and store duration
  timemsmnt = new TimeMeasurement();
  timemsmnt->setDuration(extractDuration(buf));

  forwardToClient((char*)buf.c_str(), bytesRead);
}

/***********************************************************************/
void SemiProxySession::handleSetupResponse(string &buf, int &bytesRead)
{
  Globals::sdebug << "\n::handleSetupResponse(): session initialized";

  //store sessionid in track
  uint sStart, sEnd1, sEnd2;
  sStart = buf.find("Session: ");
  if (sStart != string::npos) {
    sStart += strlen("Session: ");
    sEnd1 = buf.find("\n");
    sEnd2 = buf.find("\r");
    if (sEnd2 != string::npos && sEnd1 != string::npos && sEnd2 < sEnd1) sEnd1 = sEnd2;
    tracks.setIdOfLastTrack(atoi(buf.substr(sStart, sEnd1-sStart).c_str()));
  }

  forwardToClient((char*)buf.c_str(), bytesRead);

  state = SESSION_INITIALIZED;
}

/***********************************************************************/
void SemiProxySession::handlePlayResponse(string &buf, int &bytesRead)
{
  Globals::sdebug << "\n::handlePlayResponse(): last msg was play";

  //if this is the _first_ PLAY message
  if (tracks.getTCHavingState(TRACK_ACTIVE) == 0) {
    //and a SETUP was executed before...
    if (state == SESSION_INITIALIZED)
    {

      Globals::sdebug << "\n::handlePlayResponse(): looking for URI";
      if (RtspSessionID != 0 && SessionURI != NULL && params.getMovieId() != NULL)
      {

        //store elapsed time of origin session
        timemsmnt->setPreviousSessionDuration(prevDuration);

        assert(sp->getProfileList()->getProfileById(params.getProfileId()) != NULL);

        asess = new SSession(RtspSessionID, SessionURI, inet_ntoa(clientsock->sin_addr), params.getMovieId(), params.getSessionId(), prevDuration, sp->getProfileList()->getProfileById(params.getProfileId())->getBufferingDelayms(), timemsmnt);

        //set session state to active
        asess->setActive();

        //add this session to our global list
        sp->addSession(asess);


        //if this session was a take-over and user has chosen to migrate, REMOVE OTHER SESSION
        if (params.getSessionId() != 0 && params.getAction() == ACTION_MIGRATE)
        {
          Globals::sdebug << "\n::handlePlayResponse(): closing OTHER SESSION";
          if (sp->getSession(params.getSessionId())->getState() != STATE_CLOSED)
          {
            assert(SemiProxySession::getSemiProxySession(params.getSessionId()) != NULL);
            SemiProxySession::getSemiProxySession(params.getSessionId())->sendTeardownToClient();
            SemiProxySession::getSemiProxySession(params.getSessionId())->closeSession();
          }
          else
          {
            Globals::sdebug << "\n::handlePlayResponse(): session is already closed!";
          }
        }

      }
      else
      {
        Globals::sdebug << "\n::handlePlayResponse(): No semi-parameters where found. Session was not added to the semi-system!";
      }

    }
    else if (state == SESSION_PAUSED)
    {
      Globals::sdebug << "\n::handlePlayResponse(): session resumed";
      asess->setActive();
    }
  }

  forwardToClient((char*)buf.c_str(), bytesRead);

  //set state of track
  tracks.getTrackById(lastCRtspSessionID)->setState(TRACK_ACTIVE);

  state = SESSION_ACTIVE;

}

/***********************************************************************/
void SemiProxySession::handlePauseResponse(string &buf, int &bytesRead)
{
  Globals::sdebug << "\n::handlePauseResponse(): session paused";

  forwardToClient((char*)buf.c_str(), bytesRead);

  //set state of track
  tracks.getTrackById(lastCRtspSessionID)->setState(TRACK_PAUSED);

  state = SESSION_PAUSED;
  sessionHasBeenPaused = true;
}

/***********************************************************************/
void SemiProxySession::handleTeardownResponse(string &buf, int &bytesRead)
{
  Globals::sdebug << "\n::handleTeardownResponse(): session CLOSED";

  forwardToClient((char*)buf.c_str(), bytesRead);

  //set state of track
  tracks.getTrackById(lastCRtspSessionID)->setState(TRACK_CLOSED);

  //close session
  closeSession();
  Globals::sdebug << "\n::handleTeardownResponse(): session removed";
}


/***********************************************************************/
void SemiProxySession::parseResponseFromServer(char *buffer, int len)
{
  assert(buffer);

  Globals::sdebug << "\n::parseResponseFromServer(): starts";

  //only parse response, if all necessary params were passed from the client
  if (params.getMovieId() != NULL && params.getUserId() != 0 && params.getProfileId() != 0)
  {

    string buf (buffer);

    //look if RTSP 200 OK is contained in the message
    if (buf.find("200") != string::npos && buf.find("OK") != string::npos)
    {
      switch(lastClientRtspMsg)
      {
      case RTSP_OPTIONS:
        handleOptionsResponse(buf, len);
        break;
      case RTSP_DESCRIBE:
        handleDescribeResponse(buf, len);
        break;
      case RTSP_SETUP:
        handleSetupResponse(buf, len);
        break;
      case RTSP_PLAY:
        handlePlayResponse(buf, len);
        break;
      case RTSP_PAUSE:
        handlePauseResponse(buf, len);
        break;
      case RTSP_TEARDOWN:
        handleTeardownResponse(buf, len);
        break;
      }
    }

  }
  else
  {
    Globals::sdebug << "\n::parseResponseFromServer(): IGNORED (not all params found!)";
    cerr << "\n::parseResponseFromServer(): IGNORED (not all params found!)";
  }

  Globals::sdebug << "\n::parseResponseFromServer(): ends";
}



/***********************************************************************/
bool SemiProxySession::options(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::options(): starts";
  lastClientRtspMsg = RTSP_OPTIONS;

  if (checkServerConnection(fileName))
  {

    forwardToServer(buffer, bytesRead);
    return true;

  }
  else
  {
    return false;
  }
}

/***********************************************************************/
bool SemiProxySession::connect(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::connect(): starts";

  resetFlags();

  lastClientRtspMsg = RTSP_DESCRIBE;

  if (checkServerConnection(fileName))
  {
    //look if known players
    if (strstr(remaining, "User-Agent: PVPlayer") != NULL) playerInfo = PI_PVPLAYER;
    else if (strstr(remaining, "User-Agent: QTS") != NULL) playerInfo = PI_QUICKTIME;
    else if (strstr(remaining, "User-Agent: ItecMP4Player") != NULL) playerInfo = PI_MUVIPLAYER;


    forwardToServer(buffer, bytesRead);
    return true;

  }
  else
  {
    return false;
  }
}

/***********************************************************************/
uint SemiProxySession::getSmallerStringPos(string str, char *needle1, char *needle2, uint from)
{
  uint pos1 = str.find(needle1, from);
  uint pos2 = str.find(needle2, from);
  return (pos1 < pos2) ? pos1 : pos2;
}

/***********************************************************************/
bool SemiProxySession::setup(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::setup(): starts";
  lastClientRtspMsg = RTSP_SETUP;

  string strbuf (buffer);

  //change destination-parameter?
  if (sp->shouldAddDestination())
  {
    uint cpstart;
    if ((cpstart = strbuf.find("unicast")) != string::npos)
    {
      ostringstream strdest;
      strdest << "destination=" << inet_ntoa(clientsock->sin_addr) << ";";

      //if there is already an existing destination, replace it,
      //otherwise insert it into the string
      uint deststart, destend;
      if ((deststart = strbuf.find("destination=")) != string::npos)
      {
        destend = getSmallerStringPos(strbuf, "\r\n", ";");
        strbuf.replace(strbuf.begin()+deststart, strbuf.begin()+destend-1, strdest.str());
      }
      else
      {
        strbuf.insert(cpstart, strdest.str());
      }
    }
  }

  //store track in tracklist
  uint tstart = strbuf.find("/trackID=");
  if (tstart != string::npos) {
    uint tend = strbuf.find(" ", tstart);
    uint trackNr = atoi(strbuf.substr(tstart+strlen("/trackID="), tend-(tstart+strlen("/trackID="))).c_str());
    tracks.addTrack(trackNr);
  }

  forwardToServer((char*)strbuf.c_str(), strbuf.length());

  return true;

}

/***********************************************************************/
bool SemiProxySession::play(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::play(): starts";
  lastClientRtspMsg = RTSP_PLAY;

  string strbuf (buffer);

  //extract prebuffer-time
  ulong prebuffer = extractPrebuffer(strbuf);
  if (prebuffer == 0 && params.getProfileId() != 0)
  {
    //if no prebuffer-time was specified by the player, use prebuffer-time from profile
    prebuffer = sp->getProfileList()->getProfileById(params.getProfileId())->getBufferingDelayms();
  }
  Globals::sdebug << "\n::play(): prebuffer=" << prebuffer;

  //on known protocol: extract RTSP-SessionId and URI
  if (prot)
  {
    lastCRtspSessionID = prot->extractSessionKeyFromCMD(remaining);
    //extract sessionID and URI only for first track
    if (tracks.getTCHavingState(TRACK_ACTIVE) == 0) {
      RtspSessionID = lastCRtspSessionID;//prot->extractSessionKeyFromCMD(remaining);
      SessionURI = new char[strlen(fileName->toString())+1];
      strcpy(SessionURI, fileName->toString());
    }
  } else {
    Globals::sdebug << "\n::play(): prot IS NULL !!!";
  }

  //for consecutive play (resumes):
  //if this session is a migrated session, add elapsed time of
  //original session to the range, requested by the client
  //(otherwise, some players would start from wrong position)
  if (sessionHasBeenPaused)
  {
    Globals::sdebug << "\n::play(): consecutive play";

    if (asess->getPreviousSessionDuration() != 0)
    {
      Globals::sdebug << "\n::play(): prevDur= " << asess->getPreviousSessionDuration();
      replaceRange(strbuf, semifunc::convertToString(extractRangeFrom(strbuf)+asess->getPreviousSessionDuration()));
    }

  }


  if (state != SESSION_ACTIVE && tracks.getTCHavingState(TRACK_ACTIVE) == 0)
  {
    assert(timemsmnt != NULL);
    //create new time-section on time-measurement
    timemsmnt->addNewSection(prebuffer);
    //set requested range-from value
    timemsmnt->setTSrequestedFrom(extractRangeFrom(strbuf));
  }


  //check if this session should take over another session
  //do not migrate a migrated session again (which is only paused and resumed!)
  //moreover, do not migrate a session if the PLAY message for the second track was received
  if (params.getSessionId() != 0 && tracks.getTCHavingState(TRACK_ACTIVE) == 0)
  {

    //session, which should be taken over must exist!
    SSession *otherSession = sp->getSession(params.getSessionId());
    if (otherSession != NULL)
    {

      //get time OF OTHER  SESSION

      ulong splayout = 0, cplayout = 0;


      //should request mediatime from client?
      Globals::sdebug << "\n::play() requesting position from client?";
      if (sp->shouldRequestClientPosition() && otherSession && otherSession->getState() != STATE_CLOSED
      && SemiProxySession::getSemiProxySession(params.getSessionId())->getPlayerInfo() != PI_PVPLAYER)
      {
        //get client-playout time for other session from server
        assert(SemiProxySession::getSemiProxySession(params.getSessionId()) != NULL);
        cplayout = SemiProxySession::getSemiProxySession(params.getSessionId())->requestClientTimeMs();

        Globals::sdebug << "\n::play(" << RtspSessionID << "): client playout of other session= " << cplayout;
      }

      if (cplayout == 0)
      {
        Globals::sdebug << "\n::play(): NO REQUEST FROM CLIENT, try server";

        //should request mediatime from server?
        if (sp->shouldRequestServerPosition()
            && otherSession && otherSession->getState() != STATE_CLOSED)
        {
          //get client-playout time for other session from server
          assert(SemiProxySession::getSemiProxySession(params.getSessionId()) != NULL);
          splayout = SemiProxySession::getSemiProxySession(params.getSessionId())->requestServerTimeMs();

          Globals::sdebug << "\n::play(" << RtspSessionID << "): server playout of other session= " << splayout;
        }
        else
        {
          Globals::sdebug << "\n::play(): NO REQUEST FROM SERVER, use own estimation";
        }
      }


      //calculate position (correct value from server or user own estimation)
      ulong msecsOS = sp->getSession(params.getSessionId())->getElapsedMsecs(params.getSection(), splayout, cplayout);
      Globals::sdebug << "\n::play(): msecs of other session= " << msecsOS;

      //add/subtract the specified number of seconds (if specified)
      if (msecsOS >= (uint)(params.getSubtractSecs() * 1000))
      {
        msecsOS -= params.getSubtractSecs() * 1000;
      }

      Globals::sdebug << "\n::play(): msecs of other session after subtract("
      << params.getSubtractSecs() * 1000 << ") = " << msecsOS;

      //store time of old session in variable 'elapsedTimeMsecs' for NEW SESSION
      //(will be used on creation of SSession)
      //prevDuration = msecsOS + startupOffset;
      prevDuration = msecsOS;

      //convert time to string and replace range-parameter in the message
      replaceRange(strbuf, semifunc::convertToString(msecsOS));

    }
  } else if (params.getSessionId() != 0) {
    replaceRange(strbuf, semifunc::convertToString(prevDuration));
  }


  //check if an explicit range parameter were specified
  if (params.getRange() != NULL)
  {
    //if so, replace the previous range
    replaceRange(strbuf, params.getRange(), false);
  }

  forwardToServer((char*)strbuf.c_str(), strbuf.length());

  return true;
}

/***********************************************************************/
bool SemiProxySession::pause(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::pause(): starts (state=" << state << ")";

  if (tracks.getTCHavingState(TRACK_PAUSED) == 0)
  {
    if (state == SESSION_ACTIVE && asess != NULL)
    {
      Globals::sdebug << "\n::pause(): set inactive";

      //set state of active session to PAUSED
      asess->setInactive();
    }

    //should request mediatime from server?
    if (sp->shouldRequestServerPosition())
    {
      //get client-playout time from server
      ulong playout = SemiProxySession::getSemiProxySession(this->RtspSessionID)->getServerTimeMs();
      //set client playout-time on current time-section
      timemsmnt->setTSserverPlayout(playout);
    }
  }

  if (prot) {
    lastCRtspSessionID = prot->extractSessionKeyFromCMD(remaining);
  }

  lastClientRtspMsg = RTSP_PAUSE;

  forwardToServer(buffer, bytesRead);

  return true;
}

/***********************************************************************/
bool SemiProxySession::tearDown(int sessionKey, bool immediate,
                                const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::teardown(): starts";
  lastClientRtspMsg = RTSP_TEARDOWN;

  if (prot) {
    lastCRtspSessionID = prot->extractSessionKeyFromCMD(remaining);
  }

  forwardToServer(buffer, bytesRead);

  return true;
}

/***********************************************************************/
bool SemiProxySession::getOptions(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::getOptions(): starts";
  lastClientRtspMsg = RTSP_GETPARAMETER;

  forwardToServer(buffer, bytesRead);

  return true;
}

/***********************************************************************/
bool SemiProxySession::setOptions(const Url* fileName, const char* remaining)
{
  assert(remaining); assert(fileName);
  Globals::sdebug << "\n::setOptions(): starts";
  lastClientRtspMsg = RTSP_SETPARAMETER;

  forwardToServer(buffer, bytesRead);

  return true;
}

/***********************************************************************/
void SemiProxySession::setUrl(const Url *uri, bool makeExactMatch)
{}

/***********************************************************************/
void SemiProxySession::setStateClosed()
{
  this->state = SESSION_CLOSED;
}

/***********************************************************************/
bool SemiProxySession::containsSessionID(uint SessionID)
{
  Globals::sdebug << "\n::containsSessionID(): searching for " << SessionID << "\n";
  if (asess != NULL)
  {
    vector<Track*>::const_iterator iter = tracks.begin();
    for (; iter != tracks.end(); iter++)
    {
      Track *trk = *iter;
      if (trk->getId() == SessionID) return true;
    }
  }

  return false;
}


/***********************************************************************/
uint SemiProxySession::requestServerTimeMs()
{
  Globals::sdebug << "\nSPS::requestServerTimeMs(" << RtspSessionID << "): **starts**";
  receivedServerPosition = 0;
  sendServerPositionRequest = true;

  ulong sleepms = PROXY_SLEEP_USECS;
  int maxSecsToWait = Globals::getPRMaxWaitSecs();
  struct timeval timeStart, timeCurr;
  gettimeofday(&timeStart, NULL);
  gettimeofday(&timeCurr, NULL);

  while (receivedServerPosition == 0)
  {
    if ((timeCurr.tv_sec - timeStart.tv_sec) >= maxSecsToWait)
    {
      Globals::sdebug << "\nSPS::requestServerTimeMs(): ABORT waiting for position from Server!";
      Globals::sdebug << "\nSPS::requestServerTimeMs(): s=" << timeStart.tv_sec << " c=" << timeCurr.tv_sec;
      Globals::sdebug << "(\nmaxSecsToWait=" << maxSecsToWait << " reached!) ";
      break;
    }
    gettimeofday(&timeCurr, NULL);
#ifndef WIN32
    usleep(sleepms);
#else
        Sleep(sleepms);
#endif
  }

  Globals::sdebug << "\nSPS::requestServerTimeMs(" << RtspSessionID << "): **ends**";
  return receivedServerPosition;
}

/***********************************************************************/
uint SemiProxySession::requestClientTimeMs()
{
  Globals::sdebug << "\nSPS::requestClientTimeMs(" << RtspSessionID << "): **starts**";
  receivedClientPosition = 0;
  sendClientPositionRequest = true;

  ulong sleepms = PROXY_SLEEP_USECS;
  int maxSecsToWait = Globals::getPRMaxWaitSecs();
  struct timeval timeStart, timeCurr;
  gettimeofday(&timeStart, NULL);
  gettimeofday(&timeCurr, NULL);

  while (receivedClientPosition == 0)
  {
    if ((timeCurr.tv_sec - timeStart.tv_sec) >= maxSecsToWait)
    {
      Globals::sdebug << "\nSPS::requestClientTimeMs(): ABORT waiting for position from Client!";
      Globals::sdebug << "\nSPS::requestClientTimeMs(): s=" << timeStart.tv_sec << " c=" << timeCurr.tv_sec;
      Globals::sdebug << "\n(maxSecsToWait=" << maxSecsToWait << " reached!) ";
      break;
    }
    gettimeofday(&timeCurr, NULL);
#ifndef WIN32
    usleep(sleepms);
#else
        Sleep(sleepms);
#endif
  }

  Globals::sdebug << "\nSPS::requestClientTimeMs(" << RtspSessionID << "): **ends**";
  return receivedClientPosition;
}


/***********************************************************************/
uint SemiProxySession::getServerTimeMs()
{
  uint msecs = 0;
  if (fdserver != 0)
  {
    char tmpbuffer[MSG_BUFFER_SIZE + 1];
    memset(tmpbuffer, 0, MSG_BUFFER_SIZE + 1);

    string str("GET_PARAMETER ");
    str.append(SessionURI);
    str.append(" RTSP/1.0\r\n");
    str.append("CSeq: " + semifunc::toString(lastClientCSeq+1) + "\r\n");
    str.append("Content-Type: text/parameters\r\n");
    str.append("Session: " + semifunc::toString(RtspSessionID) + "\r\n");
    str.append("Content-Length: 12\r\n\r\n");
    str.append("position\r\n\r\n");

    Globals::sdebug << "\nSPS::getServerTimeMs(): sending buffer: \r\n" << str << "\r\n";

    //send message and wait for response
    send(this->fdserver, str.c_str(), str.length(), 0);
    //sendMessage(this->fdserver, str.c_str(), str.length());
    uint bytesRead = recv(fdserver, tmpbuffer, MSG_BUFFER_SIZE, 0);

    extractCSeq(tmpbuffer, lastServerCSeq);

    Globals::sdebug << "\nSPS::getServerTimeMs(): received buffer: \r\n" << tmpbuffer<< "(" << bytesRead  << ")\r\n";

    if (bytesRead > 0)
    {
      char *positionPos;
      if ((positionPos = strstr(tmpbuffer, "position: ")) != NULL)
      {
        msecs = atoi(positionPos + 10);
        Globals::sdebug << "\nSPS::getServerTimeMs(): received msecs= " << msecs;
      }
    }
    else
    {
      cerr << "\nSPS::getServerTimeMs(): Error reading get_parameter response" << endl; cerr.flush();
      //could not retrieve client-time from server: set time to 0
      msecs = 0;
    }
  }
  else
  {
    Globals::sdebug << "\nSemiProxySession::getServerTimeMs(): server socket closed!";
  }

  return msecs;

}

/***********************************************************************/
void SemiProxySession::testClientOptions()
{
  char tmpbuffer[MSG_BUFFER_SIZE + 1];
  memset(tmpbuffer, 0, MSG_BUFFER_SIZE+1);

  string str("OPTIONS * RTSP/1.0\r\n");
  str.append("CSeq: " + semifunc::toString(lastServerCSeq+1) + "\r\n\r\n");

  Globals::sdebug << "\nSPS::testClientOptions(): sending buffer: \r\n" << str << "\r\n";

  //send message and wait for response
  send(fdclient, str.c_str(), str.length(), 0);
  //sendMessage(this->fdclient, str.c_str(), str.length());
  uint bytesRead = recv(fdclient, tmpbuffer, MSG_BUFFER_SIZE, 0);

  extractCSeq(tmpbuffer, lastClientCSeq);

  Globals::sdebug << "\nSPS::testClientOptions(): received buffer: \r\n" << tmpbuffer << "(" << bytesRead << ")\r\n";

}

/***********************************************************************/
uint SemiProxySession::getClientTimeMs()
{
  uint msecs = 0;
  if (fdclient != 0)
  {
    char tmpbuffer[MSG_BUFFER_SIZE + 1];
    memset(tmpbuffer, 0, MSG_BUFFER_SIZE+1);

    string str("GET_PARAMETER ");
    str.append(params.getFullURI());
    str.append(" RTSP/1.0\r\n");
    str.append("CSeq: " + semifunc::toString(lastServerCSeq+1) + "\r\n");
    str.append("Content-Type: text/parameters\r\n");
    str.append("Session: " + semifunc::toString(RtspSessionID) + "\r\n");
    str.append("Content-Length: 12\r\n\r\n");
    str.append("position\r\n\r\n");

    Globals::sdebug << "\nSPS::getClientTimeMs(): sending buffer: \r\n" << str << "\r\n";

    //send message and wait for response
    send(fdclient, str.c_str(), str.length(), 0);

    //wait for a response
    uint bytesRead = recv(fdclient, tmpbuffer, MSG_BUFFER_SIZE, 0);

    //extractCSeq(tmpbuffer, lastClientCSeq);

    Globals::sdebug << "\nSPS::getClientTimeMs(): received buffer: \r\n" << tmpbuffer << "(" << bytesRead << ")\r\n";

    if (bytesRead > 0)
    {
      char *positionPos;
      if ((positionPos = strstr(tmpbuffer, "position: ")) != NULL)
      {
        msecs = atoi(positionPos + 10);
        Globals::sdebug << "\nSPS::getClientTimeMs(): received msecs= " << msecs;
      }
    }
    else
    {
      cerr << "\nSPS::getClientTimeMs(): Error reading get_parameter response" << endl; cerr.flush();
      //could not retrieve client-time from player: set time to 0
      msecs = 0;
    }
  }
  else
  {
    Globals::sdebug << "\nSemiProxySession::getClientTimeMs(): client socket closed!";
  }

  return msecs;

}

/***********************************************************************/
void SemiProxySession::sendTeardownToClient()
{
  char tmpbuffer[MSG_BUFFER_SIZE + 1];
  memset(tmpbuffer, 0, MSG_BUFFER_SIZE+1);

  string str("TEARDOWN ");
  str.append(params.getFullURI());
  str.append(" RTSP/1.0\r\n");
  str.append("CSeq: " + semifunc::toString(lastServerCSeq+1) + "\r\n");
  str.append("Session: " + semifunc::toString(RtspSessionID) + "\r\n\r\n");

  Globals::sdebug << "\nSPS::sendTeardownToClient(): sending buffer: \r\n" << str << "\r\n";

  //send message and wait for response
  send(fdclient, str.c_str(), str.length(), 0);

//  uint bytesRead = recv(fdclient, tmpbuffer, MSG_BUFFER_SIZE, 0);
//  Globals::sdebug << "\nSPS::sendTeardownToClient(): received buffer: \r\n" << tmpbuffer << "(" << bytesRead << ")\r\n";
  Globals::sdebug << "\nSPS::sendTeardownToClient(): done!\r\n";
}


/***********************************************************************/
bool SemiProxySession::checkForValidAddress(char *recbuffer, int &bytesRead)
{
  Globals::sdebug << "\n::checkForValidAddress(): starts";

  if (bytesRead <= 0 || recbuffer == NULL)
  {
    Globals::sdebug << "\n::checkForValidAddress(): returning false (bytesRead=" << bytesRead << ")";
    return false;
  }

  //NOTE(!): bei SETUP wird der filename nicht mitgeschickt! (hacky)
  if (strstr(recbuffer, "SETUP rtsp://") != NULL || strstr(recbuffer, "PLAY rtsp://") != NULL) return true;


  //this functions assumes the following URI-Syntax:
  //rtsp://<servername>[:<serverport>]/<filename>[/port=<paramport>][/host=<paramhost>]
  char *servername;
  uint serverport;
  char *snstart, *snend, *ptstart, *fnbegin;
  if ((snstart = strstr(recbuffer, "rtsp://")) != NULL)
  {


    Globals::sdebug << "\n::checkForValidAddress(): found rtsp protocol";

    snstart += 7;
    if (snstart == NULL) return false;

    //find end of hostname (this is either ':' or '/')
    ptstart = snend =strstr(snstart, ":");
    fnbegin = strstr(snstart, "/");
    if (fnbegin != NULL && (snend == NULL || snend > fnbegin))
    {
      Globals::sdebug << "\n::checkForValidAddress(): / found before :";
      snend = fnbegin;
      ptstart = NULL;
    }

    if (snstart != NULL && snend != NULL)
    {

      Globals::sdebug << "\n::checkForValidAddress(): now copying name (" << (snend-snstart) << "b)...";

      //copy address
      servername = semifunc::newStrCpy(snstart, snend-snstart);
      //store reference to requested hostname for checkServerConnection();
      requestedHostname = servername;
      Globals::sdebug << "success! (" << servername << ")";

      //copy port
      serverport = DEFAULT_RTSPSERVER_PORT;
      if (ptstart != NULL)
      {
        Globals::sdebug << "\n::checkForValidAddress(): copying port...";
        serverport = atoi(ptstart+1);
        Globals::sdebug << "success! << (" << serverport << ")";
      }

      //find out IP-Address of this host
      char name[255];
      char *address, *localaddress, *serveraddress;
      if (gethostname(name, sizeof(name)) == 0)
      {
        //find out localhost address
        hostent *host = gethostbyname(name);
        if (host != NULL) {
          address = inet_ntoa(*(reinterpret_cast<in_addr*>(host->h_addr)));
          localaddress = semifunc::newStrCpy(address);

          Globals::sdebug << "\n::checkForValidAddress(): localaddress copied (" << localaddress << ")";
        } else {
          Globals::sdebug << "\n::checkForValidAddress(): FATAL cannot resolve hostname " << name;
        }

        //find out address of specified server
        hostent *host2 = gethostbyname(servername);
        address = inet_ntoa(*(reinterpret_cast<in_addr*>(host2->h_addr)));
        serveraddress = semifunc::newStrCpy(address);

        Globals::sdebug << "\n::checkForValidAddress(): serveraddress copied (" << serveraddress <<")";
      }
      else
      {
        throw GetHostNameProblem();
      }

      Globals::sdebug << "\nservername=" << servername
      << "\nserverport=" << serverport << "\nName=" << name << "\nAddress=" << localaddress << "\nServer=" << serveraddress;

      if ((strcmp(serveraddress, localaddress) == 0 || strcmp(serveraddress, "127.0.0.1") == 0)
          && serverport == sp->getProxyPort())
      {

        //CLIENT HAS SPECIFIED THE ADDRESS+PORT OF SEMIPROXY AS SERVER -> NOT ALLOWED !!!

        //check if this is only an OPTIONS message
        //(which have no file specified)
        if (strncmp(recbuffer, "OPTIONS ", 8) == 0)
        {
          Globals::sdebug << "\n::checkForValidAddress(): OPTIONS MESSAGE";
          //to OPTIONS MESSAGE only reply like a server do
          //WARNING: this may be not the real supported options by the server
          //TODO:
          ostringstream reply;
          reply << "RTSP/1.0 200 OK\r\nCSeq: " << (lastClientCSeq+1) << "\r\nPublic: "
          << "OPTIONS, DESCRIBE, SETUP, PLAY, PAUSE, TEARDOWN, GET_PARAMETER, SET_PARAMETER, REDIRECT" << "\r\n\r\n";
          send(fdclient, reply.str().c_str(), reply.str().length(), 0);
          //sendMessage(this->fdclient, reply.str().c_str(), reply.str().length());
          return false;
        }


        //if there is no other address specified in the params, close session!
        if (params.getHost() == NULL && params.getPort() == 0)
        {
          cerr << "\nERROR: Proxy cannot be used as server!";
          removeSession();
        }
        else
        {
          //***************create new buffer starts***************
          //create new buffer with correct rtsp-uri
          //(if port or host specified, the original values of the URI
          //will be replaced by the values from the params; the params
          //will be erased!)
          char *strbuf = new char[MSG_BUFFER_SIZE];

          uint count = snstart-recbuffer;
          //copy start of message
          strncpy(strbuf, recbuffer, count);
          //if a param 'host=' was specified, copy this host
          if (params.getHost() != NULL)
          {
            //store reference to requested hostname for checkServerConnection()
            requestedHostname = params.getHost();

            //copy new hostname
            strncpy(&strbuf[count], params.getHost(), strlen(params.getHost()));
            count += strlen(params.getHost());
            Globals::sdebug << "\n::checkForValidAddress: hostname copied: " << requestedHostname;
          }
          else
          {
            Globals::sdebug << "\n::checkForValidAddress: no explicit specified host!";
            //copy hostname
            strncpy(&strbuf[count], snstart, snend-snstart);
            count += snend-snstart;
          }
          if (ptstart != NULL || params.getPort() != 0) strbuf[count++] = ':';
          if (params.getPort() != 0)
          {
            //copy new port
            string port = semifunc::toString(params.getPort());
            strncpy(&strbuf[count], port.c_str(), port.length());
            count += port.length();
            Globals::sdebug << "\n::checkForValidAddress: port copied: " << port;
          }
          else if (ptstart != NULL)
          {
            Globals::sdebug << "\n::checkForValidAddress: no explicit specified port!";
            //copy port
            strncpy(&strbuf[count], ptstart+1, fnbegin-(ptstart+1));
            count += fnbegin - (ptstart+1);
          }

          //copy the remaining of the message
          uint i=0;
          //while (ctstart[i] != 0) strbuf[count++] = ctstart[i++];
          while (fnbegin[i] != 0) strbuf[count++] = fnbegin[i++];
          strbuf[++count] = 0;
          //***************create new buffer ends***************

          //Globals::sdebug << "\n::checkHostnameAndPort(): newBUFFER=" << strbuf;
          memcpy(recbuffer, strbuf, count);
          bytesRead = count;

          delete strbuf;
          strbuf = NULL;

          return true;
        }
      }

    }
  }

  return true;
}

/***********************************************************************/
void SemiProxySession::readFromSocket(int fdsock, struct timeval &tv, fd_set &rfds)
{
  bytesRead = 0;
  uint n = 0;
  bool abortReading = false;
  while (abortReading == false)
  {
    n = recv(fdsock, buffer + bytesRead, MSG_BUFFER_SIZE, 0);
    bytesRead += n;
    FD_ZERO(&rfds);
    select(fdsock+1, &rfds, NULL, NULL, &tv);
    if (!FD_ISSET(fdsock, &rfds)) abortReading = true;
  }
}

/***********************************************************************/
void SemiProxySession::run()
{

  fd_set rfds;
  struct timeval tv;

  //number of microseconds to sleep after a loop run
  ulong sleep_msecs = PROXY_SLEEP_USECS;

  int bytesReadClient = -1;
  int bytesReadServer = -1;

  //pointer to begin of buffer
  char *bufferstart = buffer;


  while (state!=SESSION_ERR && state!=SESSION_CLOSED)
  {
    //first check if socket has closed
    if (fdclient == 0)
    {
      Globals::sdebug << "\n::run(): Client has closed socket ->  CLOSE SESSION";
      closeSession();
      break;
    }

    //(maximum) waiting time for select
    tv.tv_sec = 0;
    tv.tv_usec = 10000;

    FD_ZERO(&rfds);
    //only add client or server to FD_LIST, when socket has not been closed!
    if (bytesReadClient != 0) FD_SET(fdclient, &rfds);
    if (bytesReadServer != 0) FD_SET(fdserver, &rfds);
    //use bigger socket-number for select
    int maxsocknr = (fdclient < fdserver) ? fdserver : fdclient;
    int retval = select(maxsocknr+1, &rfds, NULL, NULL, &tv);
    if (retval == -1)
    {
      cerr << "\nSPS::run(): ERROR select()" << endl;
    }
    else if (retval)
    {

      //************************READ FROM CLIENT start*************************
      if (FD_ISSET(fdclient, &rfds))
      {
        sessionControlChannel = fdclient;

        buffer = bufferstart;
        memset(buffer, 0, MSG_BUFFER_SIZE);


        //read until no more bytes (because of MTU)
        readFromSocket(fdclient, tv, rfds);
        bytesReadClient = bytesRead;


        //**readRequest does not correctly work with other players !!!**
        //bytesReadClient = bytesRead = readRequest(buffer, MSG_BUFFER_SIZE);

        //on PAUSE stop time-measurement
        if (strstr(buffer, "PAUSE rtsp://") != NULL)
        {
          //stop time-measurement for current time-section
          timemsmnt->stopTS();
        }


        //special handling for quicktime embedded
        //(TODO:CAN BE REMOVED, IF applyReqToSession can handle several callbacks)
        char *teardownstart;
        if (strncmp(buffer, "PAUSE", 5) == 0
            && (teardownstart = strstr(buffer, "TEARDOWN")) != NULL)
        {
          //remove pause
          bytesReadClient = bytesRead = bytesRead - (teardownstart - buffer);
          buffer = teardownstart;
        }
        char *playstart;
        if (strncmp(buffer, "SET_PARAMETER", 13) == 0
            && (playstart = strstr(buffer, "PLAY")) != NULL)
        {
          bytesReadClient = bytesRead = bytesRead - (playstart - buffer);
          //remove set_parameter
          buffer = playstart;
        }


        //on DESCRIBE extract full-URI
        if (strstr(buffer, "DESCRIBE rtsp://") != NULL)
        {
          char *fnstart, *fnend;
          if ((fnstart = strstr(buffer, "rtsp://")) != NULL)
          {
            if ((fnend = strstr(fnstart, " ")) != NULL)
            {
              params.setFullURI(semifunc::newStrCpy(fnstart, fnend-fnstart));
            }
          }
        }


        //new extract (and remove!) ALL PARAMETERS
        string bufferstr (buffer);


        //look for parameters in the URI and remove them
        char *pmovieid, *prange, *phost;
        int puid, pproid, psid, pport, action, section, subtractMsecs;
        if ((puid = extractParameter(bufferstr, "/uid=", true)) >= 0)
        {
          params.setUserId(puid);
        }
        if ((pproid = extractParameter(bufferstr, "/proid=", true)) >= 0)
        {
          params.setProfileId(pproid);
        }
        if ((pmovieid = extractStrParameter(bufferstr, "/id=", true)) != NULL)
        {
          params.setMovieId(pmovieid);
        }
        if ((psid = extractParameter(bufferstr, "/sid=", true)) >= 0)
        {
          params.setSessionId(psid);
        }
        if ((action = extractParameter(bufferstr, "/action=", true)) >= 0)
        {
          params.setAction(action);
        }
        if ((section = extractParameter(bufferstr, "/section=", true)) >= 0)
        {
          params.setSection(section);
        }
        if ((subtractMsecs = extractParameter(bufferstr, "/sub=", true)) >= 0)
        {
          params.setSubtractSecs(subtractMsecs);
        }
        //special parameters (if no RTSP proxy can be used!)
        if ((prange =extractStrParameter(bufferstr, "/range=",true)) != NULL)
        {
          params.setRange(prange);
        }
        if ((phost = extractStrParameter(bufferstr, "/host=", true)) != NULL)
        {
          params.setHost(phost);
        }
        if ((pport = extractParameter(bufferstr, "/port=", true)) >= 0)
        {
          params.setPort(pport);
        }

        //store back buffer (with params removed)
        buffer = bufferstart;
        memset(buffer, 0, MSG_BUFFER_SIZE);
        bufferstr.copy(buffer, bufferstr.length());
        //buffer = (char*)bufferstr.c_str();


        //check hostname and port (cannot be same as host+port of proxy)
        //NOTE: this function may change the address and port of the request!!!
        if (checkForValidAddress(buffer, bytesRead))
        {

          Globals::sdebug << "\nSP::run(): received from client:\n\t" << buffer;

          if (bytesRead == 0)
          {
            //no data read; the other side has closed the connection, teardown all
            tearDown(TEARDOWN_ALL,true, NULL, NULL);
          }
          else if (bytesRead < 0)
          {
            cerr << "\nSPS::run(): Error reading from controlchannel" << endl;
            tearDown(TEARDOWN_ALL,true,NULL, NULL);
            state = SESSION_ERR;
          }
          else
          {
            // we have got a command from the client; parse it and forward it to the server

            //determine protocol of message
            if (!prot)
            {
              if ( determineProtocol(buffer) == PROTO_UNKNOWN)
              {
                cerr << "\nSPS::run(): Unknown protocol: " << buffer << endl;
              }
            }

            //if known protocol was recognized, perform further parsing...
            if (prot)
            {
              switch (prot->getID())
              {
              case PROTO_RTSP:
                if (bytesRead >= MSG_BUFFER_SIZE)
                {
                  cerr << "\nSPS::run(): received command exceeded buffer size" << endl;
                  break;
                }
                break;
              default:
                cerr << "\nSPS::run(): Unknown protocol: " << buffer << endl;
                break;
              }

              //call control-function in RTSP-object; this function will callback other functions
              //in this object like connect(), setup(), play(), pause(), teardown()...
              if (!prot->applyReqToSession(buffer, bytesRead, this, true))
              {
                cerr << "\nSPS::run(): Failed to parse request '" << buffer << "'" << endl;
              }

            }
          }
        }
      }
      //************************read from client end*************************



      //************************READ FROM SERVER start*************************
      if (FD_ISSET(fdserver, &rfds))
      {
        sessionControlChannel = fdserver;

        buffer = bufferstart;
        memset(buffer, 0, MSG_BUFFER_SIZE);
        //use common  receive-function, because readRequest do not
        //work sometimes (doesn't call options/setup/... functions)

        //read until no more bytes (because of MTU)
        readFromSocket(fdserver, tv, rfds);
        bytesReadServer = bytesRead;
        //bytesReadServer = bytesRead = recv(fdserver, buffer, MSG_BUFFER_SIZE, 0);
        //bytesReadServer = bytesRead = readRequest(buffer, MSG_BUFFER_SIZE);

        Globals::sdebug << "\nSP::run(): received from server (" << bytesReadServer << " bytes):\n\t" << buffer;

        if (bytesRead == 0)
        {
          //no data read; the server has closed the connection, teardown all
          cerr << "\nSPS::run(): No data read from ControlChannel (SERVER has closed connection)" << endl;
          removeSession();
        }
        else if (bytesRead < 0)
        {
          cerr << "\nSPS::run(): Error reading from controlchannel" << endl;
          removeSession();
        }
        else
        {
          // we got a command from the server; parse it and forward to client
          parseResponseFromServer(buffer, bytesRead);
        }
      }
      //************************read from server end*************************
    }

    //look if there is an outstanding position-request
    //this special handling is necessary, because otherwise (if another session directly
    //calls 'getServerTimeMs()') the response could be received in this main-loop as
    //instead of the recv() of 'getServerTimeMs()'. This is because concurrent execution
    if (state != SESSION_ERR && state != SESSION_CLOSED) {
      if (sendServerPositionRequest == true)
      {
        Globals::sdebug << "\n::run(" << RtspSessionID << "): outstanding server position request - STARTS";
        receivedServerPosition = this->getServerTimeMs();
        sendServerPositionRequest = false;
        Globals::sdebug << "\n::run(" << RtspSessionID << "): outstanding server position request - DONE";
      }

      else if (sendClientPositionRequest == true)
      {
        Globals::sdebug << "\n::run(" << RtspSessionID << "): outstanding client position request - STARTS";
        receivedClientPosition = this->getClientTimeMs();
        sendClientPositionRequest = false;
        Globals::sdebug << "\n::run(" << RtspSessionID << "): outstanding client position request - DONE";
      }

#ifndef WIN32
      usleep(sleep_msecs);
#else
          Sleep(sleep_msecs);
#endif
    }

  }

  Globals::sdebug << "::run() closing SemiProxySession " << RtspSessionID << "\n";
}

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