Socket/INetAddressing.hh

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
   5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
   6 //     Stefan Bund <stefan.bund@fokus.fraunhofer.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 "SocketPolicy.hh"
  35 #include "ClientSocketHandle.hh"
  36 #include "CommunicationPolicy.hh"
  37 #include "GenericAddressingPolicy.hh"
  38
  39 //#include "INetAddressing.mpp"
  40 ///////////////////////////////hh.p////////////////////////////////////////
  41
  42 namespace senf {
  43
  44     /// \addtogroup addr_group
  45     /// @{
  46
  47     /** \brief IPv4 socket address
  48
  49         INet4Address wrapps the standard sockaddr_in datatype. It provides simple accessor methods
  50         to accss the host and port. It does \e not integrate \c gethostbyname or DNS lookup.
  51
  52         \todo Implement real INet4Address datatype and rename this one to INet4SockAddress ...
  53         \todo Implement more complete interface
  54         \todo  gethostbyname support ?
  55      */
  56     class INet4Address
  57     {
  58     public:
  59         INet4Address();
  60         INet4Address(char const * address); ///< Set address and port
  61                                         /**< See INet4Address(std::string)
  62                                              \throws InvalidINetAddressException
  63                                              \fixme Why do I need this version? Shouldn't the
  64                                              std::string version be enough ? */
  65         INet4Address(std::string address); ///< Set address and port
  66                                         /**< This constructor expects a string of the form
  67                                              'xxx.xxx.xxx.xxx:pppp'. The constructor will use this
  68                                              value to initialize the host and port members. This
  69                                              constructor does \e only support numeric ip addresses
  70                                              not hostnames
  71                                              \param[in] address Address and port
  72                                              \throws InvalidINetAddressException */
  73         INet4Address(std::string host, unsigned port); ///< Set address and port explicitly
  74                                         /**< \param[in] host ip address in dotted-quad notation
  75                                              \param[in] port port number
  76                                              \throws InvalidINetAddressException */
  77
  78
  79         bool operator==(INet4Address const & other) const; ///< Check INet4Address for equality
  80
  81         std::string str() const;        ///< Return "address:port" string
  82         std::string host() const;       ///< Return address in doted quad notation
  83         unsigned port() const;          ///< Return portnumber
  84
  85         void clear();                   ///< Clear address/port to 0.0.0.0:0
  86
  87         /// \name Generic Address Interface
  88         /// @{
  89
  90         struct sockaddr * sockaddr_p();
  91         struct sockaddr const * sockaddr_p() const;
  92         unsigned sockaddr_len() const;
  93
  94         /// @}
  95
  96     private:
  97         void assignString(std::string addr);
  98
  99         struct ::sockaddr_in addr_;
 100     };
 101
 102     /** \brief Write address and port to os
 103
 104         \related INet4Address
 105      */
 106     std::ostream & operator<<(std::ostream & os, INet4Address const & addr);
 107
 108     /** \brief IPv6 network address
 109
 110         \todo Implement
 111      */
 112     class INet6Address
 113     {
 114     public:
 115         ///////////////////////////////////////////////////////////////////////////
 116         // Types
 117
 118         ///////////////////////////////////////////////////////////////////////////
 119         ///\name Structors and default members
 120         ///@{
 121
 122         INet6Address();
 123         INet6Address(std::string const & addr);
 124         INet6Address(char const * addr);
 125         INet6Address(struct in6_addr const & addr);
 126
 127         ///@}
 128         ///////////////////////////////////////////////////////////////////////////
 129
 130         void clear();
 131         std::string address() const;
 132
 133         bool operator==(INet6Address const & other) const;
 134         bool operator!=(INet6Address const & other) const;
 135
 136         struct in6_addr & addr();
 137         struct in6_addr const & addr() const;
 138         struct in6_addr * addr_p();
 139         struct in6_addr const * addr_p() const;
 140         unsigned addr_len() const;
 141
 142     protected:
 143
 144     private:
 145         struct in6_addr addr_;
 146     };
 147
 148     std::ostream & operator<<(std::ostream & os, INet6Address const & addr);
 149
 150     /** \brief IPv6 socket address
 151
 152         \implementation The sockaddr_in6 structure has an sin6_flowinfo member. However RFC3493 does
 153         not give the use of this field and specifies, that the field should be ignored ... so that's
 154         what we do. Furthermore, the GNU libc reference states, that this field is not implemented
 155         in the library.
 156
 157         \idea Implement a INet6Address_ref class which has an interface identical to INet6Address
 158         and is convertible to INet6Address (the latter has a conversion constructor taking the
 159         former as arg). This class however references an external in6_addr instead of containing one
 160         itself. This can be used in INet6SocketAddress to increase the performance of some
 161         operations.
 162      */
 163     class INet6SocketAddress
 164     {
 165     public:
 166         ///////////////////////////////////////////////////////////////////////////
 167         // Types
 168
 169         ///////////////////////////////////////////////////////////////////////////
 170         ///\name Structors and default members
 171         ///@{
 172
 173         INet6SocketAddress();
 174         INet6SocketAddress(std::string const & addr);
 175         INet6SocketAddress(char const * addr);
 176         INet6SocketAddress(INet6Address const & addr, unsigned port);
 177         INet6SocketAddress(INet6Address const & addr, unsigned port, std::string const & iface);
 178         INet6SocketAddress(std::string const & addr, std::string const & iface);
 179
 180         ///@}
 181         ///////////////////////////////////////////////////////////////////////////
 182
 183         bool operator==(INet6SocketAddress const & other) const;
 184         bool operator!=(INet6SocketAddress const & other) const;
 185
 186         void clear();
 187
 188         std::string address() const;
 189         void address(std::string const & addr);
 190
 191         INet6Address host() const;
 192         void host(INet6Address const & addr);
 193
 194         unsigned port() const;
 195         void port(unsigned poirt);
 196
 197         std::string iface() const;
 198         void iface(std::string const & iface);
 199
 200         ///\name Generic SocketAddress interface
 201         ///@{
 202
 203         struct sockaddr * sockaddr_p();
 204         struct sockaddr const * sockaddr_p() const;
 205         unsigned sockaddr_len() const;
 206
 207         ///@}
 208
 209     protected:
 210
 211     private:
 212         void assignAddr(std::string const & addr);
 213         void assignIface(std::string const & iface);
 214
 215         struct sockaddr_in6 sockaddr_;
 216     };
 217
 218     std::ostream & operator<<(std::ostream & os, INet6SocketAddress const & addr);
 219
 220     /** \brief Signal invalid INet address syntax
 221
 222         \related INet4Address
 223         \relatesalso INet6Address
 224      */
 225     struct InvalidINetAddressException : public std::exception
 226     { char const * what() const throw() { return "invalid inet address"; } };
 227
 228     /// @}
 229
 230     /// \addtogroup policy_impl_group
 231     /// @{
 232
 233     /** \brief Addressing policy supporting IPv4 addressing
 234
 235         \par Address Type:
 236             INet4Address
 237
 238         This addressing policy implements addressing using Internet V4
 239         addresses.
 240
 241         The various members are directly importet from
 242         GenericAddressingPolicy which see for a detailed
 243         documentation.
 244      */
 245     struct INet4AddressingPolicy
 246         : public AddressingPolicyBase,
 247           private GenericAddressingPolicy<INet4Address>
 248     {
 249         typedef INet4Address Address;
 250
 251         using GenericAddressingPolicy<INet4Address>::peer;
 252         using GenericAddressingPolicy<INet4Address>::local;
 253         using GenericAddressingPolicy<INet4Address>::connect;
 254         using GenericAddressingPolicy<INet4Address>::bind;
 255     };
 256
 257     /** \brief Addressing policy supporting IPv6 addressing
 258
 259         \par Address Type:
 260             INet6Address
 261
 262         This addressing policy implements addressing using Internet V6
 263         addresses.
 264
 265         The various members are directly importet from
 266         GenericAddressingPolicy which see for a detailed
 267         documentation.
 268
 269         \todo implement
 270      */
 271     struct INet6AddressingPolicy
 272         : public AddressingPolicyBase,
 273           private GenericAddressingPolicy<INet6SocketAddress>
 274     {
 275         typedef INet6SocketAddress Address;
 276
 277         using GenericAddressingPolicy<INet6SocketAddress>::peer;
 278         using GenericAddressingPolicy<INet6SocketAddress>::local;
 279         using GenericAddressingPolicy<INet6SocketAddress>::connect;
 280         using GenericAddressingPolicy<INet6SocketAddress>::bind;
 281     };
 282
 283     /// @}
 284
 285 }
 286
 287 ///////////////////////////////hh.e////////////////////////////////////////
 288 #include "INetAddressing.cci"
 289 //#include "INetAddressing.ct"
 290 //#include "INetAddressing.cti"
 291 //#include "INetAddressing.mpp"
 292 #endif
 293
 294 \f
 295 // Local Variables:
 296 // mode: c++
 297 // c-file-style: "senf"
 298 // fill-column: 100
 299 // End: