CAMiddleMix.cpp File Reference

#include "StdAfx.h"
#include "CAMiddleMix.hpp"
#include "CASingleSocketGroup.hpp"
#include "CAMsg.hpp"
#include "CACmdLnOptions.hpp"
#include "CASocketAddrINet.hpp"
#include "CASocketAddrUnix.hpp"
#include "CAThread.hpp"
#include "CAInfoService.hpp"
#include "CAUtil.hpp"
#include "CABase64.hpp"
#include "CAPool.hpp"
#include "xml/DOM_Output.hpp"
#include "CAStatusManager.hpp"
#include "CALibProxytest.hpp"
#include "CAControlChannelDispatcher.hpp"
#include "CASymChannelCipher.hpp"
#include "CASymChannelCipherFactory.hpp"

Include dependency graph for CAMiddleMix.cpp:

Go to the source code of this file.

Macros
#define	MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS   2*KEY_SIZE
#define	MIDDLE_MIX_ASYM_PADDING_SIZE   42
#define	RETRIES   100
#define	RETRYTIME   10

Functions
THREAD_RETURN	mm_loopSendToMixAfter (void *param)
	UPSTREAM (to WEB) Take the packets from the Queue and write them to the Socket. More...
THREAD_RETURN	mm_loopSendToMixBefore (void *param)
	DOWNSTREAM (to Client) Take the packets from the Queue and write them to the Socket. More...
THREAD_RETURN	mm_loopReadFromMixBefore (void *param)
THREAD_RETURN	mm_loopReadFromMixAfter (void *param)

Macro Definition Documentation

MIDDLE_MIX_ASYM_PADDING_SIZE

#define MIDDLE_MIX_ASYM_PADDING_SIZE   42

Definition at line 1041 of file CAMiddleMix.cpp.

MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS

#define MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS   2*KEY_SIZE

Definition at line 1040 of file CAMiddleMix.cpp.

RETRIES

#define RETRIES   100

RETRYTIME

#define RETRYTIME   10

Function Documentation

mm_loopReadFromMixAfter()

THREAD_RETURN mm_loopReadFromMixAfter

(

void *

param

)

SGX MIX locksem(downstreamSemPreId, SN_EMPTY); memcpy(downstreamPreBuffer,pPoolEntry, sizeof(tPoolEntry)); unlocksem(downstreamSemPreId, SN_FULL);

locksem(downstreamSemPostId, SN_FULL); memcpy(pPoolEntry,downstreamPostBuffer, sizeof(tPoolEntry)); unlocksem(downstreamSemPostId, SN_EMPTY); getRandom(pMixPacket->data,DATA_SIZE);

SGX MIX locksem(pMix->downstreamSemPreId, SN_EMPTY); memcpy(pMix->downstreamPreBuffer,pPoolEntry, sizeof(tPoolEntry)); unlocksem(pMix->downstreamSemPreId, SN_FULL);

locksem(pMix->downstreamSemPostId, SN_FULL); memcpy(pPoolEntry,pMix->downstreamPostBuffer, sizeof(tPoolEntry)); unlocksem(pMix->downstreamSemPostId, SN_EMPTY);

