CAMuxSocket Class Reference

#include <CAMuxSocket.hpp>

Collaboration diagram for CAMuxSocket:

Public Member Functions
	CAMuxSocket (SYMCHANNELCIPHER_ALGORITHM algCipher)
	~CAMuxSocket ()
SINT32	getHashKey ()
	Returns a Hashkey which uniquely identifies this socket. More...
SINT32	accept (UINT16 port)
SINT32	accept (const CASocketAddr &oAddr)
	Waits for an incoming connection on oAddr. More...
SINT32	connect (CASocketAddr &psa)
SINT32	connect (CASocketAddr &psa, UINT retry, UINT32 time)
SINT32	close ()
	Closes the underlying socket. More...
SINT32	send (MIXPACKET *pPacket)
	Sends a MixPacket over the Network. More...
SINT32	send (MIXPACKET *pPacket, UINT8 *buff)
SINT32	prepareForSend (MIXPACKET *inoutPacket)
SINT32	receive (MIXPACKET *pPacket)
	Receives a whole MixPacket. More...
SINT32	receive (MIXPACKET *pPacket, UINT32 timeout)
	Trys to receive a Mix-Packet. More...
SINT32	receiveFully (UINT8 *buff, UINT32 len)
	Receives some "plain" bytes from the underlying socket - just a convenient function... More...
SINT32	receiveFully (UINT8 *buff, UINT32 len, UINT32 msTimeOut)
CASocket *	getCASocket ()
SINT32	setCASocket (CASocket *pSocket)
	This will set the underlying CASocket. More...
SOCKET	getSocket ()
SINT32	setCrypt (bool b)
bool	getIsEncrypted ()
SINT32	setCipher (SYMCHANNELCIPHER_ALGORITHM algCipher)
SINT32	setKey (UINT8 *key, UINT32 keyLen)
	Sets the symmetric keys used for de-/encrypting the Mux connection. More...
SINT32	setSendKey (UINT8 *key, UINT32 keyLen)
SINT32	setReceiveKey (UINT8 *key, UINT32 keyLen)

Static Public Member Functions
static SINT32	init ()
static SINT32	cleanup ()

Private Attributes
CASocket *	m_pSocket
UINT32	m_aktBuffPos
UINT8 *	m_Buff
CASymCipherMuxSocket *	m_pCipherIn
CASymCipherMuxSocket *	m_pCipherOut
bool	m_bIsCrypted
CAMutex	m_csSend
CAMutex	m_csReceive
t_hashkeylistEntry *	m_pHashKeyEntry

Static Private Attributes
static t_hashkeylistEntry *	ms_phashkeylistAvailableHashKeys =NULL
static SINT32	ms_nMaxHashKeyValue =0
static CAMutex *	ms_pcsHashKeyList =NULL

Detailed Description

Definition at line 45 of file CAMuxSocket.hpp.

Constructor & Destructor Documentation

CAMuxSocket()

CAMuxSocket::CAMuxSocket

(

SYMCHANNELCIPHER_ALGORITHM

algCipher

)

Definition at line 42 of file CAMuxSocket.cpp.

  {
    m_pSocket = new CASocket();
    m_Buff=new UINT8[MIXPACKET_SIZE];
    m_aktBuffPos=0;
    m_bIsCrypted=false;
    ms_pcsHashKeyList->lock();
    if(ms_phashkeylistAvailableHashKeys==NULL)
      {//generate new hash keys
        for(UINT i=0;i<512;i++)
          {
            m_pHashKeyEntry=new t_hashkeylistEntry;
            m_pHashKeyEntry->next=ms_phashkeylistAvailableHashKeys;
            m_pHashKeyEntry->hashkey=ms_nMaxHashKeyValue++;
            ms_phashkeylistAvailableHashKeys=m_pHashKeyEntry;
          }
      }
    m_pHashKeyEntry=ms_phashkeylistAvailableHashKeys;
    ms_phashkeylistAvailableHashKeys=m_pHashKeyEntry->next;
    ms_pcsHashKeyList->unlock();
    m_pCipherIn = NULL;
    m_pCipherOut = NULL;
    setCipher(algCipher);
  }

