proxytest.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
*/
// proxytest.cpp : Definiert den Einsprungpunkt fuer die Konsolenanwendung.
//
 
#include "StdAfx.h"
 
#include "CACmdLnOptions.hpp"
#include "CAMsg.hpp"
#include "CALocalProxy.hpp"
#include "CAQueue.hpp"
#include "CAThreadList.hpp"
#include "CAStatusManager.hpp"
#include "CALibProxytest.hpp"
#include "CACryptoBenchmark.hpp"
#include "UDPMix/CAUDPMixMiddle.hpp"
 
#ifdef _DEBUG //For FreeBSD memory checking functionality
  const char* _malloc_options="AX";
#endif
 
#ifdef REPLAY_DATABASE_PERFORMANCE_TEST
#include "CAReplayDatabase.hpp"
#endif
 
#ifdef DO_MIDDLE_MIX_BENCHMARK
#include "benchmarking/CAMiddleMixBenchmarkDummy.hpp"
#endif
 
 
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX || defined INLUDE_LAST_MIX
 
#ifdef INCLUDE_MIDDLE_MIX
#include "CAMiddleMix.hpp"
#endif
 
#ifdef INCLUDE_LAST_MIX
  #ifdef NEW_MIX_TYPE
    /* use TypeB mixes */
    #include "TypeB/CAFirstMixB.hpp"
    #include "TypeB/CALastMixB.hpp"
  #else
    #include "TypeA/CAFirstMixA.hpp"
    #include "TypeA/CALastMixA.hpp"
  #endif
#endif
 
 
// The Mix....
CAMix* pMix=NULL;
 
 
 
#endif
 
#ifndef ONLY_LOCAL_PROXY
  #include "xml/DOM_Output.hpp"
  #include "CAMix.hpp"
  #ifdef LOG_CRIME
    #include "tre/tre.h"
  #endif
  #ifdef NEW_MIX_TYPE
    /* use TypeB mixes */
    #include "TypeB/CAFirstMixB.hpp"
    #include "TypeB/CALastMixB.hpp"
  #else
    #include "TypeA/CAFirstMixA.hpp"
    #include "TypeA/CALastMixA.hpp"
  #endif
  #include "CALogPacketStats.hpp"
  #include "CATLSClientSocket.hpp"
 
#ifdef REPLAY_DATABASE_PERFORMANCE_TEST
  #include "CAReplayDatabase.hpp"
#endif
#endif
 
bool bTriedTermination = false;
 
#if defined(HAVE_CRTDBG)
    _CrtMemState* s1;
    _CrtMemState s2, s3;
#endif
 
#ifndef _WIN32
  #ifdef _DEBUG
    void signal_broken_pipe( int sig)
      {
        CAMsg::printMsg(LOG_INFO,"Hm.. Broken Pipe.... Who cares!\n");
        signal(SIGPIPE,signal_broken_pipe);
      }
  #endif
#endif
 
 
void removePidFile()
  {
    if(CALibProxytest::getOptions()==NULL)
      {
        return;
      }
    UINT8 strPidFile[512];
    if(CALibProxytest::getOptions()->getPidFile(strPidFile,512)==E_SUCCESS)
      {
        if(::remove((char*)strPidFile)!=0)
          {
#ifndef _WIN32
            int old_uid=geteuid(); //old uid... stored if we have to switch to root
            seteuid(0);
            ::remove((char*)strPidFile);
            seteuid(old_uid);
#endif
          }
      }
  }
 
 
void init()
  {
    CALibProxytest::init();
  }
 
void cleanup()
  {
#ifdef ENABLE_GPERFTOOLS_CPU_PROFILER
    ProfilerFlush();
    ProfilerStop();
#endif
//    delete pRTT;
#ifndef ONLY_LOCAL_PROXY
    if(pMix!=NULL)
      delete pMix;
    pMix=NULL;
#endif
    CAMsg::printMsg(LOG_CRIT,"Terminating Programm!\n");
    removePidFile();
    CALibProxytest::cleanup();
#if defined(HAVE_CRTDBG)
    _CrtMemCheckpoint( &s2 );
    if ( _CrtMemDifference( &s3, s1, &s2 ) )
      _CrtMemDumpStatistics( &s3 );
    else
      {
        printf("Memory leak check clean!\n");
      }
    delete s1;
#endif
#ifdef CWDEBUG
    Debug(list_allocations_on(libcw_do));
#endif
  }
 
