C++的tcp和udp例子类 2011

const unsigned int MySOCKET_DEFAULT_PORT= 4096;

mylinuxsocket::mylinuxsocket()

{

m_bstate_connect = false;

address_family=AF_INET;

socket_type=SOCK_STREAM;

protocol_family=IPPROTO_TCP;

port_number = MySOCKET_DEFAULT_PORT;

mysocket = -1;

socket_error = MySOCKET_NO_ERROR;

bytes_send = 0;

bytes_read = 0;
}

//构造函数：指定端口，套接字类型，端口名,创建套接字

mylinuxsocket::mylinuxsocket(int port, int stype, char* strhostname)

{

bytes_send = 0;

bytes_read = 0;

m_bstate_connect = false;

socket_error=MySOCKET_NO_ERROR;

address_family=AF_INET;

port_number=port;

if (stype == 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;

}
sockaddr_sin.sin_family=address_family;
if (strhostname)

{

hostent *hostentnm = gethostbyname(strhostname);

if (hostentnm==(struct hostent *)0){

socket_error=MySOCKET_HOSTNAME_ERROR;

return -1;

}

sockaddr_sin.sin_addr.s_addr=*((unsigned long*) hostentnm->h_addr);

else

sockaddr_sin.sin_addr.s_addr=INADDR_ANY;
sockaddr_sin.sin_port=htons(port_number);

mysocket=socket(address_family, socket_type, protocol_family);

}

//构造函数：指定协议家族， 地址家族，端口，套接字类型，端口名，创建套接字

mylinuxsocket::mylinuxsocket(sa_family_t af,int stype,int pro_family,

int port,char *strhostname)

{

bytes_send = 0;

bytes_read = 0;

address_family = af;

socket_type = stype;

protocol_family = pro_family;

port_number = port;

sockaddr_sin.sin_family = address_family;

socket_error = MySOCKET_NO_ERROR;

m_bstate_connect = false;

if (strhostname) {

struct hostent *hostentnm = gethostbyname(strhostname);

if(hostentnm==(struct hostent *) 0) {

socket_error=MySOCKET_HOSTNAME_ERROR;

return -1;

}

sockaddr_sin.sin_addr.s_addr=*((unsigned long*) hostnm->h_addr);
}

else

sockaddr_sin.sin_addr.s_addr=INADDR_ANY;

sockaddr_sin.sin_port=htons(port_number);
Mysocket=socket(address_family, socket_type, protocol_family);
}
//创建初始化套接字函数，创建套接字

int mylinuxsocket::socket_create(void)

{

mysocket = =socket(address_family, socket_type, protocol_family);

if (mysocket<0)

{

socket_error=MySOCKET_INIT_ERROR;

return -1;

}

return mysocket;

}
//服务端套接字绑定监听函数， 返回值 -1：失败 0：成功

unsigned long mylinuxsocket::bindserver_listen(int maxconn_num)

{

if(bind(mysocket,(struct sockaddr*)&sockaddr_sin, sizeof(struct sockaddr*)) == -1)

{

socket_error=MySOCKET_BIND_ERROR;

return -1;

}

if(listen(Mysocket,maxconn_num) == -1)

{

socket_error=MySOCKET_LISTEN_ERROR;

return -1;

}

return 0;
}
//客户端套接字连接函数

unsigned int mylinuxsocket::sock_connect()

{

if(connect(mysocket,(struct sockaddr*)&sin,sizeof(sin)) == -1)

{

socket_error=MySOCKET_CONNECT_ERROR;

m_bstate_connect = false;

return -1;

}

else

{

m_bstate_connect = true;

return 1;

}
}
//服务端接受函数

unsigned int mylinuxsocket::sock_accept()

{

socklen_t addr_size = (socklen_t)sizeof(remote_addrsin);

conn_socket = accept(mysocket,(struct sockaddr*)&remote_addrsin , &addr_size);

if(conn_socket < 0)

{

socket_error = MySOCKET_ACCEPT_ERROR;

return -1;

}

return conn_socket;

}
//服务端轮询监听接收操作

int mylinuxsocket::Read_Select(int maxsock,int seconds,int useconds)

{

struct timeval timeout;

fd_set readfds;

FD_ZERO(&readfds);

FD_SET(maxsock, &readfds);

timeout.tv_sec = seconds;

timeout.tv_usec = useconds;

return select(maxsock+1, &readfds, 0 ,0, &timeout);

}
//TCP客户端接收函数

int mylinuxsocket::client_recv(void *buf, int bytes, int flags)

{

bytes_read = 0;

int num_reads = 0;

int num_requestrecv = bytes; //需要接收的字节数

char *preceivebuffer = (char*)buf;

//循环接收需要接收的字节数

while(bytes_read < bytes){

if((num_reads = recv(mysocket, preceivebuffer, num_requestrecv - bytes_read, flags))>0)

{

bytes_read += num_read;

preceivebuffer += num_read;

}

if (num_read<0){

socket_error=MySOCKET_RECEIVE_ERROR;

return -1;

}

}

return bytes_read;
}
//TCP服务端接收函数

int mylinuxsocket::server_recv(int socket, void *buf, int bytes,int seconds,int useconds,int flags)

{

bytes_read=0;

int num_read = 0;

int num_requestrecv = (int)bytes;

char*preceivebuffer = (char*)buf;

while(bytes_read < bytes)

{

if(!ReadSelect(socket, seconds,useconds)){

socket_error=MySOCKET_REQUEST_TIMEOUT;

return -1;

}

if((num_read = recv(socket, p, num_requestrecv - bytes_read, flags))>0){

bytes_read += num_read;

preceivebuffer += num_read;

}

if(num_read < 0){

socket_error = MySOCKET_RECEIVE_ERROR;

return -1;

}

}

return bytes_read;

}
//TCP发送函数

int mylinuxsocket::sock_send(int soket,const void *buf,int bytes,int flags)

{

bytes_send = 0;
int num_sends = 0;

int num_requestsend = (int)bytes;

char *psendbuffer = (char*)buf;

while(bytes_send < num_requestsend)

{

if((num_sends = send(soket, psendbuffer, num_requestsend - bytes_send, flags))>0)

{

bytes_send += num_sends;

psendbuffer += num_sends;

}

if(num_sends<0){

socket_error=MySOCKET_TRANSMIT_ERROR;

return -1;

}

}

return bytes_send;

}
//服务端UDP接收函数

int mylinuxsocket::udprecvfrom(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 *preceivebuffer = (char *)buf;
while(bytes_read < bytes) {

if(!ReadSelect(mysocket, seconds, useconds)) {

socket_error = MySOCKET_REQUEST_TIMEOUT;

return -1;

}

if((num_read = recvfrom(mysocket, preceivebuffer, num_req - bytes_read, flags

, (struct sockaddr *)remote_addrsin, &addr_size)) > 0) {

bytes_read += num_read;

preceivebuffer += num_read;

}

if(num_read < 0) {

socket_error = MySOCKET_RECEIVE_ERROR;

return -1;

}

}

return bytes_read;
}
//客户端UDP接收函数

int mylinuxsocket::udprecvfrom(void *buf, int bytes, int flags)

{
socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);

int num_read = 0;

int num_req = (int)bytes;

char *preceivebuffer = (char *)buf;

while(bytes_read < bytes)

{

if((num_read = recvfrom(mysocket, preceivebuffer, num_req - bytes_read

, flags, (struct sockaddr *)sockaddr_sin, &addr_size)) > 0)

{

bytes_read += num_read;

p += num_read;

}

if(num_read < 0)

{

socket_error = MySOCKET_RECEIVE_ERROR;

return -1;

}

}

return bytes_read;
}
//udp发送函数

