mysocket.cpp

可以实现socket_t通信

#include <string>
#include <fcntl.h>
#include "mysocket.h"

MySocket::MySocket()
{
	address_family = AF_INET;
	socket_type = SOCK_STREAM;
	protocol_family = IPPROTO_TCP;
	port_number = MYSOCKET_DEFAULT_PORT;
	Mysocket = -1;
	conn_socket = -1;
	bytes_read = bytes_moved = 0;
	is_connected = 0;
	is_bound = 0;
	socket_error = MYSOCKET_NO_ERROR;
}

MySocket::MySocket(char af, int st, int pf, int port, char *hostname)
{
	Mysocket = -1;
	conn_socket = -1;
	bytes_read = bytes_moved = 0;
	is_connected = 0;
	is_bound = 0;
	socket_error = MYSOCKET_NO_ERROR;
	InitSocket(af, st, pf, port, hostname);
}

MySocket::MySocket(int st, int port, char *hostname)
{
	Mysocket = -1;
	conn_socket = -1;
	bytes_read = bytes_moved = 0;
	is_connected = 0;
	is_bound = 0;
	socket_error = MYSOCKET_NO_ERROR;
	InitSocket(st, port, hostname);
}

MySocket::~MySocket()
{
	Close();
}

int MySocket::Socket()
{
	Mysocket = socket(address_family, socket_type, protocol_family);
	if (Mysocket < 0)
	{
		socket_error = MYSOCKET_INIT_ERROR;
		return -1;
	}
	return Mysocket;
}

int MySocket::InitSocket(char af, int st, int pf, int port, char *hostname)
{
	address_family = af;
	socket_type = st;
	protocol_family = pf;
	port_number = port;
	sin.sin_family = address_family;

	if (hostname)
	{
		hostent *hostnm = gethostbyname(hostname);
		if (hostnm == (struct hostent *)0 )
		{
			socket_error = MYSOCKET_HOSTNAME_ERROR;
			return -1;
		}
		sin.sin_addr.s_addr = *((unsigned long*)hostnm -> h_addr);
	}
	else
	{
		sin.sin_addr.s_addr = INADDR_ANY;
	}

	sin.sin_port = htons(port_number);

	if (Socket() < 0)
	{
		socket_error = MYSOCKET_INIT_ERROR;
		return -1;
	}

	return Mysocket;
}

int MySocket::InitSocket(int st, int port, char *hostname)
{
	address_family = AF_INET;
	port_number = port;
	if(st == SOCK_STREAM)
	{
		socket_type = SOCK_STREAM;
		protocol_family = IPPROTO_TCP;
	}
	else if(st == SOCK_DGRAM)
	{
		socket_type = SOCK_DGRAM;
		protocol_family = IPPROTO_UDP;
	}
	else
	{
		socket_error = MYSOCKET_SOCKETTYPE_ERROR;
		return -1;
	}

	sin.sin_family = address_family;

	if(hostname)
	{
		hostent *hostnm = gethostbyname(hostname);
		if(hostnm == (struct hostent *)0 )
		{
			socket_error - MYSOCKET_HOSTNAME_ERROR;
			return -1;
		}

		sin.sin_addr.s_addr = *((unsigned long *)hostnm->h_addr);
	}
	else
		sin.sin_addr.s_addr = INADDR_ANY;

	sin.sin_port = htons(port_number);

	if(Socket()<0)
	{
		socket_error = MYSOCKET_INIT_ERROR;
		return -1;
	}

	return Mysocket;
}

int MySocket::Bind()
{
	int rv = bind(Mysocket, (struct sockaddr *)&sin, sizeof(sin));
	if(rv >= 0)
	{
		is_bound = 1;
	}
	else
	{
		socket_error = MYSOCKET_BIND_ERROR;
		is_bound = 0;
	}
	return rv;
}

int MySocket::Connect()
{
	int rv = connect(Mysocket, (struct sockaddr *)&sin, sizeof(sin));
	if(rv >= 0)
	{
		is_connected = 1;
	}
	else
	{
		socket_error = MYSOCKET_CONNECT_ERROR;
		is_connected = 0;
	}

	return rv;
}

int MySocket::ReadSelect(int s, int seconds, int useconds)
{
	struct timeval timeout;
	fd_set fds;
	FD_ZERO(&fds);
	FD_SET(s, &fds);

	timeout.tv_sec = seconds;
	timeout.tv_usec = useconds;

	return select(s+1, &fds, 0, 0, &timeout);
}

int MySocket::Recv(void *buf, int bytes, int flags)
{
	return Recv(Mysocket, buf, bytes, flags);
}

int MySocket::Recv(void *buf, int bytes, int seconds, int useconds, int flags)
{
	return Recv(Mysocket, buf, bytes, seconds, useconds, flags);
}

