CAChain Class Reference

#include <CAChain.hpp>

Collaboration diagram for CAChain:

Public Member Functions
	CAChain (UINT8 *a_chainId)
	~CAChain (void)
UINT8 *	getChainId ()
void	setSocket (CASocket *a_socket)
void	addChannel (t_lastMixBChannelListEntry *a_channel, bool a_fastResponse)
void	addDataToUpstreamQueue (UINT8 *a_buffer, UINT32 a_size)
void	signalConnectionError ()
void	signalUnknownChain ()
void	closeUpstream ()
void	closeDownstream ()
UINT8 *	getPrintableChainId ()
void	addToSocketGroup (CASocketGroupEpoll *a_socketGroup)
void	removeFromSocketGroup (CASocketGroupEpoll *a_socketGroup)
bool	isSignaledInSocketGroup (CASocketGroupEpoll *a_socketGroup)
UINT32	sendUpstreamData (UINT32 a_maxLength, CASocketGroupEpoll *a_removedSocketGroup)
SINT32	processDownstream (CASocketGroupEpoll *a_signalingGroup, MIXPACKET *a_downstreamPacket, UINT32 *a_processedBytes)
	Returns: 0, if a packet was created. More...

Private Member Functions
void	closeChainInternal ()
void	forceImmediateResponsesInternal ()
void	removeFromAllSocketGroupsInternal ()
UINT32	sendUpstreamDataInternal (UINT32 a_maxLength)

Private Attributes
UINT8 *	m_chainId
SINT32	m_lastAccessTime
CASocket *	m_socket
CAQueue *	m_upstreamSendQueue
t_channelEntry *	m_firstChannel
t_socketGroupEntry *	m_firstSocketGroup
bool	m_connectionError
bool	m_downstreamClosed
bool	m_upstreamClosed
bool	m_firstDownstreamPacket
bool	m_unknownChainId

Detailed Description

Definition at line 64 of file CAChain.hpp.

Constructor & Destructor Documentation

CAChain()

CAChain::CAChain

(

UINT8 *

a_chainId

)

