Tuple.hxx

Go to the documentation of this file.

#if !defined(RESIP_TUPLE_HXX)
#define RESIP_TUPLE_HXX
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include <memory>
#include <vector>
 
#include "rutil/Socket.hxx"
#include "rutil/compat.hxx"
 
#include "rutil/HashMap.hxx"
#include "rutil/TransportType.hxx"
#include "rutil/HeapInstanceCounter.hxx"
#include "rutil/Data.hxx"
 
#if defined(WIN32)
#include <Ws2tcpip.h>
#else
#include <netinet/in.h>
#endif
 
namespace resip
{
 
struct GenericIPAddress;
struct AddressMask;   // defined below (embeds a Tuple, so it follows the Tuple class)
 
// WARNING!!
// When you change this structure, make sure to update the hash function,
// operator== and operator< to be consistent with the new structure. Be
// careful not to include members that change value in the Tuple over
// its lifetime (they must not be included in the hash or comparisons). 
 
typedef unsigned long FlowKey;
typedef unsigned long TransportKey;
 
class Tuple
{
   public:
      RESIP_HeapCount(Tuple);
 
      Tuple();
 
      explicit Tuple(const GenericIPAddress& genericAddress, 
                     TransportType type=UNKNOWN_TRANSPORT, 
                     const Data& targetDomain = Data::Empty);
 
      Tuple(const Data& printableAddress, 
            int port, 
            IpVersion ipVer, 
            TransportType type=UNKNOWN_TRANSPORT, 
            const Data& targetDomain = Data::Empty,
            const Data& netNs = Data::Empty);
 
      Tuple(const Data& printableAddress, 
            int port, 
            TransportType type, 
            const Data& targetDomain = Data::Empty,
            const Data& netNs = Data::Empty);
 
      Tuple(const in_addr& pipv4, 
            int pport,
            TransportType ptype, 
            const Data& targetDomain = Data::Empty,
            const Data& netNs = Data::Empty);
 
      Tuple(const sockaddr& addr, 
            TransportType ptype, 
            const Data& targetDomain = Data::Empty);
 
#ifdef IPPROTO_IPV6
      // enable this if the current platform supports IPV6; the USE_IPV6 #define
      // will determine if this c'tor is actually implemented.
      // ?bwc? Is there a more standard preprocessor macro for this?
      // ?bwc? Is there a way we can add something more informative to the 
      // linker error we'll see if we compiled without USE_IPV6, on a platform
      // with IPV6, and someone tries to invoke this c'tor? (ie; "This library
      // was built with IPV6 support disabled")
      Tuple(const in6_addr& pipv6,  
            int pport, 
            TransportType ptype, 
            const Data& targetDomain = Data::Empty,
            const Data& netNs = Data::Empty);
#endif
      
      const sockaddr& getSockaddr() const { return mSockaddr; }
 
      sockaddr& getMutableSockaddr() { return mSockaddr; }
      void copySockaddrAnyPort(sockaddr *sa);
 
      void setSockaddr(const GenericIPAddress &);
 
      TransportType getType() const { return mTransportType; }
      void setType(TransportType type) { mTransportType = type; }
      void setPort(int port);
      int getPort() const;
      inline FlowKey getFlowKey() const { return mFlowKey; }
      void setFlowKey(FlowKey flowKey) { mFlowKey = flowKey; }
 
      bool isV4() const; 
 
      IpVersion ipVersion() const;
 
      bool isAnyInterface() const;
      socklen_t length() const; // of sockaddr
      bool isLoopback() const;
      bool isPrivateAddress() const;  // Return boolean based on definitions in RFC1918(v4) and RFC4193(v6)
      bool isSpecialPurposeAddress() const; // Return boolean based on definitions in RFC6890
      
      bool operator<(const Tuple& rhs) const;
 
      bool operator==(const Tuple& rhs) const;
 
      bool isEqual(const Tuple& tuple, bool ignorePort = false, bool ignoreTransport = false) const;
 
      Data presentationFormat() const;
      
      static TransportType toTransport( const Data& );
 
      static const Data& toData( TransportType );
 
      static const Data& toDataLower(TransportType type);
 
      static Data inet_ntop(const Tuple& tuple);
 
      // Creates a binary token from the provided Tuple - if salt is provided, then an HMAC is appended
      // to the end of the token
      static void writeBinaryToken(const Tuple& tuple, Data& container, const Data& salt=Data::Empty);
      // Creates a Tuple from the provided binary token - if salt is provided, then an HMAC is checked
      static Tuple makeTupleFromBinaryToken(const Data& binaryToken, const Data& salt=Data::Empty);
 
      GenericIPAddress toGenericIPAddress() const;
 
      FlowKey mFlowKey;
      TransportKey mTransportKey;
 
      bool onlyUseExistingConnection;
 
      bool isEqualWithMask(const Tuple& tuple, short mask, bool ignorePort=false, bool ignoreTransport=false) const;
 
      bool isAddressAllowed(const std::vector<AddressMask>& allowed,
                            const std::vector<AddressMask>& denied) const;
 
      class AnyInterfaceCompare
      {
         public:
            bool operator()(const Tuple& x,
                            const Tuple& y) const;
      };
      friend class AnyInterfaceCompare;
 
      class AnyPortCompare
      {
         public:
            bool operator()(const Tuple& x,
                            const Tuple& y) const;
      };
      friend class AnyPortCompare;
 
      class AnyPortAnyInterfaceCompare
      {
         public:
            bool operator()(const Tuple& x,
                            const Tuple& y) const;
      };
      friend class AnyPortAnyInterfaceCompare;
 
      class FlowKeyCompare
      {
         public:
            bool operator()(const Tuple& x,
                            const Tuple& y) const;
      };
      friend class FlowKeyCompare;
 
      void setTargetDomain(const Data& target)
      {
         mTargetDomain = target;
      }
      
      const Data& getTargetDomain() const
      {
         return mTargetDomain;
      }
 
      void setNetNs(const Data& netNs)
      {
          mNetNs = netNs;
      }
 
      const Data& getNetNs() const
      {
          return(mNetNs);
      }
 
      size_t hash() const;   
 
private:
      union 
      {
            sockaddr mSockaddr;
            sockaddr_in m_anonv4;
#ifdef IPPROTO_IPV6
            // enable this if the current platform supports IPV6
            // ?bwc? Is there a more standard preprocessor macro for this?
            sockaddr_in6 m_anonv6;
#endif
            char pad[RESIP_MAX_SOCKADDR_SIZE]; //< this make union same size if v6 is in or out
      };
      TransportType mTransportType;
      Data mTargetDomain; 
 
      Data mNetNs;  
 
      friend EncodeStream& operator<<(EncodeStream& strm, const Tuple& tuple);
      friend class DnsResult;
};
 
 
EncodeStream&
operator<<(EncodeStream& ostrm, const Tuple& tuple);
 
struct AddressMask
{
   Tuple mAddress;
   short mMaskBits = 0;
};
 
EncodeStream&
operator<<(EncodeStream& ostrm, const AddressMask& addressMask);
 
}
 
HashValue(resip::Tuple);
 
#endif
/* ====================================================================
 * The Vovida Software License, Version 1.0 
 * 
 * Copyright (c) 2026 SIP Spectrum, Inc. https://www.sipspectrum.com
 * 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/>.
 *
 */