Enter your search terms GNU-Darwin Web Submit search form

socket.h Go to the documentation of this file. // Copyright (C) 1999-2000 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 to the GNU General Public License, permission is // granted for additional uses of the text contained in its release // of Common C++. // // The exception is that, if you link the Common C++ library with other files // to produce an executable, this does not by itself cause the // resulting executable to be covered by the GNU General Public License. // Your use of that executable is in no way restricted on account of // linking the Common C++ library code into it. // // 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 Common C++. If you copy code from other releases into a copy of // 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 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. #ifndef __CCXX_SOCKET_H__ #define __CCXX_SOCKET_H__ #include "config.h" #if defined(WIN32) # ifndef __CCXX_THREAD_H__ # include <thread.h> # endif # include <winsock.h> # define TIMEOUT_INF ~((timeout_t) 0) typedef int socklen_t; #else # ifndef __CCXX_THREAD_H__ # include <cc++/thread.h> # elif defined(__CCXX_NAMESPACE_H__) # include <cc++/macros.h> # endif # define INVALID_SOCKET -1 # ifdef __EXPORT # undef __EXPORT # endif # define __EXPORT typedef int SOCKET; #endif #include <iostream.h> #ifndef MSG_DONTWAIT #define MSG_DONTWAIT 0 #endif typedef enum { SOCKET_COMPLETION_IMMEDIATE, SOCKET_COMPLETION_DELAYED } sockcomplete_t; typedef enum { SOCKET_INITIAL, SOCKET_AVAILABLE, SOCKET_BOUND, SOCKET_CONNECTED, SOCKET_CONNECTING, SOCKET_STREAM } sockstate_t; typedef enum { SOCKET_SUCCESS = 0, SOCKET_CREATE_FAILED, SOCKET_COPY_FAILED, SOCKET_INPUT_ERROR, SOCKET_INPUT_INTERRUPT, SOCKET_RESOURCE_FAILURE, SOCKET_OUTPUT_ERROR, SOCKET_OUTPUT_INTERRUPT, SOCKET_NOT_CONNECTED, SOCKET_CONNECT_REFUSED, SOCKET_CONNECT_REJECTED, SOCKET_CONNECT_TIMEOUT, SOCKET_CONNECT_FAILED, SOCKET_CONNECT_INVALID, SOCKET_CONNECT_BUSY, SOCKET_CONNECT_NOROUTE, SOCKET_BINDING_FAILED, SOCKET_BROADCAST_DENIED, SOCKET_ROUTING_DENIED, SOCKET_KEEPALIVE_DENIED, SOCKET_SERVICE_DENIED, SOCKET_SERVICE_UNAVAILABLE, SOCKET_MULTICAST_DISABLED, SOCKET_EXTENDED_ERROR } sockerror_t; typedef enum { SOCKET_IPTOS_LOWDELAY, SOCKET_IPTOS_THROUGHPUT, SOCKET_IPTOS_RELIABILITY, SOCKET_IPTOS_MINCOST, SOCKET_IPTOS_INVALID } socktos_t; typedef enum { SOCKET_PENDING_INPUT, SOCKET_PENDING_OUTPUT, SOCKET_PENDING_ERROR } sockpend_t; typedef unsigned short tpport_t; class __EXPORT InetAddress; class __EXPORT InetHostAddress; class __EXPORT InetMaskAddress; class __EXPORT BroadcastAddress; class __EXPORT Socket; class __EXPORT UDPSocket; class __EXPORT UDPBroadcast; class __EXPORT UDPTransmit; class __EXPORT UDPReceive; class __EXPORT UDPDuplex; class __EXPORT TCPSocket; class __EXPORT TCPStream; class __EXPORT tcpstream; class __EXPORT TCPSession; class InetAddress { protected: struct in_addr * ipaddr; size_t addr_count; #if defined(WIN32) static MutexCounter counter; #else static Mutex mutex; #endif bool setIPAddress(const char *host); void setAddress(const char *host); public: InetAddress(); InetAddress(struct in_addr addr); InetAddress(const char *address); InetAddress(const InetAddress &rhs); virtual ~InetAddress(); const char *getHostname(void) const; bool isInetAddress(void) const; struct in_addr getAddress(void) const; struct in_addr getAddress(size_t i) const; size_t getAddressCount() const { return addr_count; } InetAddress &operator=(const char *str); InetAddress &operator=(struct in_addr addr); InetAddress &operator=(const InetAddress &rhs); InetAddress &operator=(unsigned long addr); inline bool operator!() const {return !isInetAddress();}; bool operator==(const InetAddress &a) const; bool operator!=(const InetAddress &a) const; }; class InetMaskAddress : public InetAddress { public: InetMaskAddress(const char *mask); friend InetHostAddress operator&(const InetHostAddress &addr, const InetMaskAddress &mask); InetAddress &operator=(unsigned long addr) { return InetAddress::operator =(addr); } }; class InetHostAddress : public InetAddress { public: InetHostAddress(const char *host = NULL); InetHostAddress(struct in_addr addr); InetAddress &operator=(unsigned long addr) { return InetAddress::operator =(addr); } InetHostAddress &operator&=(const InetMaskAddress &mask); friend class InetMaskAddress; friend InetHostAddress operator&(const InetHostAddress &addr, const InetMaskAddress &mask); }; class BroadcastAddress : public InetAddress { public: BroadcastAddress(const char *net = "255.255.255.255"); }; class Socket { private: // used by exception handlers.... mutable sockerror_t errid; mutable const char *errstr; mutable struct { bool thrown: 1; bool broadcast: 1; bool route: 1; bool keepalive: 1; bool loopback: 1; bool multicast: 1; unsigned ttl: 8; } flags; void setSocket(void); protected: SOCKET so; sockstate_t state; sockerror_t Error(sockerror_t error, char *errstr = NULL) const; inline void Error(char *estr) {Error(SOCKET_EXTENDED_ERROR, estr);}; inline void setError(bool enable) {flags.thrown = !enable;}; void endSocket(void); sockerror_t connectError(void); sockerror_t setBroadcast(bool enable); sockerror_t setMulticast(bool enable); sockerror_t setLoopback(bool enable); sockerror_t setTimeToLive(unsigned char ttl); sockerror_t Join(InetAddress &ia); sockerror_t Drop(InetAddress &ia); sockerror_t setRouting(bool enable); Socket(int domain, int type, int protocol = 0); Socket(SOCKET fd); Socket(const Socket &source); ssize_t Readline(char *buf, size_t len); public: virtual ~Socket() {endSocket();}; Socket &operator=(const Socket &from); InetHostAddress getSender(tpport_t *port = NULL) const; InetHostAddress getPeer(tpport_t *port = NULL) const; InetHostAddress getLocal(tpport_t *port = NULL) const; void setCompletion(sockcomplete_t completion); sockerror_t setKeepAlive(bool enable); sockerror_t setTypeOfService(socktos_t service); bool isConnected(void) const; bool isActive(void) const; bool operator!() const; inline bool isBroadcast(void) const {return flags.broadcast;}; inline bool isRouted(void) const {return flags.route;}; inline sockerror_t getErrorNumber(void) const {return errid;} inline const char *getErrorString(void) const {return errstr;} virtual bool isPending(sockpend_t pend, timeout_t timeout = TIMEOUT_INF); }; class UDPSocket : public Socket { private: inline sockerror_t setKeepAlive(bool enable) {return Socket::setKeepAlive(enable);}; protected: struct sockaddr_in peer; public: UDPSocket(void); UDPSocket(const InetAddress &bind, tpport_t port); ~UDPSocket() {endSocket();}; void setPeer(const InetHostAddress &host, tpport_t port); inline int Send(void *buf, size_t len) {return ::sendto(so, (const char *)buf, len, 0, (struct sockaddr *)&peer, (socklen_t)sizeof(peer));}; inline int Recv(void *buf, size_t len) {return ::recv(so, (char *)buf, len, 0);}; InetHostAddress getPeer(tpport_t *port = NULL) const; inline int Peek(void *buf, size_t len) {return ::recv(so, (char *)buf, len, MSG_PEEK);}; }; class UDPBroadcast : public UDPSocket { private: void setPeer(const InetHostAddress &ia, tpport_t port) {}; sockerror_t setBroadcast(bool enable) {return Socket::setBroadcast(enable);}; public: UDPBroadcast(const InetAddress &ia, tpport_t port); void setPeer(const BroadcastAddress &subnet, tpport_t port); }; class UDPTransmit : private UDPSocket { protected: UDPTransmit(); UDPTransmit(const InetAddress &bind, tpport_t port = 5005); sockerror_t Connect(const InetHostAddress &host, tpport_t port); sockerror_t Connect(const BroadcastAddress &subnet, tpport_t port); sockerror_t Disconnect(void); inline int Send(void *buf, int len) {return ::send(so, (char *)buf, len, 0);} inline void endTransmitter(void) {Socket::endSocket();} /* * Get transmitter socket. * * @return transmitter. */ inline SOCKET getTransmitter(void) {return so;}; public: inline int Transmit(const char *buffer, size_t len) {return ::send(so, buffer, len, MSG_DONTWAIT);} inline bool isOutputReady(unsigned long timeout = 0l) {return Socket::isPending(SOCKET_PENDING_OUTPUT, timeout);}; inline sockerror_t setRouting(bool enable) {return Socket::setRouting(enable);}; inline sockerror_t setTypeOfService(socktos_t tos) {return Socket::setTypeOfService(tos);}; inline sockerror_t setBroadcast(bool enable) {return Socket::setBroadcast(enable);}; }; class UDPReceive : private UDPSocket { protected: UDPReceive(const InetAddress &bind, tpport_t port); sockerror_t Connect(const InetHostAddress &host, tpport_t port); sockerror_t Disconnect(void); bool isPendingReceive(timeout_t timeout) {return Socket::isPending(SOCKET_PENDING_INPUT, timeout);}; inline void endReceiver(void) {Socket::endSocket();} inline SOCKET getReceiver(void) {return so;}; inline sockerror_t setRouting(bool enable) {return Socket::setRouting(enable);}; public: inline int Receive(void *buf, size_t len) {return ::recv(so, (char *)buf, len, 0);}; inline bool isInputReady(timeout_t timeout = TIMEOUT_INF) {return Socket::isPending(SOCKET_PENDING_INPUT, timeout);}; }; class UDPDuplex : public UDPTransmit, public UDPReceive { public: UDPDuplex(const InetAddress &bind, tpport_t port); sockerror_t Connect(const InetHostAddress &host, tpport_t port); sockerror_t Disconnect(void); }; class TCPSocket : private Socket { protected: virtual bool OnAccept(const InetHostAddress &ia, short port) { return false; } virtual bool OnAccept(const InetHostAddress &ia, tpport_t port) {return true;}; friend class TCPStream; friend class SocketPort; friend class tcpstream; public: TCPSocket(const InetAddress &bind, tpport_t port, int backlog = 5); inline InetHostAddress getRequest(tpport_t *port = NULL) const {return Socket::getSender(port);}; void Reject(void); inline InetHostAddress getLocal(tpport_t *port = NULL) const {return Socket::getLocal(port);}; inline bool isPendingConnection(timeout_t timeout = TIMEOUT_INF) {return Socket::isPending(SOCKET_PENDING_INPUT, timeout);} ~TCPSocket() {endSocket();}; }; /* :\projects\libraries\cplusplus\commonc++\win32\socket.h(357) : warning C4275: non dll-interface class 'streambuf' used as base for dll-interface class 'TCPStream' c:\program files\microsoft visual studio\vc98\include\streamb.h(69) : see declaration of 'streambuf' c:\projects\libraries\cplusplus\commonc++\win32\socket.h(358) : warning C4275: non dll-interface class 'iostream' used as base for dll-interface class 'TCPStream' c:\program files\microsoft visual studio\vc98\include\iostream.h(66) : see declaration of 'iostream' */ #ifndef __KCC #pragma warning(disable:4275) // disable C4275 warning #endif #if defined(STLPORT) || defined(__KCC) #define iostream iostream_withassign #endif #ifdef __KCC using std::iostream; #endif class TCPStream : public Socket, public streambuf, public iostream { private: inline sockerror_t setBroadcast(bool enable) {return Socket::setBroadcast(enable);}; inline InetHostAddress getSender(tpport_t *port) const {return InetHostAddress();}; int doallocate(); friend TCPStream& crlf(TCPStream&); friend TCPStream& lfcr(TCPStream&); protected: int bufsize; char *gbuf, *pbuf; TCPStream(); void Allocate(int size); void endStream(void); virtual int underflow(void); int uflow(void); int overflow(int ch); void Connect(const InetHostAddress &host, tpport_t port, int size); iostream *tcp(void) {return ((iostream *)this);}; public: TCPStream(TCPSocket &server, int size = 512); TCPStream(const InetHostAddress &host, tpport_t port, int size = 512); TCPStream(const TCPStream &source); ~TCPStream() {endStream();}; int sync(void); bool isPending(sockpend_t pend, timeout_t timeout = TIMEOUT_INF); int getBufferSize(void) const {return bufsize;}; }; class tcpstream : public TCPStream { public: tcpstream(); tcpstream(const char *addr, int buffer = 512); tcpstream(TCPSocket &tcp, int buffer = 512); void open(const char *addr, int buffer = 512); void open(TCPSocket &tcp, int buffer = 512); void close(void); bool operator!() const; }; class TCPSession : public TCPStream, public Thread { protected: int WaitConnection(timeout_t timeout = TIMEOUT_INF); void Initial(void); void Final(void) {delete this;}; public: TCPSession(Semaphore *start, const InetHostAddress &host, tpport_t port, int size = 512, int pri = 0, int stack = 0); TCPSession(Semaphore *start, TCPSocket &server, int size = 512, int pri = 0, int stack = 0); }; extern __EXPORT ::ostream &operator<<(::ostream &os, const InetAddress &ia); inline struct in_addr getaddress(const InetAddress &ia) {return ia.getAddress();} #if defined(WIN32) class init_WSA { public: init_WSA(); private: WSADATA wsaData; }; #else // !WIN32 class SocketService; class SocketPort : public Socket, public TimerPort { private: SocketPort *next, *prev; SocketService *service; struct timeval porttimer; #ifdef __CCXX_USE_POLL struct pollfd * ufd; #endif bool detect_pending; bool detect_output; bool detect_disconnect; friend class SocketService; protected: SocketPort(SocketService *svc, TCPSocket &tcp); SocketPort(SocketService *svc, const InetAddress &ia, tpport_t port); void Attach( SocketService* svc ); virtual ~SocketPort(); void setDetectPending( bool ); bool getDetectPending( void ) const { return detect_pending; } void setDetectOutput( bool ); bool getDetectOutput( void ) const { return detect_output; } virtual void Expired(void) {return;}; virtual void Pending(void) {return;}; virtual void Output(void) {return;}; virtual void Disconnect(void) {return;}; sockerror_t Connect(const InetAddress &ia, tpport_t port); inline int Send(void *buf, int len) {return ::send(so, (char *)buf, len, 0);}; inline int Recv(void *buf, size_t len) {return ::recv(so, (char *)buf, len, 0);}; inline int Peek(void *buf, size_t len) {return ::recv(so, (char *)buf, len, MSG_PEEK);}; public: void setTimer(timeout_t timeout = 0); void incTimer(timeout_t timeout); }; class SocketService : public Thread, private Mutex { private: fd_set connect; int iosync[2]; int hiwater; int count; SocketPort *first, *last; void Attach(SocketPort *port); void Detach(SocketPort *port); void Run(void); friend class SocketPort; protected: virtual void OnUpdate(unsigned char buf) {return;}; virtual void OnEvent(void) {return;}; virtual void OnCallback(SocketPort *port) {return;}; public: void Update(unsigned char flag = 0xff); SocketService(int pri = 0); ~SocketService(); inline int getCount(void) const {return count;}; }; #ifdef __CCXX_NAMESPACE_H__ #undef __CCXX_NAMESPACE_H__ #include <cc++/namespace.h> #endif #endif // !WIN32 #endif