Definition at line 40 of file CAChain.cpp.

                                 {
#else
CAChain::CAChain(UINT8* a_chainId, CAMutex* a_delayBucketMutex, SINT32* a_delayBucket) {
#endif
  m_chainId = a_chainId;
  m_firstChannel = NULL;
  m_socket = NULL;
  m_lastAccessTime = -1;
  m_upstreamSendQueue = new CAQueue(DATA_SIZE);
  m_upstreamClosed = false;
  m_downstreamClosed = false;
  m_firstSocketGroup = NULL;
  m_connectionError = false;
  m_unknownChainId = false;
  m_firstDownstreamPacket = true;
  #ifdef LOG_CHAIN_STATISTICS
    m_packetsFromUser = 0;
    m_bytesFromUser = 0;
    m_packetsToUser = 0;
    m_bytesToUser = 0;
    getcurrentTimeMicros(m_creationTime);
  #endif
  #ifdef DELAY_CHANNELS
    m_pDelayBucketMutex = a_delayBucketMutex;
    m_pDelayBucket = a_delayBucket;
  #endif
}

References DATA_SIZE, getcurrentTimeMicros(), m_chainId, m_connectionError, m_downstreamClosed, m_firstChannel, m_firstDownstreamPacket, m_firstSocketGroup, m_lastAccessTime, m_socket, m_unknownChainId, m_upstreamClosed, and m_upstreamSendQueue.

Here is the call graph for this function:

~CAChain()

CAChain::~CAChain

(

void

)

Definition at line 68 of file CAChain.cpp.

                      {
  if (m_socket != NULL) {
    removeFromAllSocketGroupsInternal();
    m_socket->close();
    delete m_socket;
    m_socket = NULL;
  }
  m_upstreamSendQueue->clean();
  delete m_upstreamSendQueue;
  m_upstreamSendQueue = NULL;
  /* remove all associated channels (normally there shouldn't be any, but in
   * case of a shutdown, some channels may be still open)
   */
  while (m_firstChannel != NULL) {
    t_channelEntry* channelEntry = m_firstChannel;
    /* remove the entry from the channel-table */
    channelEntry->channel->associatedChannelList->removeFromTable(channelEntry->channel);
    /* remove all deadlines */
    while (channelEntry->channel->firstResponseDeadline != NULL) {
      t_deadlineEntry* currentDeadline = channelEntry->channel->firstResponseDeadline;
      channelEntry->channel->firstResponseDeadline = currentDeadline->nextDeadline;
      delete currentDeadline;
      currentDeadline = NULL;
    }
    /* remove the channel-cipher */
    delete channelEntry->channel->channelCipher;
    channelEntry->channel->channelCipher = NULL;
    m_firstChannel = channelEntry->nextChannel;
    delete channelEntry;
    channelEntry = NULL;
  }
  #ifdef LOG_CHAIN_STATISTICS
    /* log chain-statistics with format:
     * Chain-ID, Chain duration [micros], Upload (bytes), Download (bytes), Packets from user, Packets to user
     */
     UINT64 currentTime;
     getcurrentTimeMicros(currentTime);
     UINT32 duration = diff64(currentTime, m_creationTime);
     UINT8* chainId = getPrintableChainId();
     CAMsg::printMsg(LOG_DEBUG, "%s,%u,%u,%u,%u,%u\n", chainId, duration, m_bytesFromUser, m_bytesToUser, m_packetsFromUser, m_packetsToUser);
     delete []chainId;
     chainId = NULL;
  #endif
  delete []m_chainId;
  m_chainId = NULL;
  #ifdef DELAY_CHANNELS
    /* free the delay-bucket (set it to -1), don't delete the mutex because it
     * is used for all delay-buckets
     */
    m_pDelayBucketMutex->lock();
    *m_pDelayBucket = -1;
    m_pDelayBucketMutex->unlock();
  #endif
  }

References t_lastMixBChannelListEntry::associatedChannelList, chainId, t_channelEntry::channel, t_lastMixBChannelListEntry::channelCipher, CAQueue::clean(), CASocket::close(), diff64(), t_lastMixBChannelListEntry::firstResponseDeadline, getcurrentTimeMicros(), getPrintableChainId(), m_chainId, m_firstChannel, m_socket, m_upstreamSendQueue, t_channelEntry::nextChannel, t_deadlineEntry::nextDeadline, CAMsg::printMsg(), removeFromAllSocketGroupsInternal(), and CALastMixBChannelList::removeFromTable().

Here is the call graph for this function:

Member Function Documentation

addChannel()

void CAChain::addChannel	(	t_lastMixBChannelListEntry *	a_channel,
		bool	a_fastResponse
	)

Definition at line 485 of file CAChain.cpp.

                                                                                   {
  t_channelEntry* lastChannel = NULL;
  bool invalidChannel = false;
  if (m_firstChannel != NULL) {
    if (m_firstChannel->nextChannel != NULL) {
      /* somebody is trying to add a third channel to the chain but currently
       * only 2 channels can be associated to a data-chain -> ignore the new
       * channel (attention: currently we have to send at least a
       * CHANNEL-CLOSE because there is no channel-timeout at first and middle
       * mixes), send an IOException and close the chain
       */
      invalidChannel = true;
      signalConnectionError();
      /* find the last associated channel */
      lastChannel = m_firstChannel->nextChannel;
      while (lastChannel->nextChannel != NULL) {
        lastChannel = lastChannel->nextChannel;
      }   
    }
    else {
      lastChannel = m_firstChannel;
    }
  }
  t_channelEntry* newChannel = new t_channelEntry;
  /* initialize the fields */
  newChannel->nextChannel = NULL;
  newChannel->channel = a_channel;
  if (lastChannel != NULL) {
    /* close all previous channels immediately */
    forceImmediateResponsesInternal();
    /* now add the new channel */
    lastChannel->nextChannel = newChannel;
  }
  else {
    m_firstChannel = newChannel;
  }
  timespec currentTime;
  getcurrentTime(currentTime);
  if (!invalidChannel) {
    if ((!(m_upstreamClosed && m_downstreamClosed)) && (m_lastAccessTime != -1)) {
      /* if not downstream and upstream is closed and also an access-timeout
       * is running -> stop that access-timeout
       */
      m_lastAccessTime = -1;
    }
    a_channel->remainingDownstreamPackets = CHANNEL_DOWNSTREAM_PACKETS;
    /* create deadlines for the new downstream-packets */
    t_deadlineEntry** lastNextDeadlinePointer = &(a_channel->firstResponseDeadline);
    for (UINT32 i = 0; i < CHANNEL_DOWNSTREAM_PACKETS; i++) {
      t_deadlineEntry* currentDeadline = new t_deadlineEntry;
      currentDeadline->nextDeadline = NULL;
      if (!m_downstreamClosed) {
        if (a_fastResponse && (i == 0)) {
          /* we shall send a fast response -> send back the first packet of
           * the new channel immediately
           */
          currentDeadline->deadline.tv_sec = currentTime.tv_sec;
        }
        else {
          /* use normal channel-timeout */
          currentDeadline->deadline.tv_sec = currentTime.tv_sec + CHANNEL_TIMEOUT;
        }
      }
      else {
        /* downstream is already closed -> send packets back immediately */
        currentDeadline->deadline.tv_sec = currentTime.tv_sec;
      }
      currentDeadline->deadline.tv_nsec = currentTime.tv_nsec;
      *lastNextDeadlinePointer = currentDeadline;
      lastNextDeadlinePointer = &(currentDeadline->nextDeadline);
    }
  }
  else {
    /* send only one packet (will be CHANNEL-CLOSE) */
    a_channel->remainingDownstreamPackets = 1;
    a_channel->firstResponseDeadline = new t_deadlineEntry;
    a_channel->firstResponseDeadline->nextDeadline = NULL;
    a_channel->firstResponseDeadline->deadline.tv_sec = currentTime.tv_sec;
    a_channel->firstResponseDeadline->deadline.tv_nsec = currentTime.tv_nsec;
  }
}

References t_channelEntry::channel, CHANNEL_DOWNSTREAM_PACKETS, CHANNEL_TIMEOUT, t_deadlineEntry::deadline, t_lastMixBChannelListEntry::firstResponseDeadline, forceImmediateResponsesInternal(), getcurrentTime(), m_downstreamClosed, m_firstChannel, m_lastAccessTime, m_upstreamClosed, t_channelEntry::nextChannel, t_deadlineEntry::nextDeadline, t_lastMixBChannelListEntry::remainingDownstreamPackets, and signalConnectionError().

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

addDataToUpstreamQueue()

void CAChain::addDataToUpstreamQueue	(	UINT8 *	a_buffer,
		UINT32	a_size
	)

Definition at line 444 of file CAChain.cpp.

                                                                   {
  if (!m_upstreamClosed) {
    /* only add data if upstream isn't closed */
    m_upstreamSendQueue->add(a_buffer, a_size);
    #ifdef LOG_CHAIN_STATISTICS
      m_packetsFromUser++;
      m_bytesFromUser = m_bytesFromUser + a_size;
    #endif
  }
}

References CAQueue::add(), m_upstreamClosed, and m_upstreamSendQueue.

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

addToSocketGroup()

void CAChain::addToSocketGroup

(

CASocketGroupEpoll *

a_socketGroup

)

Definition at line 372 of file CAChain.cpp.

                                                                {
#else
void CAChain::addToSocketGroup(CASocketGroup* a_socketGroup) {
#endif
  if (m_socket != NULL) {
    /* check whether our socket isn't already in the specified socket-group
    */
    t_socketGroupEntry* currentEntry = m_firstSocketGroup;
    t_socketGroupEntry** previousNextEntryPointer = &m_firstSocketGroup;
    bool alreadyIncluded = false;
    while ((currentEntry != NULL) && (!alreadyIncluded)) {
      if (currentEntry->socketGroup == a_socketGroup) {
        alreadyIncluded = true;
      }
      else {
        previousNextEntryPointer = &(currentEntry->nextSocketGroup);
        currentEntry = currentEntry->nextSocketGroup;
      }
    }
    if (!alreadyIncluded) {
      #ifdef HAVE_EPOLL
        a_socketGroup->add(*m_socket, this);
      #else
        a_socketGroup->add(*m_socket);
      #endif
      currentEntry = new t_socketGroupEntry;
      currentEntry->nextSocketGroup = NULL;
      currentEntry->socketGroup = a_socketGroup;
      *previousNextEntryPointer = currentEntry;
    }
  }
}

References CASocketGroup::add(), m_firstSocketGroup, m_socket, t_socketGroupEntry::nextSocketGroup, and t_socketGroupEntry::socketGroup.

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

closeChainInternal()

void CAChain::closeChainInternal ( )

private

Definition at line 567 of file CAChain.cpp.

                                 {
  m_upstreamClosed = true;
  m_downstreamClosed = true;
  m_upstreamSendQueue->clean();
  if (m_socket != NULL) {
    removeFromAllSocketGroupsInternal();
    m_socket->close();
    delete m_socket;
    m_socket = NULL;
  }
  /* send back all response-packets immediately */
  forceImmediateResponsesInternal();
}

References CAQueue::clean(), CASocket::close(), forceImmediateResponsesInternal(), m_downstreamClosed, m_socket, m_upstreamClosed, m_upstreamSendQueue, and removeFromAllSocketGroupsInternal().

Referenced by closeDownstream(), closeUpstream(), processDownstream(), signalConnectionError(), and signalUnknownChain().

Here is the call graph for this function:

Here is the caller graph for this function:

closeDownstream()

void CAChain::closeDownstream

(

)

Definition at line 460 of file CAChain.cpp.

                              {
  /* currently we will close the whole chain immediately */
  closeChainInternal();
}

References closeChainInternal().

Referenced by processDownstream().

Here is the call graph for this function:

Here is the caller graph for this function:

closeUpstream()

void CAChain::closeUpstream

(

)

Definition at line 455 of file CAChain.cpp.

                            {
  /* currently we will close the whole chain immediately */
  closeChainInternal();
}

References closeChainInternal().

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

forceImmediateResponsesInternal()

void CAChain::forceImmediateResponsesInternal ( )

private

Definition at line 581 of file CAChain.cpp.

                                              {
  /* set all deadlines to the current time (if they don't have a previous
   * time) */
  timespec currentTime;
  getcurrentTime(currentTime);
  t_channelEntry* currentChannel = m_firstChannel;
  while (currentChannel != NULL) {     
    t_deadlineEntry* currentDeadline = currentChannel->channel->firstResponseDeadline;
    while (currentDeadline != NULL) {
      if (currentDeadline->deadline.tv_sec > currentTime.tv_sec) {
        currentDeadline->deadline.tv_sec = currentTime.tv_sec;
        currentDeadline->deadline.tv_nsec = currentTime.tv_nsec;
      }
      else {
        if ((currentDeadline->deadline.tv_sec == currentTime.tv_sec) && (currentDeadline->deadline.tv_nsec > currentTime.tv_nsec)) {
          currentDeadline->deadline.tv_nsec = currentTime.tv_nsec;
        }
      }
      currentDeadline = currentDeadline->nextDeadline;
    }
    currentChannel = currentChannel->nextChannel;
  }
}  

References t_channelEntry::channel, t_deadlineEntry::deadline, t_lastMixBChannelListEntry::firstResponseDeadline, getcurrentTime(), m_firstChannel, t_channelEntry::nextChannel, and t_deadlineEntry::nextDeadline.

Referenced by addChannel(), and closeChainInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

getChainId()

UINT8 * CAChain::getChainId

(

)

Definition at line 123 of file CAChain.cpp.

                           {
  return m_chainId;
}

References m_chainId.

Referenced by CAChainTable::getEntryInternal(), and CALastMixB::loop().

Here is the caller graph for this function:

getPrintableChainId()

UINT8 * CAChain::getPrintableChainId

(

)

Definition at line 479 of file CAChain.cpp.

                                    {
  UINT8* printableChainId = bytes2hex(m_chainId, CHAIN_ID_LENGTH);
  strtrim(printableChainId);
  return printableChainId;
}

References bytes2hex(), CHAIN_ID_LENGTH, m_chainId, and strtrim().

Referenced by processDownstream(), and ~CAChain().

Here is the call graph for this function:

Here is the caller graph for this function:

isSignaledInSocketGroup()

bool CAChain::isSignaledInSocketGroup

(

CASocketGroupEpoll *

a_socketGroup

)

Definition at line 356 of file CAChain.cpp.

                                                                       {
  if (m_socket != NULL) {
    return a_socketGroup->isSignaled(this);
  }
  return false;
}

References CASocketGroupEpoll::isSignaled(), and m_socket.

Referenced by CALastMixB::loop(), and processDownstream().

Here is the call graph for this function:

Here is the caller graph for this function:

processDownstream()

SINT32 CAChain::processDownstream	(	CASocketGroupEpoll *	a_signalingGroup,
		MIXPACKET *	a_downstreamPacket,
		UINT32 *	a_processedBytes
	)

Returns: 0, if a packet was created.

1, if currently nothing can be done. 2, if a packet was created and the chain can be removed from the chaintable. 3, if no packet was created, but the chain can be removed from the chaintable.

Definition at line 146 of file CAChain.cpp.

                                                                                                                               {
#else
SINT32 CAChain::processDownstream(CASocketGroup* a_signalingGroup, MIXPACKET* a_downstreamPacket, UINT32* a_processedBytes) {
#endif
  *a_processedBytes = 0;
  /* first: get the time - we will need it */
  timespec currentTime;
  getcurrentTime(currentTime);
  if (m_lastAccessTime != -1) {
    /* currently we dont't have an associated channel -> check whether the
     * access-timeout is reached
     */
    if (m_lastAccessTime + CHAIN_TIMEOUT < currentTime.tv_sec) {
      /* timeout is reached */
      closeChainInternal();
      return 3;
    }
    /* there is currently no channel associated -> we can't do anything */
    return 1;
  }
  /* we have at least one associated channel */
  /* check whether we have to drop packages because of outdated deadlines */
  t_deadlineEntry* testedDeadlineEntry = m_firstChannel->channel->firstResponseDeadline;
  if (((testedDeadlineEntry->deadline.tv_sec + DEADLINE_TIMEOUT) < currentTime.tv_sec) || (((testedDeadlineEntry->deadline.tv_sec + DEADLINE_TIMEOUT) == currentTime.tv_sec) && (testedDeadlineEntry->deadline.tv_nsec <= currentTime.tv_nsec))) {
    /* we are too late, it wouldn't make sense to send the packet -> we will
     * reduce traffic by dropping the packet (and all following packets of the
     * channel) -> currently we have to send at least a CHANNEL-CLOSE, so keep
     * one packet in the channel
     */
    if (m_firstChannel->channel->remainingDownstreamPackets > 1) {
      /* we will really loose packets -> synchronization between client and
       * server is destroyed -> signal connection error and close the chain
       */
      signalConnectionError();
      UINT8* chainId = getPrintableChainId();
      CAMsg::printMsg(LOG_INFO, "Dropped downstream-packets from chain '%s'!\n", chainId);
      delete []chainId;
      chainId = NULL;
      while (m_firstChannel->channel->remainingDownstreamPackets > 1) {
        m_firstChannel->channel->remainingDownstreamPackets--;
        m_firstChannel->channel->firstResponseDeadline = testedDeadlineEntry->nextDeadline;
        delete testedDeadlineEntry;
        testedDeadlineEntry = m_firstChannel->channel->firstResponseDeadline;
      }
    }
  }
  /* now try to send something */
  t_downstreamChainCell* pChainCell = (t_downstreamChainCell*)(a_downstreamPacket->data);
  if ((m_socket != NULL) && (!m_downstreamClosed) && (m_firstChannel != NULL)) {
    if (m_firstChannel->channel->remainingDownstreamPackets > 1) {
      /* we are able to send data to the client -> look whether data is
       * available at the socket
       */
      if (isSignaledInSocketGroup(a_signalingGroup)) {
        /* there is something available -> check how much data we can process
         */
        UINT16 payloadData = MAX_SEQUEL_DOWNSTREAM_CHAINCELL_PAYLOAD;
        if (m_firstDownstreamPacket) {
          payloadData = MAX_FIRST_DOWNSTREAM_CHAINCELL_PAYLOAD;
        }
        #ifdef DELAY_CHANNELS
          payloadData = min(payloadData, (UINT16)getDelayBucketInternal());
        #endif
        if (payloadData > 0) {
          /* we will receive something */
          /* if the packet isn't filled fully, some randomness for the
           * remainging space would be great
           */
          getRandom(a_downstreamPacket->data, DATA_SIZE);
          SINT32 bytesReceived;
          if (m_firstDownstreamPacket) {
            bytesReceived = m_socket->receive(pChainCell->firstCell.data, payloadData);
          }
          else {
            bytesReceived = m_socket->receive(pChainCell->sequelCell.data, payloadData);
          }
          if (bytesReceived >= 0) {
            if (bytesReceived == 0) {
              /* seems to be the end of the data-stream */
              closeDownstream();
            }
            else {
              /* we have received some bytes -> create the packet */
              #ifdef DELAY_CHANNELS
                removeFromDelayBucketInternal(bytesReceived);
              #endif
              if (m_firstDownstreamPacket) {
                /* also we have to send the Chain-ID */
                memcpy(pChainCell->firstCell.chainId, m_chainId, CHAIN_ID_LENGTH);
                m_firstDownstreamPacket = false;
              }
              pChainCell->lengthAndFlags = htons((UINT16)bytesReceived);
              a_downstreamPacket->channel = m_firstChannel->channel->channelId;
              a_downstreamPacket->flags = CHANNEL_DATA;
              m_firstChannel->channel->channelCipher->crypt2(a_downstreamPacket->data, a_downstreamPacket->data, DATA_SIZE);
              m_firstChannel->channel->remainingDownstreamPackets--;
              t_deadlineEntry* currentDeadline = m_firstChannel->channel->firstResponseDeadline;
              m_firstChannel->channel->firstResponseDeadline = currentDeadline->nextDeadline;
              delete currentDeadline;
              currentDeadline = NULL;
              *a_processedBytes = (UINT32)bytesReceived;
              #ifdef LOG_CHAIN_STATISTICS
                m_packetsToUser++;
                m_bytesToUser = m_bytesToUser + (UINT32)bytesReceived;
              #endif
              return 0;
            }
          }
          else {
            /* there was a connection error */
            signalConnectionError();
          }
        }
      }
    }
  }
  /* we cannot send any real data, but maybe we have to send some protocol data */
  if (m_firstChannel->channel->remainingDownstreamPackets == 1) {
    /* currently we have to send a CHANNEL-CLOSE */
    getRandom(a_downstreamPacket->data, DATA_SIZE);
    a_downstreamPacket->channel = m_firstChannel->channel->channelId;
    a_downstreamPacket->flags = CHANNEL_CLOSE;
    /* delete channel-resources */
    t_lastMixBChannelListEntry* currentChannel = m_firstChannel->channel;
    currentChannel->associatedChannelList->removeFromTable(currentChannel);
    delete currentChannel->firstResponseDeadline;
    currentChannel->firstResponseDeadline = NULL;
    delete currentChannel->channelCipher;
    currentChannel->channelCipher = NULL;
    delete currentChannel;
    currentChannel = NULL;
    t_channelEntry* currentChannelEntry = m_firstChannel;
    /* change to the next channel */
    m_firstChannel = m_firstChannel->nextChannel;
    delete currentChannelEntry;
    currentChannelEntry = NULL;
    #ifdef LOG_CHAIN_STATISTICS
      /* a packet (CHANNEL_CLOSE) without payload is sent */
      m_packetsToUser++;
    #endif
    if (m_firstChannel == NULL) {
      if (m_downstreamClosed && m_upstreamClosed) {
        /* it was the last channel and the chain is closed -> it can be
         * removed from the table
         */
        return 2;
      }
      else {
        /* it was the last channel, but the chain isn't closed -> start the
         * access timeout
         */
        timespec currentTime;
        getcurrentTime(currentTime);
        m_lastAccessTime = currentTime.tv_sec;
        return 0;
      }
    }
    /* we've sent a close but it wasn't the last channel */
    return 0;
  }
  /* no data, no channel-close, but maybe we have to send a packet because of
   * a deadline
   */
  if ((m_firstChannel->channel->firstResponseDeadline->deadline.tv_sec < currentTime.tv_sec) || ((m_firstChannel->channel->firstResponseDeadline->deadline.tv_sec == currentTime.tv_sec) && (m_firstChannel->channel->firstResponseDeadline->deadline.tv_nsec <= currentTime.tv_nsec))) {
    /* deadline reached */
    getRandom(a_downstreamPacket->data, DATA_SIZE);
    pChainCell->lengthAndFlags = 0;
    if (m_firstDownstreamPacket) {
      /* also we have to send the Chain-ID */
      memcpy(pChainCell->firstCell.chainId, m_chainId, CHAIN_ID_LENGTH);
      m_firstDownstreamPacket = false;
    }
    /* maybe we have to set some flags */
    if (m_unknownChainId) {
      pChainCell->lengthAndFlags = pChainCell->lengthAndFlags | CHAINFLAG_UNKNOWN_CHAIN;
      /* reset the flag */
      m_unknownChainId = false;
    }
    if (m_connectionError) {
      pChainCell->lengthAndFlags = pChainCell->lengthAndFlags | CHAINFLAG_CONNECTION_ERROR;
      /* reset the flag */
      m_connectionError = false;
    }
    if (m_downstreamClosed) {
      pChainCell->lengthAndFlags = pChainCell->lengthAndFlags | CHAINFLAG_STREAM_CLOSED;
      /* don't reset the flag */
    }
    /* ensure correct byte order */
    pChainCell->lengthAndFlags = htons(pChainCell->lengthAndFlags);
    /* finalize packet */
    a_downstreamPacket->channel = m_firstChannel->channel->channelId;
    a_downstreamPacket->flags = CHANNEL_DATA;
    m_firstChannel->channel->channelCipher->crypt2(a_downstreamPacket->data, a_downstreamPacket->data, DATA_SIZE);
    /* clean up */
    m_firstChannel->channel->remainingDownstreamPackets--;
    t_deadlineEntry* currentDeadline = m_firstChannel->channel->firstResponseDeadline;
    m_firstChannel->channel->firstResponseDeadline = currentDeadline->nextDeadline;
    delete currentDeadline;
    currentDeadline = NULL;
    #ifdef LOG_CHAIN_STATISTICS
      /* a packet without payload is sent */
      m_packetsToUser++;
    #endif
    return 0;
  }
  /* no deadline reached and nothing else to do */
  return 1;
}

References t_lastMixBChannelListEntry::associatedChannelList, CHAIN_ID_LENGTH, CHAIN_TIMEOUT, CHAINFLAG_CONNECTION_ERROR, CHAINFLAG_STREAM_CLOSED, CHAINFLAG_UNKNOWN_CHAIN, chainId, t_first_downstream_chain_cell::chainId, t_channelEntry::channel, t_MixPacket::channel, CHANNEL_CLOSE, CHANNEL_DATA, t_lastMixBChannelListEntry::channelCipher, t_lastMixBChannelListEntry::channelId, closeChainInternal(), closeDownstream(), CASymChannelCipher::crypt2(), t_MixPacket::data, t_first_downstream_chain_cell::data, t_sequel_downstream_chain_cell::data, DATA_SIZE, t_deadlineEntry::deadline, DEADLINE_TIMEOUT, t_downstream_chain_cell::firstCell, t_lastMixBChannelListEntry::firstResponseDeadline, t_MixPacket::flags, getcurrentTime(), getPrintableChainId(), getRandom(), isSignaledInSocketGroup(), t_downstream_chain_cell::lengthAndFlags, m_chainId, m_connectionError, m_downstreamClosed, m_firstChannel, m_firstDownstreamPacket, m_lastAccessTime, m_socket, m_unknownChainId, m_upstreamClosed, MAX_FIRST_DOWNSTREAM_CHAINCELL_PAYLOAD, MAX_SEQUEL_DOWNSTREAM_CHAINCELL_PAYLOAD, min, t_channelEntry::nextChannel, t_deadlineEntry::nextDeadline, CAMsg::printMsg(), CASocket::receive(), t_lastMixBChannelListEntry::remainingDownstreamPackets, CALastMixBChannelList::removeFromTable(), t_downstream_chain_cell::sequelCell, and signalConnectionError().

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

removeFromAllSocketGroupsInternal()

void CAChain::removeFromAllSocketGroupsInternal ( )

private

Definition at line 605 of file CAChain.cpp.

                                                {
  t_socketGroupEntry* currentEntry = m_firstSocketGroup;
  m_firstSocketGroup = NULL;
  while (currentEntry != NULL) {
    currentEntry->socketGroup->remove(*m_socket);
    t_socketGroupEntry* nextEntry = currentEntry->nextSocketGroup;
    delete currentEntry;
    currentEntry = nextEntry;
  }
}

References m_firstSocketGroup, m_socket, t_socketGroupEntry::nextSocketGroup, CASocketGroupEpoll::remove(), and t_socketGroupEntry::socketGroup.

Referenced by closeChainInternal(), and ~CAChain().

Here is the call graph for this function:

Here is the caller graph for this function:

removeFromSocketGroup()

void CAChain::removeFromSocketGroup

(

CASocketGroupEpoll *

a_socketGroup

)

Definition at line 406 of file CAChain.cpp.

                                                                     {
#else
void CAChain::removeFromSocketGroup(CASocketGroup* a_socketGroup) {
#endif
  if (m_socket != NULL) {
    /* check whether our socket is in the specified socket-group */
    t_socketGroupEntry* currentEntry = m_firstSocketGroup;
    t_socketGroupEntry** previousNextEntryPointer = &m_firstSocketGroup;
    while (currentEntry != NULL) {
      if (currentEntry->socketGroup == a_socketGroup) {
        /* we are in the specified socket group -> remove occurance */
        a_socketGroup->remove(*m_socket);
        *previousNextEntryPointer = currentEntry->nextSocketGroup;
        delete currentEntry;
        currentEntry = NULL;
      }
      else {
        previousNextEntryPointer = &(currentEntry->nextSocketGroup);
        currentEntry = currentEntry->nextSocketGroup;
      }
    }
  }
}

References m_firstSocketGroup, m_socket, t_socketGroupEntry::nextSocketGroup, CASocketGroup::remove(), and t_socketGroupEntry::socketGroup.

Referenced by sendUpstreamData().

Here is the call graph for this function:

Here is the caller graph for this function:

sendUpstreamData()

UINT32 CAChain::sendUpstreamData	(	UINT32	a_maxLength,
		CASocketGroupEpoll *	a_removedSocketGroup
	)

Definition at line 431 of file CAChain.cpp.

                                                                                             {
#else
UINT32 CAChain::sendUpstreamData(UINT32 a_maxLength, CASocketGroup* a_removedSocketGroup) {
#endif
  UINT32 processedBytes = sendUpstreamDataInternal(a_maxLength);
  if (m_upstreamSendQueue->isEmpty()) {
    /* queue is empty -> we can remove the entry from the socketgroup */
    removeFromSocketGroup(a_removedSocketGroup);
  }
  return processedBytes;
}

References CAQueue::isEmpty(), m_upstreamSendQueue, removeFromSocketGroup(), and sendUpstreamDataInternal().

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

sendUpstreamDataInternal()

UINT32 CAChain::sendUpstreamDataInternal ( UINT32  a_maxLength )

private

Definition at line 616 of file CAChain.cpp.

                                                           {
  UINT32 bytesSent = 0;
  if ((!m_upstreamClosed) && (m_socket != NULL)) {
    UINT32 length = a_maxLength;
    UINT8* buffer = new UINT8[length];
    if (m_upstreamSendQueue->peek(buffer, &length) == E_SUCCESS) {
      /* queue has filled the buffer */
      SINT32 errorCode = m_socket->send(buffer, length);
      if (errorCode >= 0) {
        length = (UINT32)errorCode;
        bytesSent = length;
        m_upstreamSendQueue->remove(&length);
      }
      else {
        /* error while sending data */
        signalConnectionError();
      }
    }
  }
  return bytesSent;
}

References E_SUCCESS, m_socket, m_upstreamClosed, m_upstreamSendQueue, CAQueue::peek(), CAQueue::remove(), CASocket::send(), and signalConnectionError().

Referenced by sendUpstreamData().

Here is the call graph for this function:

Here is the caller graph for this function:

setSocket()

void CAChain::setSocket

(

CASocket *

a_socket

)

Definition at line 134 of file CAChain.cpp.

                                            {
    m_socket = a_socket;
  }

References m_socket.

Referenced by CALastMixB::loop().

Here is the caller graph for this function:

signalConnectionError()

void CAChain::signalConnectionError

(

)

Definition at line 465 of file CAChain.cpp.

                                    {
  m_connectionError = true;
  /* we will also close the chain */
  closeChainInternal();
}

References closeChainInternal(), and m_connectionError.

Referenced by addChannel(), CALastMixB::loop(), processDownstream(), and sendUpstreamDataInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

signalUnknownChain()

void CAChain::signalUnknownChain

(

)

Definition at line 471 of file CAChain.cpp.

                                 {
  m_unknownChainId = true;
  /* we will not send any chain-id -> disable m_firstDownstreamPacket */
  m_firstDownstreamPacket = false;
  /* we will also close the chain */
  closeChainInternal();
}

References closeChainInternal(), m_firstDownstreamPacket, and m_unknownChainId.

Referenced by CALastMixB::loop().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_chainId

UINT8* CAChain::m_chainId

private

Definition at line 100 of file CAChain.hpp.

Referenced by CAChain(), getChainId(), getPrintableChainId(), processDownstream(), and ~CAChain().

m_connectionError

bool CAChain::m_connectionError

private

Definition at line 106 of file CAChain.hpp.

Referenced by CAChain(), processDownstream(), and signalConnectionError().

m_downstreamClosed

bool CAChain::m_downstreamClosed

private

Definition at line 107 of file CAChain.hpp.

Referenced by addChannel(), CAChain(), closeChainInternal(), and processDownstream().

m_firstChannel

t_channelEntry* CAChain::m_firstChannel

private

Definition at line 104 of file CAChain.hpp.

Referenced by addChannel(), CAChain(), forceImmediateResponsesInternal(), processDownstream(), and ~CAChain().

m_firstDownstreamPacket

bool CAChain::m_firstDownstreamPacket

private

Definition at line 109 of file CAChain.hpp.

Referenced by CAChain(), processDownstream(), and signalUnknownChain().

m_firstSocketGroup

t_socketGroupEntry* CAChain::m_firstSocketGroup

private

Definition at line 105 of file CAChain.hpp.

Referenced by addToSocketGroup(), CAChain(), removeFromAllSocketGroupsInternal(), and removeFromSocketGroup().

m_lastAccessTime

SINT32 CAChain::m_lastAccessTime

private

Definition at line 101 of file CAChain.hpp.

Referenced by addChannel(), CAChain(), and processDownstream().

m_socket

CASocket* CAChain::m_socket

private

Definition at line 102 of file CAChain.hpp.

Referenced by addToSocketGroup(), CAChain(), closeChainInternal(), isSignaledInSocketGroup(), processDownstream(), removeFromAllSocketGroupsInternal(), removeFromSocketGroup(), sendUpstreamDataInternal(), setSocket(), and ~CAChain().

m_unknownChainId

bool CAChain::m_unknownChainId

private

Definition at line 110 of file CAChain.hpp.

Referenced by CAChain(), processDownstream(), and signalUnknownChain().

m_upstreamClosed

bool CAChain::m_upstreamClosed

private

Definition at line 108 of file CAChain.hpp.

Referenced by addChannel(), addDataToUpstreamQueue(), CAChain(), closeChainInternal(), processDownstream(), and sendUpstreamDataInternal().

m_upstreamSendQueue

CAQueue* CAChain::m_upstreamSendQueue

private

Definition at line 103 of file CAChain.hpp.

Referenced by addDataToUpstreamQueue(), CAChain(), closeChainInternal(), sendUpstreamData(), sendUpstreamDataInternal(), and ~CAChain().

---

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

• CAChain.hpp
• CAChain.cpp