CAInfoService.cpp

Go to the documentation of this file.

/*
Copyright (c) 2000, The JAP-Team
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
 
- Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
 
- Redistributions in binary form must reproduce the above copyright
notice,
this list of conditions and the following disclaimer in the
documentation and/or
other materials provided with the distribution.
 
- Neither the name of the University of Technology Dresden, Germany nor
the names of its contributors
may be used to endorse or promote products derived from this software
without specific
prior written permission.
 
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
REGENTS OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE
*/
#include "StdAfx.h"
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX
#include "CAInfoService.hpp"
#include "CALibProxytest.hpp"
#include "xml/DOM_Output.hpp"
#include "CAHttpClient.hpp"
#endif
#ifndef ONLY_LOCAL_PROXY
#include "CASocket.hpp"
#include "CACmdLnOptions.hpp"
#include "CAMsg.hpp"
#include "CASocketAddrINet.hpp"
#include "CAUtil.hpp"
#include "CASingleSocketGroup.hpp"
#include "CALastMix.hpp"
#include "CACertificate.hpp"
#include "CAXMLBI.hpp"
 
#include "CADynamicCascadeConfigurator.hpp"
#endif
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX
 
const char * STRINGS_REQUEST_TYPES[NR_REQUEST_TYPES] = { "POST", "GET" };
const char * STRINGS_REQUEST_COMMANDS[NR_REQUEST_COMMANDS] = { "configure", "helo", "mixinfo/", "dynacascade", "cascade", "feedback", "tc" };
 
const UINT64 CAInfoService::MINUTE = 60;
const UINT64 CAInfoService::SEND_LOOP_SLEEP = 60;
const UINT64 CAInfoService::SEND_CASCADE_INFO_WAIT = MINUTE * 10;
const UINT64 CAInfoService::SEND_MIX_INFO_WAIT = MINUTE * 10;
const UINT64 CAInfoService::SEND_STATUS_INFO_WAIT = MINUTE;
const UINT32 CAInfoService::SEND_INFO_TIMEOUT_MS = 3000; // timeout for single send operations
const UINT32 CAInfoService::REPEAT_ON_STATUS_SENT_ERROR = 3;
 
struct CAInfoService::InfoServiceHeloMsg
{
  UINT8* strXML;
  UINT32 len;
  CASocketAddrINet* addr;
  CAInfoService* is;
  SINT32 requestCommand;
  const UINT8* param;
  SINT32 retVal;
};
 
 
 
THREAD_RETURN CAInfoService::InfoLoop(void *p)
{
  INIT_STACK;
  BEGIN_STACK("CAInfoService::InfoLoop");
 
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService - InfoLoop() started\n");
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService - InfoLoop() PID: %i\n", getpid());
  CAInfoService* pInfoService = (CAInfoService*)p;
  bool bIsFirst = true; //send our own certifcate only the first time
  bool bOneUpdateDone = false;
 
  UINT32 currentTime;
  UINT32 lastCascadeUpdate;
  UINT32 lastStatusUpdate;
  UINT32 lastMixInfoUpdate;
  UINT32 nextUpdate;
#ifdef DYNAMIC_MIX
  UINT32 loops = 4;
  UINT32 interval = 0;
#endif
  lastCascadeUpdate = lastMixInfoUpdate = lastStatusUpdate = (UINT32)time(NULL);
  // tell the algorithm it is time to update
  lastCascadeUpdate -= CAInfoService::SEND_CASCADE_INFO_WAIT;
  lastMixInfoUpdate -= CAInfoService::SEND_MIX_INFO_WAIT;
  lastStatusUpdate -= CAInfoService::SEND_STATUS_INFO_WAIT;
  UINT32 statusSentErrorBurst = 0;
 
  pInfoService->m_pLoopCV->lock();
  pInfoService->m_pLoopCV->wait(CAInfoService::SEND_LOOP_SLEEP * 1000);
  pInfoService->m_pLoopCV->unlock();
 
  while (pInfoService->isRunning())
    {
#ifdef DYNAMIC_MIX
      if(loops < 4)
        {
          sSleep(interval);
          loops++;
          continue;
        }
#endif
      // TODO: the "pInfoService->m_pMix->getLastConnectionTime() < (currentTime - (SEND_LOOP_SLEEP / 2))" is just a work-around until we have a proper synchronization with the xml nodes...
 
      currentTime = time(NULL);
      if (currentTime >= (lastStatusUpdate + CAInfoService::SEND_STATUS_INFO_WAIT))
        {
          if (pInfoService->m_pMix->isConnected() && pInfoService->m_pMix->getLastConnectionTime() < (currentTime - (SEND_LOOP_SLEEP / 2)) &&
              pInfoService->sendStatus(bIsFirst) == E_SUCCESS)
            {
              lastStatusUpdate = time(NULL);
              bIsFirst = false;
              bOneUpdateDone = true;
              statusSentErrorBurst = 0;
              //CAMsg::printMsg(LOG_DEBUG,"InfoService: Successfully sent Status information.\n");
            }
          else
            if (pInfoService->m_pMix->isConnected() && pInfoService->m_pMix->getLastConnectionTime() < (currentTime - (SEND_LOOP_SLEEP / 2)))
              {
                statusSentErrorBurst++;
                CAMsg::printMsg(LOG_WARNING, "InfoService: Could not send Status information.\n");
              }
          /* send terms and conditions */
          //pInfoService->sendOperatorTnCData();
        }
 
      // check every minute if configuring, every 10 minutes otherwise
      currentTime = time(NULL);
      if (currentTime >= (lastCascadeUpdate + CAInfoService::SEND_CASCADE_INFO_WAIT) || pInfoService->isConfiguring())
        {
          if (CALibProxytest::getOptions()->isFirstMix() || (CALibProxytest::getOptions()->isLastMix() && pInfoService->isConfiguring()))
            {
              if (pInfoService->m_pMix->isConnected() && pInfoService->m_pMix->getLastConnectionTime() < (currentTime - (SEND_LOOP_SLEEP / 2))
                  && pInfoService->sendCascadeHelo() == E_SUCCESS)
                {
                  lastCascadeUpdate = time(NULL);
                  bOneUpdateDone = true;
                  CAMsg::printMsg(LOG_INFO, "InfoService: Successfully sent Cascade information.\n");
                }
              else
                if (pInfoService->m_pMix->isConnected() && pInfoService->m_pMix->getLastConnectionTime() < (currentTime - (SEND_LOOP_SLEEP / 2)))
                  {
                    CAMsg::printMsg(LOG_WARNING, "InfoService: Could not send Cascade information.\n");
                  }
            }
          currentTime = time(NULL);
          if ((currentTime >= (lastMixInfoUpdate + CAInfoService::SEND_MIX_INFO_WAIT) &&
               pInfoService->m_pMix->getLastConnectionTime() < (currentTime - (SEND_LOOP_SLEEP / 2))) || pInfoService->isConfiguring())
            {
              if (pInfoService->sendMixHelo() != E_SUCCESS)
                {
                  CAMsg::printMsg(LOG_WARNING, "InfoService: Could not send MixInfo information.\n");
                }
              else
                {
                  lastMixInfoUpdate = time(NULL);
                  bOneUpdateDone = true;
                  CAMsg::printMsg(LOG_INFO, "InfoService: Successfully sent MixInfo information.\n");
                }
            }
        }
#ifdef DYNAMIC_MIX
      // LERNGRUPPE
      // Check regulary for new cascade information
      if( CALibProxytest::getOptions()->isDynamic() )
        {
          pInfoService->dynamicCascadeConfiguration();
        }
#endif
      currentTime = time(NULL);
      //@TODO BUGGy -- because it assumes knowledge about update times, which are configurable in StdAfx.hpp
      // wait CAInfoService::SEND_LOOP_SLEEP seconds at most
      /*temp = (currentTime - lastStatusUpdate);
      if (bOneUpdateDone && temp > 0)
      {
      if (temp <= CAInfoService::SEND_LOOP_SLEEP)
      {
      bPreventLoop = false;
      nextUpdate = CAInfoService::SEND_LOOP_SLEEP - temp;
      }
      else if (bPreventLoop)
      {
      // prevent infinite loops
      bPreventLoop = false;
      nextUpdate = CAInfoService::SEND_LOOP_SLEEP;
      }
      else
      {
      bPreventLoop = true;
      nextUpdate = 0;
      }
      }
      else
      {
      bPreventLoop = false;
      nextUpdate = CAInfoService::SEND_LOOP_SLEEP;
      }*/
 
      /* Not the optimal solution; would be best, if infoservice send
       * routines can be called by other threads if certain events occur, i.e.
       * cascade reconnection, etc.
       */
      if (bOneUpdateDone && (statusSentErrorBurst > 0))
        {
          //TODO: handle case when status sent error burst exceeds an upper limit */
          nextUpdate = CAInfoService::REPEAT_ON_STATUS_SENT_ERROR;
        }
      else
        {
          nextUpdate = CAInfoService::SEND_LOOP_SLEEP;
        }
#ifdef DYNAMIC_MIX
      interval = nextUpdate / 4;
      CAMsg::printMsg(LOG_DEBUG,"InfoService: Next update in %i seconds...interval %i\n", nextUpdate, interval);
      loops = 0;
#else
      if (nextUpdate > 20)
        {
          CAMsg::printMsg(LOG_DEBUG, "InfoService: Next update in %i seconds...\n", nextUpdate);
        }
      /* We can interrupt this thread if the mix is shutting down */
      pInfoService->m_pLoopCV->lock();
      pInfoService->m_pLoopCV->wait(nextUpdate * 1000);
      pInfoService->m_pLoopCV->unlock();
 
      //sSleep(nextUpdate);
#endif
    }
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService - InfoLoop() exited\n");
  FINISH_STACK("CAInfoService::InfoLoop");
  THREAD_RETURN_SUCCESS;
}
 
