CAMix.cpp

Go to the documentation of this file.

/*
Copyright (c) 2000, The JAP-Team
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
 
  - Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.
 
  - Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation and/or
    other materials provided with the distribution.
 
  - Neither the name of the University of Technology Dresden, Germany nor the names of its contributors
    may be used to endorse or promote products derived from this software without specific
    prior written permission.
 
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
*/
#include "StdAfx.h"
#if !defined ONLY_LOCAL_PROXY || defined INCLUDE_MIDDLE_MIX || defined INCLUDE_LAST_MIX 
#include "CAMix.hpp"
#include "CAUtil.hpp"
#include "CAInfoService.hpp"
#include "CACmdLnOptions.hpp"
#include "CAStatusManager.hpp"
#include "CALibProxytest.hpp"
 
const UINT32 CAMix::TIMEOUT_MIX_CONNECTION_ESTABLISHEMENT = 60000;
 
CAMix::CAMix()
  {
  m_acceptReconfiguration = CALibProxytest::getOptions()->acceptReconfiguration();
  //m_pSignature=NULL;
  m_pMultiSignature=NULL;
  m_pInfoService=NULL;
  m_pMuxOutControlChannelDispatcher=NULL;
  m_pMuxInControlChannelDispatcher=NULL;
  m_u32KeepAliveSendInterval=0;//zero means --> do not use
  m_u32KeepAliveRecvInterval=0;//zero means --> do not use
  m_bShutDown = false;
  m_docMixCascadeInfo=NULL;
  m_bConnected = false;
  m_lLastConnectionTime = 0;
//#ifdef DYNAMIC_MIX
  /* LERNGRUPPE: Run by default */
  m_bLoop = true;
#ifdef DYNAMIC_MIX
  m_bReconfiguring = false;
  m_bCascadeEstablished = false;
  m_bReconfigured = false;
#endif
#ifdef DATA_RETENTION_LOG
  m_pDataRetentionLog=NULL;
#endif
  }
 
CAMix::~CAMix()
  {
#ifdef DATA_RETENTION_LOG
  if(m_pDataRetentionLog!=NULL)
    {
    delete m_pDataRetentionLog;
    m_pDataRetentionLog=NULL;
    }
#endif
 
  }
 
SINT32 CAMix::initOnce()
  {
#ifdef DATA_RETENTION_LOG
  m_pDataRetentionLog=new CADataRetentionLog();
  CAASymCipher* pKey=NULL;
  CALibProxytest::getOptions()->getDataRetentionPublicEncryptionKey(&pKey);
  if(m_pDataRetentionLog->setPublicEncryptionKey(pKey)!=E_SUCCESS)
    { return E_UNKNOWN; }
  UINT8 strDir[4096];
  strDir[0]=0;
  if(CALibProxytest::getOptions()->getDataRetentionLogDir(strDir,4096)!=E_SUCCESS ||
      m_pDataRetentionLog->setLogDir(strDir)!=E_SUCCESS)
    {
    CAMsg::printMsg(LOG_ERR,"Data Retention Error: Could not set log dir to %s!\n",strDir);
    return E_UNKNOWN;
    }
  else
    {
    CAMsg::printMsg(LOG_INFO,"Data Retention: Set log dir to: %s\n",strDir);
    CAMsg::printMsg(LOG_INFO,"Data Retention: tQueueEntry size is: %u\n",sizeof(tQueueEntry));
    }
 
#endif
  return E_SUCCESS;
  }
 
