www.pudn.com > acdx.rar > Socket.h

#if !defined(Socket_H) 
#define Socket_H 
 
#include "Lock.h" 
#include "Thread.h" 
 
#include  
#include  
using namespace std; 
 
 
// define mapping of error methods 
#if defined( _WIN32 ) 
 
#if !defined(errno) 
#define errno	WSAGetLastError 
#endif 
 
#else 
 
// win32 define ioctl for driver control 
// so redefine ioctlsocket for normal bsd 
 
#define ioctlsocket ioctl 
 
#endif 
 
//////////////////////////////////////////////////////////////////////////////// 
// Socket 
// 
// Purpose: class for reading/writing a socket 
 
 
//##ModelId=424BB6420130 
class Socket : 
	private Lock 
{ 
protected: 
 
	//##ModelId=424BB6420142 
	SOCKET			_socket; 
	//##ModelId=424BB6420150 
	SOCKADDR_IN		_addrIn; 
	//##ModelId=424BB6420154 
	long			_port; 
public: 
 
 
	//##ModelId=424BB642015F 
	Socket () : 
		_socket(INVALID_SOCKET), 
		_port() 
	{} 
 
 
	//##ModelId=424BB6420160 
	Socket ( Socket & sock ) : 
		_socket(INVALID_SOCKET), 
		_port() 
	{ 
		create( sock._socket, (SOCKADDR &) sock._addrIn );	 
	} 
 
	//##ModelId=424BB642016F 
	virtual ~Socket () 
	{ 
		close(); 
	} 
 
	// create/release 
	//##ModelId=424BB6420171 
	bool create ( SOCKET & sock, SOCKADDR & addr ) 
	{ 
		if ( sock == INVALID_SOCKET ) 
			return false; 
 
		// get new socket 
		memcpy( &_addrIn, (SOCKADDR *) &addr, sizeof(addr) ); 
		memcpy( &_socket, &sock, sizeof(_socket) ); 
 
		return true; 
	} 
 
	//##ModelId=424BB642017E 
	void release () 
	{ 
		// close socket if open 
		if ( _socket != INVALID_SOCKET ) 
		{ 
			closesocket(_socket); 
			_socket = INVALID_SOCKET; 
		} 
	} 
 
	//##ModelId=424BB642017F 
	bool isValid () 
	{ 
		if ( _socket != INVALID_SOCKET ) 
			return true; 
		else 
			return false; 
	} 
 
	//##ModelId=424BB6420180 
	long getPort () 
	{ 
		return _port; 
	} 
 
	// open methods 
	//##ModelId=424BB642018E 
	static bool initSockAddrIn ( string & host, long port, SOCKADDR_IN & addrIn ) 
	{ 
		// init socket in struct 
		memset(&addrIn,0,sizeof(addrIn)); 
 
		// set family 
		addrIn.sin_family = AF_INET; 
 
 
		if ( !host.empty() ) 
		{ 
			// retrieve the host data corresponding to the host name 
			LPHOSTENT phost; 
			if ((phost = gethostbyname(host.c_str())) != NULL)  
			{ 
				// assign the socket IP address.  
				memcpy ( (char FAR *) &(addrIn.sin_addr),  
						  phost->h_addr,  
						  phost->h_length ); 
			} 
			else 
			{ 
				// get inet address 
				addrIn.sin_addr.s_addr = inet_addr(host.c_str()); 
			} 
		} 
		else 
		{ 
			// set inet address 
			addrIn.sin_addr.s_addr = htonl(INADDR_ANY); 
		} 
 
		// set port 
		addrIn.sin_port = htons(port); 
 
		return true; 
	} 
 
	//##ModelId=424BB642019E 
	bool open ( string host, long port ) 
	{ 
		// get socket 
		_socket = socket(PF_INET,SOCK_STREAM,0); 
 
		if ( _socket == INVALID_SOCKET ) 
			return false; 
 
		// init address in 
		_port = port; 
		initSockAddrIn( host, port, _addrIn ); 
 
		// connect to socket 
		if ( connect( _socket, (const SOCKADDR *) &_addrIn, sizeof(_addrIn) ) == SOCKET_ERROR ) 
		{ 
			int error = getLastError(); 
			return false; 
		} 
		 
		 
		return true; 
	} 
 
	// close 
	//##ModelId=424BB64201A1 
	void close () 
	{ 
		// close socket if open 
		if ( _socket != INVALID_SOCKET ) 
		{ 
			closesocket(_socket); 
			_socket = INVALID_SOCKET; 
		} 
	} 
 
	//##ModelId=424BB64201AD 
	static int getLastError () 
	{ 
		return WSAGetLastError(); 
	} 
 
	//##ModelId=424BB64201AF 
	static bool init () 
	{ 
		#if defined( _WIN32 ) 
 
		// init startup 
		WSADATA WSAData; 
		WSAStartup( MAKEWORD(2,0), &WSAData ); 
 
		#endif 
 
		return true; 
	} 
 
	//##ModelId=424BB64201B1 
	long getRecieveSize () 
	{ 
		// return not of bytes waiting 
		// if fail show none 
		long noBytes; 
		if ( ioControl(FIONREAD, (unsigned long *) &noBytes) ) 
			return noBytes; 
		else 
			return 0; 
	} 
 
	//##ModelId=424BB64201BD 
	bool setSocketNonBlocking () 
	{ 
		// set socket to non-blocking mode 
		// probably need to add more ioctl later 
		unsigned long ioctl_opt = -1; 
		return ioControl( FIONBIO, &ioctl_opt); 
 
		/* 
		unsigned long ioctl_opt = -1; 
		if ( ioctlsocket(_socket,FIONBIO,&ioctl_opt) == SOCKET_ERROR )  
		{ 
			fprintf(stderr,"ioctlsocket failed %d\n",getLastError()); 
			 
			return false; 
		} 
		else 
			return true; 
		*/ 
	} 
		 
 
 
	// recieve/send methods 
	//##ModelId=424BB64201BE 
	long send ( string & buffer ) 
	{ 
		return send( (LPTSTR) buffer.c_str(), buffer.size() ); 
	} 
 
	//##ModelId=424BB64201CC 
	long send ( LPCTSTR buffer, DWORD noToWrite ) 
	{ 
		return send( (LPTSTR) buffer, noToWrite ); 
	} 
 
	//##ModelId=424BB64201CF 
	long send ( LPTSTR pBuffer, DWORD noToWrite ) 
	{ 
		if ( !lock() ) 
			return 0; 
 
		// send to socket 
		int noWritten = 
		::send( _socket, pBuffer, noToWrite, 0 ); 
 
		unlock(); 
 
		// if error show none sent 
		if ( noWritten == SOCKET_ERROR ) 
			return 0; 
		else 
			return noWritten; 
	} 
 
	//##ModelId=424BB64201DE 
	long recieve ( LPTSTR pBuffer, DWORD noToRead ) 
	{ 
		if ( !lock() ) 
			return false; 
 
		// recieve from socket 
		int noRead = 
		recv( _socket, pBuffer, noToRead, 0 ); 
 
		// if no recieve error 
		if ( noRead == SOCKET_ERROR ) 
		{ 
			noRead = -1; 
		} 
		else 
		{ 
			// else terminate buffer 
			pBuffer[noRead] = '\0'; 
		} 
 
		unlock(); 
 
		return noRead; 
	} 
 
	//##ModelId=424BB64201ED 
	bool ioControl ( long cmd, u_long * argp ) 
	{ 
		// perfom action 
		long ret = 
		ioctlsocket(_socket,cmd,argp); 
 
		// if success show it 
		// else get error show failed 
		if ( ret == 0 ) 
			return true; 
		else 
		{ 
			// show error 
			fprintf(stderr,"ioctlsocket failed %d\n",getLastError()); 
 
			return false; 
		} 
 
	} 
 
 
	// operators 
	//##ModelId=424BB64201FB 
	operator SOCKET () 
	{ 
		return _socket; 
	} 
 
	//##ModelId=424BB64201FC 
	Socket &  operator << ( string & buffer ) 
	{ 
		send( (LPTSTR) buffer.c_str(), buffer.size() ); 
		return *this; 
	} 
 
	//##ModelId=424BB64201FE 
	Socket &  operator >> ( stringstream & strm ) 
	{ 
		send( (LPTSTR) strm.str().c_str(), strm.str().size() ); 
		return *this; 
	} 
 
	//##ModelId=424BB642020C 
	Socket &  operator << ( LPCTSTR buffer ) 
	{ 
		send( (LPTSTR) buffer, lstrlen(buffer) ); 
		return *this; 
	} 
 
	//##ModelId=424BB642020E 
	Socket &  operator << ( LPTSTR buffer ) 
	{ 
		send( buffer, lstrlen(buffer) ); 
		return *this; 
	} 
 
	// test if file open 
	//##ModelId=424BB642021B 
	bool isOpen () 
	{ 
		if ( _socket == INVALID_SOCKET ) 
			return false; 
		else 
			return true; 
	} 
}; 
 
 
 
 
 
#endif