THREAD_RETURN CAInfoService::TCascadeStatus(void *p)
{
  INIT_STACK;
  BEGIN_STACK("CAInfoService::TCascadeStatus");
 
  InfoServiceHeloMsg* message = (InfoServiceHeloMsg*)p;
  message->retVal = message->is->sendStatus(message->strXML, message->len, message->addr);
 
  FINISH_STACK("CAInfoService::TCascadeStatus");
  THREAD_RETURN_SUCCESS;
}
 
THREAD_RETURN CAInfoService::TMixHelo(void *p)
{
  INIT_STACK;
  BEGIN_STACK("CAInfoService::TMixHelo");
 
  InfoServiceHeloMsg* message = (InfoServiceHeloMsg*)p;
  message->retVal = message->is->sendMixHelo(message->strXML, message->len, message->requestCommand, message->param, message->addr);
 
  FINISH_STACK("CAInfoService::TMixHelo");
  THREAD_RETURN_SUCCESS;
}
 
#endif
#ifndef ONLY_LOCAL_PROXY
 
THREAD_RETURN CAInfoService::TCascadeHelo(void *p)
{
  INIT_STACK;
  BEGIN_STACK("CAInfoService::TCascadeHelo");
 
  InfoServiceHeloMsg* message = (InfoServiceHeloMsg*)p;
  message->retVal = message->is->sendCascadeHelo(message->strXML, message->len, message->addr);
  FINISH_STACK("CAInfoService::TCascadeHelo");
  THREAD_RETURN_SUCCESS;
}
 
 
 
 
 
#ifdef DYNAMIC_MIX
 
bool CAInfoService::newCascadeAvailable()
{
  CASocket socket;
  CASocketAddrINet *address = NULL;
  CAHttpClient httpClient;
  bool ret = false;
 
  UINT32 status, contentLength;
  UINT8 buff[255];
  UINT8 bufMixId[60];
  UINT32 mixIdLen = 60;
  CALibProxytest::getOptions()->getMixId( bufMixId, mixIdLen );
  sprintf((char*)buff, "/newcascadeinformationavailable/%s",bufMixId );
  if( CALibProxytest::getOptions()->getRandomInfoService(address) != E_SUCCESS)
    {
      CAMsg::printMsg( LOG_ERR, "Unable to get a random InfoService - This will cause problems! Check your configuration!\n");
      return false;
    }
  if(socket.connect(*address)!=E_SUCCESS)
    {
      goto EXIT;
    }
  //Send request
  httpClient.setSocket(&socket);
  httpClient.sendGetRequest(buff);
  httpClient.parseHTTPHeader(&contentLength, &status);
  if(status!=200)
    {
      socket.close();
      ret = false;
      goto EXIT;
    }
  ret = true;
EXIT:
  delete address;
  address = NULL;
  return ret;
}
 
