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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

SemiGlobals.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: SemiGlobals.cpp  (S H A R E D)                                *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * 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 "SemiGlobals.hpp"







/***********************************************************************/
SemiDebug::SemiDebug(char *logfile)
{
  stdOutEnabled = false;
  shouldFlush = false;
  this->logfile = logfile;
  if (logfile) outfile.open(logfile);
  writeTimestamp("Log started on on ");
}


/***********************************************************************/
SemiDebug::~SemiDebug()
{
  writeTimestamp("\r\nLog ended on on ");
  writeLogfile();
}

/***********************************************************************/
void SemiDebug::doFlush()
{
  cout.flush();

  if (logfile) {
        uint i = 0;
        while (i < log.size())
        {
        outfile << log[i];
        log.erase(log.begin());
        }
        //force write of file
        outfile.close();
        outfile.open(logfile, ios::app);
  }
}

/***********************************************************************/
void SemiDebug::writeTimestamp(char *str)
{
  if (logfile) {
#ifndef WIN32
        struct timeval currTime;
        gettimeofday(&currTime, NULL);
        uint hour = (currTime.tv_sec / 3600) % 24;
        uint minute = (currTime.tv_sec / 60 ) % 60;
        uint second = currTime.tv_sec % 60;
#else
        SYSTEMTIME currTime;
        GetLocalTime(&currTime);
        uint hour = currTime.wHour;
        uint minute = currTime.wMinute;
        uint second = currTime.wSecond;
#endif
        ostringstream ostr;
        ostr << str << hour << ":" << minute << ":" << second;
        log.push_back(ostr.str());
        if (shouldFlush) doFlush();
  }
}

/***********************************************************************/
void SemiDebug::writeLogfile()
{
  if (logfile) {

        if (log.size() > 0 && outfile)
        {

        vector<string>::const_iterator iter = log.begin();
        while (iter != log.end())
        {
        outfile << *iter++;
        }
        }

        if (outfile)
        {
        outfile.close();
        Globals::sdebug << "SemiDebug::writeLogfile(): logfile written \r\n";
        }
  }
}

/***********************************************************************/
void SemiDebug::enableStdOut()
{
  this->stdOutEnabled = true;
}

/***********************************************************************/
void SemiDebug::enableFlush()
{
  this->shouldFlush = true;
}