int mylinuxsocket::udpSendTo(void *buf, int bytes, int flags)

{
int addr_size = (int)sizeof(sockaddr_in);

bytes_send = 0;

int num_moved = 0;

int num_req = (int)bytes;

char *pSendbuffer = (char *)buf;

while(bytes_moved < bytes)

{

if((num_moved = sendto(mysocket, pSendbuffer, num_req-bytes_moved, flags

, (const struct sockaddr *)sockaddr_sin, addr_size)) > 0)

{

bytes_send += num_moved;

pSendbuffer += num_moved;

}

if(num_moved < 0)

{

socket_error = MySOCKET_TRANSMIT_ERROR;

return -1;

}
}

return bytes_send;

}

enum MySocketError{

MySOCKET_NO_ERROR=0,

MySOCKET_INVALID_ERROR_CODE,

MySOCKET_ACCEPT_ERROR,

MySOCKET_BIND_ERROR,

MySOCKET_BUFOVER_ERROR,

MySOCKET_CONNECT_ERROR,

MySOCKET_FILESYSTEM_ERROR,

MySOCKET_GETOPTION_ERROR,

MySOCKET_HOSTNAME_ERROR,

MySOCKET_INIT_ERROR,

MySOCKET_LISTEN_ERROR,

MySOCKET_PEERNAME_ERROR,

MySOCKET_PROTOCOL_ERROR,

MySOCKET_RECEIVE_ERROR,

MySOCKET_REQUEST_TIMEOUT,

MySOCKET_SERVICE_ERROR,

MySOCKET_SETOPTION_ERROR,

MySOCKET_SOCKNAME_ERROR,

MySOCKET_SOCKETTYPE_ERROR,

MySOCKET_TRANSMIT_ERROR,

};
#include"mysocket.h"

#include <unistd.h>

#include <sys/types.h>

#include <arpa/inet.h>

#include <netinet/in.h>

#include <sys/socket.h>

#include <sys/time.h>

#include <string.h>

#include <fcntl.h>

#include <netdb.h>
class mylinuxsocket

{

protected:

sa_family_t address_family;

int socket_type;

int port_number;

int protocol_family;

sockaddr_in remote_addrsin;
sockaddr_in sockaddr_sin;

MySocketError socket_error;

int mysocket;

public:

mylinuxsocket();

virtual ~mylinuxsocket();

mylinuxsocket(int port, int stype, char* strhostname);

mylinuxsocket(sa_family_t af,int stype,int pro_family,

int port,char *strhostname);
int socket_create(void);
unsigned long bindserver_listen(int maxconn_num);
unsigned int sock_connect()；

unsigned int sock_accept();

int Read_Select(int maxsock,int seconds,int useconds);

int client_recv(void *buf, int bytes, int flags);

int server_recv(int socket,void *pbuf,int bytes, int seconds,int useconds,int flags);

int sock_send(int soket,const void *buf,int bytes,int flags);

int udprecvfrom(void *buf, int bytes, int seconds, int useconds,int flags);

int udprecvfrom(void *buf, int bytes, int flags);

int udpSendTo(void *buf, int bytes, int flags);

private:

bool m_bstate_connect;

int conn_socket;

int bytes_read;

int bytes_send;

}