BranchParameter.cxx

Go to the documentation of this file.

#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif
 
#include "rutil/ResipAssert.h"
#include "resip/stack/BranchParameter.hxx"
#include "resip/stack/Symbols.hxx"
#include "rutil/ParseBuffer.hxx"
#include "rutil/Random.hxx"
#include "rutil/Time.hxx"
#include "rutil/DataStream.hxx"
#include "rutil/Coders.hxx"
#include "rutil/ParseException.hxx"
 
#include "rutil/Logger.hxx"
#include "rutil/WinLeakCheck.hxx"
 
using namespace resip;
using namespace std;
 
#define RESIPROCATE_SUBSYSTEM Subsystem::SIP
 
namespace {
 
inline Data generateTransactionId()
{
   Data d;
   {
      DataStream s(d);
      s << Random::getCryptoRandomHex(8) << std::hex << ResipClock::getTimeMicroSec();
   }
   return d;
}
 
}
 
BranchParameter::BranchParameter(ParameterTypes::Type type,
                                 ParseBuffer& pb, 
                                 const std::bitset<256>& terminators)
   : Parameter(type), 
     mHasMagicCookie(false),
     mIsMyBranch(false),
     mTransactionId(),
     mTransportSeq(1),
     mClientData(),
     mInteropMagicCookie(0),
     mSigcompCompartment()
{
   try
   {
      pb.skipWhitespace();
      pb.skipChar(Symbols::EQUALS[0]);
      pb.skipWhitespace();
      if (pb.lengthRemaining() >= 7)
      {
         if(memcmp(pb.position(), Symbols::MagicCookie, 7) == 0)
         {
            mHasMagicCookie=true;
            pb.skipN(7);
         }
         // !bwc! This no-case comparison is expensive; only do it if the case-
         // sensitive comparison fails.
         else if(strncasecmp(pb.position(), Symbols::MagicCookie, 7) == 0)
         {
            mHasMagicCookie=true;
            mInteropMagicCookie = new Data(pb.position(), 7);
            pb.skipN(7);
         }
      }
      
      const char* start = pb.position();
      static std::bitset<256> delimiter=Data::toBitset("\r\n\t ;=?>");
 
      if (mHasMagicCookie &&
          (pb.end() - start > 8) &&
          // look for prefix cookie (maybe make this bigger?)
          memcmp(start, Symbols::resipCookie, 8) == 0)
      {
         // ?bwc? Wrap this stuff in try/catch, just in case of false positives?
         const char* curr=start;
         mIsMyBranch = true;
         pb.skipN(8);
 
         mTransportSeq=pb.uInt32();
 
         curr=pb.skipChar('-');
         pb.skipToChar('-');
         Data encoded;
         pb.data(encoded, curr);
         if(!encoded.empty())
         {
            // !bwc! Expensive! Also, Base64 isn't case-insensitive.
            mClientData = encoded.base64decode();
         }
 
         curr=pb.skipChar('-');
         pb.skipToChar('-');
         pb.data(encoded,curr);
         if(!encoded.empty())
         {
            // !bwc! Expensive! Also, Base64 isn't case-insensitive.
            mSigcompCompartment = encoded.base64decode();
         }
 
         start=pb.skipChar('-');
      }
      pb.skipToOneOf(delimiter);
      pb.data(mTransactionId, start);
   }
   catch(resip::ParseException& e)
   {
      mTransactionId=generateTransactionId();
      throw e;
   }
}
 
BranchParameter::BranchParameter(ParameterTypes::Type type)
   : Parameter(type),
     mHasMagicCookie(true),
     mIsMyBranch(true),
     mTransactionId(generateTransactionId()),
     mTransportSeq(1),
     mInteropMagicCookie(0),
     mSigcompCompartment()
{
}
 
BranchParameter::BranchParameter(const BranchParameter& other)
   : Parameter(other), 
     mHasMagicCookie(other.mHasMagicCookie),
     mIsMyBranch(other.mIsMyBranch),
     mTransactionId(other.mTransactionId),
     mTransportSeq(other.mTransportSeq),
     mClientData(other.mClientData),
     mSigcompCompartment(other.mSigcompCompartment)
{
   if (other.mInteropMagicCookie)
   {
      mInteropMagicCookie = new Data(*other.mInteropMagicCookie);
   }
   else
   {
      mInteropMagicCookie = 0;
   }
}
 
