【Linux网络编程】TCP Echo Server的实现

本文专栏： linux网络编程

本文的基础知识是基于上篇文章：UDP Echo Server的实现

传送门：

【Linux网络编程】UDP Echo Server的实现 -CSDN博客

目录

一，InetAddr类的编写

二，客户端代码编写

创建套接字（socket）

绑定IP和端口号（bind）

建立连接（connect）

write和read

完整代码（客户端）

三，服务器端代码编写

创建套接字（socket）

绑定IP和端口号(bind)

设置监听状态（listen）

获取连接（accept）

write和read

version0------单进程版本

version1------多进程版本

version3------多线程版本

四，服务器端完整代码

五，总结

---

一，InetAddr类的编写

在上篇博客中，实现udp的echo server。其中有很多的接口，都需要进行主机序列和网络序列的相互转化。这些操作很频繁，所以可以将这些操作封装 成一个类，提供 一个个的接口。

含注释

#pragma once
#include "Common.hpp"
// 网络地址和主机地址之间进行转换的类

class InetAddr
{
public:
    //通过重载构造函数来实现网络序列和主机序列的相互转化
    
    InetAddr(){}
    //addr中的数据是网络序列（也就是大端形式）
    InetAddr(struct sockaddr_in &addr) : _addr(addr)
    {
        // 网络转主机
        _port = ntohs(_addr.sin_port); // 从网络中拿到的！网络序列
        // _ip = inet_ntoa(_addr.sin_addr); // 4字节网络风格的IP -> 点分十进制的字符串风格的IP
        char ipbuffer[64];
        inet_ntop(AF_INET, &_addr.sin_addr, ipbuffer, sizeof(_addr));
        _ip = ipbuffer;
    }
    //传入IP和端口号，在构造函数里完成主机序列转网络序列
    InetAddr(const std::string &ip, uint16_t port) : _ip(ip), _port(port)
    {
        // 主机转网络
        memset(&_addr, 0, sizeof(_addr));
        _addr.sin_family = AF_INET;
        inet_pton(AF_INET, _ip.c_str(), &_addr.sin_addr);
        _addr.sin_port = htons(_port);
    }
    //该构造函数可用于服务器端
    //服务器端传入port即可
    //ip在内部会设置为INADDR_ANY，表示任何ip都可以连接
    InetAddr(uint16_t port) :_port(port),_ip("0")
    {
        // 主机转网络
        memset(&_addr, 0, sizeof(_addr));
        _addr.sin_family = AF_INET;
        _addr.sin_addr.s_addr = INADDR_ANY;
        _addr.sin_port = htons(_port);
    }
    //获取端口号
    uint16_t Port() { return _port; }
    //获取ip
    std::string Ip() { return _ip; }
    //下面两个接口的返回值，
    const struct sockaddr_in &NetAddr() { return _addr; }
    const struct sockaddr *NetAddrPtr()
    {
        #define CONV(addr) ((struct sockaddr*)&addr)
        return CONV(_addr);//这是定义的一个宏，类型转化
    }
    //返回sockaddr_in的大小
    socklen_t NetAddrLen()
    {
        return sizeof(_addr);
    }
    bool operator==(const InetAddr &addr)
    {
        return addr._ip == _ip && addr._port == _port;
    }
    std::string StringAddr()
    {
        return _ip + ":" + std::to_string(_port);
    }
    ~InetAddr()
    {
    }

private:
    struct sockaddr_in _addr;
    std::string _ip;
    uint16_t _port;
};

二，客户端代码编写

Echo Server（回显服务器）是一种网络应用程序。其核心功能是接受客户端发来的数据，并将接受到的数据原样返回给客户端。

核心逻辑：

1. 服务端

   创建套接字 → 绑定地址 → 监听连接 → 接受请求 → 读取数据 → 回传数据。

2. 客户端

   创建套接字 → 连接服务器 → 发送数据 → 接收回显数据。

在UDP服务中是没有监听连接这一步的，但是在TCP这里就需要建立连接了。

我们约定以下，当我们使用客户端连接服务端时，是需要 服务器端的IP和端口号的。

这两个数据到时候我们通过命令行参数的形式获取。

创建套接字（socket）

认识接口：

