Socket/Protocols/INet/TCPSocketHandle.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 TCPv4SocketHandle and TCPv6SocketHandle public header
  25
  26     \todo Implement possibly non-blocking connect and SO_ERROR in the
  27     protocol interface
  28  */
  29
  30 #ifndef HH_TCPSocketHandle_
  31 #define HH_TCPSocketHandle_ 1
  32
  33 // Custom includes
  34 #include "../../../Utils/pool_alloc_mixin.hh"
  35 #include "INetProtocol.hh"
  36 #include "TCPProtocol.hh"
  37 #include "../../../Socket/Protocols/BSDSocketProtocol.hh"
  38 #include "../../../Socket/FramingPolicy.hh"
  39 #include "../../../Socket/CommunicationPolicy.hh"
  40 #include "../../../Socket/ReadWritePolicy.hh"
  41 #include "../../../Socket/ProtocolClientSocketHandle.hh"
  42 #include "../../../Socket/ProtocolServerSocketHandle.hh"
  43
  44 //#include "TCPSocketHandle.mpp"
  45 ///////////////////////////////hh.p////////////////////////////////////////
  46
  47 namespace senf {
  48
  49     /// \addtogroup concrete_protocol_group
  50     /// @{
  51
  52     typedef MakeSocketPolicy<
  53         INet4AddressingPolicy,
  54         StreamFramingPolicy,
  55         ConnectedCommunicationPolicy,
  56         ReadablePolicy,
  57         WriteablePolicy
  58         >::policy TCPv4Socket_Policy;   ///< Socket Policy of the TCPv4 Protocol
  59
  60     /** \brief IPv4 TCP Socket Protocol
  61
  62         \par Socket Handle typedefs:
  63             \ref TCPv4ClientSocketHandle (ProtocolClientSocketHandle), \ref TCPv4ServerSocketHandle
  64             (ProtocolServerSocketHandle)
  65
  66         \par Policy Interface:
  67             ClientSocketHandle::read(), ClientSocketHandle::write(), ClientSocketHandle::bind(),
  68             ClientSocketHandle::local(), ClientSocketHandle::connect(), ClientSocketHandle::peer(),
  69             ClientSocketHandle::rcvbuf(), ClientSocketHandle::sndbuf()
  70
  71         \par Address Type:
  72             INet4Address
  73
  74         TCPv4SocketProtocol provides an internet protocol stream socket based on the TCP protocol
  75         and IPv4 addressing.
  76
  77         This class is utilized as the protocol class of the ProtocolClientSocketHandle and
  78         ProtocolServerSocketHandle via the Socket Handle typedefs above.
  79
  80         \see TCPv6SocketProtocol
  81      */
  82     class TCPv4SocketProtocol
  83         : public ConcreteSocketProtocol<TCPv4Socket_Policy>,
  84           public IPv4Protocol,
  85           public TCPProtocol,
  86           public BSDSocketProtocol,
  87           public AddressableBSDSocketProtocol,
  88           public senf::pool_alloc_mixin<TCPv4SocketProtocol>
  89     {
  90     public:
  91         ///////////////////////////////////////////////////////////////////////////
  92         // internal interface
  93
  94         ///\name Constructors
  95         ///@{
  96
  97         void init_client() const;       ///< Create unconnected client socket
  98                                         /**< \note This member is implicitly called from the
  99                                              ProtocolClientSocketHandle::ProtocolClientSocketHandle()
 100                                              constructor */
 101         void init_client(INet4SocketAddress const & address) const;
 102                                         ///< Create client socket and connect
 103                                         /**< Creates a new client socket and connects to the given
 104                                              address.
 105
 106                                              \param[in] address remote address to connect to */
 107                                         /**< \note This member is implicitly called from the
 108                                              ProtocolClientSocketHandle::ProtocolClientSocketHandle()
 109                                              constructor */
 110         void init_server() const;       ///< Create server socket
 111                                         /**< \note This member is implicitly called from the
 112                                              ProtocolServerSocketHandle::ProtocolServerSocketHandle()
 113                                              constructor */
 114         void init_server(INet4SocketAddress const & address, unsigned backlog=1) const;
 115                                         ///< Create server socket and listen
 116                                         /**< Creates a new server socket, binds to \a address end
 117                                              starts listening for new connections with a backlog of
 118                                              \a backlog connections. It also enables reuseaddr().
 119
 120                                              \param[in] address address to listen on
 121                                              \param[in] backlog size of the listen backlog */
 122                                         /**< \note This member is implicitly called from the
 123                                              ProtocolServerSocketHandle::ProtocolServerSocketHandle()
 124                                              constructor */
 125
 126         ///@}
 127         ///\name Abstract Interface Implementation
 128
 129         std::auto_ptr<SocketProtocol> clone() const;
 130
 131         ///@}
 132     };
 133
 134     typedef ProtocolClientSocketHandle<TCPv4SocketProtocol> TCPv4ClientSocketHandle;
 135     typedef ProtocolServerSocketHandle<TCPv4SocketProtocol> TCPv4ServerSocketHandle;
 136
 137     typedef MakeSocketPolicy<
 138         TCPv4Socket_Policy,
 139         INet6AddressingPolicy
 140         >::policy TCPv6Socket_Policy;
 141
 142     /** \brief IPv6 TCP Socket Protocol
 143
 144         \par Socket Handle typedefs:
 145         \ref TCPv6ClientSocketHandle (ProtocolClientSocketHandle), \ref TCPv6ServerSocketHandle
 146         (ProtocolServerSocketHandle)
 147
 148         \par Policy Interface:
 149         ClientSocketHandle::read(), ClientSocketHandle::write(), ClientSocketHandle::bind(),
 150         ClientSocketHandle::local(), ClientSocketHandle::connect(), ClientSocketHandle::peer(),
 151         ClientSocketHandle::rcvbuf(), ClientSocketHandle::sndbuf()
 152
 153         \par Address Type:
 154         INet6Address
 155
 156         TCPv6SocketProtocol provides an internet protocol stream socket based on the TCP protocol
 157         and IPv6 addressing.
 158
 159         This class is utilized as the protocol class of the ProtocolClientSocketHandle and
 160         ProtocolServerSocketHandle via the Socket Handle typedefs above.
 161
 162         \see TCPv4SocketProtocol
 163      */
 164     class TCPv6SocketProtocol
 165         : public ConcreteSocketProtocol<TCPv6Socket_Policy>,
 166           public IPv6Protocol,
 167           public TCPProtocol,
 168           public BSDSocketProtocol,
 169           public AddressableBSDSocketProtocol,
 170           public senf::pool_alloc_mixin<TCPv6SocketProtocol>
 171     {
 172     public:
 173         ///////////////////////////////////////////////////////////////////////////
 174         // internal interface
 175
 176         ///\name Constructors
 177         ///@{
 178
 179         void init_client() const;       ///< Create unconnected client socket
 180                                         /**< \note This member is implicitly called from the
 181                                              ProtocolClientSocketHandle::ProtocolClientSocketHandle()
 182                                              constructor */
 183         void init_client(INet6SocketAddress const & address) const;
 184                                         ///< Create client socket and connect
 185                                         /**< Creates a new client socket and connects to the given
 186                                              address.
 187
 188                                              \param[in] address remote address to connect to */
 189                                         /**< \note This member is implicitly called from the
 190                                              ProtocolClientSocketHandle::ProtocolClientSocketHandle()
 191                                              constructor */
 192         void init_server() const;       ///< Create server socket
 193                                         /**< \note This member is implicitly called from the
 194                                              ProtocolServerSocketHandle::ProtocolServerSocketHandle()
 195                                              constructor */
 196         void init_server(INet6SocketAddress const & address, unsigned backlog=1) const;
 197                                         ///< Create server socket and listen
 198                                         /**< Creates a new server socket, binds to \a address end
 199                                              starts listening for new connections with a backlog of
 200                                              \a backlog connections. It also enables reuseaddr().
 201
 202                                              \param[in] address address to listen on
 203                                              \param[in] backlog size of the listen backlog */
 204                                         /**< \note This member is implicitly called from the
 205                                              ProtocolServerSocketHandle::ProtocolServerSocketHandle()
 206                                              constructor */
 207
 208         ///@}
 209         ///\name Abstract Interface Implementation
 210
 211         std::auto_ptr<SocketProtocol> clone() const;
 212
 213         ///@}
 214     };
 215
 216     typedef ProtocolClientSocketHandle<TCPv6SocketProtocol> TCPv6ClientSocketHandle;
 217     typedef ProtocolServerSocketHandle<TCPv6SocketProtocol> TCPv6ServerSocketHandle;
 218
 219     /// @}
 220
 221 }
 222
 223 ///////////////////////////////hh.e////////////////////////////////////////
 224 //#include "TCPSocketHandle.cci"
 225 //#include "TCPSocketHandle.ct"
 226 //#include "TCPSocketHandle.cti"
 227 #endif
 228
 229 \f
 230 // Local Variables:
 231 // mode: c++
 232 // fill-column: 100
 233 // c-file-style: "senf"
 234 // indent-tabs-mode: nil
 235 // ispell-local-dictionary: "american"
 236 // compile-command: "scons -u test"
 237 // comment-column: 40
 238 // End: