mysocket.cpp.txt

一个很好的socket多线程编程

#include <string.h>
#include <fcntl.h>
#include "mysocket.h"
MySocket::MySocket()
{
address_family =AF_INET;
socket_type = SOCK_STREAM;
protocol_family = IPOTO_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(sa_family_t af, int st,int pf,int port,char *hostname)
{
Mysocket = -1;
conn_socket = -1;
bytes_read= bytes_moved = 0;
is_connected = 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(sa_family_t 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_nymber = 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{
sock_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;
reuturn select(s+1,&fds,0,0,&timeout);
}

int MySocket::Recv(void *buf,it 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,byts,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,inf flags)
{
return Recv(conn_socket,buf,bytes,seconds,useconds,flags);
}

int MySocket::RemoteRecv(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(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()
{
int addr_size =(int )sizeof(remote_sin);
conn_socket = accept(Mysocket,(struct sockaddr * )&remote_sin,&addr_size);
if(conn_socket < 0)
{
socket_error = MySOCKET_ACCEPT_ERROR;
return -1;
}
retirm conn_socket;
}

int MySocket::GetSockName(int s,sockaddr_in *sa)
{
int namelen = (int )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 GetSocketName(Mysocket ,&sin);
}

int MySocket::GetPeerName(int s,sockaddr_in *sa)
{
int namelen = (int)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 *optLen)
{
int rv = getsockopt(s,leveloptName,optVal,(int *)optLen);
if(rv < 0) socket_error = MySOCKET_SETOPTION_ERROR;
return rv;
}

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

int MySocket::SetSocketOpt(int s,int level,int optName,const void *optVal,unsigned optLen)
{
int rv = setsocketopt(s,level,optName,optVal,(int )optLen);
if(rv < 0) socket_error = MySOCKET_SETOPTION_ERROR;
return rv;
}

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


}

servent *MySocket::GetServiceInfomation(char * name,char * protocol)
{
servent * sp = getservbyname(name,protocol);
if(sp == 0) return 0;
servent *buf = new servent;
if(!buf) return 0;
memove(buf,sp,sizeof(servent));
return buf;
}

servent *MySocket::GetServiceInfomation(int port,char *protocol)
{

servent *sp = getservbyport(port,protocol);
if(sp == 0) return 0;
servent *buf = new servent;
if(! buf) retjrn 0;
memmove(buf,sp,sizeof(sevent));
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);
}

sa_family_t MySocket::GetAddressFamily()
{
return sin.sin_family;

}

sa_family_t 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 == NULL)
{
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;
memove(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 *ostinfo = GetHostInfomation(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] == '.') bread;
}
if(++i < len)
{
len -= i;
memove(sbuf,sbuf+i,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 = newchar(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 = "UNKOWN";
for (unsigned i = 0;i<MysMAX_NAME_LEN;I++)
client_name[i] = '\0';
strcpy(client_name,unc);

}
r_port = GetRemotePortNumber();
}

int MySocket::RecFrom(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)
{
int addr_size = (int 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= MysSOCKET_REQUEST_TIMEROUT;
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)
{
int addr_size = (int )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)
{
socker_error = MysSOCKET_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 bum_moved = 0;
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;
}