NAME
socket - create an endpoint for communication

SYNOPSIS
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

    //1,创建套接字
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        std::cerr<<"创建套接字失败"<<std::endl;
        exit(1);
    }
    std::cout<<"创建套接字成功"<<sockfd<<std::endl;

绑定IP和端口号（bind）

客户端代码在编写的时候是不需要我们手动绑定的，在系统内部，系统 知道本主机的IP，同时会随机分配一个端口号给客户端。

详解看上篇文章：

【Linux网络编程】UDP Echo Server的实现 -CSDN博客

建立连接（connect）

与服务器端建立连接。 认识接口：

NAME
connect - initiate a connection on a socket

SYNOPSIS
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

• 第一个参数：是我们创建的socket套接字
• 第二个参数：是一个结构体类型，在该结构体中存储着端口号和IP地址
• 第三个参数：表示该结构体的大小

这些参数都是我们需要定义好，将服务器端的IP地址和端口号填入，但是 这里就会面临主机序列到网络序列的转换。所以这里我们可以使用提前封装好的InetAddr类，只需将IP和端口号传入 构造好一个InetAddr对象，就可以方便获取想要的字节序，不管是网络序列还是续集序列。

    //2,bind不需要我们手动绑定了
    //3，建立连接
    InetAddr addr(serverip,serverport);//这一句就搞定了
    int n=connect(sockfd,addr.NetAddrPtr(),addr.NetAddrLen());
    if(n<0)
    {
        std::cerr<<"connect err"<<std::endl;
        exit(3);
    }

write和read

建立好连接后，就可以发送 和接受数据了。认识接口 ：

NAME
write - write to a file descriptor

SYNOPSIS
#include <unistd.h>

ssize_t write(int fd, const void *buf, size_t count);

---

NAME
read - read from a file descriptor

SYNOPSIS
#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

这两个接口，其实就是文件系统中，对文件进行读写操作的方法。

    while(true)
    {
        std::string line;
        std::cout<<"Please Enter## ";
        std::getline(std::cin,line);

        write(sockfd,line.c_str(),line.size());

        //获取数据
        //定义一个缓冲区 
        char buffer[1024];
        ssize_t s=read(sockfd,buffer,sizeof(buffer)-1);
        //成功读取服务器发来的消息
        if(s>0)
        {
            std::cout<<"sever echo# "<<buffer<<std::endl;
        }
    }

完整代码（客户端）

#pragma once
//客户端
#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>
#include <unistd.h>
#include "InetAddr.hpp"

//我们期望的输入样例：【./可执行程序 IP  端口号】
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        std::cout<<"输入格式 不规范"<<std::endl;
        exit(1);
    }
    //先提取出从命令行中获取的IP和端口号
    std::string serverip=argv[1];//IP
    uint16_t serverport=std::stoi(argv[2]);//port

    //1,创建套接字
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd<0)
    {
        std::cerr<<"创建套接字失败"<<std::endl;
        exit(2);
    }
    std::cout<<"创建套接字成功"<<sockfd<<std::endl;

    //2,bind不需要我们手动绑定了
    //3，建立连接
    InetAddr addr(serverip,serverport);//这一句就搞定了
    int n=connect(sockfd,addr.NetAddrPtr(),addr.NetAddrLen());
    if(n<0)
    {
        std::cerr<<"connect err"<<std::endl;
        exit(3);
    }

    while(true)
    {
        std::string line;
        std::cout<<"Please Enter## ";
        std::getline(std::cin,line);

        write(sockfd,line.c_str(),line.size());

        //获取数据
        //定义一个缓冲区 
        char buffer[1024];
        ssize_t s=read(sockfd,buffer,sizeof(buffer)-1);
        //成功读取服务器发来的消息
        if(s>0)
        {
            std::cout<<"sever echo# "<<buffer<<std::endl;
        }
    }
    return 0;
}

三，服务器端代码编写

对服务器端代码的编写时，为了实现代码之间分模块，降低耦合度。和UDP一样，将核心部分封装成类。模块与模块之间的联系就降低了。

而类支持拷贝构造和赋值重载这些功能，但是我们的服务器是不希望有这些的功能 。直接的办法就是将这个类的拷贝构造和赋值重载禁用掉（delete），或者 将这两个函数设置为私有 成员（private），在外界就无法调用。