SINT32 CAMix::start()
  {
  SINT32 initStatus;
  m_bConnected = false;
  m_lLastConnectionTime = 0;
  m_bLoop=true;
 
  if(initOnce()!=E_SUCCESS)
    { return E_UNKNOWN; }
  if(m_pMultiSignature != NULL && CALibProxytest::getOptions()->isInfoServiceEnabled())
    {
    CAMsg::printMsg(LOG_DEBUG, "CAMix start: creating InfoService object\n");
    m_pInfoService=new CAInfoService(this);
 
    //UINT32 opCertLength;
    //CACertificate* opCert = CALibProxytest::getOptions()->getOpCertificate();
    //CACertificate* pOwnCert=CALibProxytest::getOptions()->getOwnCertificate();
    m_pInfoService->setMultiSignature(m_pMultiSignature);
    //delete pOwnCert;
    //pOwnCert = NULL;
    UINT64 currentMillis;
    if (getcurrentTimeMillis(currentMillis) != E_SUCCESS)
      {
      currentMillis = 0;
      }
    m_pInfoService->setSerial(currentMillis);
 
    //delete opCert;
    //opCert = NULL;
 
    bool allowReconf = CALibProxytest::getOptions()->acceptReconfiguration();
    bool needReconf = needAutoConfig();
 
    m_pInfoService->setConfiguring(allowReconf && needReconf);
    CAMsg::printMsg(LOG_DEBUG, "CAMix start: starting InfoService\n");
    m_pInfoService->start();
    }
  else
    {
    m_pInfoService = NULL;
    }
  bool allowReconf = CALibProxytest::getOptions()->acceptReconfiguration();
//#ifdef DYNAMIC_MIX
  /* LERNGRUPPE: We might want to break out of this loop if the mix-type changes */
  while(m_bLoop)
//#else
//  for(;;)
//#endif
    {
    if (m_pInfoService != NULL)
      { m_pInfoService->setConfiguring(allowReconf && needAutoConfig()); }
    while(allowReconf && (needAutoConfig() || m_bReconfiguring))
      {
      CAMsg::printMsg(LOG_DEBUG, "Not configured -> sleeping\n");
      sSleep(20);
      }
//#ifdef DYNAMIC_MIX
    // if we change the mix type, we must not enter init!
    if(!m_bLoop) { goto SKIP; }
//#endif
    CAMsg::printMsg(LOG_DEBUG, "CAMix main: before init()\n");
    initStatus = init();
    if(initStatus == E_SUCCESS)
      {
      m_lLastConnectionTime = time(NULL);
      m_bConnected = true;
      CAMsg::printMsg(LOG_DEBUG, "CAMix main: init() returned success\n");
      if(m_pInfoService != NULL)
        {
        m_pInfoService->setConfiguring(false);
        if( ! m_pInfoService->isRunning())
          {
          m_pInfoService->start();
          }
        m_pInfoService->signal();
        }
 
      CAMsg::printMsg(LOG_INFO, "The mix is now on-line.\n");
#ifdef DYNAMIC_MIX
      m_bReconfiguring = false;
      m_bCascadeEstablished = true;
      m_bReconfigured = false;
      if(CALibProxytest::getOptions()->isFirstMix() && CALibProxytest::getOptions()->isDynamic())
        { m_pInfoService->sendCascadeHelo(); }
#endif
      MONITORING_FIRE_SYS_EVENT(ev_sys_enterMainLoop);
      loop();
      MONITORING_FIRE_SYS_EVENT(ev_sys_leavingMainLoop);
#ifdef DYNAMIC_MIX
      m_bCascadeEstablished = false;
      if(!m_bReconfiguring)
        { m_pInfoService->dynamicCascadeConfiguration(); }
#endif
      CAMsg::printMsg(LOG_DEBUG, "CAMix main: loop() returned, maybe connection lost.\n");
      }
    else if (initStatus == E_SHUTDOWN)
      {
      CAMsg::printMsg(LOG_DEBUG, "Mix has been stopped. Waiting for shutdown...\n");
      //break;
      }
    else
      {
      CAMsg::printMsg(LOG_DEBUG, "init() failed, maybe no connection.\n");
      }
//#ifdef DYNAMIC_MIX
SKIP:
//#endif
    if(m_pInfoService != NULL)
      {
//#ifndef DYNAMIC_MIX
//      if(CALibProxytest::getOptions()->acceptReconfiguration())
//#else
      // Only keep the InfoService alive if the Mix-Type doesn't change
      if(CALibProxytest::getOptions()->acceptReconfiguration() && m_bLoop)
//#endif
        m_pInfoService->setConfiguring(true);
      /*else
      {
      CAMsg::printMsg(LOG_DEBUG, "CAMix main: stopping InfoService\n");
          m_pInfoService->stop();
      }*/
      // maybe Cascade information (e.g. certificate validity) will change on next connection
      UINT64 currentMillis;
      if (getcurrentTimeMillis(currentMillis) != E_SUCCESS)
        {
        currentMillis = 0;
        }
      m_pInfoService->setSerial(currentMillis);
      }
    m_bConnected = false;
    m_lLastConnectionTime = 0;
    CAMsg::printMsg(LOG_DEBUG, "CAMix main: before clean()\n");
    clean();
    CAMsg::printMsg(LOG_DEBUG, "CAMix main: after clean()\n");
//#ifdef DYNAMIC_MIX
    if(m_bLoop)
//#endif
      sSleep(10);
    }// Big loop....
  if(m_pInfoService != NULL)
    {
    m_pInfoService->stop();
    delete m_pInfoService;
    m_pInfoService = NULL;
    }
  m_pInfoService=NULL;
  return E_SUCCESS;
  }
 
 
