X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=Socket%2FSocketProtocol.hh;h=b41fccb8b05e182579462235abe3db3a3e5f30d0;hb=b8ca4a544cce3e6023bb56b712a03d6362f2bb79;hp=5ca81dbf8c9810a2dcfbf6c73945e9a34717298f;hpb=1ad3873b372da6187b1fbc645bf276287d2efb54;p=senf.git diff --git a/Socket/SocketProtocol.hh b/Socket/SocketProtocol.hh index 5ca81db..b41fccb 100644 --- a/Socket/SocketProtocol.hh +++ b/Socket/SocketProtocol.hh @@ -1,9 +1,9 @@ // $Id$ // // Copyright (C) 2006 -// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS) -// Kompetenzzentrum fuer Satelitenkommunikation (SatCom) -// Stefan Bund +// Fraunhofer Institute for Open Communication Systems (FOKUS) +// Competence Center NETwork research (NET), St. Augustin, GERMANY +// Stefan Bund // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by @@ -22,11 +22,6 @@ /** \file \brief SocketProtocol and ConcreteSocketProtocol public header - - \idea We should optimize the protocol handling. Allocating a protocol instance for every socket - body seems quite wasteful. We could derive SocketPolicy from SocketBody (probably privately, - since private inheritance models more of 'has a' than 'is a'). This would allow to reduce - the number of heap-allocations per socket to one which is good. */ // The private inheritance idea should indeed work very well: We just need to change the @@ -37,22 +32,19 @@ /** \defgroup protocol_group The Protocol Classes - \htmlonly - - SocketPolicy - ConcreteSocketProtocol - SocketProtocol - BSDSocketProtocol - AddressableBSDSocketProtocol - IPv4Protocol - IPv6Protocol - TCPProtocol - TCPv4SocketProtocol - TCPv6SocketProtocol - PacketProtocol - - Protocols - \endhtmlonly +
+ \ref SocketProtocol + \ref UNSocketProtocol + \ref PacketSocketProtocol + \ref ConcreteSocketProtocol + \ref BSDSocketProtocol + \ref DatagramSocketProtocol + \ref TCPSocketProtocol + \ref UNDatagramSocketProtocol + \ref AddressableBSDSocketProtocol + \ref TCPv4SocketProtocol +
+ \htmlonly Protocols \endhtmlonly The socket handle classes and templates only implement the most important socket API methods using the policy framework. To access the complete API, the protocol interface is @@ -72,9 +64,6 @@ \see \ref handle_group \n \ref policy_group - - \todo Complete the protocol interface implementations. Better distribution of members to - protocol facets and more precise distribution of functionality among the facets. */ /** \defgroup concrete_protocol_group Protocol Implementations (Concrete Protocol Classes) @@ -100,8 +89,8 @@ accessibility of the socket body from all facets. */ -#ifndef HH_SocketProtocol_ -#define HH_SocketProtocol_ 1 +#ifndef HH_SENF_Socket_SocketProtocol_ +#define HH_SENF_Socket_SocketProtocol_ 1 // Custom includes #include @@ -148,22 +137,14 @@ namespace senf { /////////////////////////////////////////////////////////////////////////// virtual SocketPolicyBase const & policy() const = 0; - ///< Access the policy instance + ///< Access the policy instance /////////////////////////////////////////////////////////////////////////// // Virtual interface - virtual std::auto_ptr clone() const = 0; - ///< Polymorphically return a copy of this protocol class - /**< This member will create a new copy of the protocol - class on the heap. - \attention This member must be implemented in every \e - leaf protocol class to return a new instance of the - appropriate type. */ - virtual unsigned available() const = 0; - ///< Return number of bytes available for reading without - ///< blocking + ///< Return (maximum) number of bytes available for reading + ///< without < blocking /**< This member will check in a (very, sigh) protocol dependent way, how many bytes may be read from a socket in a single (non-blocking) read operation. If the @@ -176,9 +157,9 @@ namespace senf { returns ethernet frames, returning 1500 from available() is ok). However, this should only be done as a last resort. Also beware, that this number should - not be to large since the socket layer will always need - to allocate that number of bytes for the data to be - read. */ + not be too large since the socket layer will always + need to allocate that number of bytes for the data to + be read. */ virtual bool eof() const = 0; ///< Check for end-of-file condition /**< This is another check which (like available()) is @@ -187,18 +168,20 @@ namespace senf { not support the notion of EOF, this member should always return \c false. */ - virtual void close() const; ///< Close socket + virtual void close(); ///< Close socket /**< This override will automatically \c shutdown() the socket whenever it is closed. - \throws senf::SystemException */ - - virtual void terminate() const; ///< Forcibly close socket + \throws senf::SystemException + \fixme Move into (at least) BSDSOcketProtocol */ + + virtual void terminate() const; ///< Forcibly close socket /**< This override will automatically \c shutdown() the - socket whenever it is called. Additionally it will - disable SO_LINGER to ensure, that v_terminate will not - block. Like the overriden method, this member will ignore - failures and will never throw. It is therefore safe to be - called from a destructor. */ + socket whenever it is called. Additionally it will + disable SO_LINGER to ensure, that v_terminate will not + block. Like the overriden method, this member will ignore + failures and will never throw. It is therefore safe to be + called from a destructor. + \fixme Move into (at least) BSDSocketProtocol */ virtual void state(SocketStateMap & map, unsigned lod) const; ///< Return socket state information @@ -209,7 +192,7 @@ namespace senf { \a lod value with a default value of 0. The interpretation of the \a lod value is completely implementation defined. - + Every class derived from SocketProtocol should reimplement state(). The reimplemented method should call (all) baseclass-implementations of this @@ -220,21 +203,21 @@ namespace senf { keys are interpreted as hierarchical strings with '.' as a separator (like hostnames or struct or class members). They are automatically sorted correctly. - + The values are std:string with one additional feature: they allow assignment or conversion from *any* type as long as that type is streamable. This simplifies assigning non-string values to the map: - + \code - map["socket.protocol.ip.address"] << peer(); - map["socket.protocol.tcp.backlog"] << backlog(); + map["socket.protocol.ip.address"] << peer(); + map["socket.protocol.tcp.backlog"] << backlog(); \endcode - + This will work even if peer() returns an ip-address object or backlog() returns an integer. The values are automatically converted to their string representation. - + Additionally, if the slot the date is written to is not empty, the \<\< operator will add add a comma as separator. */ @@ -260,25 +243,27 @@ namespace senf { ::dup2()). */ private: - // backpointer to owning SocketBody instance - - SocketBody & body() const; + virtual std::auto_ptr clone(bool isServer) const = 0; + virtual std::auto_ptr clone(int fd, bool isServer) const = 0; + virtual SocketBody & body() const = 0; - SocketBody * body_; friend class SocketBody; - }; - + }; + + template class ClientSocketHandle; + template class ServerSocketHandle; /** \brief Concrete Socket Protocol implementation base class ConcreteSocketProtocol is the base class of a concrete socket protocol implementation. The final protocol class must inherit from ConcreteSocketProtocol. The template argument \a - SocketPolicy must be set to the complete socket policy of the protocol. + SocketPolicy must be set to the complete socket policy of the protocol. \a Self is the name + of the final protocol class which inherits this class. A protocol implementation may define the protocol interface directly. It can also (additionally) make use of multiple inheritance to combine a set of protocol facets into a specific protocol implementation (i.e. TCPv4SocketProtocol inherits from - ConcreteSocketProtocol and from the protocol facets IPv4Protocol, TCPProtocol, + ConcreteSocketProtocol and from the protocol facets IPv4SocketProtocol, TCPSocketProtocol, BSDSocketProtocol and AddressableBSDSocketProtocol). The protocol facets are not concrete protocols themselves, they are combined to build concrete protocols. This structure will remove a lot of code duplication. It is important to ensure, that the protocol facets do not @@ -286,7 +271,7 @@ namespace senf { \doc init_client init_server */ - template + template class ConcreteSocketProtocol : public virtual SocketProtocol { @@ -310,12 +295,23 @@ namespace senf { /////////////////////////////////////////////////////////////////////////// Policy const & policy() const; - + protected: + ClientSocketHandle clientHandle() const; + ///< Get client handle for associated socket + /**< Returns a client handle for the socket associated with + this protocol instance */ + ServerSocketHandle serverHandle() const; + ///< Get server handle for associated socket + /**< Returns a server handle for the socket associated with + this protocol instance */ private: - Policy policy_; + virtual std::auto_ptr clone(bool isServer) const; + virtual std::auto_ptr clone(int fd, bool isServer) const; + virtual SocketBody & body() const; + Policy policy_; }; /// @}