---

我们这里用另一个 方法，定义一个新的类，类名为NoCopy，该类不需要定义任何的成员函数，直接将该类的拷贝构造和赋值重载禁用掉（delete），然后让我们编写的服务器类 class tcpserver继承自这个类。因为如果想要拷贝子类，就必须先掉用父类的拷贝构造，再调用子类的拷贝构造。赋值重载也是如此。这样，子类的拷贝构造和赋值重载也就无法调用了。

//禁止拷贝构造和赋值重载
class NoCopy
{
public:
    NoCopy()
    {}
    ~NoCopy()
    {}
    NoCopy(const NoCopy& n)=delete;
    NoCopy& operator=(const NoCopy& n)=delete;
};

在这里，由于我们在编写服务器段代码时，可能会产生不同错误，比如创建套接字失败，监听失败，绑定失败等等各种问题。所以我们可以通过enum，枚举出这些错误，这些错误分别对应一个整数，在出错时我们让进程退出，退出码就设置为对应的错误，这样方便查看哪里出错了。

//枚举退出码
enum ExitCode
{
    OK = 0,
    USAGE_ERR,
    SOCKET_ERR,
    BIND_ERR,
    LISTEN_ERR,
    CONNECT_ERR,
    FORK_ERR
};

创建套接字（socket）

接口设计与客户端一摸一样。

这里用到的 LOG(LogLevel::INFO) 是用来打印日志信息的，方便进行debug的。

在最后，会将该这个功能的实现发出来。

        //1，创建套接字
        _sockfd=socket(AF_INET,SOCK_STREAM,0);
        if(_sockfd<0)
        {
            //打印日志信息
            LOG(LogLevel::FATAL)<<"创建套接字失败";
            exit(SOCKET_ERR);
        }
        LOG(LogLevel::INFO)<<"创建套接字成功"<<_sockfd;

绑定IP和端口号(bind)

同样，这里在传参的时候，需要传入struct sockaddr类，要实现字节序到网络序的转化，这些功能已经在InetAddr这个类里封装好了。所以直接调用即可。

 //2，绑定ip和端口号
 InetAddr addr(_port);//只需传入端口号即可，这里 调用的构造函数会将IP设置为0，也就是INADDR_ANY
 int n=bind(_sockfd,addr.NetAddrPtr(),addr.NetAddrLen());
 if(n<0)
 {
     LOG(LogLevel::FATAL)<<"绑定失败";
     exit(BIND_ERR);
 }

设置监听状态（listen）

服务器端在完成绑定后，需要将自己设置为监听状态。客户端要连接我，我是服务端，那么我就需要将自己的状态设置为listen状态，随时等待 客户端连接。

认识接口：

NAME
listen - listen for connections on a socket

SYNOPSIS
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>

int listen(int sockfd, int backlog);

• 第一个参数就是我们创建的套接字
• 第二个参数：当服务端处于 监听状态时，客户端发来连接，这些连接是需要排队的，这个参数就表示处于排队中的连接的的最大个数 ，这个数字不能设置为太大，也不能太小

        //3，listen状态，监听连接
        n=listen(_sockfd,8);
        if(n<0)
        {
            LOG(LogLevel::FATAL)<<"监听失败";
            exit(LISTEN_ERR);
        }
        LOG(LogLevel::FATAL)<<"监听成功";

获取连接（accept）

客户端向服务端发来的连接，存在于哪里？操作系统内核。我们要从操作系统内核中获取。

认识接口：

NAME
accept, accept4 - accept a connection on a socket

SYNOPSIS
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

#define _GNU_SOURCE /* See feature_test_macros(7) */
#include <sys/socket.h>

int accept4(int sockfd, struct sockaddr *addr,
socklen_t *addrlen, int flags);

• 第一个参数是我们创建的套接字
• 第二个和第三个参数是sockaddr结构体，需要我们传入。同样，还是调用我们封装好的接口即可。

但是对于这个函数的返回值，是一个文件描述符。如上图，而我们创建套接字的时候，它的返回值也是一个文件描述符。这该如何理解呢？

一个场景搞定：

众所周知，现在各行各业都很卷。相信大家出去玩的时候，都遇到过这个场景。

在某个景区附近，会有各种餐馆，为了提高餐馆的收益，每个餐馆会派一个人在外面拉客，这个人就叫作张三，他给路过的人说：来我们家餐馆吃吧，我们家餐馆今天刚捕捞的鱼，可新鲜。这些客人跟着张三进入餐馆后，张三会继续到外面去拉客。而这些客人会由餐馆里的其他服务员李四，王五等照顾。而可能张三在拉客的过程中，失败了，这是正常的，我今天的就是不想吃饭。那么张三就会转头去拉另一个顾客。

---

在这个场景中，张三就是我们创建的socket，我们通过创建的socket来获取连接，就是张三拉客的过程。而餐馆里的其他服务员，他们来照顾张三拉的客人。对应的就是accept的返回值，这个返回值来提供服务，提供什么服务，就是write和read服务。

---

所以，在这里我们把先前创建的_sockfd该名为_listensockfd。而accept的返回值定义为sockfd，这个才是提供服务的。_listensockfd只是完成监听的，它是监听套接字。

如果没有连接，accept就会一直阻塞。

            //4，获取连接
            struct sockaddr_in peer;
            socklen_t len=sizeof(peer);
            //如果没有连接，accept就会阻塞
            int sockfd=accept(_listensockfd, CONV(peer), &len);
            if (sockfd < 0)
            {
                LOG(LogLevel::WARNING) << "accept error";
                continue;
            }

write和read

定义一个service方法，在这里实现write和read。这个函数作为成员函数。

 void service(int sockfd,InetAddr addr)
    {
        char buffer[1024];//定义缓冲区
        while(true)
        {
            //读取数据
            ssize_t n=read(sockfd,buffer,sizeof(buffer)-1);
            //n>0读取成功
            //n<0读取失败
            //n==0对端关闭连接，读取到了文件的末尾
            if(n>0)
            {
                buffer[n]=0;
                //查看是哪个主机的哪个进程发送的消息，在服务端回显
                LOG(LogLevel::DEBUG)<<addr.StringAddr()<<" #"<<buffer;

                //写回数据
                std::string echo_string="echo #";
                echo_string+=buffer;
                //写回给客户端
                write(sockfd,echo_string.c_str(),echo_string.size());
            }
            else if (n == 0)
            {
                LOG(LogLevel::DEBUG) << addr.StringAddr() << " 退出了...";
                close(sockfd);
                break;
            }
            else
            {
                LOG(LogLevel::DEBUG) << addr.StringAddr() << " 异常...";
                close(sockfd);
                break;
            }
        }
    }

version0------单进程版本

在实际中，这种服务器一般是不会实现的。

我们在接受连接后，直接调用service函数完成通信，这种 服务器只能处理一个客户端，因为当一个客户端建立连接后，我们服务器端调用service函数进行read和write，一直while(true)式的读和写，是一个死循环，所以就无法继续进行accept进行等待了。所以其他客户端就无法连接了，除非第一个客户端推出了。所以说这种一般不会实现的。

version1------多进程版本

通过创建父子进程的方式。让父进程一直进行accept接受连接的功能，让子进程一直执行service通信的服务。这样就可以保证多个客户端，可以同时连接这个服务器，进行通信了。

在获取连接成功之后，fork出子进程，子进程执行service方法中的write和read，父进程继续循环执行accept，获取其他客户端的连接。所以作为子进程我们只需要知道sockfd即可，通过sockfd可以进行read和write。而对于父进程，我们只需要知道_listensockfd即可，通过该套接字获取连接。所以父子进程可以关掉双方不需要的文件描述符（即sockfd和listensockfd）

---

这样的方式当然可以保证多个客户端可以进行连接我们的服务器。但是还有一个问题，子进程在退出的时候，是需要父进程进行等待的。如果不等待，父进程直接退出，那么该进程就会进入僵尸状态，一直占有内存资源，存在内存泄漏的问题。而我们的服务器是一个死循环，一直启动着，这样就会不停的生成僵尸进程，将 内存资源占用完时，我们的服务器进程就会挂掉。

---

所以父进程是需要等待子进程退出的，父进程调用pthread_wait接口，等待子进程并回收子进程。如果我们真的进行等待，那么这种方式，父进程是还需要等待的，效率较低。

---

子进程在退出的时候，会给父进程发送一个退出信号。父进程可以将信号的捕捉方式设置为忽略处理，就不需要等待子进程。

signal(SIGCHLD,SIG_IGN)

---

还有一种方法，在子进程中再次创建子进程，成为孙子进程，我们让子进程直接退出，那么父进程就可以直接等待成功，转而去执行获取其他 连接。然后让孙子进程执行service（read和write），孙子进程不需要处理，因为它的父进程已经退出了，他成为了孤儿进程，孤儿进程会被1号进程领养，1号进程就是操作系统，操作系统会将这个进程释放掉，回收资源，所以不用担心内存泄漏的问题。

            //version2
            //多进程
            pid_t id=fork();
            if(id<0)
            {
                LOG(LogLevel::FATAL)<<"创建子进程失败";
                exit(FORK_ERR);
            }
            else if(id==0)//子进程
            {
                //关掉不用的文件描述符
                close(_listensockfd);
                if(fork()>0)//再次创建子进程
                exit(OK);//正常退出

                //执行service
                service(sockfd,addr);//孙子进程执行
                exit(OK);
            }
            else
            {
                //父进程
                //关掉不用的文件描述符
                close(sockfd);
                //忽略子进程的退出信号
                //signal(SIGCHLD,SIG_IGN);

                //父进程直接退出
                pid_t rid=waitpid(id,nullptr,0);//父进程不会再等待了
                //再次循环执行获取连接的方法 accept
            }

version3------多线程版本

这种方式其实最简单，创建一个线程，新线程去执行 service方法，主线程循环执行accept方法。

    class ThreadData
    {
    public:
        ThreadData(int fd, InetAddr &ar, tcpserver *s) : sockfd(fd), addr(ar), tsvr(s)
        {
        }

    public:
        int sockfd;
        InetAddr addr;
        tcpserver *tsvr;
    };
    //新线程的入口函数
    static void *Routine(void *args)
    {
        pthread_detach(pthread_self());
        ThreadData *td = static_cast<ThreadData *>(args);
        td->tsvr->service(td->sockfd, td->addr);
        delete td;
        return nullptr;
    }


//version3------多线程
ThreadData *td = new ThreadData(sockfd, addr, this);
pthread_t tid;
pthread_create(&tid, nullptr, Routine, td);

因为我们创建新线程执行Routine方法时，该函数表示成员函数，所以需要设置为静态的。

而 调用sevice需要sockfd和InetAddr以及this指针，所以我们可以将这三个参数封装成一个结构体传参过去。

四，服务器端完整代码

tcpserver.hpp

#pragma once

#include <iostream>
#include <memory>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <signal.h>
#include "Common.hpp"
#include "Log.hpp"
#include "InetAddr.hpp"

using namespace LogModule;

const int defaultfd=-1;
//禁止拷贝构造和赋值重载
class tcpserver : public NoCopy
{
public:
    tcpserver(uint16_t port):_port(port),_listensockfd(defaultfd),_isrunning(false)
    {}
    ~tcpserver()
    {}
    void init()
    {
        //1，创建套接字
        _listensockfd=socket(AF_INET,SOCK_STREAM,0);
        if(_listensockfd<0)
        {
            //打印日志信息
            LOG(LogLevel::FATAL)<<"创建套接字失败";
            exit(SOCKET_ERR);
        }
        LOG(LogLevel::INFO)<<"创建套接字成功"<<_listensockfd;

        //2，绑定ip和端口号
        InetAddr addr(_port);//只需传入端口号即可，这里 调用的构造函数会将IP设置为0，也就是INADDR_ANY
        int n=bind(_listensockfd,addr.NetAddrPtr(),addr.NetAddrLen());
        if(n<0)
        {
            LOG(LogLevel::FATAL)<<"绑定失败";
            exit(BIND_ERR);
        }
        LOG(LogLevel::FATAL)<<"绑定成功";

        //3，listen状态，监听连接
        n=listen(_listensockfd,8);
        if(n<0)
        {
            LOG(LogLevel::FATAL)<<"监听失败";
            exit(LISTEN_ERR);
        }
        LOG(LogLevel::FATAL)<<"监听成功";
    }
    void service(int sockfd,InetAddr addr)
    {
        char buffer[1024];//定义缓冲区
        while(true)
        {
            //读取数据
            ssize_t n=read(sockfd,buffer,sizeof(buffer)-1);
            //n>0读取成功
            //n<0读取失败
            //n==0对端关闭连接，读取到了文件的末尾
            if(n>0)
            {
                buffer[n]=0;
                //查看是哪个主机的哪个进程发送的消息，在服务端回显
                LOG(LogLevel::DEBUG)<<addr.StringAddr()<<" #"<<buffer;

                //写回数据
                std::string echo_string="echo #";
                echo_string+=buffer;

                //写回给客户端
                write(sockfd,echo_string.c_str(),echo_string.size());
            }
            else if (n == 0)
            {
                LOG(LogLevel::DEBUG) << addr.StringAddr() << " 退出了...";
                close(sockfd);
                break;
            }
            else
            {
                LOG(LogLevel::DEBUG) << addr.StringAddr() << " 异常...";
                close(sockfd);
                break;
            }
        }
    }
    class ThreadData
    {
    public:
        ThreadData(int fd, InetAddr &ar, tcpserver *s) : sockfd(fd), addr(ar), tsvr(s)
        {
        }

    public:
        int sockfd;
        InetAddr addr;
        tcpserver *tsvr;
    };
    //新线程的入口函数
    static void *Routine(void *args)
    {
        pthread_detach(pthread_self());
        ThreadData *td = static_cast<ThreadData *>(args);
        td->tsvr->service(td->sockfd, td->addr);
        delete td;
        return nullptr;
    }

    void run()
    {
        _isrunning=true;
        while(_isrunning)
        {
            //4，获取连接
            struct sockaddr_in peer;
            socklen_t len=sizeof(sockaddr_in);
            //如果没有连接，accept就会阻塞
            //sockfd提供接下来的read和write
            int sockfd=accept(_listensockfd, CONV(peer), &len);
            if (sockfd < 0)
            {
                LOG(LogLevel::WARNING) << "accept error";
                continue;
            }
            InetAddr addr(peer);

            //version3------多线程
            ThreadData *td = new ThreadData(sockfd, addr, this);
            pthread_t tid;
            pthread_create(&tid, nullptr, Routine, td);
            //version1------单进程，一般不会采用
            //service(sockfd,addr);

            //version2
            //多进程
            // pid_t id=fork();
            // if(id<0)
            // {
            //     LOG(LogLevel::FATAL)<<"创建子进程失败";
            //     exit(FORK_ERR);
            // }
            // else if(id==0)//子进程
            // {
            //     //关掉不用的文件描述符
            //     close(_listensockfd);
            //     if(fork()>0)//再次创建子进程
            //     exit(OK);//正常退出

            //     //执行service
            //     service(sockfd,addr);//孙子进程执行
            //     exit(OK);
            // }
            // else
            // {
            //     //父进程
            //     //关掉不用的文件描述符
            //     close(sockfd);
            //     //忽略子进程的退出信号
            //     //signal(SIGCHLD,SIG_IGN);

            //     //父进程直接退出
            //     pid_t rid=waitpid(id,nullptr,0);//父进程不会再等待了
            //     //再次循环执行获取连接的方法 accept
            // }
        }
        _isrunning=false;
    }
private:
    uint16_t _port;
    int _listensockfd;
    bool _isrunning;
};

tcpserver.cpp

#pragma once

#include "tcpserver.hpp"

void Usage(char* proc)
{
    std::cerr<<"Usage ::"<<proc<<" port"<<std::endl;
}
int main(int argc,char* argv[])
{
    if(argc!=2)
    {
        Usage(argv[0]);
        exit(USAGE_ERR);
    }
    uint16_t  port=std::stoi(argv[1]);
    //设置日志向控制台打印
    Enable_Console_Log_Strategy();

    //开启日志，默认向控制台打印
    std::unique_ptr<tcpserver> tsvs=std::make_unique<tcpserver>(port);
    tsvs->init();
    tsvs->run();
    
    return 0;
}

Common.hpp

#pragma once

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