bool CAMix::needAutoConfig()
  {
  bool ret = false;
 
  if(!CALibProxytest::getOptions()->isLastMix())
    {
    ret = true;
 
    // look for usable target interfaces
    for(UINT32 i=0; i<CALibProxytest::getOptions()->getTargetInterfaceCount(); i++)
      {
      CATargetInterface oNextMix;
      CALibProxytest::getOptions()->getTargetInterface(oNextMix,i+1);
      if(oNextMix.getTargetType()==TARGET_MIX)
        {
        ret = false;
        }
      oNextMix.cleanAddr();
      }
 
    if(!CALibProxytest::getOptions()->hasNextMixTestCertificate())
      { ret = true; }
    }
 
  if(!CALibProxytest::getOptions()->isFirstMix() && !CALibProxytest::getOptions()->hasPrevMixTestCertificate())
    { ret = true; }
 
  return ret;
  }
 
SINT32 CAMix::initMixCascadeInfo(DOMElement* mixes)
  {
  UINT32 count;
  m_docMixCascadeInfo=createDOMDocument();
  DOMElement* elemRoot=createDOMElement(m_docMixCascadeInfo,"MixCascade");
#ifdef LOG_DIALOG
  setDOMElementAttribute(elemRoot,"study",(UINT8*)"true");
#endif
  if(CALibProxytest::getOptions()->isFirstMix())
    {
    UINT32 maxUsers = CALibProxytest::getOptions()->getMaxNrOfUsers();
    if(maxUsers > 0)
      {
      setDOMElementAttribute(elemRoot,"maxUsers", maxUsers);
      }
    setDOMElementAttribute(elemRoot, "maxOpenChannels", CHANNELS_PER_CLIENT);
 
#ifdef MANIOQ
    setDOMElementAttribute(elemRoot,"context", (UINT8*) "jondonym.business");
#else
 
#ifdef PAYMENT
    setDOMElementAttribute(elemRoot,"context", (UINT8*) "jondonym.premium");
#else
    setDOMElementAttribute(elemRoot,"context", (UINT8*) "jondonym");
#endif
#endif
    }
 
  UINT8 id[50];
  UINT8* cascadeID=NULL;
  CALibProxytest::getOptions()->getMixId(id,50);
 
  UINT8 name[255];
  m_docMixCascadeInfo->appendChild(elemRoot);
  DOMElement* elem = NULL;
 
  if(CALibProxytest::getOptions()->getCascadeName(name,255) == E_SUCCESS)
    {
    elem = createDOMElement(m_docMixCascadeInfo,"Name");
    setDOMElementValue(elem,name);
    elemRoot->appendChild(elem);
    }
  else
    {
    CAMsg::printMsg(LOG_ERR,"No cascade name given!\n");
    }
 
  elem=createDOMElement(m_docMixCascadeInfo,"Network");
  elemRoot->appendChild(elem);
  DOMElement* elemListenerInterfaces=createDOMElement(m_docMixCascadeInfo,"ListenerInterfaces");
  elem->appendChild(elemListenerInterfaces);
 
 
  for(UINT32 i=1; i<=CALibProxytest::getOptions()->getListenerInterfaceCount(); i++)
    {
    CAListenerInterface* pListener=CALibProxytest::getOptions()->getListenerInterface(i);
    if(pListener->isHidden())
      {
      //do nothing
      }
    else if(pListener->getType()==RAW_TCP|| pListener->getType() == RAW_UDP)
      {//Only TCP or UDP interfaces are meaningfull for external connections...
        DOMElement* elemTmpLI=NULL;
        pListener->toDOMElement(elemTmpLI,m_docMixCascadeInfo);
        elemListenerInterfaces->appendChild(elemTmpLI);
      }
    delete pListener;
    pListener = NULL;
    }
 
  DOMNode* elemMixesDocCascade=createDOMElement(m_docMixCascadeInfo,"Mixes");
  DOMElement* elemMix=NULL;
  count=1;
  if(CALibProxytest::getOptions()->isFirstMix())
    {
    addMixInfo(elemMixesDocCascade, false);
    getDOMChildByName(elemMixesDocCascade, "Mix", elemMix, false);
    // create signature
    if (signXML(elemMix) != E_SUCCESS)
      {
      CAMsg::printMsg(LOG_DEBUG,"Could not sign KeyInfo sent to users...\n");
      }
    //if(m_pSignature->signXML(docMixInfo,m_pcertstoreOwnCerts)!=E_SUCCESS)
    //m_pSignature, CALibProxytest::getOptions()->getOwnCertificate()
    /*
        elemMixesDocCascade.appendChild(elemThisMix);*/
    }
  elemRoot->appendChild(elemMixesDocCascade);
 
//    UINT8 cascadeId[255];
//    UINT32 cascadeIdLen=255;
 
  DOMNode* node=mixes->getFirstChild();
  while(node!=NULL)
    {
    if(node->getNodeType()==DOMNode::ELEMENT_NODE&&equals(node->getNodeName(),"Mix"))
      {
      elemMixesDocCascade->appendChild(m_docMixCascadeInfo->importNode(node,true));
      count++;
//           cascadeId = static_cast<const DOM_Element&>(node).getAttribute("id").transcode();
      }
    node=node->getNextSibling();
    }
 
  if(CALibProxytest::getOptions()->isLastMix())
    {
    addMixInfo(elemMixesDocCascade, false);
    ::getLastDOMChildByName(elemMixesDocCascade, "Mix", elemMix);
    // create signature
    if (signXML(elemMix) != E_SUCCESS)
      {
      CAMsg::printMsg(LOG_DEBUG,"Could not sign KeyInfo sent to users...\n");
      }
    cascadeID = id;
    }
  else if(CALibProxytest::getOptions()->isFirstMix())
    {
    cascadeID = id;
    }
 
  if(cascadeID != NULL)
    { setDOMElementAttribute(elemRoot,"id",cascadeID); }
  setDOMElementAttribute(elemMixesDocCascade,"count",count);
 
  DOMNode* elemPayment=createDOMElement(m_docMixCascadeInfo,"Payment");
  elemRoot->appendChild(elemPayment);
#ifdef PAYMENT
  setDOMElementAttribute(elemPayment,"required",(UINT8*)"true");
  setDOMElementAttribute(elemPayment,"version",(UINT8*)PAYMENT_VERSION);
  setDOMElementAttribute(elemPayment,"prepaidInterval", CALibProxytest::getOptions()->getPrepaidInterval());
  setDOMElementAttribute(elemPayment,"piid", CALibProxytest::getOptions()->getBI()->getID());
#else
  setDOMElementAttribute(elemPayment,"required",(UINT8*)"false");
#endif
  return E_SUCCESS;
  }
 