int MySocket::Send(const void *buf, int bytes, int flags)
{
	return Send(Mysocket, buf, bytes, flags);
}

int MySocket::Recv(int s, void *buf, int bytes, int flags)
{
	bytes_read = 0;
	int num_read = 0;
	int num_req = (int)bytes;
	char *p = (char *)buf;

	while(bytes_read < bytes)
	{
		if((num_read = recv(s, p, num_req-bytes_read, flags)) > 0)
		{
			bytes_read += num_read;
			p += num_read;
		}
		if(num_read < 0)
		{
			socket_error = MYSOCKET_RECEIVE_ERROR;
			return -1;
		}
	}

	return bytes_read;
}

int MySocket::Recv(int s, void *buf, int bytes, int seconds, int useconds, int flags)
{
	bytes_read = 0;
	int num_read = 0;
	int num_req = (int)bytes;
	char *p = (char *)buf;

	while(bytes_read < bytes)
	{
		if(!ReadSelect(s, seconds, useconds))
		{
			socket_error = MYSOCKET_REQUEST_TIMEOUT;
			return -1;
		}
		if((num_read = recv(s, p, num_req-bytes_read, flags)) > 0)
		{
			bytes_read += num_read;
			p += num_read;
		}
		if(num_read < 0)
		{
			socket_error = MYSOCKET_RECEIVE_ERROR;
			return -1;
		}
	}

	return bytes_read;
}

int MySocket::Send(int s, const void *buf, int bytes, int flags)
{
	bytes_moved = 0;
	int num_moved = 0;
	int num_req = (int)bytes;
	char *p = (char*)buf;

	while(bytes_moved < bytes)
	{
		if((num_moved = send(s, p, num_req-bytes_moved, flags)) > 0)
		{
			bytes_moved += num_moved;
			p += num_moved;
		}
		if(num_moved < 0)
		{
			socket_error = MYSOCKET_TRANSMIT_ERROR;
			return -1;
		}
	}
	return bytes_moved;
}

int MySocket::RemoteRecv(void *buf, int bytes, int seconds, int useconds, int flags)
{
	return Recv(conn_socket, buf, bytes, seconds, useconds, flags);
}

int MySocket::RemoteRecv(void* buf, int bytes, int flags)
{
	return Recv(conn_socket, buf, bytes, flags);
}

int MySocket::RemoteSend(const void *buf, int bytes, int flags)
{
	return Send(conn_socket, buf, bytes, flags);
}

void MySocket::ShutDown(int how)
{
	bytes_moved = 0;
	bytes_read = 0;
	is_connected = 0;
	is_bound = 0;

	if(Mysocket != -1) shutdown(Mysocket,how);
	if(conn_socket != -1) shutdown(conn_socket,how);

	Mysocket = -1;
	conn_socket = -1;
}

void MySocket::ShutDown(int &s, int how)
{
	if(s != -1) shutdown(s, how);
	s = -1;
}

void MySocket::ShutDownSocket(int how)
{
	if(Mysocket != -1) shutdown(Mysocket,how);
	Mysocket = -1;
}

void MySocket::ShutDownRemoteSocket(int how)
{
	if(conn_socket != -1) shutdown(conn_socket,how);
	conn_socket = -1;
}

void MySocket::Close()
{
	bytes_moved = 0;
	bytes_read = 0;
	is_connected = 0;
	is_bound = 0;

	if(Mysocket != -1) close(Mysocket);
	if(conn_socket != -1) close(conn_socket);
}

void MySocket::Close(int &s)
{
	if(s != -1) close(s);
	s = -1;
}

void MySocket::CloseSocket()
{
	if(Mysocket != -1) close(Mysocket);
	Mysocket = -1;
}

void MySocket::CloseRemoteSocket()
{
	if(conn_socket != -1) close(conn_socket);
	conn_socket = -1;
}

int MySocket::Listen(int max_connections)
{
	int rv = listen(Mysocket, max_connections);
	if(rv < 0)
	{
		socket_error = MYSOCKET_LISTEN_ERROR;
	}
	return rv;
}

int MySocket::Accept()
{
	socklen_t addr_size = (socklen_t)sizeof(remote_sin);
	conn_socket = accept(Mysocket, (struct sockaddr *)&remote_sin, &addr_size);

	if(conn_socket < 0)
	{
		socket_error = MYSOCKET_ACCEPT_ERROR;
		return -1;
	}
	return conn_socket;
}

int MySocket::GetSockName(int s, sockaddr_in *sa)
{
	socklen_t namelen = (socklen_t)sizeof(sockaddr_in);
	int rv = getsockname(s, (struct sockaddr *)sa, &namelen);
	if(rv < 0) socket_error = MYSOCKET_SOCKNAME_ERROR;
	return rv;
}