//枚举退出码
enum ExitCode
{
    OK = 0,
    USAGE_ERR,
    SOCKET_ERR,
    BIND_ERR,
    LISTEN_ERR,
    CONNECT_ERR,
    FORK_ERR
};

//禁止拷贝构造和赋值重载
class NoCopy
{
public:
    NoCopy()
    {}
    ~NoCopy()
    {}
    NoCopy(const NoCopy& n)=delete;
    const NoCopy& operator=(const NoCopy& n)=delete;
};

#define CONV(addr) ((struct sockaddr*)&addr)

日志代码，日志的实现是需要锁的

#ifndef __LOG_HPP__
#define __LOG_HPP__
// 实现一个日志打印消息

#include <iostream>
#include <filesystem> //c++17引入
#include <string>
#include <fstream>
#include <memory>
#include <unistd.h>
#include <sstream>
#include <cstdio>
#include <ctime>
#include "Mutex.hpp"


using namespace MutexModel;
namespace LogModule
{
    // 首先定义打印策略------文件打印/控制台打印
    // 通过多态实现，这样写方便后来内容的补充，比如增加向网络中刷新，只需再继承一个类
    // 基类
    const std::string gsep = "\r\n";
    class LogStrategy
    {
    public:
        LogStrategy()
        {
        }
        ~LogStrategy()
        {
        }
        // 虚函数  子类需要重写的刷新策略
        virtual void Synclog(const std::string &message) = 0;
    };
    // 控制台打印，日志信息向控制台打印
    class ConsoleLogStrategy : public LogStrategy
    {
    public:
        ConsoleLogStrategy()
        {
        }
        ~ConsoleLogStrategy()
        {
        }
        void Synclog(const std::string &message) override
        {
            // 向控制台打印
            // 需要维护线程安全
            LockGuard lockguard(_mutex);
            std::cout << message << gsep;
        }

    private:
        Mutex _mutex;
    };

    // 指定默认的文件路径和文件名
    const std::string defaultpath = "./log";
    const std::string defaultname = "my.log";
    // 指定文件打印日志
    class FileLogStrategy : public LogStrategy
    {
    public:
        FileLogStrategy(const std::string &path = defaultpath, const std::string &name = defaultname)
            : _path(path),
              _name(name)
        {
            // 维护线程安全
            LockGuard lockguard(_mutex);
            // 判断对应的路径是否存在
            if (std::filesystem::exists(_path))
            {
                return;
            }
            try
            {
                std::filesystem::create_directories(_path);
            }
            catch (const std::filesystem::filesystem_error &e)
            {
                std::cerr << e.what() << '\n';
            }
        }
        ~FileLogStrategy()
        {
        }
        void Synclog(const std::string &message)
        {
            LockGuard lockgyard(_mutex);
            std::string filename = _path + (_path.back() == '/' ? " " : "/") + _name;
            std::ofstream out(filename, std::ios::app);
            if (!out.is_open())
            {
                return;
            }
            out << message << gsep;
            out.close();
        }

    private:
        std::string _path; // 文件路径
        std::string _name; // 文件名
        Mutex _mutex;
    };