/***********************************************************************/
SemiDebug& SemiDebug::operator << (unsigned int n)
{
  if (logfile) log.push_back(semifunc::toString(n));

  if (stdOutEnabled) cout << n;
  if (shouldFlush) doFlush();
  return *this;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (int n)
{
  if (logfile) log.push_back(semifunc::toString(n));

  if (stdOutEnabled) cout << n;
  if (shouldFlush) doFlush();
  return *this;
}

/***********************************************************************/
SemiDebug& SemiDebug::operator << (unsigned long n)
{
  if (logfile) log.push_back(semifunc::toString(n));

  if (stdOutEnabled) cout << n;
  if (shouldFlush) doFlush();
  return *this;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (long n)
{
  if (logfile) log.push_back(semifunc::toString(n));

  if (stdOutEnabled) cout << n;
  if (shouldFlush) doFlush();
  return *this;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (float f)
{
  if (logfile) log.push_back(semifunc::toString(f));

  if (stdOutEnabled) cout << f;
  if (shouldFlush) doFlush();
  return *this;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (double d)
{
  if (logfile) log.push_back(semifunc::toString(d));

  if (stdOutEnabled) cout << d;
  if (shouldFlush) doFlush();
  return *this;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (char c)
{
  if (logfile) log.push_back(semifunc::toString(c));

  if (stdOutEnabled) cout << c;
  if (shouldFlush) doFlush();
  return *this;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (char *str)
{
  string strg (str);
  semifunc::replaceStr(strg, "\r\n", "\r \n\t", true);
  if (logfile) log.push_back(strg);

  if (stdOutEnabled) cout << strg;
  if (shouldFlush) doFlush();
  return *this;
}

/***********************************************************************/
SemiDebug& SemiDebug::operator << (const char *str)
{
  return *this << (char*)str;
}


/***********************************************************************/
SemiDebug& SemiDebug::operator << (string &str)
{
  string strg (str);
  semifunc::replaceStr(strg, "\r\n", "\r \n\t", true);
  if (logfile) log.push_back(strg);

  if (stdOutEnabled) cout << strg;
  if (shouldFlush) doFlush();
  return *this;
}





//define static variables
bool Globals::initialized = false;
//SemiDebug Globals::sdebug ("./semilog.txt");
SemiDebug Globals::sdebug (NULL);
map<char*,char*> Globals::config;
map<char*, char*> Globals::configDesc;


/***********************************************************************/
char *Globals::getConfigFilePath()
{
  char *dest = new char[100];
  if (getenv("HOME") != NULL) {
        strcpy(dest, getenv("HOME"));
        strcat(dest, "/.semirc");
  } else {
        strcpy(dest, "/.semirc");
  }
  return dest;
}

/***********************************************************************/
void Globals::initialize()
{
  loadConfiguration(getConfigFilePath());
  initialized = true;
}

/***********************************************************************/
string Globals::getCGIPath()
{
  if (!initialized) initialize();
  return config["CGIPath"];
}

/***********************************************************************/
char *Globals::getProxyComHost()
{
  if (!initialized) initialize();
  return config["ProxyComHost"];
}

/***********************************************************************/
int Globals::getProxyComPort()
{
  if (!initialized) initialize();
  return atoi(config["ProxyComPort"]);
}

/***********************************************************************/
char *Globals::getMoviesFileName()
{
  if (!initialized) initialize();
  return config["MoviesFilePath"];
}

/***********************************************************************/
char *Globals::getAbsoluteImagesFilePath()
{
  if (!initialized) initialize();
  return config["AbsoluteImagesFilePath"];
}

/***********************************************************************/
char *Globals::getRelativeImagesFilePath()
{
  if (!initialized) initialize();
  return config["RelativeImagesFilePath"];
}

/***********************************************************************/
char *Globals::getMediaserverHttpHost()
{
  if (!initialized) initialize();
  return config["MediaserverHttpHost"];
}

/***********************************************************************/
int Globals::getMediaserverHttpPort()
{
  if (!initialized) initialize();
  return atoi(config["MediaserverHttpPort"]);
}

/***********************************************************************/
char *Globals::getAbsoluteSDPFilePath()
{
  if (!initialized) initialize();
  return config["AbsoluteSDPFilePath"];
}

/***********************************************************************/
char *Globals::getRelativeSDPFilePath()
{
  if (!initialized) initialize();
  return config["RelativeSDPFilePath"];
}

uint Globals::getHoursToPreserveClosedSessions()
{
  if (!initialized) initialize();
  return atoi(config["HoursToPreserveClosedSessions"]);
}

uint Globals::getPRMaxWaitSecs()
{
  if (!initialized) initialize();
  return atoi(config["PRMaxWaitSecs"]);
}



/***********************************************************************/
void Globals::readConfigValues(char *buffer)
{

  uint i = 0, k;
  while (buffer[i] != 0)
  {
    //ignore users part
    if (strncmp(buffer+i, "############USERS start############", strlen("############USERS start############")) == 0) {
      uint oldi = i;
      while (strncmp(buffer+i, "############USERS end############", strlen("############USERS end############")) != 0) i++;
      sdebug << "\nusers part ignored (" << (i-oldi) << " bytes)";
    }

    //ignore profiles part
    if (strncmp(buffer+i, "############PROFILES start############", strlen("############PROFILES start############")) == 0) {
      uint oldi = i;
      while (strncmp(buffer+i, "############PROFILES end############", strlen("############PROFILES end############")) != 0) i++;
      sdebug << "\nprofiles part ignored (" << (i-oldi) << " bytes)";
    }

    //ignore comments
    if (buffer[i] == '#')
    {
      //look for end of line
      while (buffer[i] != '\r' && buffer[i] != '\n' && buffer[i] != 0) i++;
      if (buffer[i] == 0) break;
    }
    else if (buffer[i] == '\r' || buffer[i] == '\n')
    {
      //ignore empty lines
      i++;
    }
    else
    {
      //look for param
      k = i;
      while (buffer[i] != '=' && buffer[i] != 0) i++;
      k = i - k;
      if (k == 0) break;

      char *param = new char[k + 1];
      strncpy(param, &buffer[i-k], k);
      param[k] = 0;

      //look for value
      i++;
      //look for end of line
      k = i;
      while (buffer[i] != '\r' && buffer[i] != '\n' && buffer[i] != 0) i++;
      k = i - k;
      if (k == 0) break;

      char *val = new char[k + 1];
      strncpy(val, &buffer[i-k], k);
      val[k] = 0;

      sdebug << "\nGlobals::readConfigValues(): found param:" << param << "=" << val;

      if (strcmp(param, "CGIPath") == 0) config["CGIPath"] = val;
      else if (strcmp(param, "ProxyComHost") == 0) config["ProxyComHost"] = val;
      else if (strcmp(param, "ProxyComPort") == 0) config["ProxyComPort"] = val;
      else if (strcmp(param, "MoviesFilePath") == 0) config["MoviesFilePath"] = val;
      else if (strcmp(param, "AbsoluteImagesFilePath") == 0) config["AbsoluteImagesFilePath"] = val;
      else if (strcmp(param, "RelativeImagesFilePath") == 0) config["RelativeImagesFilePath"] = val;
      else if (strcmp(param, "MediaserverHttpHost") == 0) config["MediaserverHttpHost"] = val;
      else if (strcmp(param, "MediaserverHttpPort") == 0) config["MediaserverHttpPort"] = val;
      else if (strcmp(param, "AbsoluteSDPFilePath") == 0) config["AbsoluteSDPFilePath"] = val;
      else if (strcmp(param, "RelativeSDPFilePath") == 0) config["RelativeSDPFilePath"] = val;
      else if (strcmp(param, "HoursToPreserveClosedSessions") == 0) config["HoursToPreserveClosedSessions"] = val;
      else if (strcmp(param, "PRMaxWaitSecs") == 0) config["PRMaxWaitSecs"] = val;
    }
  }
}

/***********************************************************************/
void Globals::loadDefaultConfiguration()
{

  config["CGIPath"] = "/cgi-bin/";
  config["ProxyComHost"] = "localhost";
  config["ProxyComPort"] = "6556";
  config["MoviesFilePath"] = "metadata/MovieList.xml";
  config["AbsoluteImagesFilePath"] = "images/";
  config["RelativeImagesFilePath"] = "/images/";
  config["MediaserverHttpHost"] = "localhost";
  config["MediaserverHttpPort"] = "8080";
  config["AbsoluteSDPFilePath"] = "SDPs/";
  config["RelativeSDPFilePath"] = "/SDPs/";
  config["HoursToPreserveClosedSessions"] = "12";
  config["PRMaxWaitSecs"] = "3";

  configDesc["CGIPath"] = "#path of cgi-files used by the semiserver";
  configDesc["ProxyComHost"] = "#host running semiproxy (used from semiserver)";
  configDesc["ProxyComPort"] = "#port of semiproxy used to communicate with semiserver programs";
  configDesc["MoviesFilePath"] = "#filepath to movielist (which was requested from mediaserver)";
  configDesc["AbsoluteImagesFilePath"] = "#absolute path of images (used from semiserver to store requested images)";
  configDesc["RelativeImagesFilePath"] = "#relative path of images used from semiserver";
  configDesc["MediaserverHttpHost"] = "#host running the http-server of the mediaserver";
  configDesc["MediaserverHttpPort"] = "#port running the http-server of the mediaserver";
  configDesc["AbsoluteSDPFilePath"] = "#absolute path of SDP-files (used from semiserver to store on-the-fly created SDP files)";
  configDesc["RelativeSDPFilePath"] = "#relative path of SDP-files used from semiserver";
  configDesc["HoursToPreserveClosedSessions"] = "#number of hours, a closed session should be remained in the list of started sessions";
  configDesc["PRMaxWaitSecs"] = "#maximum number of seconds to wait for the response of a position request\r\n#(if this number is reached, the proxy will abort waiting for a response)";
}

/***********************************************************************/
void Globals::showCurrentConfiguration()
{
  if (!initialized) initialize();

  typedef map<char*, char*>::const_iterator MI;

  cout << "------------Current Configuration------------" << endl;
  for (MI c = config.begin(); c != config.end(); ++c)
  {
    cout << c->first << "=" << c->second << endl;
  }
  cout << "---------------------------------------------" << endl;
}

/***********************************************************************/
void Globals::writeConfiguration(char *filename)
{
  ofstream fout (filename);

  typedef map<char*, char*>::const_iterator MI;

  for (MI c = config.begin(); c != config.end(); ++c)
  {
    fout << configDesc[c->first] << endl;
    fout << c->first << "=" << c->second << endl << endl;
  }

  //write default users to config file
  fout << "\n\n############USERS start############\n";
  fout << "# This file is used for users.!\n";
  fout << "# Each user starts with a name (enclosed by brackets)\n";
  fout << "# and has the following properties:\n";
  fout << "#       - username (in brackets)\n";
  fout << "#       - userid\n";
  fout << "#       - password\n";
  fout << "#\n";
  fout << "# please do not use characters like öäüß...\n";
  fout << "#\n";
  fout << "[adam]\n";
  fout << "        uid=1\n";
  fout << "        pwd=adam\n\n";
  fout << "[eve]\n";
  fout << "        uid=2\n";
  fout << "        pwd=eve\n\n";
  fout << "[klaus]\n";
  fout << "        uid=3\n";
  fout << "        pwd=klaus\n\n";
  fout << "############USERS end############\n";

  //write default profiles to config file
  fout << "\n\n############PROFILES start############\n";
  fout << "# This file is used for profiles.!\n";
  fout << "# Each profile starts with a name (enclosed by brackets) \n";
  fout << "# and has the following properties:\n";
  fout << "#\tprofileId\t\tID of profil\n";
  fout << "#\t\t\t\tPLEASE USE CONSECUTIVE IDs!\n";
  fout << "#\t- uids\t\t\tIDs of users which are allowed, to \n";
  fout << "#\t\t\t\tto use this profile\n";
  fout << "#\t- width\t\t\tWidth of display in pixel\n";
  fout << "#\t- height\t\tHeight of display in pixel\n";
  fout << "#\t- color\t\t\tIs display color-capable ('yes'/'no')\n";
  fout << "#\t- bpp\t\t\tNumber of bits-per-pixel used for display\n";
  fout << "#\t- bufferingDelay\t\tBuffering-delay of the used device/player\n";
  fout << "#\t\t\t\tin milliseconds\n";
  fout << "#\t\t\t\tTHIS VALUE WILL ONLY BE USED, IF THE \n";
  fout << "#\t\t\t\tPLAYER DO NOT ANNOUNCE AN DELAY ITSELF!\n";
  fout << "#\t- netkBps\t\tNetwork bandwidth (in kilo-Bytes per sec)\n";
  fout << "#\t- refreshRate\t\tRefreshrate in Hertz (e.g. 100)\n";
  fout << "#\n";
  fout << "# please do not use characters like öäüß... \n";
  fout << "#\n";
  fout << "[Common (CIF)]\n";
  fout << "        profileId=1\n";
  fout << "        uids=1,2,3\n";
  fout << "        width=352\n";
  fout << "        height=288\n";
  fout << "        color=yes\n";
  fout << "        bpp=16\n";
  fout << "        bufferingDelay=8000\n";
  fout << "        netkBps=128\n";
  fout << "        refreshRate=100\n\n";
  fout << "[Common Gray]\n";
  fout << "        profileId=2\n";
  fout << "        uids=1,2,3\n";
  fout << "        width=352\n";
  fout << "        height=288\n";
  fout << "        color=no\n";
  fout << "        bpp=16\n";
  fout << "        bufferingDelay=8000\n";
  fout << "        netkBps=128\n";
  fout << "        refreshRate=100\n\n";
  fout << "[iPAQ]\n";
  fout << "        profileId=3\n";
  fout << "        uids=3\n";
  fout << "        width=192\n";
  fout << "        height=144\n";
  fout << "        color=yes\n";
  fout << "        bpp=16\n";
  fout << "        bufferingDelay=9000\n";
  fout << "        netkBps=64\n";
  fout << "        refreshRate=100\n\n";
  fout << "[iPAQ Gray]\n";
  fout << "        profileId=4\n";
  fout << "        uids=3\n";
  fout << "        width=192\n";
  fout << "        height=144\n";
  fout << "        color=no\n";
  fout << "        bpp=16\n";
  fout << "        bufferingDelay=9000\n";
  fout << "        netkBps=64\n";
  fout << "        refreshRate=100\n\n";
  fout << "[iPAQ small]\n";
  fout << "        profileId=5\n";
  fout << "        uids=3\n";
  fout << "        width=96\n";
  fout << "        height=72\n";
  fout << "        color=yes\n";
  fout << "        bpp=16\n";
  fout << "        bufferingDelay=9000\n";
  fout << "        netkBps=64\n";
  fout << "        refreshRate=100\n\n";
  fout << "[iPAQ small gray]\n";
  fout << "        profileId=6\n";
  fout << "        uids=3\n";
  fout << "        width=96\n";
  fout << "        height=72\n";
  fout << "        color=no\n";
  fout << "        bpp=16\n";
  fout << "        bufferingDelay=9000\n";
  fout << "        netkBps=64\n";
  fout << "        refreshRate=100\n";
  fout << "############PROFILES end############\n";

  fout.close();
}

/***********************************************************************
Loads the SeMi configuration from the specified config-file.
If the file not exists, this function writes the default config-file.
***********************************************************************/
bool Globals::loadConfiguration(char *filename)
{
  char buffer [CONFIGFILE_MAXLEN];
  ifstream fin (filename);

  //first load default configuration
  loadDefaultConfiguration();

  if (!fin)
  {
    cerr << "\nGlobals::loadConfiguration(): No SeMi-configfile detected!" << endl;
    writeConfiguration(filename);
    cout << "A default-configfile was written to:" << filename << endl;
    return false;
  }
  else
  {
    memset(buffer, 0, CONFIGFILE_MAXLEN);
    fin.read(buffer, CONFIGFILE_MAXLEN);
    fin.close();

    readConfigValues(buffer);

    return true;
  }
}

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