// Copyright (C) 1999-2005 Open Source Telecom Corporation.//// 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// the Free Software Foundation; either version 2 of the License, or// (at your option) any later version.//// This program is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the// GNU General Public License for more details.//// You should have received a copy of the GNU General Public License// along with this program; if not, write to the Free Software// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.//// As a special exception, you may use this file as part of a free software// library without restriction.  Specifically, if other files instantiate// templates or use macros or inline functions from this file, or you compile// this file and link it with other files to produce an executable, this// file does not by itself cause the resulting executable to be covered by// the GNU General Public License.  This exception does not however    // invalidate any other reasons why the executable file might be covered by// the GNU General Public License.    //// This exception applies only to the code released under the name GNU// Common C++.  If you copy code from other releases into a copy of GNU// Common C++, as the General Public License permits, the exception does// not apply to the code that you add in this way.  To avoid misleading// anyone as to the status of such modified files, you must delete// this exception notice from them.//// If you write modifications of your own for GNU Common C++, it is your choice// whether to permit this exception to apply to your modifications.// If you do not wish that, delete this exception notice.///** * @file socket.h * @short Network addresses and sockets related classes. **/#ifndef	CCXX_SOCKET_H_#define	CCXX_SOCKET_H_#ifndef	CCXX_ADDRESS_H_#include <cc++/address.h>#endif#if defined(WIN32) && !defined(__CYGWIN32__)#include <io.h>#define	_IOLEN64	(unsigned)#define	_IORET64	(int)#define TIMEOUT_INF ~((timeout_t) 0)typedef int socklen_t;#else#define INVALID_SOCKET	-1typedef int SOCKET;#endif#ifndef	_IOLEN64#define	_IOLEN64#endif#ifndef	_IORET64#define	_IORET64#endif#ifndef	MSG_DONTWAIT#define	MSG_DONTWAIT	0#endif#ifndef	MSG_NOSIGNAL#define	MSG_NOSIGNAL	0#endif#ifdef	CCXX_NAMESPACESnamespace ost {#endif/** * Transport Protocol Ports. */typedef unsigned short tpport_t;/** * The Socket is used as the base for all Internet protocol services * under Common C++.  A socket is a system resource (or winsock descriptor) * that occupies a specific port address (and may be bound to a specific * network interface) on the local machine.  The socket may also be * directly connected to a specific socket on a remote internet host. *  * This base class is not directly used, but is * provided to offer properties common to other Common C++ socket classes, * including the socket exception model and the ability to set socket * properties such as QoS, "sockopts" properties like Dont-Route * and Keep-Alive, etc. *  * * @author David Sugar <dyfet@ostel.com> * @short base class of all sockets. */class __EXPORT Socket{public:	enum Family	{#ifdef	CCXX_IPV6		IPV6 = AF_INET6,#endif		IPV4 = AF_INET	};	typedef enum Family Family;	enum Error	{		errSuccess = 0,		errCreateFailed,		errCopyFailed,		errInput,		errInputInterrupt,		errResourceFailure,		errOutput,		errOutputInterrupt,		errNotConnected,		errConnectRefused,		errConnectRejected,		errConnectTimeout,		errConnectFailed,		errConnectInvalid,		errConnectBusy,		errConnectNoRoute,		errBindingFailed,		errBroadcastDenied,		errRoutingDenied,		errKeepaliveDenied,		errServiceDenied,		errServiceUnavailable,		errMulticastDisabled,		errTimeout,		errNoDelay,		errExtended,		errLookupFail,		errSearchErr,		errInvalidValue	};	typedef enum Error Error;	enum Tos	{		tosLowDelay = 0,		tosThroughput,		tosReliability,		tosMinCost,		tosInvalid	};	typedef enum Tos Tos;	enum Pending	{		pendingInput,		pendingOutput,		pendingError	};	typedef enum Pending Pending;protected:	enum State	{		INITIAL,		AVAILABLE,		BOUND,		CONNECTED,		CONNECTING,		STREAM	};	typedef enum State State;private:	// used by exception handlers....	mutable Error errid;	mutable const char *errstr;	mutable long syserr;	void setSocket(void);	friend SOCKET dupSocket(SOCKET s,Socket::State state);protected:	static Mutex mutex;	mutable struct	{		bool thrown: 1;		bool broadcast: 1;		bool route: 1;		bool keepalive: 1;		bool loopback: 1;		bool multicast: 1;		bool completion: 1;		bool linger: 1;		unsigned ttl: 8;	} flags;	/**	 * the actual socket descriptor, in Windows, unlike posix it 	 * *cannot* be used as an file descriptor	 * that way madness lies -- jfc	 */	SOCKET volatile so;	State volatile state;	/**	 * This service is used to throw all socket errors which usually	 * occur during the socket constructor.	 *	 * @param error defined socket error id.	 * @param err string or message to pass.	 * @param systemError the system error# that caused the error	 */	Error error(Error error, char *err = NULL, long systemError = 0) const;	/**	 * This service is used to throw application defined socket errors	 * where the application specific error code is a string.	 *	 * @param err string or message to pass.	 */	inline void error(char *err) const		{error(errExtended, err);};		/**	 * This service is used to turn the error handler on or off for	 * "throwing" exceptions by manipulating the thrown flag.	 *	 * @param enable true to enable handler.	 */	inline void setError(bool enable)		{flags.thrown = !enable;};	/**	 * Used as the default destructor for ending a socket.  This	 * will cleanly terminate the socket connection.  It is provided	 * for use in derived virtual destructors.	 */	void endSocket(void);	/**	 * Used as a common handler for connection failure processing.	 *	 * @return correct failure code to apply.	 */	Error connectError(void);	/**	 * Set the send limit.	 */	Error sendLimit(int limit = 2048);	/**	 * Set thr receive limit.	 */	Error receiveLimit(int limit = 1);	/**	 * Set the send timeout for sending raw network data.	 *	 * @return errSuccess if set.	 * @param timer value in millisec.	 */	Error sendTimeout(timeout_t timer);	/**	 * Receive timeout for receiving raw network data.	 *	 * @return errSuccess if set.	 * @param timer value in milliseconds.	 */	Error receiveTimeout(timeout_t timer);	/**	 * Set the protocol stack network kernel send buffer size 	 * associated with the socket.	 *	 * @return errSuccess on success, or error.	 * @param size of buffer in bytes.	 */	Error sendBuffer(unsigned size);        /**         * Set the protocol stack network kernel receive buffer size	 * associated with the socket.         *          * @return errSuccess on success, or error.          * @param size of buffer in bytes.         */        Error receiveBuffer(unsigned size);	/**	 * Set the total protocol stack network kernel buffer size 	 * for both send and receive together.	 *	 * @return errSuccess on success	 * @param size of buffer.	 */	Error bufferSize(unsigned size);	/**	 * Set the subnet broadcast flag for the socket.  This enables	 * sending to a subnet and may require special image privileges	 * depending on the operating system.	 *	 * @return 0 (errSuccess) on success, else error code.	 * @param enable when set to true.	 */	Error setBroadcast(bool enable);	/**	 * Setting multicast binds the multicast interface used for	 * the socket to the interface the socket itself has been	 * implicitly bound to.  It is also used as a check flag	 * to make sure multicast is enabled before multicast	 * operations are used.	 *	 * @return 0 (errSuccess) on success, else error code.	 * @param enable when set to true.	 * @param family of protocol.	 */	Error setMulticastByFamily(bool enable, Family family = IPV4);	/**	 * Set the multicast loopback flag for the socket.  Loopback	 * enables a socket to hear what it is sending.	 *	 * @return 0 (errSuccess) on success, else error code.	 * @param enable when set to true.	 * @param family of protocol.	 */	Error setLoopbackByFamily(bool enable, Family family = IPV4);	/**	 * Set the multicast time to live for a multicast socket.	 *	 * @return 0 (errSuccess) on success, else error code.	 * @param ttl time to live.	 * @param fam family of protocol.	 */	Error setTimeToLiveByFamily(unsigned char ttl, Family fam = IPV4);	/**	 * Join a multicast group.	 *	 * @return 0 (errSuccess) on success, else error code.	 * @param ia address of multicast group to join.	 */	Error join(const IPV4Multicast &ia);#ifdef	CCXX_IPV6	Error join(const IPV6Multicast &ia);#endif	/**	 * Drop membership from a multicast group.	 *	 * @return 0 (errSuccess) on success, else error code.	 * @param ia address of multicast group to drop.	 */	Error drop(const IPV4Multicast &ia);#ifdef	CCXX_IPV6	Error drop(const IPV6Multicast &ia);#endif	/**	 * Set the socket routing to indicate if outgoing messages	 * should bypass normal routing (set false).	 *	 * @return 0 on success.	 * @param enable normal routing when set to true.	 */	Error setRouting(bool enable);	/**	 * Enable/disable delaying packets (Nagle algorithm)	 *	 * @return 0 on success.	 * @param enable disable Nagle algorithm when set to true.	 */	Error setNoDelay(bool enable);	/**	 * An unconnected socket may be created directly on the local	 * machine.  Sockets can occupy both the internet domain (AF_INET)	 * and UNIX socket domain (AF_UNIX) under unix.  The socket type	 * (SOCK_STREAM, SOCK_DGRAM) and protocol may also be specified.	 * If the socket cannot be created, an exception is thrown.	 * 	 * @param domain socket domain to use.	 * @param type base type and protocol family of the socket.	 * @param protocol specific protocol to apply.	 */	Socket(int domain, int type, int protocol = 0);	/**	 * A socket object may be created from a file descriptor when that	 * descriptor was created either through a socket() or accept()	 * call.  This constructor is mostly for internal use.	 * 	 * @param fd file descriptor of an already existing socket.	 */	Socket(SOCKET fd);	/**	 * Create an inactive socket object for base constructors.	 */	Socket();	/**         * A socket can also be constructed from an already existing         * Socket object. On POSIX systems, the socket file descriptor         * is dup()'d. On Win32, DuplicateHandle() is used.	 * 	 * @param source of existing socket to clone.	 */	Socket(const Socket &source);	/**	 * Process a logical input line from a socket descriptor	 * directly.	 *	 * @param buf pointer to string.	 * @param len maximum length to read.	 * @param timeout for pending data in milliseconds.	 * @return number of bytes actually read.	 */	ssize_t readLine(char *buf, size_t len, timeout_t timeout = 0);        /**         * Read in a block of len bytes with specific separator.  Can         * be zero, or any other char.  If \\n or \\r, it's treated just         * like a readLine().  Otherwise it looks for the separator.         *         * @param buf pointer to byte allocation.         * @param len maximum length to read.         * @param separator separator for a particular ASCII character         * @param t timeout for pending data in milliseconds.         * @return number of bytes actually read.         */        virtual ssize_t readData(void * buf,size_t len,char separator=0,timeout_t t=0);        /**         * Write a block of len bytes to socket.         *         * @param buf pointer to byte allocation.         * @param len maximum length to write.         * @param t timeout for pending data in milliseconds.         * @return number of bytes actually read.         */        virtual ssize_t writeData(const void* buf,size_t len,timeout_t t=0);public:	/**	 * The socket base class may be "thrown" as a result of an	 * error, and the "catcher" may then choose to destroy the	 * object.  By assuring the socket base class is a virtual	 * destructor, we can assure the full object is properly	 * terminated.	 */	virtual ~Socket();	/**	 * See if a specific protocol family is available in the	 * current runtime environment.	 *	 * @return true if family available.	 */	static bool check(Family fam);	/**	 * Sockets may also be duplicated by the assignment operator.	 */	Socket &operator=(const Socket &from);	/**	 * May be used to examine the origin of data waiting in the	 * socket receive queue.  This can tell a TCP server where pending	 * "connect" requests are coming from, or a UDP socket where it's