void my_terminate(void)
{
  if(!bTriedTermination)
  {
    bTriedTermination = true;
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX
    if(pMix!=NULL)
    {
      pMix->shutDown();
      for (UINT32 i = 0; i < 200 && !(pMix->isShutDown()); i++)
      {
        msSleep(1000);
      }
      delete pMix;
      pMix=NULL;
    }
#endif
    cleanup();
  }
}
 
 
void signal_segv( int )
{
  signal(SIGSEGV,SIG_DFL); //otherwise we might end up in endless loops...
 
  MONITORING_FIRE_SYS_EVENT(ev_sys_sigSegV);
  CAMsg::printMsg(LOG_CRIT,"Oops ... caught SIG_SEGV! Exiting...\n");
 
  // wait 1 second so that log files may still be written
  sSleep(1);
 
#ifdef PRINT_THREAD_STACK_TRACE
  METHOD_STACK* stack = CAThread::getCurrentStack();
  if (stack != NULL)
  {
    CAMsg::printMsg( LOG_CRIT, "Stack trace: %s, \"%s\"\n", stack->strMethodName, stack->strPosition);
 
  }
  else
  {
    CAMsg::printMsg( LOG_CRIT, "Stack trace: none available\n");
  }
#endif
  // my_terminate();  temporarily disabled
  exit(1);
}
 
 
 
 
void signal_term( int )
  {
    MONITORING_FIRE_SYS_EVENT(ev_sys_sigTerm);
    CAMsg::printMsg(LOG_INFO,"Hm.. Signal SIG_TERM received... exiting!\n");
    my_terminate();
    exit(0);
  }
 
void signal_interrupt( int)
  {
    MONITORING_FIRE_SYS_EVENT(ev_sys_sigInt);
    CAMsg::printMsg(LOG_INFO,"Hm.. Strg+C pressed... exiting!\n");
#if defined _DEBUG && ! defined (ONLY_LOCAL_PROXY)
    CAMsg::printMsg(LOG_INFO,"%d threads listed.\n",CALibProxytest::getThreadList()->getSize());
    CALibProxytest::getThreadList()->showAll();
#endif
    my_terminate();
    exit(0);
  }
 
#ifndef ONLY_LOCAL_PROXY
void signal_hup(int)
  {
    CALibProxytest::getOptions()->reread(pMix);
  }
