封装socket整理

不管是socket通信程序的客户端还是服务端，准备工作的代码较长，影响了主程序的简洁性，不过可以分离出来，追求简单实用。

 用c语言封装

C语言只能把程序封装成函数。

测试：客户端

int connectclient(const char *severip,const int port);
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
int main()
{
    int sockfd;
    sockfd=connectclient("47.100.224.30",5001);
   if(sockfd<=0)
   {
     printf("连接失败i\n");  return -1;}

         char buffer[1024];

          while(1)
         {
          int iret;
          memset(buffer,0,sizeof(buffer));
          printf("请输入您要发送的信息：\n");
          scanf("%s",buffer);
         if ( (iret=send(sockfd,buffer,strlen(buffer),0))<=0)
          { perror("send"); break; }

         printf("iret=%d,发送成功：%s\n",iret,buffer);
         memset(buffer,0,sizeof(buffer));
         if ( (iret=recv(sockfd,buffer,sizeof(buffer),0))<=0)
                {
        printf("iret=%d\n",iret); break;
             }
        printf("iret=%d,接收成功：%s\n",iret,buffer);
              }

        close(sockfd);
    return 0;
          }
int connectclient(const char *severip,const int port)
{
         int sockfd= socket(AF_INET,SOCK_STREAM,0);

         struct hostent* h;
         if ( (h = gethostbyname(severip)) == 0 )
          { printf("gethostbyname failed.\n"); 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;
}

 

服务端封装：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
int connectclient(int port);
int main()
{
   // 第1步：创建服务端的socket。
  int listenfd=connectclient(5001);
       int  clientfd;                 // 客户端的socket。
       int  socklen=sizeof(struct sockaddr_in); // struct sockaddr_in的大小
       struct sockaddr_in clientaddr;    // 客户端的地址信息。
       clientfd=accept(listenfd,(struct sockaddr *)&clientaddr,(socklen_t*)&socklen);
       printf("客户端（%s）已连接。\n",inet_ntoa(clientaddr.sin_addr));

     // 第5步：与客户端通信，接收客户端发过来的报文后，回复ok。
         char buffer[1024];
          while (1)
           {
            int iret;
           memset(buffer,0,sizeof(buffer));
           if ( (iret=recv(clientfd,buffer,sizeof(buffer),0))<=0) // 接收客户端的请求报文。
                {
         printf("iret=%d\n",iret); break;
              }
         printf("ret=%d,接收成功：%s\n",iret,buffer);
              if(strcmp(buffer,"bye")==0)  break;
            memset(buffer,0,sizeof(buffer));
          printf("请输入您要发送的内容：");
          scanf("%s",buffer);
         if ( (iret=send(clientfd,buffer,strlen(buffer),0))<=0) // 向客户端发送响应结果。
             { perror("send"); break; }
             printf("iret=%d,发送成功：%s\n",iret,buffer);

           }
                 close(listenfd); close(clientfd);
             }
int connectclient(int port)
{
    int listenfd;
  if ( (listenfd = socket(AF_INET,SOCK_STREAM,0))==-1) { perror("socket"); return -1; }
  // 第2步：把服务端用于通信的地址和端口绑定到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_addr.s_addr = inet_addr("172.19.8.95");   //指定ip地址。
  servaddr.sin_port = htons(port);    //指定通信端口
  if (bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
  { perror("bind"); close(listenfd); return -1; }
         // 第3步：把socket设置为监听模式。
   if (listen(listenfd,5) != 0 ) { perror("listen"); close(listenfd); return -1; }


       return listenfd;
}

经过测试，交互成功。

用C++封装

客户端：  

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
// TCP客户端类
class CTcpClient
{
public:
  int m_sockfd;
 
  CTcpClient();
 
  // 向服务器发起连接，serverip-服务端ip，port通信端口
  bool ConnectToServer(const char *serverip,const int port);
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
 ~CTcpClient();
};
 
int main()
{
  CTcpClient TcpClient;
 
  // 向服务器发起连接请求
  if (TcpClient.ConnectToServer("118.89.50.198",5051)==false)
  { printf("TcpClient.ConnectToServer(\"118.89.50.198\",5051) failed,exit...\n"); return -1; }
 
  char strbuffer[1024];
 
  for (int ii=0;ii<5;ii++)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    sprintf(strbuffer,"这是第%d个超级女生，编号%03d。",ii+1,ii+1);
    if (TcpClient.Send(strbuffer,strlen(strbuffer))<=0) break;
    printf("发送：%s\n",strbuffer);
   
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpClient.Recv(strbuffer,sizeof(strbuffer))<=0) break;
    printf("接收：%s\n",strbuffer);
  }
}
 