SINT32 CAInfoService::dynamicCascadeConfiguration()
{
  SINT32 ret = E_UNKNOWN;
  CADynamicCascadeConfigurator *configurator = NULL;
 
  if(!newCascadeAvailable())
    {
      return E_SUCCESS;
    }
 
  if(m_bReconfig)
    {
      return E_SUCCESS;
    }
  CAMsg::printMsg( LOG_DEBUG, "Starting dynamic reconfiguration...\n");
  m_bReconfig = true;
 
  configurator = new CADynamicCascadeConfigurator( m_pSignature, m_pMix );
  ret = configurator->configure();
  if(ret != E_SUCCESS)
    {
      CALibProxytest::getOptions()->resetNextMix();
      CALibProxytest::getOptions()->resetPrevMix();
      CALibProxytest::getOptions()->setCascadeProposal(NULL, 0);
      m_pMix->dynaReconfigure(false);
    }
  m_bReconfig = false;
  delete configurator;
  configurator = NULL;
 
  return ret;
}
#endif
 
 
 
 
 
 
#endif
 
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX
CAInfoService::CAInfoService()
{
  m_pMix = NULL;
  m_bRun = false;
  //m_pSignature=NULL;
  m_pMultiSignature = NULL;
  m_minuts = 0;
  m_lastMixedPackets = 0;
  m_expectedMixRelPos = 0;
  m_pLoopCV = new CAConditionVariable();
  m_pthreadRunLoop = new CAThread((UINT8*)"InfoServiceThread");
#ifdef DYNAMIC_MIX
  m_bReconfig = false;
#endif
}
CAInfoService::CAInfoService(CAMix* pMix)
{
  m_pMix = NULL;
  m_bRun = false;
  //m_pSignature=NULL;
  m_pMultiSignature = NULL;
  m_minuts = 0;
  m_lastMixedPackets = 0;
  m_expectedMixRelPos = 0;
  m_pLoopCV = new CAConditionVariable();
  m_pthreadRunLoop = new CAThread((UINT8*)"InfoServiceThread");
  m_pMix = pMix;
#ifdef DYNAMIC_MIX
  m_bReconfig = false;
#endif
}
 
CAInfoService::~CAInfoService()
{
  stop();
  delete m_pLoopCV;
  m_pLoopCV = NULL;
  delete m_pthreadRunLoop;
  m_pthreadRunLoop = NULL;
}
SINT32 CAInfoService::setMultiSignature(CAMultiSignature* pMultiSig)
{
  m_pMultiSignature = pMultiSig;
  return E_SUCCESS;
}
 
SINT32 CAInfoService::getLevel(SINT32* puser, SINT32* prisk, SINT32* ptraffic)
{
#if !defined ONLY_LOCAL_PROXY
  if (m_pMix != NULL && CALibProxytest::getOptions()->isFirstMix())
    {
      return ((CAFirstMix*)m_pMix)->getLevel(puser, prisk, ptraffic);
    }
#endif
  return E_UNKNOWN;
}
 
SINT32 CAInfoService::getMixedPackets(UINT64& ppackets)
{
#if ! defined ONLY_LOCAL_PROXY
  if (m_pMix != NULL && CALibProxytest::getOptions()->isFirstMix())
    {
      return ((CAFirstMix*)m_pMix)->getMixedPackets(ppackets);
    }
#endif
  return E_UNKNOWN;
}
 
SINT32 CAInfoService::start()
{
  if (m_pMultiSignature == NULL)
    {
      return E_UNKNOWN;
    }
  m_bRun = true;
  set64(m_lastMixedPackets, (UINT32)0);
  m_minuts = 1;
  m_pthreadRunLoop->setMainLoop(InfoLoop);
#ifdef DEBUG
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService::start() - starting InfoService thread\n");
#endif
 
  return m_pthreadRunLoop->start(this);
}
 
 
SINT32 CAInfoService::signal()
{
  m_pLoopCV->lock();
  m_pLoopCV->signal();
  m_pLoopCV->unlock();
  return E_SUCCESS;
}
 
SINT32 CAInfoService::stop()
{
  if (m_bRun)
    {
      m_bRun = false;
      /* Interrupt this thread */
      m_pLoopCV->lock();
      m_pLoopCV->signal();
      m_pLoopCV->unlock();
 
      m_pthreadRunLoop->join();
    }
  return E_SUCCESS;
}
 
SINT32 CAInfoService::sendStatus(bool bIncludeCerts)
{
  if (!CALibProxytest::getOptions()->isFirstMix())
    {
      return E_SUCCESS;
    }
 
 
  if (!(m_pMix->isConnected())) // && !bIncludeCerts )
    {
#ifdef DEBUG
      CAMsg::printMsg(LOG_INFO, "Mix not connected. Skipping status.\n");
#endif
      return E_UNKNOWN;
    }
 
  UINT32 len = 0;
  SINT32 ret = E_UNKNOWN;
  UINT8* strStatusXML = getStatusXMLAsString(bIncludeCerts, len);
 
  if (strStatusXML == NULL)
    {
      return E_UNKNOWN;
    }
 
  if (!(m_pMix->isConnected()))
    {
      CAMsg::printMsg(LOG_INFO, "Mix not connected. Skip sending already created status message.\n");
    }
  else
    {
      ret = sendHelo(strStatusXML, len, TCascadeStatus, (UINT8*)"Status Thread", REQUEST_COMMAND_STATUS);
    }
 
  delete[] strStatusXML;
  strStatusXML = NULL;
  return ret;
}
 
 
UINT8* CAInfoService::getStatusXMLAsString(bool bIncludeCerts, UINT32& len)
{
  SINT32 tmpUser, tmpRisk, tmpTraffic;
  UINT64 tmpPackets;
 
  //httpClient.setSocket(&oSocket);
  UINT8 strMixId[255];
  CALibProxytest::getOptions()->getMixId(strMixId, 255);
 
  tmpUser = tmpTraffic = tmpRisk = -1;
  set64(tmpPackets, (UINT32)-1);
  getLevel(&tmpUser, &tmpRisk, &tmpTraffic);
  SINT32 ret = getMixedPackets(tmpPackets);
  if (ret == E_SUCCESS)
    {
      UINT32 avgTraffic = div64(tmpPackets, m_minuts);
      UINT32 diffTraffic = diff64(tmpPackets, m_lastMixedPackets);
      if (avgTraffic == 0)
        {
          if (diffTraffic == 0)
            {
              tmpTraffic = 0;
            }
          else
            {
              tmpTraffic = 100;
            }
        }
      else
        {
          double dTmp = (double)diffTraffic / (double)avgTraffic;
          tmpTraffic = min(SINT32(50.*dTmp), 100);
        }
      set64(m_lastMixedPackets, tmpPackets);
    }
  m_minuts++;
  //let the attributes in alphabetical order..
#define XML_MIX_CASCADE_STATUS "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\
  <MixCascadeStatus LastUpdate=\"%s\" currentRisk=\"%i\" id=\"%s\" mixedPackets=\"%s\" nrOfActiveUsers=\"%i\" trafficSituation=\"%i\"\
  ></MixCascadeStatus>"
 
  UINT32 buffLen = 8192;
  UINT8* buff = new UINT8[buffLen];
  memset(buff, 0, buffLen);
  UINT8 tmpBuff[1024];
  UINT8 buffMixedPackets[50];
  print64(buffMixedPackets, tmpPackets);
  UINT64 currentMillis;
  UINT8 tmpStrCurrentMillis[50];
  if (getcurrentTimeMillis(currentMillis) == E_SUCCESS)
    {
      print64(tmpStrCurrentMillis, currentMillis);
    }
  else
    {
      tmpStrCurrentMillis[0] = 0;
    }
  sprintf((char*)tmpBuff, XML_MIX_CASCADE_STATUS, tmpStrCurrentMillis, tmpRisk, strMixId, buffMixedPackets, tmpUser, tmpTraffic);
 
 
  if (m_pMultiSignature->signXML(tmpBuff, strlen((char*)tmpBuff), buff, &buffLen, bIncludeCerts) != E_SUCCESS)
    {
      delete[] buff;
      buff = NULL;
    }
  else
    {
      len = buffLen;
    }
  return buff;
}
 