References __t_hash_key_entry__::hashkey, CAMutex::lock(), m_aktBuffPos, m_bIsCrypted, m_Buff, m_pCipherIn, m_pCipherOut, m_pHashKeyEntry, m_pSocket, MIXPACKET_SIZE, ms_nMaxHashKeyValue, ms_pcsHashKeyList, ms_phashkeylistAvailableHashKeys, __t_hash_key_entry__::next, setCipher(), and CAMutex::unlock().

Here is the call graph for this function:

~CAMuxSocket()

CAMuxSocket::~CAMuxSocket

(

)

Definition at line 67 of file CAMuxSocket.cpp.

  {
    close();
    delete []m_Buff;
    m_Buff = NULL;
    ms_pcsHashKeyList->lock();
    m_pHashKeyEntry->next=ms_phashkeylistAvailableHashKeys;
    ms_phashkeylistAvailableHashKeys=m_pHashKeyEntry;
    ms_pcsHashKeyList->unlock();
    delete m_pCipherIn;
    delete m_pCipherOut;
    delete m_pSocket;
  } 

References close(), CAMutex::lock(), m_Buff, m_pCipherIn, m_pCipherOut, m_pHashKeyEntry, m_pSocket, ms_pcsHashKeyList, ms_phashkeylistAvailableHashKeys, __t_hash_key_entry__::next, and CAMutex::unlock().

Here is the call graph for this function:

Member Function Documentation

accept() [1/2]

SINT32 CAMuxSocket::accept

(

const CASocketAddr &

oAddr

)

Waits for an incoming connection on oAddr.

Return values

E_SUCCESS,if	successful
E_SOCKET_BIND,E_SOCKET_LISTEN
E_UNKOWN

Definition at line 146 of file CAMuxSocket.cpp.

  {
    CASocket oSocket;
    oSocket.create(oAddr.getType());
    oSocket.setReuseAddr(true);
    SINT32 ret=oSocket.listen(oAddr);
    if(ret!=E_SUCCESS)
      return ret;
    ret=oSocket.accept(*m_pSocket);
    if(ret!=E_SUCCESS)
      return E_UNKNOWN;
    oSocket.close();
    //m_Socket.setRecvLowWat(MIXPACKET_SIZE);
    m_aktBuffPos=0;
    return E_SUCCESS;
  }

References CASocket::accept(), CASocket::close(), CASocket::create(), E_SUCCESS, E_UNKNOWN, CASocketAddr::getType(), CASocket::listen(), m_aktBuffPos, m_pSocket, and CASocket::setReuseAddr().

Here is the call graph for this function:

accept() [2/2]

SINT32 CAMuxSocket::accept

(

UINT16

port

)

Definition at line 126 of file CAMuxSocket.cpp.

  {
    CASocket oSocket;
    oSocket.create();
    oSocket.setReuseAddr(true);
    if(oSocket.listen(port)!=E_SUCCESS)
      return E_UNKNOWN;
    if(oSocket.accept(*m_pSocket)!=E_SUCCESS)
      return E_UNKNOWN;
    oSocket.close();
    //m_Socket.setRecvLowWat(MIXPACKET_SIZE);
    m_aktBuffPos=0;
    return E_SUCCESS;
  }

References CASocket::accept(), CASocket::close(), CASocket::create(), E_SUCCESS, E_UNKNOWN, CASocket::listen(), m_aktBuffPos, m_pSocket, and CASocket::setReuseAddr().

Referenced by CALastMix::init(), and CAMiddleMix::init().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup()

static SINT32 CAMuxSocket::cleanup ( )

inlinestatic

Definition at line 172 of file CAMuxSocket.hpp.

          {
            while(ms_phashkeylistAvailableHashKeys!=NULL)
              {
                t_hashkeylistEntry* tmpEntry = ms_phashkeylistAvailableHashKeys;
                ms_phashkeylistAvailableHashKeys=ms_phashkeylistAvailableHashKeys->next;
                delete tmpEntry;
              }
            delete ms_pcsHashKeyList;
            ms_pcsHashKeyList=NULL;
            return E_SUCCESS;
          }