int MySocket::GetSockName()
{
	return GetSockName(Mysocket, &sin);
}

int MySocket::GetPeerName(int s, sockaddr_in *sa)
{
	socklen_t namelen = (socklen_t)sizeof(sockaddr_in);
	int rv = getpeername(s, (struct sockaddr *)&sa, &namelen);
	if(rv < 0) socket_error = MYSOCKET_PEERNAME_ERROR;
	return rv;
}

int MySocket::GetPeerName()
{
	return GetPeerName(conn_socket, &remote_sin);
}

int MySocket::GetSockOpt(int s, int level, int optName, void* optVal, unsigned int *optLen)
{
	int rv = getsockopt(s, level, optName, optVal, (socklen_t *)optLen);
	if(rv < 0)
	{
		socket_error = MYSOCKET_SETOPTION_ERROR;
	}
	return rv;
}

int MySocket::GetSockOpt(int level, int optName, void *optVal, unsigned int *optLen)
{
	return GetSockOpt(Mysocket, level, optName, optVal, optLen);
}

int MySocket::SetSockOpt(int s, int level, int optName, const void* optVal, unsigned int optLen)
{
	int rv = setsockopt(s, level, optName, optVal, (socklen_t)optLen);
	if(rv < 0) socket_error = MYSOCKET_SETOPTION_ERROR;
	return rv;
}

int MySocket::SetSockOpt(int level, int optName, const void* optVal, unsigned int optLen)
{
	return SetSockOpt(Mysocket, level, optName, optVal, optLen);
}

servent *MySocket::GetServiceInformation(char *name, char *protocol)
{
	servent *sp = getservbyname(name, protocol);
	if(sp == 0) return 0;

	servent *buf = new servent;
	if(!buf) return 0;
	memmove(buf, sp, sizeof(servent));
	return buf;
}

servent *MySocket::GetServiceInformation(int port, char *protocol)
{
	servent *sp = getservbyport(port, protocol);
	if(sp == 0) return 0;
	servent *buf = new servent;
	if(!buf) return 0;
	memmove(buf, sp, sizeof(servent));
	return buf;
}

int MySocket::GetServByName(char *name, char *protocol)
{
	servent *sp = getservbyname(name, protocol);
	if(sp == 0)
	{
		socket_error = MYSOCKET_PROTOCOL_ERROR;
		return -1;
	}
	sin.sin_port = sp->s_port;
	return 0;
}

int MySocket::GetServByPort(int port, char *protocol)
{
	servent *sp = getservbyport(port, protocol);
	if(sp == 0)
	{
		socket_error = MYSOCKET_PROTOCOL_ERROR;
		return -1;
	}
	sin.sin_port = sp->s_port;
	return 0;
}

int MySocket::GetPortNumber()
{
	return ntohs(sin.sin_port);
}

int MySocket::GetRemotePortNumber()
{
	return ntohs(remote_sin.sin_port);
}

char MySocket::GetAddressFamily()
{
	return sin.sin_family;
}

char MySocket::GetRemoteAddressFamily()
{
	return remote_sin.sin_family;
}

hostent *MySocket::GetHostInformation(char *hostname)
{
	in_addr hostia;
	hostent *hostinfo;
	hostia.s_addr = inet_addr(hostname);

	if(hostia.s_addr == 0)
	{
		hostinfo = gethostbyname(hostname);
	}
	else
	{
		hostinfo = gethostbyaddr((const char *)&hostia, sizeof(in_addr), AF_INET);
	}
	if(hostinfo == (hostent *)0)
	{
		return 0;
	}
	hostent *buf = new hostent;
	if(!buf) return 0;
	memmove(buf, hostinfo, sizeof(hostent));
	return buf;
}

int MySocket::GetHostName(char *sbuf)
{
	if(!sbuf) sbuf = new char[MYSMAX_NAME_LEN];
	int rv = gethostname(sbuf, MYSMAX_NAME_LEN);
	if(rv < 0) socket_error = MYSOCKET_HOSTNAME_ERROR;
	return rv;
}

int MySocket::GetIPAddress(char *sbuf)
{
	char hostname[MYSMAX_NAME_LEN];
	int rv = GetHostName(hostname);
	if(rv <0 )
	{
		return rv;
	}

	in_addr *ialist;
	hostent *hostinfo = GetHostInformation(hostname);
	if(!hostinfo)
	{
		socket_error = MYSOCKET_HOSTNAME_ERROR;
		return -1;
	}
	ialist = (in_addr *)hostinfo->h_addr_list[0];

	if(!sbuf)
	{
		sbuf = new char[MYSMAX_NAME_LEN];
	}
	
	strcpy(sbuf, inet_ntoa(*ialist));
	delete hostinfo;
	return 0;
}