SINT32 CAInfoService::sendHelo(UINT8* a_strXML, UINT32 a_len, THREAD_RETURN(*a_thread)(void *), UINT8* a_strThreadName, SINT32 requestCommand, const UINT8* param)
{
  SINT32 returnValue = E_UNKNOWN;
  UINT32 nrAddresses;
  CAListenerInterface** socketAddresses = CALibProxytest::getOptions()->getInfoServices(nrAddresses);
  CAThread** threads = new CAThread*[nrAddresses];
  InfoServiceHeloMsg** messages = new InfoServiceHeloMsg*[nrAddresses];
 
  for (UINT32 i = 0; i < nrAddresses; i++)
    {
      messages[i] = new InfoServiceHeloMsg();
      messages[i]->addr = (CASocketAddrINet*)socketAddresses[i]->getAddr();
      messages[i]->len = a_len;
      messages[i]->strXML = a_strXML;
      messages[i]->is = this;
      messages[i]->requestCommand = requestCommand;
      messages[i]->param = param;
#if !defined(NO_INFOSERVICE_TRHEADS)
      threads[i] = new CAThread(a_strThreadName);
      threads[i]->setMainLoop((THREAD_RETURN (*)(void *))a_thread);
      threads[i]->start((void*)(messages[i]), false, true);
#else
      (*a_thread)(messages[i]);
      if (messages[i]->retVal == E_SUCCESS)
        {
          returnValue = E_SUCCESS;
        }
#endif
    }
 
  for (UINT32 i = 0; i < nrAddresses; i++)
    {
#if !defined(NO_INFOSERVICE_TRHEADS)
      if (threads[i]->join() == E_SUCCESS)
        {
          // CAMsg::printMsg(LOG_DEBUG,"InfoService: helo thread %u joined.\n", i);
          if (messages[i]->retVal == E_SUCCESS)
            {
              returnValue = E_SUCCESS;
            }
        }
      delete threads[i];
      threads[i] = NULL;
#endif
      delete messages[i]->addr;
      messages[i]->addr = NULL;
      delete messages[i];
      messages[i] = NULL;
    }
  //Message looks senseless but please keep it because Rolf reported a helo thread deadlock.
  //Perhaps there is a problem when the threads are joined.
  // CAMsg::printMsg(LOG_DEBUG,"InfoService: all helo threads joined. continue.\n");
  delete[] messages;
  messages = NULL;
  delete[] threads;
  threads = NULL;
 
  return returnValue;
}
 
 
 
 
SINT32 CAInfoService::sendStatus(const UINT8* a_strStatusXML, UINT32 a_len, const CASocketAddrINet* a_pSocketAddress) const
{
  UINT8 buffHeader[512];
  SINT32 ret = E_UNKNOWN;
  UINT8 hostname[255];
  UINT32 currentTimeout = MIX_TO_INFOSERVICE_TIMEOUT;
  UINT64 startupTime, currentMillis;
 
 
#ifdef DEBUG
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService::sendStatus()\n");
#endif
  if (!CALibProxytest::getOptions()->isFirstMix())
    {
      return E_SUCCESS;
    }
  CASocket oSocket(true);
  if (a_pSocketAddress == NULL)
    {
      oSocket.close();
      return E_UNKNOWN;
    }
 
 
  if (oSocket.connect(*a_pSocketAddress, MIX_TO_INFOSERVICE_TIMEOUT) != E_SUCCESS)
    {
      if (a_pSocketAddress->getIPAsStr(hostname, 255) == E_SUCCESS)
        {
          CAMsg::printMsg(LOG_DEBUG, "InfoService: Could not connect to InfoService %s:%d. Reason: %s (%i)\n",
                          hostname, a_pSocketAddress->getPort(), GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
        }
      else
        {
          CAMsg::printMsg(LOG_DEBUG, "InfoService: Could not connect to InfoService (host unknown) at port %d. Reason: %s (%i)\n",
                          a_pSocketAddress->getPort(), GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
        }
      oSocket.close();
      return E_UNKNOWN;
    }
 
  if (a_pSocketAddress->getIPAsStr(hostname, 255) == E_SUCCESS)
    {
      CAMsg::printMsg(LOG_DEBUG, "InfoService: Sending current status to InfoService %s:%d.\n", hostname, a_pSocketAddress->getPort());
      sprintf((char*)buffHeader, "POST /feedback HTTP/1.0\r\nContent-Length: %u\r\n\r\n", a_len);
 
      getcurrentTimeMillis(startupTime);
      oSocket.sendFullyTimeOut(buffHeader, strlen((char*)buffHeader), currentTimeout, SEND_INFO_TIMEOUT_MS);
 
      getcurrentTimeMillis(currentMillis);
      currentTimeout -= (currentMillis - startupTime);
      ret = oSocket.sendFullyTimeOut(a_strStatusXML, a_len, currentTimeout, SEND_INFO_TIMEOUT_MS);
    }
 
  oSocket.close();
  if (ret == E_SUCCESS)
    {
      return E_SUCCESS;
    }
  CAMsg::printMsg(LOG_DEBUG, "InfoService: Sending status failed, ret: %d \n", ret);
  return E_UNKNOWN;
}
SINT32 CAInfoService::sendMixHelo(SINT32 requestCommand, const UINT8* param)
{
  UINT32 len;
  SINT32 ret;
  UINT8* strMixHeloXML = getMixHeloXMLAsString(len);
 
  if (strMixHeloXML == NULL)
    {
      CAMsg::printMsg(LOG_DEBUG, "InfoService:sendMixHelo() -- Error: getMixHeloXMLAsString() returned NULL!\n");
      return E_UNKNOWN;
    }
 
  // CAMsg::printMsg(LOG_DEBUG,"InfoService:sendMixHelo(): Initialising helo thread...\n");
  ret = sendHelo(strMixHeloXML, len, TMixHelo, (UINT8*)"Mix Helo Thread", requestCommand, param);
  // CAMsg::printMsg(LOG_DEBUG,"InfoService:sendMixHelo(): Finished helo thread!\n");
 
  delete[] strMixHeloXML;
  strMixHeloXML = NULL;
  return ret;
}
 
UINT8* CAInfoService::getMixHeloXMLAsString(UINT32& a_len)
{
  XERCES_CPP_NAMESPACE::DOMDocument* docMixInfo = NULL;
  DOMElement* mixInfoRoot = NULL;
 
  if ((CALibProxytest::getOptions()->getMixXml(docMixInfo) != E_SUCCESS) ||
      (docMixInfo == NULL))
    {
      return NULL;
    }
 
  if (m_serial != 0)
    {
      mixInfoRoot = docMixInfo->getDocumentElement();
      if (mixInfoRoot != NULL)
        {
          setDOMElementAttribute(mixInfoRoot, ATTRIBUTE_SERIAL, m_serial);
        }
    }
  return xmlDocToStringWithSignature(docMixInfo, a_len, true);
}
 
UINT8* CAInfoService::xmlDocToStringWithSignature(DOMNode *a_node, UINT32& a_len, bool bIncludeCerts)
{
  a_len = 0;
 
  UINT32 sendBuffLen = 0;
  UINT8* sendBuff = NULL;
 
  if (a_node == NULL)
    {
      return NULL;
    }
  if (m_pMultiSignature->signXML(a_node, bIncludeCerts) != E_SUCCESS)
    {
      return NULL;
    }
 
  sendBuff = DOM_Output::dumpToMem(a_node, &sendBuffLen);
  if (sendBuff == NULL)
    {
      return NULL;
    }
  a_len = sendBuffLen;
  return sendBuff;
}
 
SINT32 CAInfoService::sendMixHelo(const UINT8* a_strMixHeloXML, UINT32 a_len, SINT32 requestCommand, const UINT8* param,
                                  const CASocketAddrINet* a_pSocketAddress)
{
  UINT8* recvBuff = NULL;
  SINT32 ret = E_SUCCESS;
  UINT32 len = 0;
 
  CASocket oSocket(true);
  UINT8 hostname[255];
  UINT8 buffHeader[255];
  CAHttpClient httpClient;
 
  UINT64 currentTimeout = MIX_TO_INFOSERVICE_TIMEOUT;
  UINT64 startupTime, currentMillis;
 
  UINT32 requestType = REQUEST_TYPE_POST;
  bool receiveAnswer = false;
 
  if (a_pSocketAddress == NULL)
    {
      goto ERR;
    }
 
  if (requestCommand < 0)
    {
      if (m_bConfiguring)
        {
          requestCommand = REQUEST_COMMAND_CONFIGURE;
          receiveAnswer = true;
        }
      else
        {
          requestCommand = REQUEST_COMMAND_HELO;
          receiveAnswer = true;
        }
    }
  else
    if (requestCommand == REQUEST_COMMAND_MIXINFO)
      {
        requestType = REQUEST_TYPE_GET;
        receiveAnswer = true;
      }
 
  if (a_pSocketAddress->getIPAsStr(hostname, 255) != E_SUCCESS)
    {
      goto ERR;
    }
 
  oSocket.setRecvBuff(255);
  if ((ret = oSocket.connect(*a_pSocketAddress, MIX_TO_INFOSERVICE_TIMEOUT)) == E_SUCCESS)
    {
      httpClient.setSocket(&oSocket);
      const char* strRequestCommand = STRINGS_REQUEST_COMMANDS[requestCommand];
      const char* strRequestType = STRINGS_REQUEST_TYPES[requestType];
      CAMsg::printMsg(LOG_DEBUG, "InfoService: Sending [%s] %s to InfoService %s:%d.\r\n", strRequestType, strRequestCommand, hostname, a_pSocketAddress->getPort());
      if (requestCommand == REQUEST_COMMAND_MIXINFO)
        {
          sprintf((char*)buffHeader, "%s /%s%s HTTP/1.0\r\nContent-Length: %u\r\n\r\n", strRequestType, strRequestCommand, param, a_len);
        }
      else
        {
          sprintf((char*)buffHeader, "%s /%s HTTP/1.0\r\nContent-Length: %u\r\n\r\n", strRequestType, strRequestCommand, a_len);
        }
 
      getcurrentTimeMillis(startupTime);
      if (oSocket.sendFullyTimeOut(buffHeader, strlen((char*)buffHeader), currentTimeout, SEND_INFO_TIMEOUT_MS) != E_SUCCESS)
        {
          goto ERR;
        }
 
      // CAMsg::printMsg(LOG_DEBUG,"InfoService: Sending XML data...\n");
      getcurrentTimeMillis(currentMillis);
      currentTimeout -= (currentMillis - startupTime);
      if (currentTimeout <= 0 ||
          oSocket.sendFullyTimeOut(a_strMixHeloXML, a_len, currentTimeout, SEND_INFO_TIMEOUT_MS) != E_SUCCESS)
        {
          goto ERR;
        }
 
      if (receiveAnswer)
        {
          // CAMsg::printMsg(LOG_DEBUG,"InfoService: Parsing header...\n");
          getcurrentTimeMillis(currentMillis);
          currentTimeout -= (currentMillis - startupTime);
          if (currentTimeout <= 0 || httpClient.parseHTTPHeader(&len) != E_SUCCESS)
            {
              goto ERR;
            }
          // CAMsg::printMsg(LOG_DEBUG,"InfoService: Header parsed!\n");
 
          if (len > 0)
            {
              getcurrentTimeMillis(currentMillis);
              currentTimeout -= (currentMillis - startupTime);
 
              recvBuff = new UINT8[len + 1];
              CAMsg::printMsg(LOG_DEBUG, "InfoService: Receiving answer...\n");
              if (currentTimeout <= 0 ||
                  oSocket.receiveFullyT(recvBuff, len, currentTimeout) != E_SUCCESS)
                {
                  delete[]recvBuff;
                  recvBuff = NULL;
                  goto ERR;
                }
              recvBuff[len] = 0;
              CAMsg::printMsg(LOG_DEBUG, "Received from Infoservice:\n");
              CAMsg::printMsg(LOG_DEBUG, (char*)recvBuff);
              CAMsg::printMsg(LOG_DEBUG, "\n");
            }
        }
      oSocket.close();
 
      if (recvBuff != NULL)
        {
          delete[] recvBuff;
          recvBuff = NULL;
        }
      /* REMOVED by Rolf Wendolsky on 2009-12-11 becuase this looks  dangerous: each InfoService may reconfigure the Mix! Without verificaton!
      if(recvBuff != NULL)
      {
      XERCES_CPP_NAMESPACE::DOMDocument* doc=parseDOMDocument(recvBuff,len);
      delete[] recvBuff;
      recvBuff=NULL;
      DOMElement* root=NULL;
      if(doc!=NULL && (root = doc->getDocumentElement()) != NULL)
      {
      if(equals(root->getNodeName(),"MixCascade"))
      {
      ret = handleConfigEvent(doc);
      if(ret == E_SUCCESS)
      m_bConfiguring = false;
      else
      return ret;
      }
      else if(equals(root->getNodeName(),"Mix"))
      {
      if(m_expectedMixRelPos < 0)
      {
      XMLCh* id=XMLString::transcode("id");
      char* tmpStr=XMLString::transcode(root->getAttribute(id));
      CAMsg::printMsg(LOG_DEBUG,"InfoService: Setting new previous mix: %s\n",tmpStr);
      XMLString::release(&tmpStr);
      XMLString::release(&id);
      CALibProxytest::getOptions()->setPrevMix(doc);
      }
      else if(m_expectedMixRelPos > 0)
      {
      XMLCh* id=XMLString::transcode("id");
      char* tmpStr=XMLString::transcode(root->getAttribute(id));
      CAMsg::printMsg(LOG_DEBUG,"InfoService: Setting new next mix: %s\n",tmpStr);
      XMLString::release(&id);
      XMLString::release(&tmpStr);
      CALibProxytest::getOptions()->setNextMix(doc);
      }
      }
      CAMsg::printMsg(LOG_DEBUG,"InfoService::sendMixHelo(): XML infoservice doc 0x%x not needed anymore.\n",
      doc);
      }
      else
      {
      CAMsg::printMsg(LOG_CRIT,"InfoService: Error parsing answer from InfoService!\n");
      }
      }*/
      return E_SUCCESS;
    }
  else
    {
      if (ret != E_UNKNOWN)
        {
          CAMsg::printMsg(LOG_ERR, "InfoService: sendMixHelo() connecting to InfoService %s:%d failed for reason: %s (%i)\n",
                          hostname, a_pSocketAddress->getPort(), GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
        }
      else
        {
          CAMsg::printMsg(LOG_ERR, "InfoService: sendMixHelo() connecting to InfoService %s:%d failed!\n",
                          hostname, a_pSocketAddress->getPort());
        }
    }
ERR:
 
  //CAMsg::printMsg(LOG_DEBUG,"InfoService: Closing socket to %s:%d due to error...\n", hostname, a_pSocketAddress->getPort());
  oSocket.close();
  //CAMsg::printMsg(LOG_DEBUG,"InfoService: Socket closed to %s:%d due to error.\n", hostname, a_pSocketAddress->getPort());
  return E_UNKNOWN;
}
 
 
#endif
#ifndef ONLY_LOCAL_PROXY
 
SINT32 CAInfoService::sendOperatorTnCData()
{
  /*SINT32 ret = E_SUCCESS;
  UINT32 *lengths_ptr = NULL;
  XMLSize_t nrOfTnCs = 0;
  UINT32 i = 0;
  UINT8 **tncData = getOperatorTnCsAsStrings(&lengths_ptr, &nrOfTnCs);
 
  if(tncData != NULL)
  {
  for (;i < nrOfTnCs; i++)
  {
  #ifdef DEBUG
  CAMsg::printMsg(LOG_DEBUG,"InfoService:sendMixTnCData(), object: %s, len: %u\n",
  tncData[i], lengths_ptr[i]);
  #endif
  if( tncData[i] != NULL )
  {
  ret |= sendHelo(tncData[i], lengths_ptr[i],
  TMixHelo, (UINT8*)"Mix TnC Thread",
  REQUEST_COMMAND_TNC_DATA, NULL);
  delete [] tncData[i];
  tncData[i] = NULL;
  }
  else
  {
  CAMsg::printMsg(LOG_ERR,"InfoService:sendMixTnCData() -- Element %u is invalid!\n", (i+1) );
  ret |= E_UNKNOWN;
  }
 
  }
  delete [] lengths_ptr;
  lengths_ptr = NULL;
 
  delete [] tncData;
  }
  else
  {
  CAMsg::printMsg(LOG_DEBUG,"InfoService:sendMixTnCData() -- No TnC data specified!\n");
  return E_SUCCESS;
  }
  return ret;*/
  return E_SUCCESS;
}
 
/*SINT32 CAInfoService::sendMixInfo(const UINT8* pMixID)
{
return sendMixHelo(REQUEST_COMMAND_MIXINFO,pMixID, NULL);
}
*/
UINT8 **CAInfoService::getOperatorTnCsAsStrings(UINT32 **lengths, UINT32 *nrOfTnCs)
{
 
 DOMElement *tnCs = CALibProxytest::getOptions()->getTermsAndConditions();
  if (tnCs == NULL)
    {
      return NULL;
    }
 
  DOMNodeList *docTnCsList =
    getElementsByTagName(tnCs, OPTIONS_NODE_TNCS_TRANSLATION);
 
  if (docTnCsList == NULL)
    {
      return NULL;
    }
 
  UINT8 **elementList = NULL;
  DOMNode *iterator = NULL;
  UINT32 i = 0;
 
  UINT8 tmpOpSKIBuff[TMP_BUFF_SIZE];
  UINT32 tmpOpSKILen = TMP_BUFF_SIZE;
 
  CALibProxytest::getOptions()->getOperatorSubjectKeyIdentifier(tmpOpSKIBuff, &tmpOpSKILen);
  if (tmpOpSKILen == 0)
    {
      return NULL;
    }
 
  UINT8 tmpDate[TMP_BUFF_SIZE];
  UINT32 tmpDateLen = TMP_BUFF_SIZE;
 
  getDOMElementAttribute(tnCs, OPTIONS_ATTRIBUTE_TNC_DATE, tmpDate, &tmpDateLen);
  if (tmpDateLen == 0)
    {
      return NULL;
    }
 
  UINT8 tmpVersion[TMP_BUFF_SIZE];
  UINT32 tmpVersionLen = TMP_BUFF_SIZE;
 
  UINT8* serial = NULL;
 
  getDOMElementAttribute(tnCs, OPTIONS_ATTRIBUTE_TNC_VERSION, tmpVersion, &tmpVersionLen);
  if (tmpVersionLen > 0)
    {
      serial = new UINT8[tmpDateLen + tmpVersionLen + 1];
      memcpy(serial, tmpDate, tmpDateLen);
      memcpy(serial + tmpDateLen, tmpVersion, tmpVersionLen);
      serial[tmpDateLen + tmpVersionLen] = 0;
    }
  else
    {
      serial = new UINT8[tmpDateLen + 1];
      memcpy(serial, tmpDate, tmpDateLen);
      serial[tmpDateLen] = 0;
    }
 
  UINT32 locale_len = 3;
  UINT8* id = new UINT8[tmpOpSKILen + locale_len + 1];
  UINT8* locale = new UINT8[locale_len];
 
  locale[locale_len - 1] = 0;
 
  memcpy(id, tmpOpSKIBuff, tmpOpSKILen);
  id[tmpOpSKILen] = 0;
  id[tmpOpSKILen + (locale_len - 1) + 1] = 0;
 
  (*nrOfTnCs) = docTnCsList->getLength();
  elementList = new UINT8 *[(*nrOfTnCs)];
  (*lengths) = new UINT32[(*nrOfTnCs)];
  for (; i < (*nrOfTnCs); i++)
    {
      //after every loop turn locale is explicitly reset to 3 because ...
      locale_len = 3;
      iterator = docTnCsList->item(i);
      //... it is modified by getDOMElementAttribute
      getDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_LOCALE, locale, &locale_len);
      if (locale_len == 0)
        {
          elementList[i] = NULL;
          continue;
        }
      //only append the locale code to the id when it is
      //not the default locale
      if (strncasecmp((char *)locale, LOCALE_DEFAULT, 2) == 0)
        {
          id[tmpOpSKILen] = 0;
        }
      else
        {
          id[tmpOpSKILen] = '_';
          memcpy((id + tmpOpSKILen + 1), locale, locale_len);
        }
 
      if (setDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_ID, id) != E_SUCCESS)
        {
          elementList[i] = NULL;
          continue;
        }
      if (setDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_DATE, tmpDate) != E_SUCCESS)
        {
          elementList[i] = NULL;
          continue;
        }
      if (setDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_SERIAL, serial) != E_SUCCESS)
        {
          elementList[i] = NULL;
          continue;
        }
      setCurrentTimeMilliesAsDOMAttribute(iterator);
      elementList[i] = xmlDocToStringWithSignature(iterator, (*lengths)[i], true);
    }
 
  delete[] serial;
  delete[] id;
  delete[] locale;
  return elementList;
 
}
 
 
 
 
 
 
SINT32 CAInfoService::sendCascadeHelo()
{
  if (CALibProxytest::getOptions()->isMiddleMix())
    {
      return E_SUCCESS;
    }
 
  UINT32 len;
  SINT32 ret;
  UINT8* strCascadeHeloXML = getCascadeHeloXMLAsString(len);
  if (strCascadeHeloXML == NULL)
    {
      return E_UNKNOWN;
    }
 
  if (!(m_pMix->isConnected()))
    {
#ifdef DEBUG
      CAMsg::printMsg(LOG_INFO, "not connected: skipping cascade helo.\n");
#endif
      delete[] strCascadeHeloXML;
      strCascadeHeloXML = NULL;
      return E_UNKNOWN;
    }
 
  ret = sendHelo(strCascadeHeloXML, len, TCascadeHelo, (UINT8*)"Cascade Helo Thread", REQUEST_COMMAND_CASCADE);
  delete[] strCascadeHeloXML;
  strCascadeHeloXML = NULL;
  return ret;
}
 