References E_SUCCESS, ms_pcsHashKeyList, ms_phashkeylistAvailableHashKeys, and __t_hash_key_entry__::next.

Referenced by CALibProxytest::cleanup().

Here is the caller graph for this function:

close()

SINT32 CAMuxSocket::close

(

)

Closes the underlying socket.

Definition at line 175 of file CAMuxSocket.cpp.

  {
    m_aktBuffPos=0;
    return m_pSocket->close();
  }

References CASocket::close(), m_aktBuffPos, and m_pSocket.

Referenced by CAFirstMix::clean(), CALastMix::clean(), CALocalProxy::clean(), CAMiddleMix::clean(), CAMiddleMix::loop(), CAFirstMixB::loop(), CALastMixB::loop(), and ~CAMuxSocket().

Here is the call graph for this function:

Here is the caller graph for this function:

connect() [1/2]

SINT32 CAMuxSocket::connect

(

CASocketAddr &

psa

)

Definition at line 163 of file CAMuxSocket.cpp.

  {
    return connect(psa,1,0);
  }

Referenced by CAFirstMix::connectToNextMix(), CAMiddleMix::connectToNextMix(), and CALocalProxy::init().

Here is the caller graph for this function:

connect() [2/2]

SINT32 CAMuxSocket::connect	(	CASocketAddr &	psa,
		UINT	retry,
		UINT32	time
	)

Definition at line 168 of file CAMuxSocket.cpp.

  {
    //m_Socket.setRecvLowWat(MIXPACKET_SIZE);
    m_aktBuffPos=0;
    return m_pSocket->connect(psa,retry,time);
  }

References CASocket::connect(), m_aktBuffPos, and m_pSocket.

Here is the call graph for this function:

getCASocket()

CASocket* CAMuxSocket::getCASocket ( )

inline

Definition at line 84 of file CAMuxSocket.hpp.

{return m_pSocket;}

References m_pSocket.

Referenced by CASocketGroupEpoll::add(), CAFirstMixChannelList::add(), CAFirstMix::doUserLogin_internal(), CAFirstMix::init(), CALastMix::init(), CALocalProxy::init(), CAMiddleMix::init(), CAFirstMixB::loop(), CALastMix::processKeyExchange(), CAMiddleMix::processKeyExchange(), CALocalProxy::processKeyExchange(), CASocketGroupEpoll::remove(), CAFirstMixA::sendToUsers(), and CAFirstMixChannelList::test().

Here is the caller graph for this function:

getHashKey()

SINT32 CAMuxSocket::getHashKey ( )

inline

Returns a Hashkey which uniquely identifies this socket.

Definition at line 52 of file CAMuxSocket.hpp.

        {
          return m_pHashKeyEntry->hashkey;
        }

References __t_hash_key_entry__::hashkey, and m_pHashKeyEntry.

Referenced by CAFirstMixChannelList::add(), CAFirstMixChannelList::addChannel(), CAFirstMix::doUserLogin_internal(), CAFirstMixChannelList::get(), CAFirstMixChannelList::getFirstChannelForSocket(), CAFirstMixChannelList::remove(), and CAFirstMixChannelList::removeChannel().

Here is the caller graph for this function:

getIsEncrypted()

bool CAMuxSocket::getIsEncrypted ( )

inline

Definition at line 96 of file CAMuxSocket.hpp.

        {
          return m_bIsCrypted;
        }

References m_bIsCrypted.

getSocket()

SOCKET CAMuxSocket::getSocket ( )

inline

Definition at line 92 of file CAMuxSocket.hpp.

{return m_pSocket->getSocket();}

References CASocket::getSocket(), and m_pSocket.

Referenced by CASocketGroup::add(), CASocketGroup::isSignaled(), CASocketGroupEpoll::isSignaled(), CAFirstMixB::loop(), and CASocketGroup::remove().