SINT32 CAMix::addMixInfo(DOMNode* a_element, bool a_bForceFirstNode)
  {
    // this is a complete mixinfo node to be sent to the InfoService
    XERCES_CPP_NAMESPACE::DOMDocument* docMixInfo=NULL;
    if(CALibProxytest::getOptions()->getMixXml(docMixInfo)!=E_SUCCESS)
      {
        return E_UNKNOWN;
      }
    DOMNode* nodeMixInfo = a_element->getOwnerDocument()->importNode(docMixInfo->getDocumentElement(), true);
    if (a_bForceFirstNode && a_element->hasChildNodes())
      {
        a_element->insertBefore(nodeMixInfo, a_element->getFirstChild());
      }
    else
      {
        a_element->appendChild(nodeMixInfo);
      }
    return E_SUCCESS;
  }
 
#ifdef PAYMENT
DOMNode *CAMix::appendTermsAndConditionsExtension(XERCES_CPP_NAMESPACE::DOMDocument *ownerDoc,DOMElement *root)
  {
  if(CALibProxytest::getOptions()->getTermsAndConditions() != NULL)
    {
    if( (root == NULL) || (ownerDoc == NULL) )
      {
      return NULL;
      }
 
    DOMElement *elemTnCExtension = NULL, *elemExtensions = NULL,
                *elemTemplates = NULL;
    /* Tag for Nodes that can be removed without destroying the signature.
     * To be appended to the "mixes"-node so older mix versions won't get confused.
     */
    getDOMChildByName(root, KEYINFO_NODE_EXTENSIONS, elemExtensions);
    if(elemExtensions == NULL)
      {
      elemExtensions = createDOMElement(ownerDoc, KEYINFO_NODE_EXTENSIONS);
      root->appendChild(elemExtensions);
      }
    else
      {
      getDOMChildByName(elemExtensions, KEYINFO_NODE_TNC_EXTENSION, elemTnCExtension);
      }
 
    if(elemTnCExtension == NULL)
      {
      elemTnCExtension = createDOMElement(ownerDoc, KEYINFO_NODE_TNC_EXTENSION);
      elemExtensions->appendChild(elemTnCExtension);
      }
 
    //First add templates if there are any
    UINT32 nrOfTemplates = CALibProxytest::getOptions()->getNumberOfTermsAndConditionsTemplates();
 
    if(nrOfTemplates > 0)
      {
      UINT32 nrOfSentTemplates = 0;
      UINT8 **sentTemplatesRefIds = NULL;
      getDOMChildByName(elemTnCExtension, OPTIONS_NODE_TNCS_TEMPLATES, elemTemplates);
      if(elemTemplates == NULL)
        {
        elemTemplates = createDOMElement(ownerDoc, OPTIONS_NODE_TNCS_TEMPLATES);
        elemTnCExtension->appendChild(elemTemplates);
        }
      else
        {
        DOMNodeList *nl = getElementsByTagName(elemTemplates, "TermsAndConditionsTemplate");
        nrOfSentTemplates = nl->getLength();
        if(nrOfSentTemplates > 0)
          {
          sentTemplatesRefIds = new UINT8*[nrOfSentTemplates];
          for (UINT32 i = 0; i < nrOfSentTemplates; i++)
            {
            sentTemplatesRefIds[i] = getTermsAndConditionsTemplateRefId(nl->item(i));
            }
          }
        }
 
      XERCES_CPP_NAMESPACE::DOMDocument **allTemplates = CALibProxytest::getOptions()->getAllTermsAndConditionsTemplates();
      UINT8 *currentTemplateRefId = NULL;
      bool duplicate = false;
      for(UINT32 i = 0; i < nrOfTemplates; i++)
        {
        currentTemplateRefId =
          getTermsAndConditionsTemplateRefId(allTemplates[i]->getDocumentElement());
        duplicate = false;
        if(currentTemplateRefId != NULL)
          {
          for(UINT32 j=0; j < nrOfSentTemplates; j++)
            {
            if(strncmp((char *)currentTemplateRefId, (char *)sentTemplatesRefIds[j], TEMPLATE_REFID_MAXLEN) == 0)
              {
              duplicate = true;
              break;
              }
            }
          if(!duplicate)
            {
            //TODO: avoid duplicates.
            elemTemplates->appendChild(ownerDoc->importNode(
                                         allTemplates[i]->getDocumentElement(), true));
            CAMsg::printMsg(LOG_DEBUG,"appended a tc template node!\n");
            }
          else
            {
            CAMsg::printMsg(LOG_DEBUG,"template '%s' already sent.\n", currentTemplateRefId);
            }
          delete [] currentTemplateRefId;
          currentTemplateRefId = NULL;
          }
        }
 
      for(UINT32 i = 0; i < nrOfSentTemplates; i++)
        {
        delete [] sentTemplatesRefIds[i];
        sentTemplatesRefIds[i] = NULL;
        }
      delete [] sentTemplatesRefIds;
      sentTemplatesRefIds = NULL;
      }
 
    DOMNode* elemTnCs = ownerDoc->importNode(CALibProxytest::getOptions()->getTermsAndConditions(), true);
    UINT8 tmpOpSKIBuff[TMP_BUFF_SIZE];
    UINT32 tmpOpSKILen = TMP_BUFF_SIZE;
    memset(tmpOpSKIBuff, 0, tmpOpSKILen);
    CALibProxytest::getOptions()->getOperatorSubjectKeyIdentifier(tmpOpSKIBuff, &tmpOpSKILen);
    setDOMElementAttribute(elemTnCs, OPTIONS_ATTRIBUTE_TNC_ID, tmpOpSKIBuff);
 
    DOMNodeList *tncDefEntryList = getElementsByTagName((DOMElement *)elemTnCs, OPTIONS_NODE_TNCS_TRANSLATION);
    for (XMLSize_t i = 0; i < tncDefEntryList->getLength(); i++)
      {
      //TODO don't know if to include certs here
      m_pMultiSignature->signXML((DOMElement *)tncDefEntryList->item(i), false);
      }
    elemTnCExtension->appendChild(elemTnCs);
    return elemTnCExtension;
    }
  else
    {
    return NULL;
    }
  }
 
