C/C++封装socket通信类
不管是socket通信程序的客户端还是服务端，准备工作的代码又长又难看占地方，影响了主程序的结构，必须分离出来。
一、读取、写入数据
1、recvn函数
//从已经准备好的socket中读取数据。
//sockfd：已经准备好的socket连接。
//buffer：接收数据缓冲区的地址。
//n：本次接收数据的字节数。
//返回值：成功接收到n字节的数据后返回true，socket连接不可用返回false。
bool recvn(const int sockfd, char *buffer, const size_t n) {
int remain, len, idx;
remain = n;
idx = 0;
while (remain > 0) {
if ((len = recv(sockfd, buffer + idx, remain,0)) <= 0)
return false;
idx += len;
remain -= len;
}
return true;
}
2、sendn函数
//向已经准备好的socket中写入数据。
//sockfd：已经准备好的socket连接。
//buffer：待发送数据缓冲区的地址。
//n：待发送数据的字节数，缺省值是0时默认为buffer的大小。
//返回值：成功发送完n字节的数据后返回true，socket连接不可用返回false。
bool sendn(const int sockfd, const char *buffer, const size_t n = 0) {
int remain, len, idx;
remain = (n == 0) ? strlen(buffer) : n;
idx = 0;
while (remain > 0) {
if ((len = send(sockfd,buffer + idx, remain,0)) <= 0)
return false;
idx += len;
remain -= len;
}
return true;
}
3、TcpRecv函数
//接收socket的对端发送过来的数据。
//sockfd：可用的socket连接。
//buffer：接收数据缓冲区的地址。
//ibuflen：本次成功接收数据的字节数。解决TCP网络传输「粘包」
//itimeout：接收等待超时的时间，单位：秒，缺省值是0-无限等待。
//返回值：true-成功；false-失败，失败有两种情况：1）等待超时；2）socket连接已不可用。
bool TcpRecv(const int sockfd,char *buffer,int *ibuflen,const int itimeout = 0) {
if (sockfd == -1) return false;
if (itimeout > 0) {
//延时操作
fd_set tmpfd;
FD_ZERO(&tmpfd);
FD_SET(sockfd,&tmpfd);
struct timeval timeout;
timeout.tv_sec = itimeout;
timeout.tv_usec = 0;
//如果在itimeout时间内没有可用资源的文件描述符的话就退出
if (select(sockfd+1,&tmpfd,0,0,&timeout) <= 0) return false;
}
//数据包 = 数据大小 + 数据
(*ibuflen) = 0;
if(!recvn(sockfd,(char*)ibuflen,4)) return false;
(*ibuflen)=ntohl(*ibuflen); //把网络字节序转换为主机字节序。
return recvn(sockfd, buffer, *ibuflen);
}
4、TcpSend函数
//向socket的对端发送数据。
//sockfd：可用的socket连接。
//buffer：待发送数据缓冲区的地址。
//ibuflen：待发送数据的字节数，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
//itimeout：接收等待超时的时间，单位：秒，值是0-无限等待。
//返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
bool TcpSend(const int sockfd,const char *buffer,const int ibuflen = 0,const int itimeout = 5) {
if (sockfd == -1 ) return false;
if (itimeout > 0) {
//延时操作
fd_set tmpfd;
FD_ZERO(&tmpfd);
FD_SET(sockfd,&tmpfd);
struct timeval timeout;
timeout.tv_sec = itimeout;
timeout.tv_usec = 0;
//如果在itimeout时间内没有可用资源的文件描述符的话就退出
if (select(sockfd+1,&tmpfd,0,0,&timeout) <= 0) return false;
}
//如果长度为0，就采用字符串的长度
int ilen = (ibuflen == 0) ? strlen(buffer) : ibuflen;
int ilenn=htonl(ilen); //转换为网络字节序
//数据包 = 数据大小 + 数据
char strTBuffer[ilen+4]; //前面保存长度
memset (strTBuffer,0,sizeof(strTBuffer));
memcpy (strTBuffer, &ilenn, 4);
memcpy (strTBuffer+4, buffer, ilen);
return sendn(sockfd,strTBuffer, ilen+4);
}
二、C的封装方法
C语言只能把程序代码封装成函数。
1、客户端
把客户端连接服务端的socket操作封装到connecttoserver函数中，主程序的代码更简洁。
// TCP客户端连服务端的函数，serverip-服务端ip，port通信端口
// 返回值：成功返回已连接socket，失败返回-1。
int connecttoserver(const char *serverip,const int port) {
int sockfd = socket(AF_INET,SOCK_STREAM,0); // 创建客户端的socket
struct hostent* h; // ip地址信息的数据结构
if ( (h = gethostbyname(serverip)) == 0 ) {
perror("gethostbyname");
close(sockfd);
return -1;
}
// 把服务器的地址和端口转换为数据结构
struct sockaddr_in servaddr;
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(port);
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
// 向服务器发起连接请求
if (connect(sockfd, (struct sockaddr *)&servaddr,sizeof(servaddr)) != 0) {
perror("connect");
close(sockfd);
return -1;
}
return sockfd;
}
2、服务端
把服务端初始化socket操作封装到initserver函数中，主程序的代码更简洁。
// 初始化服务端的socket，port为通信端口
// 返回值：成功返回初始化的socket，失败返回-1。
int initserver(int port) {
int listenfd = socket(AF_INET,SOCK_STREAM,0); // 创建服务端的socket
//设置SO_REUSEADDR选项，解决关闭程序端口还在占用，再运行socket bind不成功的问题
int opt = 1;
unsigned int len = sizeof(opt);
setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,len);
// 把服务端用于通信的地址和端口绑定到socket上
struct sockaddr_in servaddr; // 服务端地址信息的数据结构
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET; // 协议族，在socket编程中只能是AF_INET
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 本主机的任意ip地址
servaddr.sin_port = htons(port); // 绑定通信端口
if (bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 ) {
perror("bind");
close(listenfd);
return -1;
}
// 把socket设置为监听模式
if (listen(listenfd,5) != 0 ) {
perror("listen");
close(listenfd);
return -1;
}
return listenfd;
}
三、C++的封装方法
C++语言可以封装数据和函数，采用的是类。
1、客户端
// socket通信的客户端类
class CTcpClient {
public:
int m_sockfd; // 客户端的socket.
char m_ip[21]; // 服务端的ip地址。
int m_port; // 与服务端通信的端口。
bool m_btimeout; // 调用Recv和Send方法时，失败的原因是否是超时：true-超时，false-未超时。
int m_buflen; // 调用Recv方法后，接收到的报文的大小，单位：字节。
CTcpClient(); // 构造函数。
// 向服务端发起连接请求。
// ip：服务端的ip地址。
// port：服务端监听的端口。
// 返回值：true-成功；false-失败。
bool ConnectToServer(const char *ip,const int port);
// 接收服务端发送过来的数据。
// buffer：接收数据缓冲区的地址，数据的长度存放在m_buflen成员变量中。
// itimeout：等待数据的超时时间，单位：秒，缺省值是0-无限等待。
// 返回值：true-成功；false-失败，失败有两种情况：1）等待超时，成员变量m_btimeout的值被设置为true；2）socket连接已不可用。
bool Recv(char *buffer,const int itimeout=0);
// 向服务端发送数据。
// buffer：待发送数据缓冲区的地址。
// ibuflen：待发送数据的大小，单位：字节，缺省值为0，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
//itimeout：接收等待超时的时间，单位：秒，值是0-无限等待。
// 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
bool Send(const char *buffer,const int ibuflen=0,const int itimeout=5);
// 断开与服务端的连接
void Close();
~CTcpClient(); // 析构函数自动关闭socket，释放资源。
};
CTcpClient::CTcpClient() {
m_sockfd=-1;
memset(m_ip,0,sizeof(m_ip));
m_port=0;
m_btimeout=false;
}
bool CTcpClient::ConnectToServer(const char *ip,const int port) {
if (m_sockfd != -1) {
close(m_sockfd);
m_sockfd = -1;
}
strcpy(m_ip,ip);
m_port=port;
struct hostent* h;
struct sockaddr_in servaddr;
if ( (m_sockfd = socket(AF_INET,SOCK_STREAM,0) ) < 0) return false;
if ( !(h = gethostbyname(m_ip)) ) {
close(m_sockfd);
m_sockfd = -1;
return false;
}
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(m_port); // 指定服务端的通讯端口
memcpy(&servaddr.sin_addr,h->h_addr,h->h_length);
if (connect(m_sockfd, (struct sockaddr *)&servaddr,sizeof(servaddr)) != 0) {
close(m_sockfd);
m_sockfd = -1;
return false;
}
return true;
}
bool CTcpClient::Recv(char *buffer,const int itimeout) {
if (m_sockfd == -1) return false;
if (itimeout>0) {
fd_set tmpfd;
FD_ZERO(&tmpfd);
FD_SET(m_sockfd,&tmpfd);
struct timeval timeout;
timeout.tv_sec = itimeout;
timeout.tv_usec = 0;
m_btimeout = false;
int i;
if ( (i = select(m_sockfd+1,&tmpfd,0,0,&timeout)) <= 0 ) {
if (i==0) m_btimeout = true;
return false;
}
}
m_buflen = 0;
return (TcpRecv(m_sockfd,buffer,&m_buflen));
}
bool CTcpClient::Send(const char *buffer,const int ibuflen,const int itimeout) {
if (m_sockfd == -1) return false;
if (itimeout>0) {
fd_set tmpfd;
FD_ZERO(&tmpfd);
FD_SET(m_sockfd,&tmpfd);
struct timeval timeout;
timeout.tv_sec = itimeout;
timeout.tv_usec = 0;
m_btimeout = false;
int i;
if ( (i = select(m_sockfd+1,&tmpfd,0,0,&timeout)) <= 0 ) {
if (i==0) m_btimeout = true;
return false;
}
}
int ilen=ibuflen;
if (ibuflen==0) ilen=strlen(buffer);
return(TcpSend(m_sockfd,buffer,ilen));
}
void CTcpClient::Close() {
if (m_sockfd > 0) close(m_sockfd);
m_sockfd=-1;
memset(m_ip,0,sizeof(m_ip));
m_port=0;
m_btimeout=false;
}
CTcpClient::~CTcpClient() {
Close();
}
2、服务端
// socket通信的服务端类
class CTcpServer {
private:
int m_socklen; // 结构体struct sockaddr_in的大小。
struct sockaddr_in m_clientaddr; // 客户端的地址信息。
struct sockaddr_in m_servaddr; // 服务端的地址信息。
public:
int m_listenfd; // 服务端用于监听的socket。
int m_connfd; // 客户端连接上来的socket。
bool m_btimeout; // 调用Recv和Send方法时，失败的原因是否是超时：true-超时，false-未超时。
int m_buflen; // 调用Recv方法后，接收到的报文的大小，单位：字节。
CTcpServer(); // 构造函数。
// 服务端初始化。
// port：指定服务端用于监听的端口。
// 返回值：true-成功；false-失败，一般情况下，只要port设置正确，没有被占用，初始化都会成功。
bool InitServer(const unsigned int port);
// 阻塞等待客户端的连接请求。
// 返回值：true-有新的客户端已连接上来，false-失败，Accept被中断，如果Accept失败，可以重新Accept。
bool Accept();
// 获取客户端的ip地址。
// 返回值：客户端的ip地址，如"192.168.1.100"。
char *GetIP();
// 接收客户端发送过来的数据。
// buffer：接收数据缓冲区的地址，数据的长度存放在m_buflen成员变量中。
// itimeout：等待数据的超时时间，单位：秒，缺省值是0-无限等待。
// 返回值：true-成功；false-失败，失败有两种情况：1）等待超时，成员变量m_btimeout的值被设置为true；2）socket连接已不可用。
bool Recv(char *buffer,const int itimeout=0);
// 向客户端发送数据。
// buffer：待发送数据缓冲区的地址。
// ibuflen：待发送数据的大小，单位：字节，缺省值为0，如果发送的是ascii字符串，ibuflen取0，如果是二进制流数据，ibuflen为二进制数据块的大小。
//itimeout：接收等待超时的时间，单位：秒，值是0-无限等待。
// 返回值：true-成功；false-失败，如果失败，表示socket连接已不可用。
bool Send(const char *buffer,const int ibuflen=0,const int itimeout=5);
// 关闭监听的socket，即m_listenfd，常用于多进程服务程序的子进程代码中。
void CloseListen();
// 关闭客户端的socket，即m_connfd，常用于多进程服务程序的父进程代码中。
void CloseClient();
~CTcpServer(); // 析构函数自动关闭socket，释放资源。
};
CTcpServer::CTcpServer() {
m_listenfd=-1;
m_connfd=-1;
m_socklen=0;
m_btimeout=false;
}
bool CTcpServer::InitServer(const unsigned int port) {
CloseListen();
if ( (m_listenfd = socket(AF_INET,SOCK_STREAM,0))<=0) return false;
//设置SO_REUSEADDR选项，解决关闭程序端口还在占用，再运行socket bind不成功的问题
// WINDOWS平台如下
//char b_opt='1';
//setsockopt(m_listenfd,SOL_SOCKET,SO_REUSEADDR,&b_opt,sizeof(b_opt));
// Linux如下
int opt = 1;
unsigned int len = sizeof(opt);
setsockopt(m_listenfd,SOL_SOCKET,SO_REUSEADDR,&opt,len);
memset(&m_servaddr,0,sizeof(m_servaddr));
m_servaddr.sin_family = AF_INET;
m_servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
m_servaddr.sin_port = htons(port);
if (bind(m_listenfd,(struct sockaddr *)&m_servaddr,sizeof(m_servaddr)) != 0 ) {
CloseListen();
return false;
}
if (listen(m_listenfd,5) != 0 ) {
CloseListen();
return false;
}
m_socklen = sizeof(struct sockaddr_in);
return true;
}
bool CTcpServer::Accept() {
if (m_listenfd == -1) return false;
if ((m_connfd=accept(m_listenfd,(struct sockaddr *)&m_clientaddr,(socklen_t*)&m_socklen)) < 0)
return false;
return true;
}
char *CTcpServer::GetIP() {
return(inet_ntoa(m_clientaddr.sin_addr));
}
bool CTcpServer::Recv(char *buffer,const int itimeout) {
if (m_connfd == -1) return false;
if (itimeout>0) {
fd_set tmpfd;
FD_ZERO(&tmpfd);
FD_SET(m_connfd,&tmpfd);
struct timeval timeout;
timeout.tv_sec = itimeout;
timeout.tv_usec = 0;
m_btimeout = false;
int i;
if ( (i = select(m_connfd+1,&tmpfd,0,0,&timeout)) <= 0 ) {
if (i==0) m_btimeout = true;
return false;
}
}
m_buflen = 0;
return(TcpRecv(m_connfd,buffer,&m_buflen));
}
bool CTcpServer::Send(const char *buffer,const int ibuflen,const int itimeout) {
if (m_connfd == -1) return false;
if (itimeout>0) {
fd_set tmpfd;
FD_ZERO(&tmpfd);
FD_SET(m_connfd,&tmpfd);
struct timeval timeout;
timeout.tv_sec = itimeout;
timeout.tv_usec = 0;
m_btimeout = false;
int i;
if ( (i = select(m_connfd+1,&tmpfd,0,0,&timeout)) <= 0 ) {
if (i==0) m_btimeout = true;
return false;
}
}
int ilen = ibuflen;
if (ilen==0) ilen=strlen(buffer);
return(TcpSend(m_connfd,buffer,ilen));
}
void CTcpServer::CloseListen() {
if (m_listenfd > 0) {
close(m_listenfd);
m_listenfd=-1;
}
}
void CTcpServer::CloseClient() {
if (m_connfd > 0) {
close(m_connfd);
m_connfd=-1;
}
}
CTcpServer::~CTcpServer() {
CloseListen();
CloseClient();
}