Socket/Protocols/BSDSocketAddress.hh

   1 // $Id$
   2 //
   3 // Copyright (C) 2008
   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 BSDSocketAddress public header */
  25
  26 #ifndef HH_BSDSocketAddress_
  27 #define HH_BSDSocketAddress_ 1
  28
  29 // Custom includes
  30 #include "../../Utils/safe_bool.hh"
  31 #include <sys/socket.h>
  32 #include <iostream>
  33
  34 //#include "BSDSocketAddress.mpp"
  35 ///////////////////////////////hh.p////////////////////////////////////////
  36
  37 namespace senf {
  38
  39     /** \brief Socket addressing, BSD style
  40
  41         BSDSocketAddress is the base class of all BSD \c sockaddr based addressing classes. The \c
  42         sockaddr addressing interface is split into several parts
  43
  44         \li The BSDSocketAddress provides a read-only and generic \c sockaddr interface
  45         \li Address family specific derived classes implement addressing of a specific type. These
  46             are INet4SocketAddress (\c AF_INET), INet6SocketAddress (\c AF_INET6), UNSocketAddress
  47             (\c AF_UNIX) and LLSocketAddress (\c AF_PACKET)
  48         \li GenericBSDSocketAddress provides writable support for generic addresses.
  49
  50         It is \e not possible to create or store BSDSocketAddress instances: You must either store
  51         an address in one of the specifically typed subclasses or using GenericBSDSocketAddress.
  52
  53         All these classes provide a generic \c sockaddr API to interface with legacy \c sockaddr
  54         based code (e.g. the BSD socket API). In this base-class, this interface is read-only, the
  55         derived classes however provide a read-write interface.
  56
  57         \ingroup addr_group
  58       */
  59     class BSDSocketAddress
  60         : public senf::comparable_safe_bool<BSDSocketAddress>
  61     {
  62     public:
  63         bool operator==(BSDSocketAddress const & other) const; ///< Compare two arbitrary addresses
  64                                         /**< For addresses to be considered equal, they must have
  65                                              the same family, length and the data must be
  66                                              identical. */
  67         bool operator!=(BSDSocketAddress const & other) const; ///< Inverse of operator==
  68
  69         bool boolean_test() const;      ///< Return \c true, if address is not empty
  70                                         /**< An address is considered empty if
  71                                              \li the family is AF_UNSPEC
  72                                              \li or the size is 0
  73                                              \li or all data bytes are 0 */
  74
  75         short family() const;           ///< Return the address family.
  76                                         /**< This value is found in the \c addressFamily member of
  77                                              each typed derived class
  78                                              (e.g. INet4Address::addressFamily) */
  79
  80         ///////////////////////////////////////////////////////////////////////////
  81         ///\name Generic sockaddr interface
  82         ///\{
  83
  84         struct sockaddr const * sockaddr_p() const;
  85         socklen_t socklen() const;
  86         socklen_t const * socklen_p() const;
  87
  88         ///\}
  89
  90     protected:
  91         BSDSocketAddress(socklen_t len, short family);
  92         BSDSocketAddress(BSDSocketAddress const & other);
  93         BSDSocketAddress & operator=(BSDSocketAddress const & other);
  94
  95         struct sockaddr * sockaddr_p();
  96         socklen_t * socklen_p();
  97
  98         void socklen(socklen_t len);
  99
 100     private:
 101
 102         socklen_t len_;
 103     };
 104
 105     /** \brief Safe socket address down-cast
 106
 107         sockaddr_cast allows to safely cast a socket address to it's derived type. Only the family
 108         specific derived addressing classes are permissible for \a Target.
 109
 110         This cast is especially useful to cast a GenericBSDSocketAddress to it's concrete type.
 111
 112         \related BSDSocketAddress
 113      */
 114     template <class Target>
 115     Target & sockaddr_cast(BSDSocketAddress & source);
 116
 117     /** \brief Safe socket address down-cast (const)
 118         \see sockaddr_cast()
 119         \related BSDSocketAddress
 120      */
 121     template <class Target>
 122     Target const & sockaddr_cast(BSDSocketAddress const & source);
 123
 124     /** \brief Output generic socket address
 125
 126         This stream operator will output a generic BSDSocketAddress in a family depending format.
 127
 128         \related BSDSocketAddress
 129      */
 130     std::ostream & operator<<(std::ostream & os, BSDSocketAddress const & addr);
 131
 132     /** \brief Generic BSD \c sockaddr storage
 133
 134         While BSDSocketAddress provides read-only generic \c sockaddr access,
 135         GenericBSDSocketAddress allows to store (write) arbitrary socket addresses. (It is
 136         internally based on \c sockaddr_storage).
 137
 138         To access the stored address, use sockaddr_cast to cast the GenericBSDSocketAddress to the
 139         correct family specific address class.
 140
 141         \ingroup addr_group
 142       */
 143     class GenericBSDSocketAddress
 144         : public BSDSocketAddress
 145     {
 146     public:
 147         ///////////////////////////////////////////////////////////////////////////
 148         ///\name Structors and default members
 149         ///@{
 150
 151         GenericBSDSocketAddress();
 152         GenericBSDSocketAddress(BSDSocketAddress const & other);
 153         GenericBSDSocketAddress& operator=(const BSDSocketAddress & other);
 154
 155         GenericBSDSocketAddress(const GenericBSDSocketAddress& other);
 156         GenericBSDSocketAddress& operator=(const GenericBSDSocketAddress& other);
 157
 158         ///@}
 159         ///////////////////////////////////////////////////////////////////////////
 160         ///\name Generic sockaddr interface
 161         ///\{
 162
 163         struct sockaddr const * sockaddr_p() const;
 164         struct sockaddr * sockaddr_p();
 165
 166         using BSDSocketAddress::socklen_p;
 167
 168         ///\}
 169
 170     protected:
 171
 172     private:
 173         struct sockaddr_storage addr_;
 174     };
 175
 176 }
 177
 178 ///////////////////////////////hh.e////////////////////////////////////////
 179 #include "BSDSocketAddress.cci"
 180 //#include "BSDSocketAddress.ct"
 181 //#include "BSDSocketAddress.cti"
 182 #endif
 183
 184 \f
 185 // Local Variables:
 186 // mode: c++
 187 // fill-column: 100
 188 // comment-column: 40
 189 // c-file-style: "senf"
 190 // indent-tabs-mode: nil
 191 // ispell-local-dictionary: "american"
 192 // compile-command: "scons -u test"
 193 // End: