手搓TCP服务器实现基础IO

在有了UDP服务器的基础，搓一个TCP服务器就简单很多了，套接字、绑定，结构体协议家族都是套路，我们主要看二者的区别在代码上的体现。其中TCP是有连接的，也就是说当有客户端访问服务器想发送数据包时，需先和服务器进行连接，然后进行相关操作，而UDP的无连接则不需要，直接向服务器发送数据即可。建议先看一下UDP服务器的代码再看此文会更加清晰。、

套接字与UDP服务器代码https://blog.csdn.net/czt230610/article/details/149817538?fromshare=blogdetail&sharetype=blogdetail&sharerId=149817538&sharerefer=PC&sharesource=czt230610&sharefrom=from_link上面说过 socket的套路不变，但其通信方式我们需要改变一下，在UDP中是SOCK_DGRAM，而TCP是SOCK_STREAM。

除此之外，TCP需要时刻观察是否有客户端访问，就像饭店老板时刻等待顾客一样，因此我们需要给绑定的套接字加上监听功能。

第一个参数就是我们需要监听的套接字文件描述符，第二个参数是排队的容量（即如果有多个客户端访问最多支持排多少个，这里我们定义了宏为8）。

除此之外，我们也要进行“揽客”即告诉客户端我这里可以连接了。

第一个参数是我们负责“揽客”的套接字（最初绑定的），就相当于饭店外面揽客的人，他们并不在里面吃饭，但是会告诉别人让他们来吃饭，因此这个描述符不做IO工作，只是单纯的“揽客”。后两个是输出型参数，代表哪个客户端来访问了。

可是，他返回值也是一个文件描述符。这个和前面的功能一样吗？

这个返回的文件描述符，其实才是真正做IO工作的。

图中的sockfd才是我们真正做IO的，我们类内定义的是_listensockfd。

接下来就是IO工作，我们单独写一个函数来处理任务，由于TCP是面向字节流的，IO更像文件，因此我们用文件的读写接口。

void HandlerRequest(int sockfd)
    {
        while(true)
        {
            char inbuffer[4096];
           ssize_t n=::read(sockfd,inbuffer,sizeof(inbuffer)-1);
           if(n>0)
           {
               inbuffer[n]=0;
               std::string echo_str="server echo";
               echo_str+=inbuffer;

               ::write(sockfd,echo_str.c_str(),echo_str.size());

           }
           else if (n=0)//客户端退出
           
           {
              std::cout<<"client exit"<<std::endl;
              break;  
           }
           else
           {
            break;
           }
           
        }
        ::close(sockfd);
    }

这个函数能够基础的进行IO但是只支持一个客户端连接，先来看客户端的编写。

在进行套接字的创建后，我们遇到了新的问题，如何建立连接？因为TCP是有连接的，需要连接才能进行read write操作。因此我们介绍一个新接口。

即把创建的套接字与目标服务器的ip+port连接。（客户端不需要显示的bind）

剩下的IO工作和UDP就类似了，只是接口换一下。

以上即可满足单个客户端进行不断重连且能进行IO的服务器操作了。

完整代码：

服务器hpp

#pragma once

#include <iostream>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>
static const uint16_t gport=8080;

#define BACKLOG 8 //排队容量
class TcpServer
{
public:
    TcpServer(int port=gport):_port(port),_isrunning(false)
    {
    }
    void InitServer()
    {
        _listensockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_listensockfd < 0)
        {
            std::cout << "socket falied" << std::endl;
            exit(1);
        }
        std::cout<<"socket success"<<std::endl;

        struct sockaddr_in local;
        memset(&local,0,sizeof(local));
        local.sin_family=AF_INET;
        local.sin_port=htons(_port);
        local.sin_addr.s_addr=INADDR_ANY;

        int n=::bind(_listensockfd,(struct sockaddr*)&local,sizeof(local));
        if(n<0)
        {
            std::cout<<"bind error"<<std::endl;
        }
        std::cout<<"bind success"<<std::endl;
        //tcp随时等待被连接
        //需要将tcp的socket设置为监听状态
        n=::listen(_listensockfd,BACKLOG);
        if(n<0)
        {
            std::cout<<"listen failed"<<std::endl;
        }
        std::cout<<"listen success"<<std::endl;
    }
    void HandlerRequest(int sockfd)
    {
        while(true)
        {
            char inbuffer[4096];
           ssize_t n=::read(sockfd,inbuffer,sizeof(inbuffer)-1);
           if(n>0)
           {
               inbuffer[n]=0;
               std::string echo_str="server echo";
               echo_str+=inbuffer;

               ::write(sockfd,echo_str.c_str(),echo_str.size());

           }
           else if (n=0)//客户端退出
           
           {
              std::cout<<"client exit"<<std::endl;
              break;  
           }
           else
           {
            break;
           }
           
        }
        ::close(sockfd);
    }

    void Start()
    {
      _isrunning =true;
      while(_isrunning)
      {
         //获取新连接
         struct sockaddr_in peer;
         socklen_t peerlen;
         //获取客户端信息
         int sockfd=::accept(_listensockfd,(struct sockaddr*)&peer,&peerlen);
         if(sockfd<0)
         {
            //揽客失败
            std::cout<<"accept failed"<<std::endl;
            continue;
         }
          //获取成功
          std::cout<<"success : "<<sockfd<<std::endl;
          //Echo
         HandlerRequest(sockfd);
      }
    }
    void Stop()
    {
        _isrunning=false;
    }
    ~TcpServer()
    {
    }

private:
    int _listensockfd;
    uint16_t _port;
    bool _isrunning;
};

服务端.cc

#include "TcpServer.hpp"
#include <memory>



int main()
{
    std::unique_ptr<TcpServer> tsvr=std::make_unique<TcpServer>();

    tsvr->InitServer();
    tsvr->Start();

    return 0;
}

客户端.cc

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cstring>
#include <unistd.h>


 // ./client_tcp ip port
int main(int argc, char* argv[])
{
    if(argc!= 3)
    {
        std::cout << "Usage:./client_tcp ip port" << std::endl;
        return 1;
    }
    std::string server_ip = argv[1];
    int server_port = std::stoi(argv[2]);
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd < 0)
    {
        std::cout << "Error in creating socket" << std::endl;
        return 2;
    }
    //服务器的socket已传入
    struct sockaddr_in server_addr;
    memset(&server_addr, 0, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(server_port);
    server_addr.sin_addr.s_addr = inet_addr(server_ip.c_str());
    int n=::connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
    if(n < 0)
    {
        std::cout << "Error in connecting to server" << std::endl;
        return 3;
    }
    std::string message;
  
    while(true)
    {
            std::cout << "Enter message to send: ";
            std::getline(std::cin, message);
            int n=::write(sockfd, message.c_str(), message.size());
            char buffer[1024];
            if(n>0)
            {
              int m=::read(sockfd, buffer, sizeof(buffer));
              if(m>0)
              {
                buffer[m]=0;
                std::cout << "Received message: " << buffer << std::endl;
              }
                
            }
            
            
    }

    ::close(sockfd);
    
    return 0;
}