#endif
 
 
void checkSizesOfTypes()
  {
#ifdef _MSC_VER
    #pragma warning( push )
    #pragma warning( disable : 4127 ) //Disable: Bedingter Ausdruck ist konstant
#endif
    if(sizeof(SINT8)!=1)
      {
        CAMsg::printMsg(LOG_CRIT,"sizeof(SINT8) != 1 --> maybe a compiler (optimization) problem!\n");
        exit(-1);
      }
    if(sizeof(UINT8)!=1)
      {
        CAMsg::printMsg(LOG_CRIT,"sizeof(UINT8) != 1 --> maybe a compiler (optimization) problem!\n");
        exit(-1);
      }
    if(sizeof(SINT16)!=2)
      {
        CAMsg::printMsg(LOG_CRIT,"sizeof(SINT16) != 2 --> maybe a compiler (optimization) problem!\n");
        exit(-1);
      }
    if(sizeof(UINT16)!=2)
      {
        CAMsg::printMsg(LOG_CRIT,"sizeof(UINT16) != 2 --> maybe a compiler (optimization) problem!\n");
        exit(-1);
      }
    if(sizeof(SINT32)!=4)
      {
        CAMsg::printMsg(LOG_CRIT,"sizeof(SINT32) != 4 --> maybe a compiler (optimization) problem!\n");
        exit(-1);
      }
    if(sizeof(UINT32)!=4)
      {
        CAMsg::printMsg(LOG_CRIT,"sizeof(UINT32) != 4 --> maybe a compiler (optimization) problem!\n");
        exit(-1);
      }
    #ifdef HAVE_NATIVE_UINT64
      if(sizeof(UINT64)!=8)
        {
          CAMsg::printMsg(LOG_CRIT,"sizeof(UINT64) != 8 --> maybe a compiler (optimization) problem!\n");
          exit(-1);
        }
    #endif
 
#ifdef _MSC_VER
    #pragma warning( pop )
#endif
 
      #ifndef NEW_MIX_TYPE
      if (MIXPACKET_SIZE != sizeof(MIXPACKET))
        {
          CAMsg::printMsg(LOG_CRIT, "MIXPACKET_SIZE [%u] != sizeof(MUXPACKET) [%u] --> maybe a compiler (optimization) problem!\n", MIXPACKET_SIZE, sizeof(MIXPACKET));
          CAMsg::printMsg(LOG_CRIT, "Offsets:\n");
          MIXPACKET oPacket;
          UINT8 *p = (UINT8 *)&oPacket;
          UINT32 soffsets[7] = { 0, 4, 6, 6, 6, 8, 9 };
          UINT32 hoffsets[7];
          CAMsg::printMsg(LOG_CRIT, ".channel %u (should be 0)\n", hoffsets[0] = (UINT8 *)&(oPacket.channel) - p);
          CAMsg::printMsg(LOG_CRIT, ".flags: %u (should be 4)\n", hoffsets[1] = (UINT8 *)&oPacket.flags - p);
          CAMsg::printMsg(LOG_CRIT, ".data: %u (should be 6)\n", hoffsets[2] = (UINT8 *)&oPacket.data - p);
          CAMsg::printMsg(LOG_CRIT, ".payload: %u (should be 6)\n", hoffsets[3] = (UINT8 *)&oPacket.payload - p);
          CAMsg::printMsg(LOG_CRIT, ".payload.len: %u (should be 6)\n", hoffsets[4] = (UINT8 *)&oPacket.payload.len - p);
          CAMsg::printMsg(LOG_CRIT, ".payload.type: %u (should be 8)\n", hoffsets[5] = (UINT8 *)&oPacket.payload.type - p);
          CAMsg::printMsg(LOG_CRIT, ".payload.data: %u (should be 9)\n", hoffsets[6] = (UINT8 *)&oPacket.payload.data - p);
          for (int i = 0; i < 7; i++)
            if (soffsets[i] != hoffsets[i])
              exit(EXIT_FAILURE);
          CAMsg::printMsg(LOG_CRIT, "Hm, The Offsets seams to be ok - so we try to continue - hope that works...\n");
        }
#endif
      if (UDPMIXPACKET_SIZE != sizeof(UDPMIXPACKET))
        {
          CAMsg::printMsg(LOG_CRIT, "UDPMIXPACKET_SIZE [%u] != sizeof(UDPMUXPACKET) [%u] --> maybe a compiler (optimization) problem!\n", UDPMIXPACKET_SIZE, sizeof(UDPMIXPACKET));
        }
      if (UDPMIXPACKET_LINKHEADER_TYPE_SIZE != sizeof(UDPMIXPACKET_LINKHEADER))
        {
          CAMsg::printMsg(LOG_CRIT, "UDPMIXPACKET_LINKHEADER_TYPE_SIZE [%u] != sizeof(UDPMIXPACKET_LINKHEADER) [%u] --> maybe a compiler (optimization) problem!\n", UDPMIXPACKET_LINKHEADER_TYPE_SIZE, sizeof(UDPMIXPACKET_LINKHEADER));
        }
 
  }
 
 
int main(int argc, const char* argv[])
  {
    SINT32 exitCode=0;
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX || defined INLUDE_LAST_MIX|| defined INLUDE_FIRST_MIX
    pMix=NULL;
#endif
#if defined(HAVE_CRTDBG)
//      _CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
      _CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
//      _CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
      _CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDOUT );
//      _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
      _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDOUT );
 
    UINT32 tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
    tmpDbgFlag |= _CRTDBG_ALLOC_MEM_DF;
    tmpDbgFlag |=_CRTDBG_LEAK_CHECK_DF;
    _CrtSetDbgFlag(tmpDbgFlag);
    s1=new _CrtMemState;
    _CrtMemCheckpoint( s1 );
#endif
//Switch on debug infos
#ifdef CWDEBUG
    Debug(libcw_do.on());
    Debug(dc::malloc.on());
#endif
    init();
    checkSizesOfTypes();
#ifdef LOG_CRIME
//      testTre();
#endif
 
#ifdef REPLAY_DATABASE_PERFORMANCE_TEST
    CAReplayDatabase::measurePerformance((UINT8*)"dbperformace.log",1,10000001,500000,10,100000);
    exit(0);
#endif
 
 
#ifdef DATA_RETENTION_LOG
    if(sizeof(t_dataretentionLogEntry)!=18)
    {
        CAMsg::printMsg(LOG_CRIT,"sizeof(tDataRetentionLogEntry) [%u] != 18 --> maybe a compiler (optimization) problem!\n",sizeof(t_dataretentionLogEntry));
        exit(EXIT_FAILURE);
    }
#endif
 
#ifdef _DEBUG
      UINT32 start;