DOMNode *CAMix::termsAndConditionsInfoNode(XERCES_CPP_NAMESPACE::DOMDocument *ownerDoc)
  {
  if(CALibProxytest::getOptions()->getTermsAndConditions() != NULL)
    {
    DOMElement *elemTnCInfos = createDOMElement(ownerDoc, KEYINFO_NODE_TNC_INFOS);
    UINT8 tmpBuff[TMP_BUFF_SIZE];
    UINT32 tmpLen = TMP_BUFF_SIZE;
    memset(tmpBuff, 0, tmpLen);
 
    DOMNodeList *list = getElementsByTagName(CALibProxytest::getOptions()->getTermsAndConditions(), OPTIONS_NODE_TNCS_TRANSLATION);
    DOMElement *iterator = NULL;
    DOMElement *currentInfoNode = NULL;
    bool defaultLangDefined = false;
    for (XMLSize_t i = 0; i < list->getLength(); i++)
      {
      iterator = (DOMElement *) list->item(i);
      currentInfoNode = createDOMElement(ownerDoc, KEYINFO_NODE_TNC_INFO);
 
      getDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_LOCALE, tmpBuff, &tmpLen);
      setDOMElementAttribute(currentInfoNode, OPTIONS_ATTRIBUTE_TNC_LOCALE, tmpBuff);
      getDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_DEFAULT_LANG_DEFINED, defaultLangDefined);
      if(defaultLangDefined)
        {
        setDOMElementAttribute(elemTnCInfos, OPTIONS_ATTRIBUTE_TNC_DEFAULT_LANG, tmpBuff);
        }
      defaultLangDefined = false;
      tmpLen = TMP_BUFF_SIZE;
 
      getDOMElementAttribute(iterator, OPTIONS_ATTRIBUTE_TNC_TEMPLATE_REFID, tmpBuff, &tmpLen);
      setDOMElementAttribute(currentInfoNode, OPTIONS_ATTRIBUTE_TNC_TEMPLATE_REFID, tmpBuff);
      tmpLen = TMP_BUFF_SIZE;
 
      elemTnCInfos->appendChild(currentInfoNode);
      }
 
    getDOMElementAttribute(CALibProxytest::getOptions()->getTermsAndConditions(), OPTIONS_ATTRIBUTE_TNC_DATE, tmpBuff, &tmpLen);
    setDOMElementAttribute(elemTnCInfos, OPTIONS_ATTRIBUTE_TNC_DATE, tmpBuff);
 
    tmpLen = TMP_BUFF_SIZE;
    //memset(tmpBuff, 0, tmpLen);
 
    CALibProxytest::getOptions()->getOperatorSubjectKeyIdentifier(tmpBuff, &tmpLen);
    setDOMElementAttribute(elemTnCInfos, OPTIONS_ATTRIBUTE_TNC_ID, tmpBuff);
    return elemTnCInfos;
    }
  else
    {
    return NULL;
    }
 
  }
 
#endif
SINT32 CAMix::appendCompatibilityInfo(DOMNode* a_parent)
  {
  DOMElement* elemCompatibility=createDOMElement(a_parent->getOwnerDocument(),"Compatibility");
  setDOMElementAttribute(elemCompatibility,"version",(UINT8*)MIX_VERSION);
  a_parent->appendChild(elemCompatibility);
 
  DOMElement* elemFlags=NULL;
  DOMElement* elemFlag=NULL;
 
  elemFlags = createDOMElement(a_parent->getOwnerDocument(), "Flags");
  elemCompatibility->appendChild(elemFlags);
 
#ifdef PAYMENT
  elemFlag = createDOMElement(a_parent->getOwnerDocument(), PAYMENT_COMPATIBILITY);
  //setDOMElementValue(elemFlag,(UINT8*)"true"); // you might add a version number here for a protocol etc.
  elemFlags->appendChild(elemFlag);
#endif
 
  elemFlag = createDOMElement(a_parent->getOwnerDocument(), NEW_FLOW_CONTROL_COMPATIBILITY);
  //setDOMElementValue(elemFlag,(UINT8*)"true");
  elemFlags->appendChild(elemFlag);
 
  elemFlag = createDOMElement(a_parent->getOwnerDocument(), NEW_CHANNEL_ENCRYPTION_COMPATIBILITY);
  //setDOMElementValue(elemFlag,(UINT8*)"true");
  elemFlags->appendChild(elemFlag);
 
#ifdef WITH_INTEGRITY_CHECK
  elemFlag = createDOMElement(a_parent->getOwnerDocument(), WITH_INTEGRITY_CHECK_COMPATIBILITY);
  //setDOMElementValue(elemFlag,(UINT8*)"true");
  elemFlags->appendChild(elemFlag);
#endif
 
  return E_SUCCESS;
  }
 
SINT32 CAMix::checkCompatibility(DOMNode* a_parent, const char* a_mixPosition)
  {
  // get compatibility info
  DOMElement* elemCompatibility=NULL;
  DOMElement* elemFlags=NULL;
  DOMElement* elemDummy=NULL;
  UINT8 strAllFlags[500];
  UINT32 lenAllFlags;
  UINT8 strNodeName[50];
  UINT32 lenNodeName=50;
  UINT8 strVersion[50];
  UINT32 len=50;
  SINT32 iCompare;
  UINT8* strComment;
  UINT32 iCountFlags = 0;
  UINT32 iLogLevel = LOG_INFO;
  bool bCompatible = true;
  bool bCompatibleFlags = true;
 
  if (getDOMChildByName(a_parent,"Compatibility",elemCompatibility,false) != E_SUCCESS ||
      getDOMElementAttribute(elemCompatibility, "version", strVersion, &len) != E_SUCCESS)
    {
    CAMsg::printMsg(LOG_WARNING,"Could not get any compatibility information from the %s mix. It may or may not be compatible. If the connection fails for an unknown reason, the %s mix should be updated.\n", a_mixPosition, a_mixPosition);
    return E_SUCCESS;
    }
 
  iCompare = strncmp (MIX_VERSION, (char*)strVersion, len);
 
  if (iCompare == 0)
    {
    strComment = (UINT8*)" We have the same version.";
    }
  else if (iCompare < 0)
    {
    strComment = (UINT8*)" Our version (" MIX_VERSION ") might be too old. If the connection fails for an unknown reason, you should think about an update.";
    iLogLevel = LOG_WARNING;
    }
  else
    {
    if (strncmp ("00.08.71", (char*)strVersion, len) > 0)
      {
      strComment = (UINT8*)" This version is NOT COMPATIBLE with our version (" MIX_VERSION ")! The mixes will not work together in a cascade.";
      bCompatible = false;
      iLogLevel = LOG_CRIT;
      }
    else
      {
      strComment = (UINT8*)" We have a newer version (" MIX_VERSION "), but both are known to work fine together.";
      }
    }
 
  CAMsg::printMsg(iLogLevel,"The software version of the %s mix is %s.%s\n", a_mixPosition, strVersion, strComment);
 
#ifdef PAYMENT
  iCountFlags++;
#endif
 
  iCountFlags++;
 
  iCountFlags++;
 
#ifdef WITH_INTEGRITY_CHECK
  iCountFlags++;
#endif
 
  if (getDOMChildByName(elemCompatibility, "Flags", elemFlags, false) == E_SUCCESS)
    {
    DOMNodeList* flags = elemFlags->getChildNodes();
    if (flags->getLength() != iCountFlags)
      {
      bCompatibleFlags = false;
      }
 
    // Hint: We might also check for a version of the compile flags if available; it should be set in the content of each tag instead of 'true'.
#ifdef PAYMENT
    if (getDOMChildByName(elemFlags, PAYMENT_COMPATIBILITY, elemDummy, false) != E_SUCCESS)
      {
      bCompatibleFlags = false;
      }
#endif
    if (getDOMChildByName(elemFlags, NEW_FLOW_CONTROL_COMPATIBILITY, elemDummy, false) != E_SUCCESS)
      {
      bCompatibleFlags = false;
      }
    if (getDOMChildByName(elemFlags, NEW_CHANNEL_ENCRYPTION_COMPATIBILITY, elemDummy, false) != E_SUCCESS)
      {
      bCompatibleFlags = false;
      }
#ifdef WITH_INTEGRITY_CHECK
    if (getDOMChildByName(elemFlags, WITH_INTEGRITY_CHECK_COMPATIBILITY, elemDummy, false) != E_SUCCESS)
      {
      bCompatibleFlags = false;
      }
#endif
 
    if (!bCompatibleFlags)
      {
      // get the flags of the other mix
      strAllFlags[0] = 0;
      lenAllFlags = 1;
      for (UINT32 i = 0; i < flags->getLength(); i++)
        {
        if (::getNodeName(flags->item(i), strNodeName, &lenNodeName) == E_SUCCESS)
          {
 
          lenAllFlags += strlen((char*)strNodeName) + 1;
          if (lenAllFlags > 500)
            {
            break;
            }
          strcat((char*)strAllFlags, " ");
          strcat((char*)strAllFlags, (char*)strNodeName);
          }
 
        lenNodeName = 50;
        }
 
      CAMsg::printMsg(LOG_CRIT, "The compile flags of the %s mix are NOT COMPATIBLE with our flags. We have: %s They have: %s  --> The mixes won't run together.\n", a_mixPosition, MIX_VERSION_COMPATIBILITY, strAllFlags);
      return E_UNKNOWN;
 
      }
    }
 
 
  if (!bCompatible)
    {
    return E_UNKNOWN;
    }
 
  return E_SUCCESS;
  }
 
 
SINT32 CAMix::signXML(DOMNode* a_element)
  {
  return m_pMultiSignature->signXML(a_element, true);
  /*CACertStore* tmpCertStore=new CACertStore();
 
  CACertificate* ownCert=CALibProxytest::getOptions()->getOwnCertificate();
  if(ownCert==NULL)
    {
      CAMsg::printMsg(LOG_DEBUG,"Own Test Cert is NULL!\n");
    }
 
  // Operator Certificates
  CACertificate* opCert = CALibProxytest::getOptions()->getOpCertificate();
  if(opCert==NULL)
  {
      CAMsg::printMsg(LOG_DEBUG,"Op Test Cert is NULL!\n");
  }
  else
  {
  // Own  Mix Certificates first, then Operator Certificates
  tmpCertStore->add(opCert);
  }
  tmpCertStore->add(ownCert);
 
  if(m_pSignature->signXML(a_element, tmpCertStore)!=E_SUCCESS)
  {
  return E_UNKNOWN;
  }
 
  CASignature* test = new CASignature();
  test->setVerifyKey(ownCert);
 
  if(test->verifyXML(a_element) != E_SUCCESS)
  {
  CAMsg::printMsg(LOG_DEBUG, "Error verifying own Signature!!\n");
  m_pSignature->signXML(a_element, tmpCertStore);
  }
  else
  {
  CAMsg::printMsg(LOG_DEBUG, "Own Signature looks ok!\n");
  }
 
 
  delete ownCert;
  ownCert = NULL;
 
  delete opCert;
  opCert = NULL;
 
  delete tmpCertStore;
  tmpCertStore = NULL;
 
  return E_SUCCESS;*/
  }
#ifdef DYNAMIC_MIX
SINT32 CAMix::dynaReconfigure(bool a_bChangeMixType)
  {
  SINT32 ret = E_UNKNOWN;
  CASocket tmpSock;
  const CASocketAddr* pAddr=NULL;
 
  m_bReconfigured = true;
  m_bLoop = !a_bChangeMixType;
 
  if(m_bCascadeEstablished)
    { stopCascade(); }
  m_docMixCascadeInfo = NULL;
 
  CAListenerInterface* pListener=NULL;
  UINT32 interfaces=CALibProxytest::getOptions()->getListenerInterfaceCount();
  for(UINT32 i=1; i<=interfaces; i++)
    {
    pListener=CALibProxytest::getOptions()->getListenerInterface(i);
    if(!pListener->isVirtual())
      { break; }
    delete pListener;
    pListener=NULL;
    }
  if(pListener==NULL)
    {
    CAMsg::printMsg(LOG_CRIT," failed!\n");
    CAMsg::printMsg(LOG_CRIT,"Reason: no useable (non virtual) interface found!\n");
    goto EXIT;
    }
 
  pAddr=pListener->getAddr();
  delete pListener;
  pListener = NULL;
 
  tmpSock.connect(*pAddr);
  delete pAddr;
  pAddr = NULL;
  tmpSock.close();
 
  ret = E_SUCCESS;
EXIT:
  CAMsg::printMsg(LOG_DEBUG, "Mix has been reconfigured!\n");
  m_bReconfiguring = false;
  return ret;
  }
#endif //DYNAMIC_MIX
#endif //ONLY_LOCAL_PROXY