UINT8* CAInfoService::getCascadeHeloXMLAsString(UINT32& a_len)
{
  a_len = 0;
  UINT32 sendBuffLen;
  UINT8* sendBuff = NULL;
  XERCES_CPP_NAMESPACE::DOMDocument* docMixInfo = NULL;
  DOMElement* elemTimeStamp = NULL;
  DOMElement* elemRoot = NULL;
 
  if (m_pMix->getMixCascadeInfo(docMixInfo) != E_SUCCESS)
    {
      // CAMsg::printMsg(LOG_INFO,"InfoService: Cascade not yet configured.\n");
      goto ERR;
    }
  //insert (or update) the Timestamp
  elemRoot = docMixInfo->getDocumentElement();
 
  if (getDOMChildByName(elemRoot, "LastUpdate", elemTimeStamp, false) != E_SUCCESS)
    {
      elemTimeStamp = createDOMElement(docMixInfo, "LastUpdate");
      elemRoot->appendChild(elemTimeStamp);
    }
  UINT64 currentMillis;
  getcurrentTimeMillis(currentMillis);
  UINT8 tmpStrCurrentMillis[50];
  print64(tmpStrCurrentMillis, currentMillis);
  setDOMElementValue(elemTimeStamp, tmpStrCurrentMillis);
 
  if (m_serial != 0)
    {
      print64(tmpStrCurrentMillis, m_serial);
      setDOMElementAttribute(elemRoot, ATTRIBUTE_SERIAL, tmpStrCurrentMillis);
    }
 
  if (m_pMultiSignature->signXML(docMixInfo, true) != E_SUCCESS)
    {
      goto ERR;
    }
 
  sendBuff = DOM_Output::dumpToMem(docMixInfo, &sendBuffLen);
  if (sendBuff == NULL)
    {
      goto ERR;
    }
 
  a_len = sendBuffLen;
  return sendBuff;
ERR:
  delete[]sendBuff;
  sendBuff = NULL;
  return NULL;
}
 
