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