BranchParameter::~BranchParameter()
{
   delete mInteropMagicCookie;
}
 
BranchParameter& 
BranchParameter::operator=(const BranchParameter& other)
{
   if (this != &other)
   {
      mHasMagicCookie = other.mHasMagicCookie;
      mIsMyBranch = other.mIsMyBranch;
      mTransactionId = other.mTransactionId;
      mTransportSeq = other.mTransportSeq;
      mClientData = other.mClientData;
      mSigcompCompartment = other.mSigcompCompartment;
      if (other.mInteropMagicCookie)
      {
         delete mInteropMagicCookie;         
         mInteropMagicCookie = new Data(*other.mInteropMagicCookie);
      }
      else
      {
         delete mInteropMagicCookie;
         mInteropMagicCookie = 0;
      }
   }
   return *this;
}
 
bool
BranchParameter::operator==(const BranchParameter& other) const
{
   if (mIsMyBranch != other.mIsMyBranch ||
       mHasMagicCookie != other.mHasMagicCookie ||
       mTransportSeq != other.mTransportSeq ||
       mTransactionId != other.mTransactionId ||
       mClientData != other.mClientData ||
       mSigcompCompartment != other.mSigcompCompartment)
   {
      return false;
   }
   return true;
}
 
bool
BranchParameter::hasMagicCookie() const
{
   return mHasMagicCookie;
}
 
const Data& 
BranchParameter::getTransactionId() const
{
   return mTransactionId;
}
 
void
BranchParameter::incrementTransportSequence()
{
   resip_assert(mIsMyBranch);
   mTransportSeq++;
}
 
Data&
BranchParameter::clientData()
{
    return mClientData;
}
 
const Data&
BranchParameter::clientData() const
{
    return mClientData;
}
 
void
BranchParameter::setSigcompCompartment(const Data &id)
{
  if (id.size() == 0)
  {
    mSigcompCompartment = Data::Empty;
  }
 
  // These will often (but not always) be UUID URNs in angle brackets;
  // e.g.: <urn:uuid:fa33c72d-121f-47e8-42e2-1eb6e24aba64>
 
  // Ideally, we would detect this, strip out everything that isn't
  // hex, and convert the hex to raw data.
 
  mSigcompCompartment = id;
}
 
Data
BranchParameter::getSigcompCompartment() const
{
  return mSigcompCompartment;
}
 
void
BranchParameter::reset(const Data& transactionId)
{
   mHasMagicCookie = true;
   mIsMyBranch = true;
   delete mInteropMagicCookie;
   mInteropMagicCookie = 0;   
 
   mSigcompCompartment = Data::Empty;
 
   mTransportSeq = 1;
   if (!transactionId.empty())
   {
      mTransactionId = transactionId;
   }
   else
   {
      mTransactionId = generateTransactionId();
   }
}
 
Parameter* 
BranchParameter::clone() const
{
   return new BranchParameter(*this);
}
 
EncodeStream& 
BranchParameter::encode(EncodeStream& stream) const
{
   stream << getName() << Symbols::EQUALS;
   if (mHasMagicCookie)
   {
      if (mInteropMagicCookie)
      {
         stream << *mInteropMagicCookie;         
      }
      else
      {
         stream << Symbols::MagicCookie;
      }
   }
   if (mIsMyBranch)
   {
      stream << Symbols::resipCookie;
      stream << mTransportSeq;
      stream << Symbols::DASH;
      if(!mClientData.empty()) // base64encode() makes copies
      {
         // !bwc! We should be using hex encoding; branch params are supposed to
         // be case-insensitive.
         stream << mClientData.base64encode(true/*safe URL*/);
      }
      stream << Symbols::DASH;
      if(!mSigcompCompartment.empty()) // base64encode() makes copies
      {
         // !bwc! We should be using hex encoding; branch params are supposed to
         // be case-insensitive.
         stream << mSigcompCompartment.base64encode(true);
      }
      stream << Symbols::DASH;
   }
   stream << mTransactionId;
      
   return stream;
}
 
 
/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 
 * 2. 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.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 *    and "Vovida Open Communication Application Library (VOCAL)" must
 *    not be used to endorse or promote products derived from this
 *    software without prior written permission. For written
 *    permission, please contact vocal@vovida.org.
 *
 * 4. Products derived from this software may not be called "VOCAL", nor
 *    may "VOCAL" appear in their name, without prior written
 *    permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY 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.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 *
 */