Here is the call graph for this function:

Here is the caller graph for this function:

init()

static SINT32 CAMuxSocket::init ( )

inlinestatic

Definition at line 166 of file CAMuxSocket.hpp.

          {
            ms_pcsHashKeyList=new CAMutex();
            return E_SUCCESS;
          }

References E_SUCCESS, and ms_pcsHashKeyList.

Referenced by CALibProxytest::init().

Here is the caller graph for this function:

prepareForSend()

SINT32 CAMuxSocket::prepareForSend

(

MIXPACKET *

inoutPacket

)

Definition at line 232 of file CAMuxSocket.cpp.

  { 
    m_csSend.lock();
    pinoutPacket->channel=htonl(pinoutPacket->channel);
    pinoutPacket->flags=htons(pinoutPacket->flags);
    m_pCipherOut->crypt1(((UINT8*)pinoutPacket),((UINT8*)pinoutPacket),16);
    m_csSend.unlock();
    return MIXPACKET_SIZE;
  }

References t_MixPacket::channel, t_MixPacket::flags, CAMutex::lock(), m_csSend, m_pCipherOut, MIXPACKET_SIZE, and CAMutex::unlock().

Referenced by CAFirstMix::doUserLogin_internal(), CAFirstMixB::loop(), and CAFirstMixA::sendToUsers().

Here is the call graph for this function:

Here is the caller graph for this function:

receive() [1/2]

SINT32 CAMuxSocket::receive

(

MIXPACKET *

pPacket

)

Receives a whole MixPacket.

Blocks until a packet is received or a socket error occurs.

Parameters

pPacket

on return stores the received MixPacket

Return values

SOCKET_ERROR,in	case of an error
MIXPACKET_SIZE	otherwise

Definition at line 249 of file CAMuxSocket.cpp.

  {
    SINT32 retLock = m_csReceive.lock();
    if (retLock != E_SUCCESS)
    {
      CAMsg::printMsg(LOG_CRIT, "Could not lock MuxSocket receive method! Error code: %d\n", retLock);
      return E_UNKNOWN;
    }
    
    if(m_pSocket->receiveFully((UINT8*)pPacket,MIXPACKET_SIZE)!=E_SUCCESS)
    {
      m_csReceive.unlock();
      return SOCKET_ERROR;
    }
    if(m_bIsCrypted)
      m_pCipherIn->crypt1((UINT8*)pPacket,(UINT8*)pPacket,16);
    pPacket->channel=ntohl(pPacket->channel);
    pPacket->flags=ntohs(pPacket->flags);
    m_csReceive.unlock();
    return MIXPACKET_SIZE;
  }

References t_MixPacket::channel, E_SUCCESS, E_UNKNOWN, t_MixPacket::flags, CAMutex::lock(), m_bIsCrypted, m_csReceive, m_pCipherIn, m_pSocket, MIXPACKET_SIZE, CAMsg::printMsg(), CAClientSocket::receiveFully(), SOCKET_ERROR, and CAMutex::unlock().

Referenced by CAFirstMix::doUserLogin_internal(), CALocalProxy::loop(), CAFirstMixA::loop(), and CAFirstMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

receive() [2/2]

SINT32 CAMuxSocket::receive	(	MIXPACKET *	pPacket,
		UINT32	msTimeout
	)

Trys to receive a Mix-Packet.

If after timout milliseconds not a whole packet is available E_AGAIN will be returned. In this case you should later try to get the rest of the packet