SINT32 CAInfoService::sendCascadeHelo(const UINT8* a_strCascadeHeloXML, UINT32 a_len, const CASocketAddrINet* a_pSocketAddress) const
{
  if (CALibProxytest::getOptions()->isMiddleMix() || (CALibProxytest::getOptions()->isLastMix() && !m_bConfiguring))
    {
      return E_SUCCESS;
    }
  CASocket oSocket(true);
  UINT8 hostname[255];
  UINT8 buffHeader[255];
  UINT64 currentTimeout = MIX_TO_INFOSERVICE_TIMEOUT;
  UINT64 startupTime, currentMillis;
 
  if (a_pSocketAddress == NULL)
    {
      goto ERR;
    }
 
  if (a_pSocketAddress->getIPAsStr(hostname, 255) != E_SUCCESS)
    {
      goto ERR;
    }
  if (oSocket.connect(*a_pSocketAddress, MIX_TO_INFOSERVICE_TIMEOUT) == E_SUCCESS)
    {
      if (CALibProxytest::getOptions()->isFirstMix())
        {
          CAMsg::printMsg(LOG_DEBUG, "InfoService: Sending cascade helo to InfoService %s:%d.\r\n", hostname, a_pSocketAddress->getPort());
        }
      else
        {
          CAMsg::printMsg(LOG_DEBUG, "InfoService: Sending cascade configuration request to InfoService %s:%d.\r\n", hostname, a_pSocketAddress->getPort());
        }
      // LERNGRUPPE
      // Semi-dynamic cascades are temporary cascades, not yet established! InfoService can cope with them now
      // using the /dynacascade command
      if (CALibProxytest::getOptions()->isLastMix() && m_bConfiguring)
        {
          sprintf((char*)buffHeader, "POST /dynacascade HTTP/1.0\r\nContent-Length: %u\r\n\r\n", a_len);
        }
      else
        {
          sprintf((char*)buffHeader, "POST /cascade HTTP/1.0\r\nContent-Length: %u\r\n\r\n", a_len);
        }
 
      getcurrentTimeMillis(startupTime);
      if (oSocket.sendFullyTimeOut(buffHeader, strlen((char*)buffHeader), currentTimeout, SEND_INFO_TIMEOUT_MS) != E_SUCCESS)
        {
          goto ERR;
        }
      getcurrentTimeMillis(currentMillis);
      currentTimeout -= (currentMillis - startupTime);
      if (currentTimeout <= 0 ||
          oSocket.sendFullyTimeOut(a_strCascadeHeloXML, a_len, currentTimeout, SEND_INFO_TIMEOUT_MS) != E_SUCCESS)
        {
          goto ERR;
        }
      //Receive answer --> 200 Ok or failure
      //HTTP/1.1 200 Ok
      getcurrentTimeMillis(currentMillis);
      currentTimeout -= (currentMillis - startupTime);
      if (currentTimeout <= 0 ||
          oSocket.receiveFullyT(buffHeader, 12, currentTimeout) != E_SUCCESS)
        {
          goto ERR;
        }
      if (memcmp(buffHeader + 9, "200", 3) != 0)
        {
          goto ERR;
        }
      oSocket.close();
      return E_SUCCESS;
    }
ERR:
  oSocket.close();
  return E_UNKNOWN;
}
 
