CAFirstMixChannelList.hpp

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
*/
#ifndef __CAFRISTMIXCHANNELLIST__
#define __CAFRISTMIXCHANNELLIST__
#include "doxygen.h"
#ifndef ONLY_LOCAL_PROXY
#include "CAMuxSocket.hpp"
#include "CAQueue.hpp"
#include "CASymCipher.hpp"
#include "CAMutex.hpp"
#include "CAMsg.hpp"
#include "CAControlChannelDispatcher.hpp"
#ifdef DELAY_USERS
  #include "CAThread.hpp"
#endif
#ifdef PAYMENT

class CAAccountingControlChannel;

#endif

#define KICKOUT_FORCED true
#define MAX_KICKOUT_RETRIES 4

struct t_fmhashtableentry
  {
    public:
      CAMuxSocket*  pMuxSocket;
      CAQueue*    pQueueSend;
      /* Separate handling of control messages allows to assign control messages a higher priority. */
      CAQueue*    pControlMessageQueue;
      CAControlChannelDispatcher* pControlChannelDispatcher;
      SINT32      uAlreadySendPacketSize;
      tQueueEntry   oQueueEntry;
      UINT32        cSuspend;
#ifdef CH_LOG_STUDY
      time_t channelOpenedLastIntervalTS;
#endif

#ifdef LOG_TRAFFIC_PER_USER
      UINT32        trafficIn;
      UINT32        trafficOut;
      UINT64        timeCreated;
#endif
      UINT64        id;

      CASymCipher*  pSymCipher;
      UINT8         peerIP[4]; //needed for flooding control
#ifdef DATA_RETENTION_LOG
      UINT32        peerPort;
#endif
#ifdef COUNTRY_STATS
      UINT32 countryID; 
#endif

#ifdef LOG_DIALOG
      UINT8*        strDialog;
#endif

#ifdef DELAY_USERS
      volatile UINT32       delayBucket;
      volatile UINT32       delayBucketID;
#endif
      // if false, the entry should be deleted the next time it is read from the queue
      bool bRecoverTimeout;
      SINT32 kickoutSendRetries;
    private:
      UINT32        cNumberOfChannels;
      struct t_firstmixchannellist* pChannelList;

      struct
        {
          struct t_fmhashtableentry* prev;
          struct t_fmhashtableentry* next;
        } list_HashEntries;

      // the timeout list
      // At the moement only enabled for payment Mixes (to be changed iff new mix protcol supports this for all clients)
#ifdef PAYMENT
      struct
      {
        struct t_fmhashtableentry* prev;
        struct t_fmhashtableentry* next;
        SINT32 timoutSecs;
      } list_TimeoutHashEntries;

      CAConditionVariable *cleanupNotifier;
#endif
    friend class CAFirstMixChannelList;

    public:
      bool bCountPacket;
#ifdef PAYMENT
    private:
      tAiAccountingInfo* pAccountingInfo;
    friend class CAAccountingInstance;
    friend class CAAccountingControlChannel;
    friend class CAFirstMixA;
#endif
  };

typedef struct t_fmhashtableentry fmHashTableEntry;
typedef fmHashTableEntry* LP_fmHashTableEntry;



struct t_firstmixchannellist
  {
    public:
      fmHashTableEntry* pHead;

      HCHANNEL channelIn;
      HCHANNEL channelOut;

      CASymCipher* pCipher;
      bool bIsSuspended;

#ifdef LOG_CHANNEL
      UINT32        packetsInFromUser;
      UINT64        timeCreated;
      UINT32        packetsOutToUser;
#endif

#ifdef SSL_HACK
      UINT32        downStreamBytes; /* a hack to solve the SSL problem */
#endif
    private:
      struct
        {
          struct t_firstmixchannellist* prev;
          struct t_firstmixchannellist* next;
        } list_OutChannelHashTable;

      struct
        {
          struct t_firstmixchannellist* prev;
          struct t_firstmixchannellist* next;
        } list_InChannelPerSocket;

    friend class CAFirstMixChannelList;
  };

typedef struct t_firstmixchannellist fmChannelList;
typedef struct t_firstmixchannellist fmChannelListEntry;
typedef fmChannelListEntry* LP_fmChannelListEntry;

THREAD_RETURN fml_loopDelayBuckets(void* param);