Definition at line 278 of file CAMuxSocket.cpp.

  {
    if (m_pSocket->isClosed())
    {
      return E_NOT_CONNECTED;
    }
    
    SINT32 retLock = m_csReceive.lock();
    if (retLock != E_SUCCESS)
    {
      CAMsg::printMsg(LOG_CRIT,
        "Could not lock MuxSocket timed receive method! Error code: %d\n", retLock);
      return E_UNKNOWN;
    }
    SINT32 len=MIXPACKET_SIZE-m_aktBuffPos;
    SINT32 ret=m_pSocket->receive(m_Buff+m_aktBuffPos,len);
    if(ret<=0&&ret!=E_AGAIN) //if socket was set in non-blocking mode
    {
      m_csReceive.unlock();
      return E_UNKNOWN;
    }
    if(ret==len) //whole packet recieved
    {
      if(m_bIsCrypted)
        m_pCipherIn->crypt1(m_Buff,m_Buff,16);
      memcpy(pPacket,m_Buff,MIXPACKET_SIZE);
      pPacket->channel=ntohl(pPacket->channel);
      pPacket->flags=ntohs(pPacket->flags);
      m_aktBuffPos=0;
      m_csReceive.unlock();
      return MIXPACKET_SIZE;
    }
    if(ret>0) //some new bytes arrived
      m_aktBuffPos+=ret;
    if(msTimeout==0) //we should not wait any more
    {
      m_csReceive.unlock();
      return E_AGAIN;
    }
    UINT64 timeE;
    UINT64 timeC;
    getcurrentTimeMillis(timeE);
    add64(timeE,msTimeout);
    UINT32 dt=msTimeout;
    CASingleSocketGroup oSocketGroup(false);
    oSocketGroup.add(*this);
    for(;;)
      {
        if (m_pSocket->isClosed())
        {
          m_csReceive.unlock();
          return E_NOT_CONNECTED;
        }       
        ret=oSocketGroup.select(dt);
        if(ret!=1)
        {
          m_csReceive.unlock();
          return E_UNKNOWN;
        }
        len=MIXPACKET_SIZE-m_aktBuffPos;
        if (m_pSocket->isClosed())
        {
          m_csReceive.unlock();
          return E_NOT_CONNECTED;
        }       
        ret=m_pSocket->receive(m_Buff+m_aktBuffPos,len);
        if(ret<=0&&ret!=E_AGAIN)
        {
          if (m_pSocket->isClosed())
          {
            CAMsg::printMsg(LOG_ERR, "Error while receiving from socket. Socket is closed! Receive returned: %i Reason: %s (%i)\n", ret, GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
          }
          else
          {
            CAMsg::printMsg(LOG_ERR, "Error while receiving from socket. Receive returned: %i Reason: %s (%i)\n", ret, GET_NET_ERROR_STR(GET_NET_ERROR), GET_NET_ERROR);
          }
          m_csReceive.unlock();
          return E_UNKNOWN;
        }
        if(ret==len)
        {
          if(m_bIsCrypted)
            m_pCipherIn->crypt1(m_Buff,m_Buff,16);
          memcpy(pPacket,m_Buff,MIXPACKET_SIZE);
          pPacket->channel=ntohl(pPacket->channel);
          pPacket->flags=ntohs(pPacket->flags);
          m_aktBuffPos=0;
          m_csReceive.unlock();
          return MIXPACKET_SIZE;
        }
        if(ret>0)
          m_aktBuffPos+=ret;
        getcurrentTimeMillis(timeC);
        if(isGreater64(timeC,timeE)||isEqual64(timeC,timeE))
          break;
        dt=diff64(timeE,timeC);
      }
    m_csReceive.unlock();
    return E_AGAIN;
  }

References CASocketGroup::add(), add64(), t_MixPacket::channel, diff64(), E_AGAIN, E_NOT_CONNECTED, E_SUCCESS, E_UNKNOWN, t_MixPacket::flags, GET_NET_ERROR, GET_NET_ERROR_STR, getcurrentTimeMillis(), CASocket::isClosed(), isEqual64(), isGreater64(), len, CAMutex::lock(), m_aktBuffPos, m_bIsCrypted, m_Buff, m_csReceive, m_pCipherIn, m_pSocket, MIXPACKET_SIZE, CAMsg::printMsg(), CASocket::receive(), CASocketGroup::select(), and CAMutex::unlock().

Here is the call graph for this function:

receiveFully() [1/2]

SINT32 CAMuxSocket::receiveFully ( UINT8 *  buff, UINT32  len  )

inline

Receives some "plain" bytes from the underlying socket - just a convenient function...

Definition at line 69 of file CAMuxSocket.hpp.

      {
        return m_pSocket->receiveFully(buff,len);
      }

References len, m_pSocket, and CAClientSocket::receiveFully().

Referenced by CALastMix::processKeyExchange(), and CAMiddleMix::processKeyExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

receiveFully() [2/2]

SINT32 CAMuxSocket::receiveFully ( UINT8 *  buff, UINT32  len, UINT32  msTimeOut  )

inline

Definition at line 74 of file CAMuxSocket.hpp.

      {
        return m_pSocket->receiveFullyT(buff,len, msTimeOut);
      }

References len, m_pSocket, and CASocket::receiveFullyT().

Here is the call graph for this function:

send() [1/2]

SINT32 CAMuxSocket::send

(

MIXPACKET *

pPacket

)

Sends a MixPacket over the Network.

Will block until the whole packet is send.

Parameters

pPacket

MixPacket to send

Return values

MIXPACKET_SIZE	if MixPacket was successful send
E_UNKNOWN	otherwise

Definition at line 186 of file CAMuxSocket.cpp.

  {
    m_csSend.lock();
    int ret;
    UINT8 tmpBuff[16];
    memcpy(tmpBuff,pPacket,16);
    pPacket->channel=htonl(pPacket->channel);
    pPacket->flags=htons(pPacket->flags);
    if(m_bIsCrypted)
      m_pCipherOut->crypt1(((UINT8*)pPacket),((UINT8*)pPacket),16);
    ret=m_pSocket->sendFully(((UINT8*)pPacket),MIXPACKET_SIZE);
    if(ret!=E_SUCCESS)
      {
        #ifdef _DEBUG
          CAMsg::printMsg(LOG_DEBUG,"MuxSocket-Send-Error!\n");
          CAMsg::printMsg(LOG_DEBUG,"SOCKET-ERROR: %i\n",GET_NET_ERROR);
        #endif
        ret=E_UNKNOWN;
      }
    else
    {
      ret=MIXPACKET_SIZE;
    }
    memcpy(pPacket,tmpBuff,16);
    m_csSend.unlock();
    return ret;
  }

References t_MixPacket::channel, E_SUCCESS, E_UNKNOWN, t_MixPacket::flags, GET_NET_ERROR, CAMutex::lock(), m_bIsCrypted, m_csSend, m_pCipherOut, m_pSocket, MIXPACKET_SIZE, CAMsg::printMsg(), CASocket::sendFully(), and CAMutex::unlock().

Referenced by CALocalProxy::loop(), and CALocalProxy::processKeyExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

send() [2/2]

SINT32 CAMuxSocket::send	(	MIXPACKET *	pPacket,
		UINT8 *	buff
	)

Definition at line 215 of file CAMuxSocket.cpp.

  {
    m_csSend.lock();
    int ret;
    UINT8 tmpBuff[16];
    memcpy(tmpBuff,pPacket,16);
    pPacket->channel=htonl(pPacket->channel);
    pPacket->flags=htons(pPacket->flags);
    if(m_bIsCrypted)
      m_pCipherOut->crypt1(((UINT8*)pPacket),((UINT8*)pPacket),16);
    memcpy(buff,((UINT8*)pPacket),MIXPACKET_SIZE);
    ret=MIXPACKET_SIZE;
    memcpy(pPacket,tmpBuff,16);
    m_csSend.unlock();
    return ret;
  }

References t_MixPacket::channel, t_MixPacket::flags, CAMutex::lock(), m_bIsCrypted, m_csSend, m_pCipherOut, MIXPACKET_SIZE, and CAMutex::unlock().

Here is the call graph for this function:

setCASocket()

SINT32 CAMuxSocket::setCASocket

(

CASocket *

pSocket

)

This will set the underlying CASocket.

Note: The object will be under full controll of CAMuxSocket. It will be destroyed by CAMuxSocket, if not longer needed. Therefore it must have be dynamically allocated.

Parameters

pSocket

the new CASocket to use, should not be NULL

Returns

E_SUCCESS, if successful, E_UNKNOWN otherwise

Definition at line 81 of file CAMuxSocket.cpp.

  {
    if (m_pSocket == NULL)
      return E_UNKNOWN;
    delete m_pSocket;
    m_pSocket = pSocket;
    return E_SUCCESS;
  }

References E_SUCCESS, E_UNKNOWN, and m_pSocket.

setCipher()

SINT32 CAMuxSocket::setCipher

(

SYMCHANNELCIPHER_ALGORITHM

algCipher

)

Definition at line 90 of file CAMuxSocket.cpp.

{
  if (algCipher == UNDEFINED_CIPHER)
    return E_UNKNOWN;
  if (m_pCipherIn != NULL)
  {
    delete m_pCipherIn;
  }
  if (m_pCipherOut != NULL)
  {
    delete m_pCipherOut;
  }
#ifndef MUXSOCKET_CIPHER_NO_ENCRYPTION
  m_pCipherIn = CASymChannelCipherFactory::createCipher(algCipher);
  m_pCipherOut = CASymChannelCipherFactory::createCipher(algCipher);
#else
#ifdef DEUBG
  CAMsg::printMsg(LOG_WARN, "MuxSocket: Using NULL cipher (no encryption)!\n");
#endif
  m_pCipherIn = CASymChannelCipherFactory::createCipher(NULL_CIPHER);
  m_pCipherOut = CASymChannelCipherFactory::createCipher(NULL_CIPHER);
#endif
  return E_SUCCESS;
}

References CASymChannelCipherFactory::createCipher(), E_SUCCESS, E_UNKNOWN, m_pCipherIn, m_pCipherOut, NULL_CIPHER, CAMsg::printMsg(), and UNDEFINED_CIPHER.

Referenced by CAMuxSocket(), and CALocalProxy::processKeyExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

setCrypt()

SINT32 CAMuxSocket::setCrypt

(

bool

b

)

Definition at line 115 of file CAMuxSocket.cpp.

  {
    m_csSend.lock();
    m_csReceive.lock();
    m_bIsCrypted=b;
    m_csReceive.unlock();
    m_csSend.unlock();
    return E_SUCCESS;
  }

References E_SUCCESS, CAMutex::lock(), m_bIsCrypted, m_csReceive, m_csSend, and CAMutex::unlock().

Referenced by CAFirstMix::doUserLogin_internal(), CAMiddleMix::loop(), CALastMix::processKeyExchange(), and CALocalProxy::processKeyExchange().

Here is the call graph for this function:

Here is the caller graph for this function:

setKey()

SINT32 CAMuxSocket::setKey ( UINT8 *  key, UINT32  keyLen  )

inline

Sets the symmetric keys used for de-/encrypting the Mux connection.

Parameters

key	buffer conntaining the key bits
keyLen	size of the buffer (keys) if keylen=16, then the key is used for incomming and outgoing direction (key only) if keylen=32, then the first bytes are used for incoming and the last bytes are used for outgoing

Return values

E_SUCCESS	if successful
E_UNKNOWN	otherwise

Definition at line 115 of file CAMuxSocket.hpp.

        {
          if(keyLen==16)
            {
              m_pCipherIn->setKey(key);
              m_pCipherOut->setKey(key);
            }
          else if(keyLen==32)
            {
              m_pCipherOut->setKey(key);
              m_pCipherIn->setKey(key+16);
            }
        else
            return E_UNKNOWN;
          return E_SUCCESS;
        }

References E_SUCCESS, E_UNKNOWN, m_pCipherIn, and m_pCipherOut.

setReceiveKey()

SINT32 CAMuxSocket::setReceiveKey ( UINT8 *  key, UINT32  keyLen  )

inline

Definition at line 148 of file CAMuxSocket.hpp.

      {
        if(keyLen==16)
        {
          m_pCipherIn->setKey(key);
        }
        else if(keyLen==32)
        {
          m_pCipherIn->setKey(key);
          m_pCipherIn->setIVs(key+16);
        }
        else
        {
          return E_UNKNOWN;
        }
        return E_SUCCESS;
      }

References E_SUCCESS, E_UNKNOWN, and m_pCipherIn.

Referenced by CAFirstMix::doUserLogin_internal(), CALastMix::processKeyExchange(), CAMiddleMix::processKeyExchange(), and CALocalProxy::processKeyExchange().

Here is the caller graph for this function:

setSendKey()

SINT32 CAMuxSocket::setSendKey ( UINT8 *  key, UINT32  keyLen  )

inline

Definition at line 132 of file CAMuxSocket.hpp.

        {
          if(keyLen==16)
            {
              m_pCipherOut->setKey(key);
            }
          else if(keyLen==32)
            {
              m_pCipherOut->setKey(key);
              m_pCipherOut->setIVs(key+16);
            }
          else
            return E_UNKNOWN;
          return E_SUCCESS;
        }

References E_SUCCESS, E_UNKNOWN, and m_pCipherOut.

Referenced by CAFirstMix::doUserLogin_internal(), CALastMix::processKeyExchange(), CAMiddleMix::processKeyExchange(), and CALocalProxy::processKeyExchange().

Here is the caller graph for this function:

Member Data Documentation

m_aktBuffPos

UINT32 CAMuxSocket::m_aktBuffPos

private

Definition at line 187 of file CAMuxSocket.hpp.

Referenced by accept(), CAMuxSocket(), close(), connect(), and receive().

m_bIsCrypted

bool CAMuxSocket::m_bIsCrypted

private

Definition at line 191 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), getIsEncrypted(), receive(), send(), and setCrypt().