SINT32 CAInfoService::handleConfigEvent(XERCES_CPP_NAMESPACE::DOMDocument* doc) const
{
  /*    CAMsg::printMsg(LOG_INFO,"InfoService: Cascade info received from InfoService\n");
 
      DOM_Element root=doc.getDocumentElement();
      DOM_Node mixesElement;
      getDOMChildByName(root,(UINT8*)"Mixes", mixesElement, false);
      char* mixId;
      char* prevMixId = NULL;
      char* myNextMixId = NULL;
      char* myPrevMixId = NULL;
      bool bFoundMix = false;
      UINT8 myMixId[64];
      CALibProxytest::getOptions()->getMixId(myMixId,64);
      DOM_Node child = mixesElement.getFirstChild();
      while(child!=NULL)
      {
      if(child.getNodeName().equals("Mix") && child.getNodeType() == DOM_Node::ELEMENT_NODE)
      {
      mixId = static_cast<const DOM_Element&>(child).getAttribute("id").transcode();
      if(strcmp(mixId,(char*)myMixId) == 0)
      {
      bFoundMix = true;
      myPrevMixId = prevMixId;
      }
      else if(bFoundMix == true)
      {
      myNextMixId = mixId;
      break;
      }
      prevMixId = mixId;
      }
      child = child.getNextSibling();
      }
 
      SINT32 ret = 0;
      //char* c;
 
      if(myPrevMixId != NULL)
      {
      CAMsg::printMsg(LOG_INFO,"InfoService: Asking InfoService about previous mix ...\n");
 
      m_expectedMixRelPos = -1;
      //c = new char[8+strlen(myPrevMixId)+1];
      //strcpy(c,"mixinfo/");
      //strcat(c,myPrevMixId);
      ret = sendMixInfo((UINT8*)myPrevMixId);
      //delete[] c;
      if(ret != E_SUCCESS)
      {
      CAMsg::printMsg(LOG_CRIT,"InfoService: Error retrieving mix info from InfoService!\n");
      return ret;
      }
      }
 
      if(myNextMixId != NULL)
      {
      CAMsg::printMsg(LOG_INFO,"InfoService: Asking InfoService about next mix ...\n");
 
      m_expectedMixRelPos = 1;
      //c = new char[8+strlen(myNextMixId)+1];
      //strcpy(c,"mixinfo/");
      //strcat(c,myNextMixId);
      ret = sendMixInfo((UINT8*)myNextMixId);
      //delete[] c;
      if(ret != E_SUCCESS)
      {
      CAMsg::printMsg(LOG_CRIT,"InfoService: Error retrieving mix info from InfoService!\n");
      return ret;
      }
 
      }
      */
  return E_SUCCESS;
}
 