int MySocket::GetDomainName(char *sbuf)
{
	char hostname[MYSMAX_NAME_LEN];
	int rv = GetHostName(hostname);
	if(rv < 0)
	{
		return rv;
	}

	hostent *hostinfo = GetHostInformation(hostname);
	if(!hostinfo)
	{
		socket_error = MYSOCKET_HOSTNAME_ERROR;
		return -1;
	}
	if(!sbuf) sbuf = new char[MYSMAX_NAME_LEN];
	strcpy(sbuf, hostinfo->h_name);

	int i;
	int len = strlen(sbuf);
	for(i = 0; i < len; i++)
	{
		if(sbuf[i] == '.') break;
	}

	if(++i < len)
	{
		len -= i;
		memmove(sbuf, sbuf+1, len);
		sbuf[len] = 0;
	}

	delete hostinfo;
	return 0;
}

int MySocket::GetBoundIPAddress(char *sbuf)
{
	char *s = inet_ntoa(sin.sin_addr);
	if(s == 0)
	{
		socket_error = MYSOCKET_HOSTNAME_ERROR;
		return -1;
	}

	if(!sbuf) sbuf = new char[MYSMAX_NAME_LEN];

	strcpy(sbuf,s);
	return 0;
}

int MySocket::GetRemoteHostName(char *sbuf)
{
	char *s = inet_ntoa(remote_sin.sin_addr);
	if(s ==0)
	{
		socket_error = MYSOCKET_HOSTNAME_ERROR;
		return -1;
	}

	if(!sbuf)
	{
		sbuf = new char[MYSMAX_NAME_LEN];
	}

	strcpy(sbuf, s);
	return 0;
}

void MySocket::GetClientInfo(char *client_name, int &r_port)
{
	int rv = GetRemoteHostName(client_name);
	if(rv < 0)
	{
		char *unc = "UNKNOWN";
		for(unsigned i = 0; i<MYSMAX_NAME_LEN; i++) client_name[i] = '\0';
		strcpy(client_name, unc);
	}
	r_port = GetRemotePortNumber();
}

int MySocket::RecvFrom(void *buf, int bytes, int seconds, int useconds, int flags)
{
	return RecvFrom(Mysocket, &remote_sin, buf, bytes, seconds, useconds, flags);
}

int MySocket::RecvFrom(void *buf, int bytes, int flags)
{
	return RecvFrom(Mysocket, &remote_sin, buf, bytes, flags);
}

int MySocket::SendTo(void *buf, int bytes, int flags)
{
	return SendTo(Mysocket, &sin, buf, bytes, flags);
}

int MySocket::RecvFrom(int s, sockaddr_in *sa, void *buf, int bytes, int seconds, int useconds, int flags)
{
	socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);
	bytes_read = 0;
	int num_read = 0;
	int num_req = (int)bytes;
	char *p = (char *)buf;

	while(bytes_read < bytes)
	{
		if(!ReadSelect(s, seconds, useconds))
		{
			socket_error = MYSOCKET_REQUEST_TIMEOUT;
			return -1;
		}
		if((num_read = recvfrom(s, p, num_req-bytes_read, flags, (struct sockaddr *)sa, &addr_size))> 0)
		{
			bytes_read += num_read;
			p += num_read;
		}
		if(num_read < 0)
		{
			socket_error = MYSOCKET_RECEIVE_ERROR;
			return -1;
		}
	}
	return bytes_read;
}

int MySocket::RecvFrom(int s, sockaddr_in *sa, void *buf, int bytes, int flags)
{
	socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);
	bytes_read = 0;
	int num_read = 0;
	int num_req = (int)bytes;
	char* p = (char *)buf;

	while(bytes_read < bytes)
	{
		if((num_read = recvfrom(s, p, num_req-bytes_read, flags, (struct sockaddr *)sa, &addr_size)) > 0)
		{
			bytes_read += num_read;
			p += num_read;
		}
		if(num_read < 0)
		{
			socket_error = MYSOCKET_RECEIVE_ERROR;
			return -1 ;
		}
	}
	return bytes_read;
}

int MySocket::SendTo(int s, sockaddr_in *sa, void *buf, int bytes, int flags)
{
	int addr_size = (int)sizeof(sockaddr_in);
	bytes_moved = 0;
	int num_moved = 0;
	int num_req = (int)bytes;
	char *p = (char *)buf;

	while(bytes_moved < bytes)
	{
		if((num_moved = sendto(s, p, num_req-bytes_moved, flags, (const struct sockaddr *)sa, addr_size)) > 0)
		{
			bytes_moved += num_moved;
			p += num_moved;
		}

		if(num_moved < 0)
		{
			socket_error = MYSOCKET_TRANSMIT_ERROR;
			return -1;
		}
	}
	return bytes_moved;
}