CTcpClient::CTcpClient()
{
  m_sockfd=0;  // 构造函数初始化m_sockfd
}
 
CTcpClient::~CTcpClient()
{
  if (m_sockfd!=0) close(m_sockfd);  // 析构函数关闭m_sockfd
}
 
// 向服务器发起连接，serverip-服务端ip，port通信端口
bool CTcpClient::ConnectToServer(const char *serverip,const int port)
{
  m_sockfd = socket(AF_INET,SOCK_STREAM,0); // 创建客户端的socket
 
  struct hostent* h; // ip地址信息的数据结构
  if ( (h=gethostbyname(serverip))==0 )
  { close(m_sockfd); m_sockfd=0; return false; }
 
  // 把服务器的地址和端口转换为数据结构
  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(m_sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))!=0)
  { close(m_sockfd); m_sockfd=0; return false; }
 
  return true;
}
 
int CTcpClient::Send(const void *buf,const int buflen)
{
  return send(m_sockfd,buf,buflen,0);
}
 
int CTcpClient::Recv(void *buf,const int buflen)
{
  return recv(m_sockfd,buf,buflen,0);
}

服务端;

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
 
class CTcpServer
{
public:
  int m_listenfd;   // 服务端用于监听的socket
  int m_clientfd;   // 客户端连上来的socket
 
  CTcpServer();
 
  bool InitServer(int port);  // 初始化服务端
 
  bool Accept();  // 等待客户端的连接
 
  // 向对端发送报文
  int  Send(const void *buf,const int buflen);
  // 接收对端的报文
  int  Recv(void *buf,const int buflen);
 
 ~CTcpServer();
};
 
int main()
{
  CTcpServer TcpServer;
 
  if (TcpServer.InitServer(5051)==false)
  { printf("TcpServer.InitServer(5051) failed,exit...\n"); return -1; }
 
  if (TcpServer.Accept() == false) { printf("TcpServer.Accept() failed,exit...\n"); return -1; }
 
  printf("客户端已连接。\n");
 
  char strbuffer[1024];
 
  while (1)
  {
    memset(strbuffer,0,sizeof(strbuffer));
    if (TcpServer.Recv(strbuffer,sizeof(strbuffer))<=0) break;
    printf("接收：%s\n",strbuffer);
 
    strcpy(strbuffer,"ok");
    if (TcpServer.Send(strbuffer,strlen(strbuffer))<=0) break;
    printf("发送：%s\n",strbuffer);
  }
 
  printf("客户端已断开连接。\n");
}
 
CTcpServer::CTcpServer()
{
  // 构造函数初始化socket
  m_listenfd=m_clientfd=0;
}
 
CTcpServer::~CTcpServer()
{
  if (m_listenfd!=0) close(m_listenfd);  // 析构函数关闭socket
  if (m_clientfd!=0) close(m_clientfd);  // 析构函数关闭socket
}
 
// 初始化服务端的socket，port为通信端口
bool CTcpServer::InitServer(int port)
{
  m_listenfd = socket(AF_INET,SOCK_STREAM,0);  // 创建服务端的socket
 
  // 把服务端用于通信的地址和端口绑定到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(m_listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr)) != 0 )
  { close(m_listenfd); m_listenfd=0; return false; }
 
  // 把socket设置为监听模式
  if (listen(m_listenfd,5) != 0 ) { close(m_listenfd); m_listenfd=0; return false; }
 
  return true;
}
 
bool CTcpServer::Accept()
{
  if ( (m_clientfd=accept(m_listenfd,0,0)) <= 0) return false;
 
  return true;
}
 
int CTcpServer::Send(const void *buf,const int buflen)
{
  return send(m_clientfd,buf,buflen,0);
}
 
int CTcpServer::Recv(void *buf,const int buflen)
{
  return recv(m_clientfd,buf,buflen,0);
}

经过测试出现一个问题：

以云服务器作为服务端，虚拟机作为客户端，是可以连接成功并且通信的，

在虚拟机之间作为客户端或者服务端，可以连接成功并且可以通信。

以虚拟机作为服务端，云服务器作为客户端，连接不成功。