#ifdef PAYMENT
SINT32 CAInfoService::getPaymentInstance(const UINT8* a_pstrPIID,CAXMLBI** a_pXMLBI)
{
  SINT32 returnValue = E_UNKNOWN;
  SINT32 currentValue;
  UINT32 nrAddresses;
  CAListenerInterface** socketAddresses = CALibProxytest::getOptions()->getInfoServices(nrAddresses);
  for (UINT32 i = 0; i < nrAddresses; i++)
    {
      currentValue = getPaymentInstance(a_pstrPIID, a_pXMLBI,
                                        (CASocketAddrINet*)socketAddresses[i]->getAddr());
      if (currentValue == E_SUCCESS)
        {
          returnValue = currentValue;
        }
    }
  return returnValue;
}
 
 
SINT32 CAInfoService::getPaymentInstance(const UINT8* a_pstrPIID,CAXMLBI** a_pXMLBI,
    CASocketAddrINet* a_socketAddress)
{
  CASocket socket;
  CASocketAddrINet address;
  UINT8 hostname[255];
  UINT8 request[255];
  CAHttpClient httpClient;
  UINT32 status, contentLength;
  *a_pXMLBI=NULL;
  //Connect to InfoService
  if(a_socketAddress->getIPAsStr(hostname, 255)!=E_SUCCESS)
    {
      socket.close();
      return E_UNKNOWN;
    }
 
  address.setAddr(hostname,a_socketAddress->getPort());
 
  if(socket.connect(address)!=E_SUCCESS)
    {
      socket.close();
      return E_UNKNOWN;
    }
 
  //#ifdef DEBUG
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService::getPaymentInstance() - connected to InfoService %s:%d\n",hostname, a_socketAddress->getPort());
  //#endif
 
  //Send request
  httpClient.setSocket(&socket);
  sprintf((char*) request, "/paymentinstance/%s", (char*) a_pstrPIID);
  httpClient.sendGetRequest(request);
  httpClient.parseHTTPHeader(&contentLength, &status);
#ifdef DEBUG
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService::getPaymentInstance() - Request sent, HTTP status: %i, content length: %i\n", status, contentLength);
#endif
  if(status!=200||contentLength>0x00FFFF)
    {
      socket.close();
      return E_UNKNOWN;
    }
 
  UINT8* content=new UINT8[contentLength+1];
  if(httpClient.getContent(content, &contentLength)!=E_SUCCESS)
    {
      delete []content;
      content = NULL;
      socket.close();
      return E_UNKNOWN;
    }
  socket.close();
  //Parse XML
  XERCES_CPP_NAMESPACE::DOMDocument* doc = parseDOMDocument(content,contentLength);
  delete []content;
  content = NULL;
  if(doc==NULL)
    {
      return E_UNKNOWN;
    }
  DOMElement* elemRoot=doc->getDocumentElement();
 
  *a_pXMLBI = CAXMLBI::getInstance(elemRoot);
  CAMsg::printMsg(LOG_DEBUG, "CAInfoService::getPaymentInstance(): XML doc not needed anymore\n");
  if (*a_pXMLBI != NULL)
    {
      return E_SUCCESS;
    }
  else
    {
      return E_UNKNOWN;
    }
}
#endif
#endif //ONLY_LOCAL_PROXY