Socket Programming TCP

TCP Communication programming

TCP Communication programming process ：

Simulate the process of communication between the server and the client ：

Use of interfaces ：
1. Create socket ：

int socket(int domain,int type,int protocol)
domain： Address field  AF_INET/AF_INET6
type：SOCK_STREAM（TCP Streaming socket ）       SOCK_DGRAM（UDP Socket datagram ）
protocol：IPPROTO_TCP        IPPROTO_UDP
 return socket Operation handle 

2. Binding address information ：

int bind(int sockfd,(struct sockaddr*)addr,socklen_t len)

3. Start listening

listen(int sockfd,int backlog)
sockfd： Which socket Set as listening socket , Just pass in the handle of which socket 
backlog: Number of concurrent connections at the same time , Determine the maximum number of client connection requests accepted at the same time 

If a malicious host sends unlimited connection requests to the server at the same time , Whether the server should always create sockets for each request ？ If so , In the end, there is only one structure, that is, resource exhaustion , System crash .
backlog That's the solution , As mentioned in the previous process , Monitoring phase , The listening server receives a connection request to create a socket and put it into the incomplete connection queue , Bind the quintuple information and put it into the completed connection queue .
backlog This determines the number of nodes in the incomplete connection queue . But it only determines the number of nodes at the same time , But it does not determine the maximum client connection that the system can accept .

4. Get new connection

 Take a... From the completed connection queue socket, Go back to this socket Operation handle of , So you can communicate .
int accept(int sockfd,(struct sockaddr*)cli_addr,socklen* len);
sockfd :  Listening socket , Indicates which... To get tcp New connection of server socket （ There could be a lot TCP Server side ）
cli_addr: The client address information of the new socket 
len： Length of address information 
 Return value ： New socket operation handle  ---  Socket handle in external program 

5. Sending and receiving data

ssize_t recv(int sockfd,char* buf,int len,int flag);
 Default block , No data, wait , Disconnect and return 0, It's not blocking 
ssize_t send(int sockfd,char* data,int len,int flag);
 Default block , When the buffer is full, wait , When the connection is disconnected, start SIGPIPE abnormal 

6. Close socket

close(sockfd);                #include<unistd.h>

7. Send a connection request

int connect(int sockfd,struct sockaddr* srv_addr, int len);
srv_addr： Address information of the server 
connet This interface also describes the address information of the server （ Quintuples ）, So you only need to send and receive data directly .

Simple and easy TCP Communication process

socket Class encapsulation
Encapsulates a TcpSocket class , Every instantiated object is a udp Communication connection , Complete the communication process through the member methods of this object .

class TcpSocket{
public:
	TcpSocket():_sockfd(-1);
	bool Socket();
	bool Bind(const std::string& ip,uint16_t port);
	bool Listen(int backlog = MAX_LISTEN);
	bool Accept(TcpSocket* new_sock,std::string* ip =NULL,uint16_t* port);
	bool recv(std::string* buf);
	bool send(const std::string& data);
	bool Close();
	bool Connect(const std::string& ip,uint16_t port);
private:
	int _sockfd;

#pragma once 
#include<iostream> 
#include<string> 
#include<unistd.h> 
#include<sys/socket.h> 
#include<netinet/in.h> 
#include<arpa/inet.h> 
using namespace std;    
    
class TcpSocket    
{
        
  private:    
    int sockfd;    
  public:    
    TcpSocket()    
    {
        
      if(!Socket())    
      {
        
        cout<<"socket create failed"<<endl;    
      }    
    }    
    ~TcpSocket()    
    {
        
      Close();    
    }    
  public:    
    bool Socket()
    {
    
      sockfd = socket(AF_INET,SOCK_STREAM,0);
      if(sockfd == 0)
      {
    
        cerr<<"scoket error"<<endl;
        return false;
      }
      return true;
    }

    // May be wrong 
    void Addr(struct sockaddr_in* addr, const string& ip,const uint16_t& port)
    {
    
      addr->sin_family = AF_INET; 
      addr->sin_port = htons(port);
      addr->sin_addr.s_addr = inet_addr(ip.c_str());                              
    }

    bool Bind(const string& ip,const uint16_t& port)
    {
    
      struct sockaddr_in addr;
      Addr(&addr,ip,port);                                                                                                       
      socklen_t len = sizeof(addr);

      int ret = bind(sockfd,(struct sockaddr*)&addr,len);
      if(ret < 0)
      {
    
              cerr<<"bind errror"<<endl;
        return false;
      }
      return true;
    }

    bool Listen()
    {
    
      int ret = listen(sockfd,5);
      if(ret == -1) 
      {
    
        cerr<<"listen error"<<endl;
        return false;
      }
      return true;
    }

    bool Connect(const string& ip,const uint16_t& port)
    {
    
      struct sockaddr_in addr;
      Addr(&addr,ip,port);
      socklen_t len = sizeof(addr);                                                                                              

      int ret = connect(sockfd,(struct sockaddr*)&addr,len);
      if(ret < 0)
      {
    
        cerr<<"connect error"<<endl;
        return false;
      }
      return true;
    }

    bool Accept(TcpSocket* new_sock,string* ip = NULL,uint16_t* port = NULL)
    {
    
      struct sockaddr_in addr;
      socklen_t len = sizeof(addr);
      int newfd = accept(sockfd,(struct sockaddr*)&addr,&len);
      if(newfd < 0)
      {
    
        cerr<<"accept error"<<endl;
        return false;
      }
      new_sock->sockfd = newfd;
      if(ip != NULL)
      {
    
        *ip = inet_ntoa(addr.sin_addr);
      }
      if(port != NULL)
      {
                                                                                                                              
        *port = ntohs(addr.sin_port);
      }
      return true;
    }
    bool Recv(string* buf)
    {
    
      char tmp[4096] = {
    0};
      int ret = recv(sockfd,tmp,4095,0);;
      if(ret <0)
      {
    
        cerr<<"recv error"<<endl;
        return false;
      }
      *buf = tmp;
      buf->assign(tmp);
      return true;
    }
    bool Send(const string& data)
    {
    
      //UDP Is datagram transmission , The whole delivery 
      // and TCP It's byte streaming , Transmit as much as you can , Data boundaries are not distinguished 
      // If the other side's buffer is left 50 Bytes of space ,send Give each other 100 Bytes , Can only be successfully sent 50 Bytes , And return the transfer size 50 byte 
      size_t total = 0 ;
      while(total < data.size())
      {
    
        int ret = send(sockfd,&data[0]+total,data.size()-total,0);
        if(ret < 0)
        {
    
          cerr<<"send error"<<endl;
          return false;
        }
        total+=ret;
      }
      return true;
    }

    bool Close()
    {
    
      close(sockfd);
      return true;
    }                                                                                                                            
};