Definition at line 1254 of file CAMiddleMix.cpp.

  {
    CAMiddleMix* pMix = static_cast<CAMiddleMix*>(param);
    HCHANNEL channelIn;
    CASymChannelCipher* pCipher=NULL;
 
    tPoolEntry* pPoolEntry=new tPoolEntry;
    MIXPACKET* pMixPacket=&pPoolEntry->packet;
 
    SINT32 ret;
    CASingleSocketGroup oSocketGroup(false);
    oSocketGroup.add(*(pMix->m_pMuxOut));
 
    CAQueue* pQueueSendtoMix=pMix->m_pQueueSendToMixBefore;
 
#ifdef USE_POOL
    CAPool* pPool=new CAPool(MIX_POOL_SIZE);
#endif
    while(pMix->m_bRun)
      {
        if(pQueueSendtoMix->getSize()>MAX_READ_FROM_NEXT_MIX_QUEUE_SIZE)
        {
#ifdef DEBUG
          CAMsg::printMsg(LOG_DEBUG,"CAMiddleMix::Queue next is full!\n");
#endif
          msSleep(200);
          continue;
        }
        #ifndef USE_POOL
          ret=oSocketGroup.select(1000);
        #else
          ret=oSocketGroup.select(MIX_POOL_TIMEOUT);
        #endif
        if(ret!=1)
          {
            if(ret==E_TIMEDOUT)
              {
                #ifndef USE_POOL
                  continue;
                #else
                  pMixPacket->channel=DUMMY_CHANNEL;
                  pMixPacket->flags=CHANNEL_DUMMY;
                  getRandom(pMixPacket->data,DATA_SIZE);
                  pPool->pool(pPoolEntry);
/* SGX MIX
                  locksem(downstreamSemPreId, SN_EMPTY);
                  memcpy(downstreamPreBuffer,pPoolEntry, sizeof(tPoolEntry));
                  unlocksem(downstreamSemPreId, SN_FULL);
                  
                  locksem(downstreamSemPostId, SN_FULL);
                  memcpy(pPoolEntry,downstreamPostBuffer, sizeof(tPoolEntry));
                  unlocksem(downstreamSemPostId, SN_EMPTY);
*/
                  if(pMix->m_pMuxIn->send(pMixPacket)==SOCKET_ERROR)
                    pMix->m_bRun=false;
                #endif
              }
            else
            {
              CAMsg::printMsg(LOG_CRIT,"loopReadFromMixAfter -- Error on select() while waiting for data from next mix -- goto ERR!\n");
              pMix->m_bRun=false;
              MONITORING_FIRE_NET_EVENT(ev_net_nextConnectionClosed);
            }
          }
        else
          {
            ret=pMix->m_pMuxOut->receive(pMixPacket);
            if ((ret!=SOCKET_ERROR)&&(pMixPacket->flags & ~CHANNEL_ALLOWED_FLAGS))
              {
                CAMsg::printMsg(LOG_INFO,"loopReadFromMixAfter -- received a packet with invalid flags: %0X .  Removing them.\n",(pMixPacket->flags & ~CHANNEL_ALLOWED_FLAGS));
                pMixPacket->flags&=CHANNEL_ALLOWED_FLAGS;
              }
            if(ret==SOCKET_ERROR)
              {
                CAMsg::printMsg(LOG_CRIT,"loopReadFromMixAfter -- Error while receiving data from next mix. Reason: %s (%i)\n",
                  GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
                pMix->m_bRun=false;
                MONITORING_FIRE_NET_EVENT(ev_net_nextConnectionClosed);
              }
            #ifdef USE_POOL
            else if(pMixPacket->channel==DUMMY_CHANNEL)
              {
                pMixPacket->flags=CHANNEL_DUMMY;
                getRandom(pMixPacket->data,DATA_SIZE);
                pPool->pool(pPoolEntry);
                if(pMix->m_pMuxIn->send(pMixPacket)==SOCKET_ERROR)
                  pMix->m_bRun=false;
              }
            #endif
            #ifdef REPLAY_DETECTION
            else if(pMixPacket->channel==REPLAY_CONTROL_CHANNEL_ID)
              {
                pQueue->add(pPoolEntry,sizeof(tPoolEntry));
              }
            #endif
            else if(pMix->m_pMiddleMixChannelList->getOutToIn(&channelIn,pMixPacket->channel,&pCipher)==E_SUCCESS)
              {//connection found
 
#ifdef LOG_CRIME
                HCHANNEL channelOut = pMixPacket->channel;
#endif
                pMixPacket->channel=channelIn;
#ifdef LOG_CRIME
                if((pMixPacket->flags&CHANNEL_SIG_CRIME)==CHANNEL_SIG_CRIME)
                  {
                    getRandom(pMixPacket->data,DATA_SIZE);
                    //Log in and out channel number, to allow
                    CAMsg::printMsg(LOG_CRIT,"Detecting crime activity - previous mix channel: %u, "
                        "next mix channel: %u\n", channelIn, channelOut);
                  }
                else
#endif
                pCipher->crypt2(pMixPacket->data,pMixPacket->data,DATA_SIZE);
                pCipher->unlock();
                #ifdef USE_POOL
                  pPool->pool(pPoolEntry);
                #endif
                if((pMixPacket->flags&CHANNEL_CLOSE)!=0)
                  {//Channel close received -->remove channel form channellist
                    pMix->m_pMiddleMixChannelList->remove(channelIn);
                  }
                pMix->putMixPacketIntoQueueSendToMixBefore(pPoolEntry);
              }
          }
      }
 
    CAMsg::printMsg(LOG_CRIT,"loopReadFromMixAfter -- Exiting clean ups...\n");
    pMix->m_bRun=false;
    UINT8 b[sizeof(tQueueEntry)+1];
    /* write bytes to the send queues to accelerate loop()-joins for the send threads*/
    if(pMix->m_pQueueSendToMixBefore!=NULL)
    {
      pMix->m_pQueueSendToMixBefore->add(b,sizeof(tQueueEntry)+1);
    }
    if(pMix->m_pQueueSendToMixAfter!=NULL)
    {
      pMix->m_pQueueSendToMixAfter->add(b,sizeof(tQueueEntry)+1);
    }
    delete pPoolEntry;
    pPoolEntry = NULL;
    #ifdef USE_POOL
      delete pPool;
      pPool = NULL;
    #endif
    CAMsg::printMsg(LOG_CRIT,"loopReadFromMixAfter -- Now Exiting!\n");
    THREAD_RETURN_SUCCESS;
  }

mm_loopReadFromMixBefore()

THREAD_RETURN mm_loopReadFromMixBefore

(

void *

param

)

Definition at line 1045 of file CAMiddleMix.cpp.

  {
    CAMiddleMix* pMix=(CAMiddleMix*)param;
    HCHANNEL channelOut = 0;
#ifdef LOG_CRIME
    HCHANNEL channelIn = 0;
#endif
    tPoolEntry* pPoolEntry=new tPoolEntry;
    MIXPACKET* pMixPacket=&pPoolEntry->packet;
 
    CAQueue* pQueue=pMix->m_pQueueSendToMixAfter;
 
    CASymChannelCipher* pCipher;
    SINT32 ret;
    UINT8* tmpRSABuff=new UINT8[RSA_SIZE];
    UINT32 rsaOutLen=RSA_SIZE;
    CASingleSocketGroup oSocketGroup(false);
    oSocketGroup.add(*(pMix->m_pMuxIn));
 
    #ifdef USE_POOL
      CAPool* pPool=new CAPool(MIX_POOL_SIZE);
    #endif
 
    while(pMix->m_bRun)
      {
        if(pQueue->getSize()>MAX_READ_FROM_PREV_MIX_QUEUE_SIZE)
        {
#ifdef DEBUG
          CAMsg::printMsg(LOG_DEBUG,"CAFirstMix::Queue prev is full!\n");
#endif
          msSleep(200);
          continue;
        }
        #ifndef USE_POOL
          ret=oSocketGroup.select(1000);
        #else
          ret=oSocketGroup.select(MIX_POOL_TIMEOUT);
        #endif
        if(ret!=1)
          {
            if(ret==E_TIMEDOUT)
              {
                #ifndef USE_POOL
                  continue;
                #else
                  pMixPacket->channel=DUMMY_CHANNEL;
                  pMixPacket->flags=CHANNEL_DUMMY;
                  getRandom(pMixPacket->data,DATA_SIZE);
                  pPool->pool(pPoolEntry);
/*
                  locksem(upstreamSemPreId, SN_EMPTY);
                  memcpy(upstreamPreBuffer,pPoolEntry, sizeof(tPoolEntry));
                  unlocksem(upstreamSemPreId, SN_FULL);
                  
                  locksem(upstreamSemPostId, SN_FULL);
                  memcpy(pPoolEntry,upstreamPostBuffer, sizeof(tPoolEntry));
                  unlocksem(upstreamSemPostId, SN_EMPTY);
*/
                  if(m_pMuxOut->send(pMixPacket)==SOCKET_ERROR)
                    pMix->m_bRun=false;
                #endif
              }
            else
              {
                CAMsg::printMsg(LOG_CRIT,"loopUpStream -- Fehler bei select() -- goto ERR!\n");
                pMix->m_bRun=false;
                MONITORING_FIRE_NET_EVENT(ev_net_prevConnectionClosed);
              }
          }
        else
          {
            ret=pMix->m_pMuxIn->receive(pMixPacket);
 
            if ((ret!=SOCKET_ERROR)&&(pMixPacket->flags & ~CHANNEL_ALLOWED_FLAGS))
            {
              CAMsg::printMsg(LOG_INFO,"loopUpStream received a packet with invalid flags: %0X .  Removing them.\n",(pMixPacket->flags & ~CHANNEL_ALLOWED_FLAGS));
              pMixPacket->flags&=CHANNEL_ALLOWED_FLAGS;
            }
 
            if(ret==SOCKET_ERROR)
            {
 
              CAMsg::printMsg(LOG_CRIT,"Fehler beim Empfangen -- Exiting!\n");
              pMix->m_bRun=false;
              MONITORING_FIRE_NET_EVENT(ev_net_prevConnectionClosed);
            }
            #ifdef USE_POOL
            else if(pMixPacket->channel==DUMMY_CHANNEL)
            {
              pMixPacket->flags=CHANNEL_DUMMY;
              getRandom(pMixPacket->data,DATA_SIZE);
              pPool->pool(pPoolEntry);
/*  SGX MIX           locksem(upstreamSemPreId, SN_EMPTY);
              memcpy(upstreamPreBuffer,pPoolEntry, sizeof(tPoolEntry));
              unlocksem(upstreamSemPreId, SN_FULL);
              locksem(upstreamSemPostId, SN_FULL);
              memcpy(pPoolEntry,upstreamPostBuffer, sizeof(tPoolEntry));
              unlocksem(upstreamSemPostId, SN_EMPTY);
*/
              if(pMix->m_pMuxOut->send(pMixPacket)==SOCKET_ERROR)
                pMix->m_bRun=false;
            }
            #endif
 
            else //receive successful
            {
 
/*              locksem(pMix->upstreamSemPreId, SN_EMPTY);
              memcpy(pMix->upstreamPreBuffer,pPoolEntry, sizeof(tPoolEntry));
SGX MIX             unlocksem(pMix->upstreamSemPreId, SN_FULL);
              locksem(pMix->upstreamSemPostId, SN_FULL);
              memcpy(pPoolEntry,pMix->upstreamPostBuffer, sizeof(tPoolEntry));
              unlocksem(pMix->upstreamSemPostId, SN_EMPTY);
              if(pMixPacket->channel==0) continue;
              #ifdef LOG_CRIME
              crimeSurveillanceUpstream(pMixPacket, channelIn);
              #endif
              pQueue->add(pPoolEntry,sizeof(tPoolEntry));
*/
#ifdef LOG_CRIME
              channelIn = pMixPacket->channel;
#endif
              if(pMix->m_pMiddleMixChannelList->getInToOut(pMixPacket->channel,&channelOut,&pCipher)!=E_SUCCESS)
              {//new connection ?
                if(pMixPacket->flags & CHANNEL_OPEN) //if not channel-open flag set -->drop this packet
                {
                  #ifdef _DEBUG
                    CAMsg::printMsg(LOG_DEBUG,"New Connection from previous Mix!\n");
                  #endif
                  if (pMix->m_pRSA->decryptOAEP(pMixPacket->data, tmpRSABuff, &rsaOutLen) != E_SUCCESS)
                    {
                      CAMsg::printMsg(LOG_ERR, "Received wrongly decrypted Channel Open Packet!\n");
                      continue;
                    }
                  #ifdef REPLAY_DETECTION
                    // replace time(NULL) with the real timestamp ()
                    // packet-timestamp + m_u64ReferenceTime
                    UINT32 stamp=((UINT32)(tmpRSABuff[13]<<16)+(UINT32)(tmpRSABuff[14]<<8)+(UINT32)(tmpRSABuff[15]))*REPLAY_BASE;
                    if(pMix->m_pReplayDB->insert(tmpRSABuff,stamp+pMix->m_u64ReferenceTime)!=E_SUCCESS)
//                      if(pMix->m_pReplayDB->insert(tmpRSABuff,time(NULL))!=E_SUCCESS)
                      {
                        CAMsg::printMsg(LOG_INFO,"Replay: Duplicate packet ignored.\n");
                        continue;
                      }
                  #endif
 
                  pCipher=CASymChannelCipherFactory::createCipher(CALibProxytest::getOptions()->getSymChannelCipherAlgorithm());
                  pCipher->setKeys(tmpRSABuff,MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS);
                  pCipher->crypt1(pMixPacket->data+RSA_SIZE,
                        pMixPacket->data+rsaOutLen-MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS,
                        DATA_SIZE-RSA_SIZE);
                  memcpy(pMixPacket->data,tmpRSABuff+MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS,rsaOutLen-MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS);
                  getRandom(pMixPacket->data+DATA_SIZE-MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS-MIDDLE_MIX_ASYM_PADDING_SIZE,MIDDLE_MIX_SIZE_OF_SYMMETRIC_KEYS+MIDDLE_MIX_ASYM_PADDING_SIZE);
                  pMix->m_pMiddleMixChannelList->add(pMixPacket->channel,pCipher,&channelOut);
                  pMixPacket->channel=channelOut;
                  #ifdef USE_POOL
                    pPool->pool(pPoolEntry);
                  #endif
                  #ifdef LOG_CRIME
                  crimeSurveillanceUpstream(pMixPacket, channelIn);
                  #endif
                  pQueue->add(pPoolEntry,sizeof(tPoolEntry));
                }
              }
              else
              {//established connection
                pCipher->crypt1(pMixPacket->data,pMixPacket->data,DATA_SIZE);
                pCipher->unlock();
                #ifdef USE_POOL
                  pPool->pool(pPoolEntry);
                #endif
                if((pMixPacket->flags&CHANNEL_CLOSE)!=0)
                {//Channel close received -->remove channel form channellist
                  pMix->m_pMiddleMixChannelList->remove(pMixPacket->channel);
                }
                pMixPacket->channel=channelOut;
                #ifdef LOG_CRIME
                crimeSurveillanceUpstream(pMixPacket, channelIn);
                #endif
                pQueue->add(pPoolEntry,sizeof(tPoolEntry));
              }
            }
          }
      }
 
    CAMsg::printMsg(LOG_CRIT,"loopReadFromMixBefore -- Exiting clean ups...\n");
    pMix->m_bRun=false;
    UINT8 b[sizeof(tQueueEntry)+1];
    /* write bytes to the send queues to accelerate loop()-joins for the send threads*/
    if(pMix->m_pQueueSendToMixBefore!=NULL)
    {
      pMix->m_pQueueSendToMixBefore->add(b,sizeof(tQueueEntry)+1);
    }
    if(pMix->m_pQueueSendToMixAfter!=NULL)
    {
      pMix->m_pQueueSendToMixAfter->add(b,sizeof(tQueueEntry)+1);
    }
    delete[] tmpRSABuff;
    tmpRSABuff = NULL;
    delete pPoolEntry;
    pPoolEntry = NULL;
    #ifdef USE_POOL
      delete pPool;
      pPool = NULL;
    #endif
    CAMsg::printMsg(LOG_CRIT,"loopReadFromMixBefore -- Now Exiting!\n");
    THREAD_RETURN_SUCCESS;
  }

mm_loopSendToMixAfter()

THREAD_RETURN mm_loopSendToMixAfter

(

void *

param

)

UPSTREAM (to WEB) Take the packets from the Queue and write them to the Socket.

Definition at line 920 of file CAMiddleMix.cpp.

  {
    INIT_STACK;
    BEGIN_STACK("CAFirstMix::fm_loopSendToMixAfter");
 
    CAMiddleMix* pMiddleMix = static_cast<CAMiddleMix*>(param);
    CAQueue* pQueue = pMiddleMix->m_pQueueSendToMixAfter;
    CAMuxSocket* pMuxSocket=pMiddleMix->m_pMuxOut;
 
    UINT32 len;
    SINT32 ret;
    tPoolEntry* pPoolEntry=new tPoolEntry;
    MIXPACKET* pMixPacket=&pPoolEntry->packet;
    UINT32 u32KeepAliveSendInterval=pMiddleMix->m_u32KeepAliveSendInterval2;
    while(pMiddleMix->m_bRun)
      {
        len=sizeof(tPoolEntry);
        ret=pQueue->getOrWait((UINT8*)pPoolEntry,&len,u32KeepAliveSendInterval);
        if(!(pMiddleMix->m_bRun))
        {
          CAMsg::printMsg(LOG_INFO,"SendToMixAfter thread: was interrupted.\n");
          MONITORING_FIRE_NET_EVENT(ev_net_nextConnectionClosed);
          break;
        }
        if(ret==E_TIMEDOUT)
          {//send a dummy as keep-alive-traffic
            pMixPacket->flags=CHANNEL_DUMMY;
            pMixPacket->channel=DUMMY_CHANNEL;
            getRandom(pMixPacket->data,DATA_SIZE);
          }
        else if(ret!=E_SUCCESS||len!=sizeof(tQueueEntry))
          {
            MONITORING_FIRE_NET_EVENT(ev_net_nextConnectionClosed);
            CAMsg::printMsg(LOG_ERR,"CAFirstMix::lm_loopSendToMixAfter - Error in dequeueing MixPaket\n");
            CAMsg::printMsg(LOG_ERR,"ret=%i len=%i\n",ret,len);
            break;
          }
        if((pMuxSocket->send(pMixPacket)!=MIXPACKET_SIZE))
          {
            MONITORING_FIRE_NET_EVENT(ev_net_nextConnectionClosed);
            CAMsg::printMsg(LOG_ERR,"CAFirstMix::lm_loopSendToMixAfter - Error in sending MixPaket\n");
            break;
          }
#ifdef LOG_PACKET_TIMES
        if(!isZero64(pPoolEntry->timestamp_proccessing_start))
          {
            getcurrentTimeMicros(pPoolEntry->timestamp_proccessing_end);
            pMiddleMix->m_pLogPacketStats->addToTimeingStats(*pPoolEntry, pMixPacket->flags, true);
          }
#endif
      }
    pMiddleMix->m_bRun = false;
    delete pPoolEntry;
    pPoolEntry = NULL;
    FINISH_STACK("CAFirstMix::fm_loopSendToMixAfter");
 
    CAMsg::printMsg(LOG_DEBUG,"Exiting Thread SendToMixAfter\n");
    THREAD_RETURN_SUCCESS;
  }

mm_loopSendToMixBefore()

THREAD_RETURN mm_loopSendToMixBefore

(

void *

param

)

DOWNSTREAM (to Client) Take the packets from the Queue and write them to the Socket.

Definition at line 981 of file CAMiddleMix.cpp.

  {
    INIT_STACK;
    BEGIN_STACK("CAFirstMix::fm_loopSendToMixBefore");
 
    CAMiddleMix* pMiddleMix = static_cast<CAMiddleMix*>(param);
    CAQueue* pQueue=pMiddleMix->m_pQueueSendToMixBefore;
    CAMuxSocket* pMuxSocket=pMiddleMix->m_pMuxIn;
 
    UINT32 len;
    SINT32 ret;
    tPoolEntry* pPoolEntry=new tPoolEntry;
    MIXPACKET* pMixPacket=&pPoolEntry->packet;
    UINT32 u32KeepAliveSendInterval=pMiddleMix->m_u32KeepAliveSendInterval;
    while(pMiddleMix->m_bRun)
      {
        len=sizeof(tPoolEntry);
        ret=pQueue->getOrWait((UINT8*)pPoolEntry,&len,u32KeepAliveSendInterval);
        if(!(pMiddleMix->m_bRun))
        {
          CAMsg::printMsg(LOG_INFO,"SendToMixBefore thread: was interrupted.\n");
          break;
        }
        if(ret==E_TIMEDOUT)
          {//send a dummy as keep-alive-traffic
            pMixPacket->flags=CHANNEL_DUMMY;
            pMixPacket->channel=DUMMY_CHANNEL;
            getRandom(pMixPacket->data,DATA_SIZE);
          }
        else if(ret!=E_SUCCESS||len!=sizeof(tQueueEntry))
          {
            MONITORING_FIRE_NET_EVENT(ev_net_prevConnectionClosed);
            CAMsg::printMsg(LOG_ERR,"CAFirstMix::lm_loopSendToMixBefore - Error in dequeueing MixPaket\n");
            CAMsg::printMsg(LOG_ERR,"ret=%i len=%i\n",ret,len);
            break;
          }
        if((pMuxSocket->send(pMixPacket)!=MIXPACKET_SIZE))
          {
            MONITORING_FIRE_NET_EVENT(ev_net_prevConnectionClosed);
            CAMsg::printMsg(LOG_ERR,"CAFirstMix::lm_loopSendToMixBefore - Error in sending MixPaket\n");
            break;
          }
#ifdef LOG_PACKET_TIMES
        if(!isZero64(pPoolEntry->timestamp_proccessing_start))
          {
            getcurrentTimeMicros(pPoolEntry->timestamp_proccessing_end);
            pMiddleMix->m_pLogPacketStats->addToTimeingStats(*pPoolEntry,pMixPacket->flags,true);
          }
#endif
      }
    pMiddleMix->m_bRun = false;
    delete pPoolEntry;
    pPoolEntry = NULL;
    FINISH_STACK("CAFirstMix::fm_loopSendToMixBefore");
 
    CAMsg::printMsg(LOG_DEBUG,"Exiting Thread SendToMixBefore\n");
    THREAD_RETURN_SUCCESS;
  }