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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

SemiProxy.cpp

/***********************************************************************
*                                                                      *
* ViTooKi                                                              *
*                                                                      *
* title: SemiProxy.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, 2004                                 *
* Author: Klaus Schoeffmann                                            *
************************************************************************/


#include "SemiProxy.hpp"


#include "global.hpp"
#include "vitooki.hpp"

bool SemiProxy::semiproxyRunning;

/***********************************************************************
Signal handler for CTRL + C
***********************************************************************/
void sighandler(int sig)
{
  if (sig == SIGINT)
  {
    SemiProxy::setSemiProxyRunning(false);
    cout << "SIGINT" << endl;
    Globals::sdebug.writeLogfile();
    if (SemiProxy::getRefLastCreated() != NULL) SemiProxy::getRefLastCreated()->cleanup();
    exit(EXIT_SUCCESS);
  }
}


SemiProxy *SemiProxy::refLastCreated;

/***********************************************************************/
SemiProxy::SemiProxy(uint proxyPort, uint responderPort)
{
  this->proxyPort = proxyPort;
  addDestination = true;
  semiproxyRunning = true;
  requestServerPosition = true;
  requestClientPosition = true;

  //start Session-Management on specified port
  //(used for the socket-communication between semi-proxy and semi-server)
  sessMgmt = new SessionMgmt(responderPort);
  sessMgmt->start();

  //read all users from file
  ul = new UserList();
  ul->readUsersFromFile(Globals::getConfigFilePath());
  

  //read all profiles from file
  //(and also add each profile to corresponding user)
  prol = new ProfileList();
  prol->readProfilesFromFile(Globals::getConfigFilePath(), ul);

  refLastCreated = this;
}

/***********************************************************************/
SemiProxy::~SemiProxy()
{
  Globals::sdebug << "\r\ncalling ~SemiProxy()";
  cleanup();
}

/***********************************************************************/
void SemiProxy::cleanup()
{
  Globals::sdebug << "\nSemiProxy::cleanup()...";
  vector<class SemiProxySession*>::iterator iter = spsList.begin();
  while (iter != spsList.end())
  {
    SemiProxySession *sess = *iter;
    sess->setStateClosed();
    delete sess;
    iter++;
  }
  spsList.clear();

  if (sessMgmt != NULL) delete sessMgmt;
  if (ul != NULL) delete ul;
  if (prol != NULL) delete prol;
  Globals::sdebug << "\nSemiProxy::cleanup() done!";
}

/***********************************************************************/
int SemiProxy::createRtspServerSocket(const char *host, int port)
{
  struct hostent *hp;
  struct sockaddr_in sin;
  int sock;

  Globals::sdebug << "\n::createRtspServerSocket(): Trying to connect to " << host << " on port " << port << "...";

  if (!(hp = gethostbyname(host)))
  {
    cerr << "\n::createRtspServerSocket(): Cannot resolve host '" << host << "'" << endl;
    return 0;
  }

  sin.sin_family = AF_INET;
  //bcopy (hp->h_addr, (char*) &sin.sin_addr, hp->h_length);
  memcpy((char*) &sin.sin_addr, hp->h_addr, hp->h_length);
  sin.sin_port = htons(port);

  if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
  {
    cerr << "\n::createRtspServerSocket(): Cannot create socket" << endl;
    return 0;
  }

  if (::connect(sock, (struct sockaddr*) &sin, sizeof(sin)) < 0)
  {
#ifdef WIN32
    closesocket(sock);
#else
    close(sock);
#endif
    cerr << "\n::createRtspServerSocket(): Cannot connect to host '" << host << "'" << endl;
    return 0;
  }

  Globals::sdebug << "\n::createRtspServerSocket(): success!\r\n";

  return sock;
}