#endif
      /*
      CAUDPMiddleMix *pM = new CAUDPMiddleMix();
pM->start();
exit(0);
*/
  if(CALibProxytest::getOptions()->parse(argc,argv) != E_SUCCESS)
    {
      CAMsg::printMsg(LOG_CRIT,"An error occurred before we could finish parsing the configuration file. Exiting...\n");
      exitCode=EXIT_FAILURE;
      goto EXIT;
    }
 
  if (CALibProxytest::getOptions()->getCryptoBenchmark())
  {
    CACryptoBenchmark* pCryptoBenchmark = new CACryptoBenchmark();
    pCryptoBenchmark->doBenchmark();
    exit(0);
  }
 
 
 
  if(!( CALibProxytest::getOptions()->isFirstMix()||
          CALibProxytest::getOptions()->isMiddleMix()||
          CALibProxytest::getOptions()->isLastMix()||
          CALibProxytest::getOptions()->isLocalProxy()))
      {
        CAMsg::printMsg(LOG_CRIT,"You must specify which kind of Mix you want to run!\n");
        CAMsg::printMsg(LOG_CRIT,"Use -j or -c\n");
        CAMsg::printMsg(LOG_CRIT,"Or try --help for more options.\n");
        CAMsg::printMsg(LOG_CRIT,"Exiting...\n");
        exitCode=EXIT_FAILURE;
        goto EXIT;
      }
 
#ifndef _WIN32
    if(CALibProxytest::getOptions()->getDaemon()) 
      {
        CAMsg::printMsg(LOG_DEBUG,"Starting mix process as daemon...\n");
        CAMsg::cleanup();
        CAMsg::init();
        pid_t pid;
        pid=fork();
        if(pid!=0)
          {
            CAMsg::printMsg(LOG_INFO,"Exiting parent shell process...\n");
            exit(EXIT_SUCCESS);
          }
        setsid();
        #ifndef DO_TRACE
          chdir("/");
          umask(0);
        #endif
       // Close out the standard file descriptors
        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);
      }
#endif
 
 
    if (CALibProxytest::getOptions()->initLogging() != E_SUCCESS)
    {
      exitCode=EXIT_FAILURE;
      goto EXIT;
    }
    
 
 
    CAMsg::printMsg(LOG_CRIT,"Anon proxy started!\n");
    CAMsg::printMsg(LOG_CRIT, "LogLevel: %s\n", CAMsg::getLogLevelStr());
 
#ifdef ENABLE_GPERFTOOLS_CPU_PROFILER
    ProfilerStart("gperf.cpuprofiler.data");
    ProfilerRegisterThread();
#endif
 
#ifndef _WIN32
  #ifdef _DEBUG
      signal(SIGPIPE,signal_broken_pipe);
  #else
      signal(SIGPIPE,SIG_IGN);
  #endif
  #ifndef ONLY_LOCAL_PROXY
    struct sigaction newAction;
    memset(&newAction,0,sizeof(newAction));
    newAction.sa_handler=signal_hup;
    newAction.sa_flags=0;
    sigaction(SIGHUP,&newAction,NULL);
  #endif
#endif
    signal(SIGINT,signal_interrupt);
    signal(SIGTERM,signal_term);
#if !defined (_DEBUG) && !defined(NO_SIGSEV_CATCH)
    signal(SIGSEGV,signal_segv);