    // 日志等级
    enum class LogLevel
    {
        DEBUG,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };
    std::string LevelToStr(LogLevel level)
    {
        switch (level)
        {
        case LogLevel::DEBUG:
            return "DEBUG";
        case LogLevel::ERROR:
            return "ERROR";
        case LogLevel::INFO:
            return "INFO";
        case LogLevel::FATAL:
            return "FATAL";
        case LogLevel::WARNING:
            return "WARNING";
        }
        return "none";
    }
    // 获取当前时间
    std::string GetTimeStamp()
    {
        time_t curr = time(nullptr);
        struct tm curr_time;
        localtime_r(&curr, &curr_time);
        char TimeBuffer[128];
        snprintf(TimeBuffer, sizeof(TimeBuffer), "%4d-%02d-%02d %02d:%02d:%02d",
                 curr_time.tm_year + 1900,
                 curr_time.tm_mon+1,
                 curr_time.tm_mday,
                 curr_time.tm_hour,
                 curr_time.tm_min,
                 curr_time.tm_sec);
        return TimeBuffer;
    }
    // 形成一条完整的日志
    // 根据上面不同的策略，选择不同的刷新方案
    class Logger
    {
    public:
        Logger()
        {
            // 默认是向控制台刷新
            EnableConsoleStrategy();
        }
        ~Logger()
        {
        }
        // 更改刷新策略
        // 文件刷新
        void EnableFileLogStrategy()
        {
            _flush_strategy = std::make_unique<FileLogStrategy>();
        }
        // 控制台刷新
        void EnableConsoleStrategy()
        {
            _flush_strategy = std::make_unique<ConsoleLogStrategy>();
        }
        // 内部类
        // 一条完整的日志信息
        class LogMessage
        {
        public:
            LogMessage(LogLevel level, const std::string &src_name, int line_number, Logger &logger)
                : _level(level),
                  _src_name(src_name),
                  _line_number(line_number),
                  _logger(logger),
                  _pid(getpid()),
                  _curr_time(GetTimeStamp())
            {
                // 字符串流
                std::stringstream ss;
                // 合并日志的左半部分
                ss << "[" << _curr_time << "] "
                   << "[" << LevelToStr(_level) << "] "
                   << "[" << _pid << "] "
                   << "[" << _src_name << "] "
                   << "[" << _curr_time << "] " << "-";
                _loginfo = ss.str();
            }
            //支持<<"hello world"<<1<<3.14
            template <class T>
            LogMessage& operator<<(const T& info)
            {
                std::stringstream ss;
                //右半部分日志
                ss<<info;
                _loginfo+=ss.str();
                return *this;
            }
            ~LogMessage()
            {
                if(_logger._flush_strategy)
                //完成刷新
                _logger._flush_strategy->Synclog(_loginfo);
            }
        private:
            std::string _curr_time;
            LogLevel _level;
            pid_t _pid;
            std::string _src_name; // 所在文件的文件名
            int _line_number;      // 行号
            Logger &_logger;
            std::string _loginfo; // 合并之后，一条完整的日志
        };
        //重载()
        LogMessage operator()(LogLevel level,std::string name,int line_number)
        {
            return LogMessage(level,name,line_number,*this);
        }

    private:
        std::unique_ptr<LogStrategy> _flush_strategy; // 智能指针来管理刷新策略
    };

    //使用 
    //定义一个全局的对象
    Logger logger;

    //方便使用，封装成宏
    //__FILE__为指定的文件
    //__LINE__为指定的行
    #define LOG(level) logger(level,__FILE__,__LINE__)
    #define Enable_Console_Log_Strategy() logger.EnableConsoleStrategy()
    #define Enable_File_Log_Strategy() logger.EnableFileLogStrategy()
}

#endif

锁代码

/// 简单封装互斥锁
#pragma once
#include <iostream>
#include <pthread.h>

// 基础互斥锁的封装
namespace MutexModel
{
    class Mutex
    {
    public:
        Mutex()
        {
            pthread_mutex_init(&_mutex, nullptr);
        }
        ~Mutex()
        {
            pthread_mutex_destroy(&_mutex);
        }
        void Lock()
        {
            int n = pthread_mutex_lock(&_mutex);
            (void)n;
        }
        void Unlock()
        {
            int n = pthread_mutex_unlock(&_mutex);
            (void)n;
        }

    private:
        pthread_mutex_t _mutex;
    };

    // RAII守卫类
    class LockGuard
    {
    public:
        LockGuard(Mutex& mtx)
        :_mtx(mtx)
        {
            _mtx.Lock();
        }
        ~LockGuard()
        {
            _mtx.Unlock();
        }
    private:
        Mutex &_mtx;
    };
}

makefile文件

.PHONY:all
all:tcpclient tcpserver

tcpclient:tcpclient.cpp
	g++ -o $@ $^ -std=c++17  
tcpserver:tcpserver.cpp
	g++ -o $@ $^ -std=c++17 -pthread

.PHONY:clean
clean:
	rm -f tcpclient tcpserver

五，总结

这次的echo server代码的编写，我遇到的问题是客户端代码运行到connect就停止了，也就是创建完套接字就阻塞住了，没有执行 建立连接以及后序的代码。找了半天才发现是服务器端的端口号初始化时出现了问题，裂开！！！