/***********************************************************************/
int SemiProxy::openClientSocket(int proxyport)
{
  Globals::sdebug << "\n::openClientSocket(): Trying to open passive socket on port " << proxyport;

  struct sockaddr_in sin, caller;
  int sock, newsocket;
  socklen_t len;

  memset((char*) &sin, 0, sizeof(sin));
  sin.sin_family = AF_INET;
  sin.sin_addr.s_addr = INADDR_ANY;
  sin.sin_port = htons(proxyport);

  if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
  {
    cerr << "\n::openClientSocket(): Cannot create Socket!" << endl;
    return 1;
  }

  const int reuse = 1;
  if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const char *) &reuse, sizeof(reuse)) < 0)
  {
    cerr << "\n::openClientSocket(): Cannot set sockOpt!" << endl;
    return 1;
  }

  if (bind(sock, (struct sockaddr*) &sin, sizeof(sin)) < 0)
  {
    cerr << "\n::openClientSocket(): Cannot bind socket!" << endl;
    return 1;
  }

  listen(sock, MAX_PENDING);

  cout << "\nSemiProxy running on port " << proxyport << "..." << endl;

  while (SemiProxy::isSemiProxyRunning())
  {
    if ((newsocket = accept(sock, (struct sockaddr*) &caller, &len)) < 0)
    {
      cerr << "\n::openClientSocket(): Cannot accept socket!" << endl;
      return 1;
    }

    Globals::sdebug << "\n::openClientSocket(): socket connected to " << inet_ntoa(caller.sin_addr) << " on port " << caller.sin_port << "\n";

    //start new proxy thread for this connection
    SemiProxySession *rtspthread = new SemiProxySession(newsocket, &caller, this);
    spsList.push_back(rtspthread);
    rtspthread->start();

    //wait 20 microseconds
#ifndef WIN32
    usleep(20);
#else
        Sleep(20);
#endif
        
  }

  return 0; //success;
}


/***********************************************************************/
void SemiProxy::addSession(SSession *asess)
{
  assert(asess != NULL);

  this->sessMgmt->addSession(asess);
}

/***********************************************************************/
void SemiProxy::removeSession(SSession *asess)
{
  if (asess != NULL)
  {
    this->sessMgmt->removeSession(asess);
  }
}

/***********************************************************************/
SSession *SemiProxy::getSession(uint RtspSessionId)
{
  return this->sessMgmt->getSession(RtspSessionId);
}

/***********************************************************************/
UserList *SemiProxy::getUserList()
{
  return ul;
}

/***********************************************************************/
ProfileList *SemiProxy::getProfileList()
{
  return prol;
}

/***********************************************************************/
uint SemiProxy::getProxyPort()
{
  return proxyPort;
}

/**********************************************************************/
void SemiProxy::setAddDestination(bool shouldAddDestination)
{
  addDestination = shouldAddDestination;
}

/***********************************************************************/
void SemiProxy::setAddTermCaps(bool shouldAddTermCaps)
{
  addTermCaps = shouldAddTermCaps;
}

/***********************************************************************/
void SemiProxy::setRequestServerPosition(bool shouldRequestServerPosition)
{
  requestServerPosition = shouldRequestServerPosition;
}

/***********************************************************************/
void SemiProxy::setRequestClientPosition(bool shouldRequestClientPosition)
{
  requestClientPosition = shouldRequestClientPosition;
}

/***********************************************************************/
bool SemiProxy::shouldAddDestination()
{
  return addDestination;
}

/***********************************************************************/
bool SemiProxy::shouldAddTermCaps()
{
  return addTermCaps;
}

/***********************************************************************/
bool SemiProxy::shouldRequestServerPosition()
{
  return requestServerPosition;
}

/***********************************************************************/
bool SemiProxy::shouldRequestClientPosition()
{
  return requestClientPosition;
}

/***********************************************************************/
bool SemiProxy::isSemiProxyRunning()
{
  return semiproxyRunning;
}

/***********************************************************************/
void SemiProxy::setSemiProxyRunning(bool isRunning)
{
  semiproxyRunning = isRunning;
}

/***********************************************************************/
SemiProxy *SemiProxy::getRefLastCreated()
{
  return refLastCreated;
}