m_Buff

UINT8* CAMuxSocket::m_Buff

private

Definition at line 188 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), receive(), and ~CAMuxSocket().

m_csReceive

CAMutex CAMuxSocket::m_csReceive

private

Definition at line 193 of file CAMuxSocket.hpp.

Referenced by receive(), and setCrypt().

m_csSend

CAMutex CAMuxSocket::m_csSend

private

Definition at line 192 of file CAMuxSocket.hpp.

Referenced by prepareForSend(), send(), and setCrypt().

m_pCipherIn

CASymCipherMuxSocket* CAMuxSocket::m_pCipherIn

private

Definition at line 189 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), receive(), setCipher(), setKey(), setReceiveKey(), and ~CAMuxSocket().

m_pCipherOut

CASymCipherMuxSocket* CAMuxSocket::m_pCipherOut

private

Definition at line 190 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), prepareForSend(), send(), setCipher(), setKey(), setSendKey(), and ~CAMuxSocket().

m_pHashKeyEntry

t_hashkeylistEntry* CAMuxSocket::m_pHashKeyEntry

private

Definition at line 194 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), getHashKey(), and ~CAMuxSocket().

m_pSocket

CASocket* CAMuxSocket::m_pSocket

private

Definition at line 186 of file CAMuxSocket.hpp.

Referenced by accept(), CAMuxSocket(), close(), connect(), getCASocket(), getSocket(), receive(), receiveFully(), send(), setCASocket(), and ~CAMuxSocket().

ms_nMaxHashKeyValue

SINT32 CAMuxSocket::ms_nMaxHashKeyValue =0

staticprivate

Definition at line 197 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket().

ms_pcsHashKeyList

CAMutex * CAMuxSocket::ms_pcsHashKeyList =NULL

staticprivate

Definition at line 198 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), cleanup(), init(), and ~CAMuxSocket().

ms_phashkeylistAvailableHashKeys

t_hashkeylistEntry * CAMuxSocket::ms_phashkeylistAvailableHashKeys =NULL

staticprivate

Definition at line 196 of file CAMuxSocket.hpp.

Referenced by CAMuxSocket(), cleanup(), and ~CAMuxSocket().

---

The documentation for this class was generated from the following files:

• CAMuxSocket.hpp
• CAMuxSocket.cpp