class CAFirstMixChannelList
  {
    public:
      CAFirstMixChannelList();
      ~CAFirstMixChannelList();

#ifndef LOG_DIALOG
      fmHashTableEntry* add(CAMuxSocket* pMuxSocket,const UINT8 peerIP[4],CAQueue* pQueueSend,
      UINT8* controlChannelKeyRecv,UINT8* controlChannelKeySent);
#else
      fmHashTableEntry* add(CAMuxSocket* pMuxSocket,const UINT8 peerIP[4],CAQueue* pQueueSend,UINT8* strDialog);
#endif
      SINT32 addChannel(CAMuxSocket* pMuxSocket,HCHANNEL channelIn,CASymCipher* pCipher,HCHANNEL* channelOut);

      fmChannelListEntry* get(CAMuxSocket* pMuxSocket,HCHANNEL channelIn);

#ifdef PAYMENT

      fmHashTableEntry* popTimeoutEntry();

      fmHashTableEntry* popTimeoutEntry(bool a_bForce);


      bool isTimedOut(fmHashTableEntry* pHashTableEntry);
      bool isKickoutForced(fmHashTableEntry* pHashTableEntry);
      void setKickoutForced(fmHashTableEntry* pHashTableEntry, bool kickoutForced);

      bool forceKickout(fmHashTableEntry* pHashTableEntry, const XERCES_CPP_NAMESPACE::DOMDocument *pErrDoc);
      SINT32 pushTimeoutEntry(fmHashTableEntry* pHashTableEntry, bool kickoutForced = !KICKOUT_FORCED);
#endif

      SINT32 remove(CAMuxSocket* pMuxSocket);
      SINT32 removeChannel(CAMuxSocket* pMuxSocket,HCHANNEL channelIn);

      fmHashTableEntry* getFirst();
      fmHashTableEntry* getNext();
      fmHashTableEntry* get(CAMuxSocket* pMuxSocket);


      fmChannelListEntry* getFirstChannelForSocket(CAMuxSocket* pMuxSocket);
      fmChannelListEntry* getNextChannel(fmChannelListEntry* pEntry);

      static SINT32 test();

      #ifdef NEW_MIX_TYPE
        /* additional methods for TypeB first mixes */
        SINT32 removeClientPart(CAMuxSocket* pMuxSocket);
        void removeVacantOutChannel(fmChannelListEntry* pEntry);
        void cleanVacantOutChannels();
      #endif

    private:
#ifdef PAYMENT
      SINT32 removeFromTimeoutList(fmHashTableEntry* pHashTableEntry);
      SINT32 pushTimeoutEntry_internal(fmHashTableEntry* pHashTableEntry, bool kickoutForced = !KICKOUT_FORCED);

      inline bool isKickoutForced_internal(fmHashTableEntry* pHashTableEntry);
      inline void setKickoutForced_internal(fmHashTableEntry* pHashTableEntry, bool kickoutForced);

      fmHashTableEntry* popTimeoutEntry_internal(bool a_bForce);

      UINT32 countTimeoutEntries();
#endif

      fmChannelListEntry* get_intern_without_lock(HCHANNEL channelOut)
        {
          fmChannelListEntry* pEntry=m_HashTableOutChannels[channelOut&0x0000FFFF];
          while(pEntry!=NULL)
            {
              if(pEntry->channelOut==channelOut)
                {
                  return pEntry;
                }
              pEntry=pEntry->list_OutChannelHashTable.next;
            }
          return NULL;
        }

      //not thread-safe check if a ChannelList hash entry is timed out. */
      inline bool isTimedOut_internal(fmHashTableEntry* pHashTableEntry);

    public:
      fmChannelListEntry* get(HCHANNEL channelOut)
        {
          m_Mutex.lock();
          fmChannelListEntry* pEntry=get_intern_without_lock(channelOut);
          m_Mutex.unlock();
          return pEntry;
        }
    private:
      static const SINT32 EXPIRATION_TIME_SECS;

      LP_fmHashTableEntry* m_HashTable;
      LP_fmChannelListEntry* m_HashTableOutChannels;

      fmHashTableEntry* m_listHashTableHead;
      fmHashTableEntry* m_listHashTableNext;
#ifdef PAYMENT

      fmHashTableEntry* m_listTimoutHead;
      fmHashTableEntry* m_listTimoutFoot;
#endif

      CAMutex m_Mutex;
//#ifdef PAYMENT
//      CAAccountingInstance *m_pAccountingInstance;
//#endif
      #ifdef DELAY_USERS
        volatile UINT32** m_pDelayBuckets;
        CAThread* m_pThreadDelayBucketsLoop;
        CAMutex* m_pMutexDelayChannel;
        bool m_bDelayBucketsLoopRun;
        friend THREAD_RETURN fml_loopDelayBuckets(void*);
        //Parameters
        volatile UINT32 m_u32DelayChannelUnlimitTraffic;  //how many packets without any delay?
        volatile UINT32 m_u32DelayChannelBucketGrow; //how many packets to put in each bucket per time intervall
        volatile UINT32 m_u32DelayChannelBucketGrowIntervall; //duration of one time intervall in ms
                                                              //therefore the allowed max bandwith=BucketGrow/Intervall*1000 *PAYLOAD_SIZE[bytes/s]
        public:
          void setDelayParameters(UINT32 unlimitTraffic,UINT32 bucketGrow,UINT32 intervall);
          void decDelayBuckets(UINT32 delayBucketID);
          bool hasDelayBuckets(UINT32 delayBucketID);
      #endif
#ifdef DO_TRACE
      UINT32 m_aktAlloc;
      UINT32 m_maxAlloc;
      LP_fmChannelListEntry newChannelListEntry()
        {
          m_aktAlloc+=sizeof(fmChannelListEntry);
          if(m_maxAlloc<m_aktAlloc)
            {
              m_maxAlloc=m_aktAlloc;
              CAMsg::printMsg(LOG_DEBUG,"FirstMixChannelList current alloc: %u\n",m_aktAlloc);
            }
          return (LP_fmChannelListEntry)new fmChannelListEntry;
        }
      void deleteChannelListEntry(LP_fmChannelListEntry entry)
        {
          m_aktAlloc-=sizeof(fmChannelListEntry);
          delete entry;
          entry = NULL;
        }
#endif
  };
#endif
#endif //ONLY_LOCAL_PROXY