#endif
    //Try to write pidfile....
    UINT8 strPidFile[512];
    if(CALibProxytest::getOptions()->getPidFile(strPidFile,512)==E_SUCCESS)
      {
        #ifndef _WIN32
          int old_uid=geteuid(); //old uid... stored if we have to switch to root
        #endif
        pid_t pid=getpid();
        UINT8 thePid[10];
        sprintf((char*)thePid,"%i",pid);
        int len=strlen((char*)thePid);
        int hFile=open((char*)strPidFile,O_TRUNC|O_CREAT|O_WRONLY,S_IREAD|S_IWRITE);
#ifndef _WIN32
        if(hFile==-1&&seteuid(0)!=-1) //probably we do not have enough rights (because we have already switch to an other uid --> try to go back temporaly..
          {
            hFile=open((char*)strPidFile,O_TRUNC|O_CREAT|O_WRONLY,S_IREAD|S_IWRITE);
          }
#endif
        if(hFile==-1||len!=write(hFile,thePid,len))
          {
            #ifndef _WIN32
                    seteuid(old_uid);
            #endif
            CAMsg::printMsg(LOG_CRIT,"Could not write pidfile - exiting!\n");
            exitCode=EXIT_FAILURE;
            goto EXIT;
          }
        close(hFile);
#ifndef _WIN32
        seteuid(old_uid);
#endif
      }
 
    if(CALibProxytest::getOptions()->isLocalProxy())
      {
        #ifndef NEW_MIX_TYPE
          CALocalProxy* pProxy=new CALocalProxy();
          CAMsg::printMsg(LOG_INFO,"Starting LocalProxy...\n");
          if(pProxy->start()!=E_SUCCESS)
            CAMsg::printMsg(LOG_CRIT,"Error during MIX-Startup!\n");
          delete pProxy;
          pProxy = NULL;
        #else
          CAMsg::printMsg(LOG_CRIT,"Compiled without LocalProxy support!\n");
          exit(EXIT_FAILURE);
        #endif
      }
    else
      {
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX || defined INCLUDE_LAST_MIX 
      SINT32 s32MaxSockets=10000;//CASocket::getMaxOpenSockets();
      CAMsg::printMsg(LOG_INFO,"Max Number of sockets we can open: %i\n",s32MaxSockets);
      
#ifdef SERVER_MONITORING
      CAStatusManager::init();
#endif
      
      if(s32MaxSockets>100&&s32MaxSockets<10000)
        {
        CASocket::setMaxNormalSockets(s32MaxSockets-10);
        }
        MONITORING_FIRE_SYS_EVENT(ev_sys_start);
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_FIRST_MIX 
        if(CALibProxytest::getOptions()->isFirstMix())
        {
          CAMsg::printMsg(LOG_INFO,"I am the First MIX...\n");
          #if !defined(NEW_MIX_TYPE)
            pMix=new CAFirstMixA();
          #else
            pMix=new CAFirstMixB();
          #endif
          MONITORING_FIRE_NET_EVENT(ev_net_firstMixInited);
        }
        else
#endif
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX
        if(CALibProxytest::getOptions()->isMiddleMix())
        {
          CAMsg::printMsg(LOG_INFO,"I am a Middle MIX...\n");
          pMix=new CAMiddleMix();
          MONITORING_FIRE_NET_EVENT(ev_net_middleMixInited);
        }
#endif
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_LAST_MIX 
        if (CALibProxytest::getOptions()->isLastMix())
        {
          CAMsg::printMsg(LOG_INFO,"I am the Last MIX...\n");
          #if !defined(NEW_MIX_TYPE)
            pMix=new CALastMixA();
          #else
            pMix=new CALastMixB();
          #endif
          MONITORING_FIRE_NET_EVENT(ev_net_lastMixInited);
        }
#endif
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_LAST_MIX 
        if (CALibProxytest::getOptions()->isLastMix())
        {
          CAMsg::printMsg(LOG_INFO,"I am the Last MIX...\n");
          #if !defined(NEW_MIX_TYPE)
            pMix=new CALastMixA();
          #else
            pMix=new CALastMixB();
          #endif
          MONITORING_FIRE_NET_EVENT(ev_net_lastMixInited);
        }
#else
        CAMsg::printMsg(LOG_ERR,"this Mix is compiled to work only as local proxy!\n");
        exit(EXIT_FAILURE);
#endif
      }
#ifdef DO_MIDDLE_MIX_BENCHMARK
    pMix = new CAMiddleMixBenchmarkDummy();
#endif
#ifndef DYNAMIC_MIX
    CAMsg::printMsg(LOG_INFO,"Starting MIX...\n");
    if(pMix->start()!=E_SUCCESS)
    {
      CAMsg::printMsg(LOG_CRIT,"Error during MIX-Startup!\n");
      exitCode=EXIT_FAILURE;
      goto EXIT;
    }
#else
    // LERNGRUPPE 
while(true)
{
  CAMsg::printMsg(LOG_INFO,"Starting MIX...\n");
  if(pMix->start()!=E_SUCCESS)
  {
    CAMsg::printMsg(LOG_CRIT,"Error during MIX-Startup!\n");
    exit(EXIT_FAILURE);
  }
 
  delete pMix;
  pMix = NULL;
 
  if(CALibProxytest::getOptions()->isFirstMix())
  {
    CAMsg::printMsg(LOG_INFO,"I am now the First MIX..\n");
#if !defined(NEW_MIX_TYPE)
            pMix=new CAFirstMixA();
#else
            pMix=new CAFirstMixB();
#endif
  }
  else if(CALibProxytest::getOptions()->isMiddleMix())
  {
    CAMsg::printMsg(LOG_INFO,"I am now a Middle MIX..\n");
    pMix=new CAMiddleMix();
  }
  else
  {
    CAMsg::printMsg( LOG_ERR, "Tried to reconfigure a former first/middle-Mix to a LastMix -> impossible!\n");
    exit(EXIT_FAILURE);
  }
}
#endif //DYNAMIC_MIX
#endif //ONLY_LOCAL_PROXY
EXIT:
    cleanup();
 
    return exitCode;
  }