/***********************************************************************
Show usage of semiproxy.
***********************************************************************/
void showUsage(char *progname)
{
  cout << progname << " <port> [-nodest] [-debug] [-flush] [-notermcaps] [-nogetspos] [-nogetcpos] [-showconfig]\r\n\r\n";
  cout << "\t<port>............Port of SemiProxy to listen\r\n";
  cout << "\t-nodest...........no change of destination parameter\r\n";
  cout << "\t                  on Describe-Msg.\r\n";
  cout << "\t-debug............output detailed debug messages\r\n";
  cout << "\t-flush............immediately outputs debug messages\r\n";
  cout << "\t-notermcaps.......do not add terminal-capabilites to Describe-Msg\r\n";
  cout << "\t-nogetspos........do not use Get-Parameter/position to obtain\r\n";
  cout << "\t                  media-time of a session from the SERVER.\r\n";
  cout << "\t-nogetcpos........do not use Get-Parameter/position to obtain\r\n";
  cout << "\t                  media-time of a session from the CLIENT.\r\n";
  cout << "\t-showconfig.......show current configuration\r\n";
  cout << "\r\n";

  exit(1);
}



/***********************************************************************/
int main(int argc, char* argv[])
{
  try
  {

    bool addDestAllowed = true,
         addTermCapsAllowed = true,
         requestServerPositionAllowed = true,
         requestClientPositionAllowed = true,
         showConfig = false;

    //at least the port must be specified
    if (argc < 2) showUsage(argv[0]);

    //vitooki_init_all();
    uint proxyPort = atoi(argv[1]);


    //look for additional options
    if (argc > 2)
    {
      int i = 2;
      while (i < argc)
      {
        if (strcmp(argv[i], "-nodest") == 0)
        {
          Globals::sdebug << "\nSP::run(): '-nodest' detected ";
          addDestAllowed = false;
        }
        else if (strcmp(argv[i], "-notermcaps") == 0)
        {
          Globals::sdebug << "\nSP::run(): '-notermcaps' detected ";
          addTermCapsAllowed = false;
        }
        else if (strcmp(argv[i], "-nogetspos") == 0)
        {
          Globals::sdebug << "\nSP::run(): '-nogetspos' detected ";
          requestServerPositionAllowed = false;
        }
        else if (strcmp(argv[i], "-nogetcpos") == 0)
        {
          Globals::sdebug << "\nSP::run(): '-nogetcpos' detected ";
          requestClientPositionAllowed = false;
        }
        else if (strcmp(argv[i], "-debug") == 0)
        {
          Globals::sdebug << "\nSP::run(): '-debug' detected ";
          Globals::sdebug.enableStdOut();
        }
        else if (strcmp(argv[i], "-flush") == 0)
        {
          Globals::sdebug << "\nSP::run(): '-flush' detected ";
          Globals::sdebug.enableFlush();
        }
        else if (strcmp(argv[i], "-showconfig") == 0)
        {
          showConfig = true;
        }
        else
        {
          cerr << "\nSP::run(): unrecognized option: " << argv[i] << endl;
          exit(1);
        }
        i++;
      }
    }

    //register signal-handler
    signal(SIGINT, sighandler);

    if (showConfig)
    {
      Globals::showCurrentConfiguration();
      exit(EXIT_SUCCESS);
    }

        vitooki_init_all();

    //start proxy
    SemiProxy *sp = new SemiProxy(proxyPort, Globals::getProxyComPort());
    sp->setAddDestination(addDestAllowed);
    sp->setAddTermCaps(addTermCapsAllowed);
    sp->setRequestServerPosition(requestServerPositionAllowed);
    sp->setRequestClientPosition(requestClientPositionAllowed);
    sp->openClientSocket(proxyPort);
    delete sp;

  }
  catch (...)
  {
    cerr << "\nSP::run(): Unknown exception thrown!" << endl;
  }

  Globals::sdebug.writeLogfile();

  Globals::sdebug << "\nSP::run(): END";

  return 0;
}

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