Socket/Protocols/INet/INetAddressing.hh

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 2 of the License, or
  11 // (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the
  20 // Free Software Foundation, Inc.,
  21 // 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22
  23 /** \file
  24     \brief INet[46]Address and INet[46]AddressingPolicy public header
  25  */
  26
  27 #ifndef HH_INetAddressing_
  28 #define HH_INetAddressing_ 1
  29
  30 // Custom includes
  31 #include <string>
  32 #include <exception>
  33 #include <netinet/in.h>
  34 #include <boost/operators.hpp>
  35 #include "../../../Socket/SocketPolicy.hh"
  36 #include "../../../Socket/ClientSocketHandle.hh"
  37 #include "../../../Socket/CommunicationPolicy.hh"
  38 #include "../../../Socket/Protocols/GenericAddressingPolicy.hh"
  39 #include "../../../Utils/safe_bool.hh"
  40 #include "INet4Address.hh"
  41 #include "INet6Address.hh"
  42
  43 //#include "INetAddressing.mpp"
  44 ///////////////////////////////hh.p////////////////////////////////////////
  45
  46 namespace senf {
  47
  48     /** \brief IPv4 socket address
  49
  50         INet4Address wraps the standard sockaddr_in datatype. It provides simple accessor methods
  51         to access the host and port. It does \e not integrate \c gethostbyname or DNS lookup.
  52
  53         \implementation This implementation is based on sockaddr_in, which is needed since it needs
  54             to provide a non-const struct sockaddr * for legacy compatibility.
  55
  56         \ingroup addr_group
  57      */
  58     class INet4SocketAddress
  59         : public boost::equality_comparable<INet4SocketAddress>,
  60           public senf::comparable_safe_bool<INet4SocketAddress>
  61     {
  62     public:
  63         INet4SocketAddress();
  64         explicit INet4SocketAddress(std::string const & addr); ///< Set address and port
  65                                         /**< This constructor expects a string of the form
  66                                              'host:port'. The constructor will use this value to
  67                                              initialize the host and port members. Since it uses the
  68                                              INet4Address::from_string constructor, this call may
  69                                              block while waiting for the resolver.
  70                                              \throws SyntaxException if the address syntax is
  71                                                  invalid
  72                                              \throws INet4Address::UnknownHostnameException if the
  73                                                  address cannot be resolved. */
  74
  75         INet4SocketAddress(INet4Address const & addr, unsigned port);
  76                                         ///< Set address and port explicitly
  77                                         /**< \param[in] addr IP address
  78                                              \param[in] port port number */
  79
  80         bool operator==(INet4SocketAddress const & other) const;
  81                                         ///< Check INet4SocketAddress for equality
  82
  83         INet4Address address() const;   ///< Return address
  84         unsigned port() const;          ///< Return port number
  85
  86         bool boolean_test() const;      ///< \c true, if address is not empty (i.e. 0.0.0.0:0)
  87
  88         void clear();                   ///< Clear address/port to 0.0.0.0:0
  89
  90         void address(INet4Address const & addr); ///< Set address
  91         void port(unsigned p);          ///< Set port number
  92
  93         /// \name Generic Address Interface
  94         /// @{
  95
  96         struct sockaddr * sockaddr_p();
  97         struct sockaddr const * sockaddr_p() const;
  98         unsigned sockaddr_len() const;
  99
 100         /// @}
 101
 102         struct SyntaxException : public std::exception
 103         { virtual char const * what() const throw()
 104                 { return "Invalid IPv4 socket address syntax"; } };
 105
 106     private:
 107         struct ::sockaddr_in addr_;
 108     };
 109
 110     /** \brief Write address and port to os
 111
 112         \related INet4SocketAddress
 113      */
 114     std::ostream & operator<<(std::ostream & os, INet4SocketAddress const & addr);
 115
 116     /** \brief IPv6 socket address
 117
 118         This class wraps the standard \c sockaddr_in6 structure. INet6SocketAddress provides access
 119         to all members of the sockaddr_in6 structure. Additionally, INet6SocketAddress supports the
 120         string representations
 121
 122         \par ""
 123             <tt>[</tt> <i>address</i> [ <tt>%</tt> <i>zone-id</i> ] <tt>]:</tt> <i>port</i> \n
 124             <i>hostname</i> <tt>:</tt> <i>port</i>
 125
 126         Where \e address is an arbitrary numeric IPv6 address, \e zone-id is an optional network
 127         interface name and \e port is the port number. So some example addresses are
 128
 129         \par ""
 130             <tt>[2001:db8:1::1]:80</tt> \n
 131             <tt>www.6bone.net:80</tt> \n
 132             <tt>[fe80::1\%eth0]:443</tt>
 133
 134         \implementation The sockaddr_in6 structure has an sin6_flowinfo member. However RFC3493 does
 135             not give the use of this field and specifies, that the field should be ignored ... so
 136             that's what we do. Furthermore, the GNU libc reference states, that this field is not
 137             implemented in the library.
 138
 139         \idea Implement a INet6Address_ref class which has an interface identical to INet6Address
 140             and is convertible to INet6Address (the latter has a conversion constructor taking the
 141             former as arg). This class however references an external in6_addr instead of containing
 142             one itself. This can be used in INet6SocketAddress to increase the performance of some
 143             operations.
 144
 145         \ingroup addr_group
 146      */
 147     class INet6SocketAddress
 148     {
 149     public:
 150         ///////////////////////////////////////////////////////////////////////////
 151         // Types
 152
 153         ///////////////////////////////////////////////////////////////////////////
 154         ///\name Structors and default members
 155         ///@{
 156
 157         INet6SocketAddress();           ///< Create empty instance
 158         explicit INet6SocketAddress(std::string const & addr,
 159                                     INet6Address::Resolve_t resolve = INet6Address::ResolveINet6);
 160                                         ///< Initialize/convert from string representation
 161                                         /**< \throws SyntaxException if the address syntax is
 162                                                  invalid
 163                                              \throws INet6Address::UnknownHostnameException if the
 164                                                  address cannot be resolved.
 165                                              \param[in] addr Address to parse
 166                                              \param[in] resolve If this is
 167                                                  INet6Address::ResolveINet4, support IPv4
 168                                                  addresses. See INet6Address. */
 169         INet6SocketAddress(INet6Address const & addr, unsigned port);
 170                                         ///< Initialize from address and port
 171         INet6SocketAddress(INet6Address const & addr, unsigned port, std::string const & iface);
 172                                         ///< Initialize explicitly from given parameters
 173
 174         ///@}
 175         ///////////////////////////////////////////////////////////////////////////
 176
 177         bool operator==(INet6SocketAddress const & other) const; ///< Check addresses for equality
 178         bool operator!=(INet6SocketAddress const & other) const; ///< Inverse of above
 179
 180         void clear();                   ///< Clear socket address
 181
 182         INet6Address address() const;    ///< Get printable address representation
 183
 184         void address(INet6Address const & addr); ///< Change address
 185
 186         unsigned port() const;          ///< Get port number
 187         void port(unsigned poirt);      ///< Change port number
 188
 189         std::string iface() const;      ///< Get interface name
 190         void iface(std::string const & iface); ///< Change interface
 191
 192         ///\name Generic SocketAddress interface
 193         ///@{
 194
 195         struct sockaddr * sockaddr_p();
 196         struct sockaddr const * sockaddr_p() const;
 197         unsigned sockaddr_len() const;
 198
 199         ///@}
 200
 201         struct SyntaxException : public std::exception
 202         { virtual char const * what() const throw()
 203                 { return "Invalid IPv6 socket address syntax"; } };
 204
 205     protected:
 206
 207     private:
 208         void assignIface(std::string const & iface);
 209
 210         struct sockaddr_in6 sockaddr_;
 211     };
 212
 213     /** \brief Output INet6SocketAddress instance as it's string representation
 214         \related INet6SocketAddress
 215      */
 216     std::ostream & operator<<(std::ostream & os, INet6SocketAddress const & addr);
 217
 218     /// \addtogroup policy_impl_group
 219     /// @{
 220
 221     /** \brief Addressing policy supporting IPv4 addressing
 222
 223         \par Address Type:
 224             INet4Address
 225
 226         This addressing policy implements addressing using Internet V4
 227         addresses.
 228
 229         The various members are directly imported from
 230         GenericAddressingPolicy which see for a detailed
 231         documentation.
 232      */
 233     struct INet4AddressingPolicy
 234         : public AddressingPolicyBase,
 235           private GenericAddressingPolicy<INet4SocketAddress>
 236     {
 237         typedef INet4SocketAddress Address;
 238
 239         using GenericAddressingPolicy<INet4SocketAddress>::peer;
 240         using GenericAddressingPolicy<INet4SocketAddress>::local;
 241         using GenericAddressingPolicy<INet4SocketAddress>::connect;
 242         using GenericAddressingPolicy<INet4SocketAddress>::bind;
 243     };
 244
 245     /** \brief Addressing policy supporting IPv6 addressing
 246
 247         \par Address Type:
 248             INet6SocketAddress
 249
 250         This addressing policy implements addressing using Internet V6
 251         addresses.
 252
 253         The various members are directly imported from
 254         GenericAddressingPolicy which see for a detailed
 255         documentation.
 256      */
 257     struct INet6AddressingPolicy
 258         : public AddressingPolicyBase,
 259           private GenericAddressingPolicy<INet6SocketAddress>
 260     {
 261         typedef INet6SocketAddress Address;
 262
 263         using GenericAddressingPolicy<INet6SocketAddress>::peer;
 264         using GenericAddressingPolicy<INet6SocketAddress>::local;
 265         using GenericAddressingPolicy<INet6SocketAddress>::connect;
 266         using GenericAddressingPolicy<INet6SocketAddress>::bind;
 267     };
 268
 269     /// @}
 270
 271 }
 272
 273 ///////////////////////////////hh.e////////////////////////////////////////
 274 #include "INetAddressing.cci"
 275 //#include "INetAddressing.ct"
 276 //#include "INetAddressing.cti"
 277 //#include "INetAddressing.mpp"
 278 #endif
 279
 280 \f
 281 // Local Variables:
 282 // mode: c++
 283 // fill-column: 100
 284 // c-file-style: "senf"
 285 // indent-tabs-mode: nil
 286 // ispell-local-dictionary: "american"
 287 // compile-command: "scons -u test"
 288 // comment-column: 40
 289 // End: