网络：udp&&tcp套接字

目录

协议

网络传输基本流程

网络编程套接字

udp套接字编程

 udp相关代码实现

sock函数

bind函数

recvfrom函数

sendto函数

udp执行指令代码

popen函数

udp多线程版收发消息

tcp套接字编程

tcp套接字代码

listen函数

accept函数

read/write函数

connect函数

recv/send函数

---

协议

协议本质就是一种约定，网络上一定要硬件上有标志，软件上有协议

关于协议分层

1.操作系统要进行协议管理：先描述，在组织
2.协议本质就是软件，软件是可以”分层‘
3.协议在设计的时候，就是被层状的划分的
4.要划分为层状结构是因为： a. 场景复杂 b.功能解耦，便于人们进行各种维护

所以网络协议也是层状的

OSI七层模型：物理层、数据链路层、网络层、传输层、会话层、表示层、应用层这7层

但是, OSI七层模型既复杂又不实用; 所以我们按照TCP/IP四(五)层模型来讲解，即(物理层)、数据链路层、网络层、传输层、应用层

TCP/IP通讯协议采用了5层的层级结构，每一层都呼叫它的下一层所提供的网络来完成自己的需求，物理层我们不关心

传输层和网络层是在操作系统中实现的

对于一台主机, 它的操作系统内核实现了从传输层到网络层
对于一台路由器, 它实现了从网络层到物理层
对于一台交换机, 它实现了从数据链路层到物理层
对于集线器, 它只实现了物理层

---

网络传输基本流程

下面几层对应的代表性的协议

网络通信的过程中：

在逻辑上：在应用层相互直接传输
在物理上： 必须得自顶向下(从应用层->链路层)将数据报文交付到最底层，然后在以太网上传输，被你的主机收到后，再自底向上(从链路层->应用层)交付到应用层

每层都有自己的协议定制方案,
每层协议都要有自己的协议报头
从上到下交付数据的时候，要添加报头
从下到上递交数据的时候，要去掉报头

协议报头就是收到的报文当中，多出来的数据内容，可以理解为同层协议提前约定好的共识字段

把自顶向下交付的过程，称之为封装的过程，封装的本质：添加报头

自底向上交付的时候，需要将报头和有效载荷做分离，分析报头的字段，去决定将它的有效载荷向上应该交付给哪一个协议

把自底向上交付的过程，称之为解包的过程，解包的本质：去掉报头，展开分析

---

在局域网中两台主机是可以直接通信的

例如有5台主机都在一个局域网里，主机1和主机2通信，表面上是这两个主机单独通信，实际其他主机也都能看到他们通信的内容，只是每个主机对比自己的MAC地址，看是不是再和自己通信，如果不是，将当前报文丢弃即可

通过MAC地址来标识局域网中主机的唯一性

IP地址和MAC地址的区别：

IP就类似于旅游时，想从陕西去新疆去，所以此时的源IP就是陕西，目的IP就是新疆

在去的路途中，加入当前在甘肃省，当地人说下一站应该去青海省，所以此时的源MAC地址就是甘肃，下一站MAC地址就是青海

将数据在主机间转发仅仅是手段，机器收到之后，需要将数据交付给指定的进程
因此真正的网络通信过程，本质其实是进程间通信

---

在使用TCP/IP协议的网络中，IP及其向上的协议，看到的报文都是一样的。

应用层数据通过协议栈发到网络上时,每层协议都要加上一个数据首部,称为封装

数据封装成帧后发到传输介质上,到达目的主机后每层协议再剥掉相应的首部, 根据首部中的 "上层协议 字段" 将数据交给对应的上层协议处理.

---

网络编程套接字

网络4件套，只要将下面四种头文件都包含，网络中所需要的就都能使用了

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

---

IP协议有两个版本, IPv4和IPv6，没有特殊说明的, 默认都是指IPv4，IPv4来说, IP地址是一个4字节, 32位的整数

IP地址,就例如：192.168.0.1，用点分割的每一个数字表示一个字节, 范围是 0 - 255;所以理论上，表示一个IP地址，其实4字节就够了，而192.168.0.1这个字符串却需要11个字节，所以点分十进制字符串风格的IP地址，需要和4字节的IP地址互相转换

IP地址(公网IP)，它标定了主机的唯一性

端口号一般是16位的整数

端口号是标识特定主机上的网络进程的唯一性

一个进程可以绑定多个端口号; 但是一个端口号不能被多个进程绑定

所以IP+端口号就可以得到全网唯一的一个进程了

我们把IP地址+端口号，称之为套接字

---

 UDP协议

UDP协议叫做用户数据报协议，它的特点：无连接、不可靠传输、面向数据报

无连接：在使用UDP通信时，不用写代码时建立连接，直接发送数据即可

不可靠传输：UDP可能出现网络丢包的问题，或是数据包乱序重复等问题

---

TCP协议

TCP协议叫做用户数据报协议，它的特点：有连接、可靠传输、面向字节流

可靠传输：指TCP不会出现上述UDP的网络丢包等问题

---

那么UDP是不可靠传输，而TCP是可靠传输，为什么我们还需要学UDP呢，直接学TCP就好了呀

其实很简单，TCP保证可靠性，就一定决定了它在数据通信的过程中，要为了保证可靠性，而设计更多的策略，各种制度机制，都要靠协议自己完成，往往更复杂，成本更高

而UDP只要将数据发出去，就不用管可不可靠的问题了，UDP更为简单，成本更低，TCP则更为安全，所以UDP/TCP是各有所长的

因此在应用场景中，除非场景非常适合UDP，那么我们都选择TCP协议

像直播、视频一类的使用UDP更好，例如在看直播时，突然人物卡顿一下，掉帧一下，都是因为使用的UDP，导致的丢包问题，但是并不会影响我们观看直播

---

网络字节序

假设两个主机通信，一个主机是大端存储，一个主机是小段存储，那么在通信时，肯定会发生错误，因为两个主机存储的方式都不一样，肯定无法正确的通信

所以计算机网络规定，所有网络数据，都必须是大端存储的

操作系统提供了4个接口，头文件是arpa/inet.h

uint32_t htonl(uint32_t hostlong) ;
uint16_t htons(uint16_t hostshort) ;
uint32_t ntohl(uint32_t netlong) ;
uint16_t ntohs(uint16_t netshort) ;

其中h表示host，表示本地；n表示network，表示网络；l表示long，4字节；s表示short，2字节

所以hton就表示主机转网络，即无论主机是什么序列都会转成大端

ntoh就表示网络转主机

---

常见套接字：

域间socket、原始socket、网络socket

其中网络socket是使用的最多

理论上，这三种套接字是三种应用场景，对应的应该是三套接口，而Linux为了使用更方便，不想设计过多的接口，而是使用同一套接口，如下所示：

创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);

绑定端口号 (TCP/UDP, 服务器)
int bind(int socket, const struct sockaddr *address, socklen_t address_len);

开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address, socklen_t* address_len);

建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

通过观察可以发现，每一个接口都有一个共同的结构sockaddr

其中网络socket是sockaddr_in结构，它的前两个字节是AF_INET

域间socket是sockaddr_un结构，它的前两个字节是AF_UNIX

那么这个公共的结构sockaddr，前两个字节就可以用来辨别是网络socket还是域间socket，sockaddr就如同我们C语言中的void*的概念

---

udp套接字编程

 udp相关代码实现

下面初步实现服务端与客户端链接，客户端发消息，服务端可以回复消息，如下所示：

 下面是几个需要使用的函数接口：

sock函数

sock函数是计算机网络给我们提供的系统调用接口，对传输层做了文件系统级别封装的接口

socket函数需要包含头文件：sys/types.h和sys/socket.h

函数返回值：返回一个文件描述符，返回-1就表示失败，errno就表明出错的原因

函数参数：

第一个参数domain：一般表示套接字的域，有AF_INET(网络通信)、AF_UNIX(本地通信)等等

第二个参数type：type表示类型，代表你想创建这个套接字的通信种类是什么，一般填的是SOCK_DGRAM，表示用户数据报套接字

第三个参数protocol：protocol表示协议，一般前两个参数确定了，协议也就确定了，所以一般是0

使用示例如下：

---

bind函数

bind函数：将用户设置的ip和port在内核中和我们当前的进程强关联

bind函数需要包含头文件：sys/types.h和sys/socket.h

函数返回值：成功返回0，否则返回-1，errno就表明出错的原因

函数参数：

第一个参数sockfd：是刚刚创建的套接字，需要将ip和port与套接字关联起来

第二个参数addr：上面提到了填充ip和port信息的结构体

第三个参数addrlen：是addr的大小，用sizeof就能计算出来

使用示例如下：

因为bind接口的第二个参数类型是struct sockaddr*的，而我们创建的local的类型是struct sockaddr_in的，所以需要强转一下

---

recvfrom函数

recvfrom函数是读取数据的函数

函数返回值：ssize_t是有符号整数，失败会返回-1

函数参数：

第一个参数：表示刚刚创建成功的套接字

第二/三个参数：表示一段缓冲区，len表示大小

第四个参数：表示读取的方式，默认为0，表示以阻塞方式读取

第五/六个参数：表示两个输出型参数，需要我们传入特定的结构体，及特定结构体的其他信息，方便我们把客户端的IP和端口提上来，服务器就能够知道是谁发的消息，进而把消息再转发回去

除了拿到数据，我们也想知道是谁给我发的消息，即得到src_ip(源IP)，src_port(源端口号)，即客户端的IP和端口号，当client发送给server时，server就需要得到client_ip和client_port

使用示例如下：

---

sendto函数

sendto函数是返回消息的接口

第一个参数：表示创建的套接字

第二/三个参数：表示要发送的数据buf缓冲区，和它的长度len

第三个参数：flag默认设置为0

第四/五个参数：表示需要把缓冲区发给谁，长度是多少

使用示例如下：

---

关于127.0.0.1，这个IP地址称为本地环回，client和server发送数据只在本地协议栈中进行数据流动，不会吧我们的数据发送到网络中

通常用于本地网络服务器的测试，如果在127.0.0.1这里测试通过了，即客户端发消息，server能收到，那如果联通网络，再进行测试时，发现联不通，这时的问题大概率就是网络的问题

---

在云服务器中：

云服务器无法bind公网IP，也不建议bind公网IP

对于server来讲，我们也不推荐bind确定的IP

推荐使用任意IP的方案，如下

所以服务器服务端，写IP地址填充的时候，都是INADDR_ANY，当然如果未来有特殊需求，也可以在构造函数中给指定的IP，这样就bind指定的IP了

---

代码如下：

makefile：

.PHONY:all
all:udp_client udp_server
 
udp_client:udp_client.cc
	g++ -o $@ $^ -std=c++11
udp_server:udp_server.cc
	g++ -o $@ $^ -std=c++11
 
.PHONY:clean
clean:
	rm -f udp_client udp_server

---

udp_client.cc：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " ServerIp ServerPort\n" << std::endl;
}
 
int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    //创建客户端套接字
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if(sock < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(2);
    }
    //   client当然也需要bind
    //但是一般client不会显示bind，即程序员不需要自己bind
    //client是一个客户端，是被普通人下载安装使用的
    //如果程序员自己bind了，client就bind了一个固定的port
    //万一其他客户端提前占用了这个port，该client就不会启动了
    //client一般不需要显示的bind指定port，而是让0S自动随机选择
    std::string message;        
    struct sockaddr_in server;
    memset(&server,0,sizeof(server));//初始化为0
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(argv[2]));
    //inet_addr将点分十进制字符串转为4字节，再将4字节主机序列->网络序列
    server.sin_addr.s_addr = inet_addr(argv[1]);
 
    char buffer[1024];
    while(true)
    {
        std::cout << "请输入你的信息# ";
        std::getline(std::cin, message);
        if(message == "quit")
            break;
        //当client首次发送消息给服务器的时候，OS会自动给client bind他自己的IP和port
        sendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
        //读数据
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&temp, &len);
        if(s > 0)
        {
            buffer[s] = 0;
            std::cout << "server echo# " << buffer << std::endl;
        }
    }   
    close(sock);//关闭套接字
    return 0;
}

---

udp_server.hpp：

#ifndef _UDP_SERVER_HPP
#define _UDP_SERVER_HPP
 
#include "log.hpp"
#include <iostream>
#include <string>
#include <cstdio>
#include <memory>
#include <cstring>
#include <strings.h>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
 
#define SIZE 1024
 
class UdpServer
{
public:
    UdpServer(uint16_t port, std::string ip=""):
    _port(port),_ip(ip),_sock(-1)
    {}
 
    //初始化服务器
    bool initServer()
    {
        //从这里开始，就是新的系统调用，来完成网络功能
        // 1.创建套接字
        _sock = socket(AF_INET, SOCK_DGRAM, 0);
        if(_sock < 0)//_sock < 0表示创建套接字失败
        {
            //strerror将错误码转化为错误码描述
            logMessage(FATAL,"%d:%s", errno, strerror(errno));
            exit(2);
        }
        // 2. bind:将用户设置的ip和port在内核中和我们当前的进程强关联
        //sockaddr_in是结构体封装的整数
        struct sockaddr_in local;
        //结构体需要进行清0，使用bzero函数
        bzero(&local, sizeof(local));   
        //上面传入的参数是AF_INET，这里的sin_family也就是AF_INET
        local.sin_family = AF_INET; 
        //服务器的IP和端口未来也是要发送给对方主机的->先要将数据发送到网络
        //所以需要将_port主机转网络
        local.sin_port = htons(_port);
        //1.同上，先要将点分十进制字符串风格的IP地址-> 4字节
        //2. 4字节主机序列->网络序列
        //有一套接口inet_addr，可以一次帮我们做完上述这两件事情
        //宏INADDR_ANY就是0，让服务器在工作过程中，可以从任意IP中获取数据
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
        //绑定
        if(bind(_sock,(struct sockaddr*)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL,"%d:%s", errno, strerror(errno));
            exit(2);
        }   
        logMessage(NORMAL, "init udp server done %s", strerror(errno));
        //初始化结束
        return true;
    }
 
    //启动服务器
    void Start()
    {
        //作为一款网络服务器，永远不退出的
        //服务器启动->常驻进程->永远在内存中存在，除非挂了，所以要小心内存泄漏的问题
        //echo server: client给我们发送消息，我们原封不动返回即可
 
        //创建缓冲区
        char buffer[SIZE];
        for( ; ; )
        {
            //倒数第二个参数peer是纯输出型参数            
            struct sockaddr_in peer;
            bzero(&peer,sizeof(peer));
            //最后一个参数，既可以输入又可以输出
            //输入时：peer缓冲区的大小
            //输出时：实际读到的的peer
            socklen_t len = sizeof(peer);
            //start : 读取数据
            ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
            //s>0表示读取数据成功
            if(s > 0)
            {
                buffer[s] = 0;//我们目前数据当做字符串
                // 1.输出发送的信息 2. 知道是谁发送的 
                //从网络中来，所以需要网络转主机，即ntoh
                uint16_t cli_port = ntohs(peer.sin_port);
                //4字节的网络序列的IP -> 本主机的点分十进制风格的IP,使用inet_ntoa函数
                std::string cli_ip = inet_ntoa(peer.sin_addr);
                printf("[%s:%d]# %s\n", cli_ip.c_str(), cli_port, buffer);
            }
            //分析和处理数据
 
            //end : 写回数据
            sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
        }
    }
 
    ~UdpServer()
    {
        if(_sock >= 0)
            close(_sock);//关闭套接字
    }
private:
    //一个服务器，一般必须需要ip地址和port(16位的整数)
    uint16_t _port;
    std::string _ip;    
    int _sock;//通信的套接字
};
 
 
#endif
 

---

udp_server.cc：

#include "udp_server.hpp"
#include <memory>
#include <cstdlib>
 
static void usage(std::string proc)
{
    std::cout << "\nUsage:" << proc << " port\n" << std::endl;
}
 
// ./udp_server port
//命令行参数，argc是2
//argv[0]/[1]分别是./udp_server/port
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    //std::string ip = argv[1];
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<UdpServer> svr(new UdpServer(port));
    //初始化服务器、启动服务器
    svr->initServer();
    svr->Start();
    return 0;
}

---

以及使用的以前实现的log.hpp：

#pragma once
 
#include <iostream>
#include <cstdio>
#include <cstdarg>
#include <string>
#include <ctime>
 
//日志等级
#define DEBUG   0
#define NORMAL  1
#define WARNING 2
#define ERROR   3
#define FATAL   4
 
//日志等级的映射表
const char* gLevelMap[]={
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"
};
 
//日志功能至少：日志等级 时间；支持用户自定义(日志内容等等)
//format是输出格式例如%s之类的
void logMessage(int level, const char* format, ...)
{
//条件编译，如果定义了DEBUG_SHOW这个宏，在打印时就正常打印
//如果没有定义这个DEBUG_SHOW宏，所以level是DEBUG的语句就不再打印了
//我们可以在makefile命令行中定义宏，加上-D选项即可
#ifndef DEBUG_SHOW
    if(level == DEBUG) return;
#endif
    //                                        vprintf/vfprintf/vsprintf/ vsnprintf
    //是把传入的参数按照可变的方式分别进行显示到 显示器 /  文件  / 字符串 /指定长度的字符串
    //stdBuffer是日志的标准部分，如日志等级 时间
    //logBuffer是日志的自定义部分，如日志内容等
    char stdBuffer[1024];
    char logBuffer[1024];
 
    //这里的时间采用较为简单的时间戳表示
    time_t tm = time(nullptr);
    snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld]", gLevelMap[level], tm);
 
    va_list args;
    va_start(args, format);
    vsnprintf(logBuffer,sizeof logBuffer, format, args);
    va_end(args);
    //拼接两个字符串的内容，一块打印出来
    printf("%s %s\n", stdBuffer, logBuffer);
}

---

udp执行指令代码

如果是上面的聊天，发送的就是文本，如果是指令例如ls -a -l，我们想把命令执行完，把执行的结果再返回，下面实现远程实现命令的功能：

popen函数

popen可以执行传入的command指令，先建立pipe管道，然后再fork()，子进程执行(exec*，即exec系列的接口)command的命令，

返回值FILE *:可以将执行结果通过FILE*指针进行读取

---

此功能实现，仅仅改变了udp_server.hpp，其他文件没有变化：

#ifndef _UDP_SERVER_HPP
#define _UDP_SERVER_HPP
 
#include "log.hpp"
#include <iostream>
#include <string>
#include <cstdio>
#include <memory>
#include <cstring>
#include <strings.h>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
 
#define SIZE 1024
 
class UdpServer
{
public:
    UdpServer(uint16_t port, std::string ip=""):
    _port(port),_ip(ip),_sock(-1)
    {}
 
    //初始化服务器
    bool initServer()
    {
        //从这里开始，就是新的系统调用，来完成网络功能
        // 1.创建套接字
        _sock = socket(AF_INET, SOCK_DGRAM, 0);
        if(_sock < 0)//_sock < 0表示创建套接字失败
        {
            //strerror将错误码转化为错误码描述
            logMessage(FATAL,"%d:%s", errno, strerror(errno));
            exit(2);
        }
        // 2. bind:将用户设置的ip和port在内核中和我们当前的进程强关联
        //sockaddr_in是结构体封装的整数
        struct sockaddr_in local;
        //结构体需要进行清0，使用bzero函数
        bzero(&local, sizeof(local));   
        //上面传入的参数是AF_INET，这里的sin_family也就是AF_INET
        local.sin_family = AF_INET; 
        //服务器的IP和端口未来也是要发送给对方主机的->先要将数据发送到网络
        //所以需要将_port主机转网络
        local.sin_port = htons(_port);
        //1.同上，先要将点分十进制字符串风格的IP地址-> 4字节
        //2. 4字节主机序列->网络序列
        //有一套接口inet_addr，可以一次帮我们做完上述这两件事情
        //宏INADDR_ANY就是0，让服务器在工作过程中，可以从任意IP中获取数据
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
        //绑定
        if(bind(_sock,(struct sockaddr*)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL,"%d:%s", errno, strerror(errno));
            exit(2);
        }   
        logMessage(NORMAL, "init udp server done %s", strerror(errno));
        //初始化结束
        return true;
    }
 
    //启动服务器
    void Start()
    {
        //作为一款网络服务器，永远不退出的
        //服务器启动->常驻进程->永远在内存中存在，除非挂了，所以要小心内存泄漏的问题
        //echo server: client给我们发送消息，我们原封不动返回即可
 
        //创建缓冲区
        char buffer[SIZE];
        for( ; ; )
        {
            //倒数第二个参数peer是纯输出型参数            
            struct sockaddr_in peer;
            bzero(&peer,sizeof(peer));
            //最后一个参数，既可以输入又可以输出
            //输入时：peer缓冲区的大小
            //输出时：实际读到的的peer
            socklen_t len = sizeof(peer);
            char result[256];//将fgets读到的都放到result中
            std::string cmd_echo;
            //start : 读取数据
            ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
            //s>0表示读取数据成功
            if(s > 0)
            {
                buffer[s] = 0;//我们目前数据当做字符串
                //判断命令中不能有rm相关的指令
                if(strcasestr(buffer,"rm") != nullptr || strcasestr(buffer,"rmdir") != nullptr)
                {
                    std::string err_message = "非法请求: ";
                    std::cout << err_message << buffer << std::endl;
                    sendto(_sock, err_message.c_str(), err_message.size(), 0, (struct sockaddr*)&peer, len);
                    continue;
                }
                FILE* fp = popen(buffer, "r");
                if(fp == nullptr)
                {
                    logMessage(ERROR,"%d:%s", errno, strerror(errno));
                    continue;
                }
 
                while(fgets(result, sizeof(result), fp) != nullptr)//读取成功
                {
                    cmd_echo += result;
                }
                fclose(fp);
            }
            //分析和处理数据
 
            //end : 写回数据
            //sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
            sendto(_sock, cmd_echo.c_str(), cmd_echo.size(), 0, (struct sockaddr*)&peer, len);
        }
    }
 
    ~UdpServer()
    {
        if(_sock >= 0)
            close(_sock);//关闭套接字
    }
private:
    //一个服务器，一般必须需要ip地址和port(16位的整数)
    uint16_t _port;
    std::string _ip;    
    int _sock;//通信的套接字
};
 
 
#endif
 

---

udp多线程版收发消息

下面再加以改进，把所有访问当前服务器的人都记录下来，每次一个客户端发消息，另一个客户端能够收到别的客户端发送的消息

下面演示效果：有两个客户端使用mkfifo创建命名管道，分别是clientA和clientB，每一个客户端都设立两个窗口，一个窗口发数据，将收到的数据输出重定向到管道中，另一个窗口使用cat从管道读出来：

上述是4个窗口，上面两个是clientA的，下面两个是clientB的，左边的窗口发送数据，右边的窗口接收数据，并且可以根据端口号看出来是谁发的消息，例如端口号为32795的就是clientA，而端口号为44280的就是clientB

下面是服务端：

最开始运行./udp_server 8080后，直到clientA发送数据后，服务端就会打印init，key，add这三条语句，并且每当其中一个客户端发送数据，服务端都会将这条数据发送给每一个客户端，两个push语句就能够很好地体现这一点

---

下面是相关代码：

makefile的udp_client后面需要加-lpthread，因为要使用pthread库

并且这里引用了前面曾经实现过的thread.hpp

---

udp_server.hpp：

#ifndef _UDP_SERVER_HPP
#define _UDP_SERVER_HPP
 
#include "log.hpp"
#include <iostream>
#include <string>
#include <unordered_map>
#include <cstdio>
#include <memory>
#include <cstring>
#include <strings.h>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
 
#define SIZE 1024
 
class UdpServer
{
public:
    UdpServer(uint16_t port, std::string ip=""):
    _port(port),_ip(ip),_sock(-1)
    {}
 
    //初始化服务器
    bool initServer()
    {
        //从这里开始，就是新的系统调用，来完成网络功能
        // 1.创建套接字
        _sock = socket(AF_INET, SOCK_DGRAM, 0);
        if(_sock < 0)//_sock < 0表示创建套接字失败
        {
            //strerror将错误码转化为错误码描述
            logMessage(FATAL,"%d:%s", errno, strerror(errno));
            exit(2);
        }
        // 2. bind:将用户设置的ip和port在内核中和我们当前的进程强关联
        //sockaddr_in是结构体封装的整数
        struct sockaddr_in local;
        //结构体需要进行清0，使用bzero函数
        bzero(&local, sizeof(local));   
        //上面传入的参数是AF_INET，这里的sin_family也就是AF_INET
        local.sin_family = AF_INET; 
        //服务器的IP和端口未来也是要发送给对方主机的->先要将数据发送到网络
        //所以需要将_port主机转网络
        local.sin_port = htons(_port);
        //1.同上，先要将点分十进制字符串风格的IP地址-> 4字节
        //2. 4字节主机序列->网络序列
        //有一套接口inet_addr，可以一次帮我们做完上述这两件事情
        //宏INADDR_ANY就是0，让服务器在工作过程中，可以从任意IP中获取数据
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
        //绑定
        if(bind(_sock,(struct sockaddr*)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL,"%d:%s", errno, strerror(errno));
            exit(2);
        }   
        logMessage(NORMAL, "init udp server done %s", strerror(errno));
        //初始化结束
        return true;
    }
 
    //启动服务器
    void Start()
    {
        //作为一款网络服务器，永远不退出的
        //服务器启动->常驻进程->永远在内存中存在，除非挂了，所以要小心内存泄漏的问题
        //echo server: client给我们发送消息，我们原封不动返回即可
 
        //创建缓冲区
        char buffer[SIZE];
        for( ; ; )
        {
            //倒数第二个参数peer是纯输出型参数            
            struct sockaddr_in peer;
            bzero(&peer,sizeof(peer));
            //最后一个参数，既可以输入又可以输出
            //输入时：peer缓冲区的大小
            //输出时：实际读到的的peer
            socklen_t len = sizeof(peer);
            char key[64];
            char result[256];//将fgets读到的都放到result中
            std::string cmd_echo;
            //start : 读取数据
            ssize_t s = recvfrom(_sock, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
            //s>0表示读取数据成功
            if(s > 0)
            {
                buffer[s] = 0;//我们目前数据当做字符串
                //提取ip和port
                uint16_t cli_port = ntohs(peer.sin_port);
                //4字节的网络序列的IP -> 本主机的点分十进制风格的IP,使用inet_ntoa函数
                std::string cli_ip = inet_ntoa(peer.sin_addr);
                snprintf(key,sizeof(key),"%s-%u",cli_ip.c_str(),cli_port);
                logMessage(NORMAL, "key:%s", key);
                auto it = _users.find(key);//查找key
                if(it == _users.end())
                {
                    logMessage(NORMAL,"add new user : %s", key);
                    //说明用户不存在
                    _users.insert({key,peer});
                }
            }
            //分析和处理数据
 
            //end : 写回数据
            //sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
            for(auto& iter : _users)
            {
                std::string sendMessage = key;
                sendMessage += "# ";
                sendMessage += buffer;
                //因为直接发送消息，并不知道是谁发的消息，所以在消息前加上发送消息的 “IP+port#” 
                logMessage(NORMAL,"push message to %s", iter.first.c_str());
                sendto(_sock, sendMessage.c_str(), sendMessage.size(), 0, (struct sockaddr*)&(iter.second), sizeof(iter.second));
            }
        }
    }
 
    ~UdpServer()
    {
        if(_sock >= 0)
            close(_sock);//关闭套接字
    }
private:
    //一个服务器，一般必须需要ip地址和port(16位的整数)
    uint16_t _port;
    std::string _ip;    
    int _sock;//通信的套接字
    std::unordered_map<std::string, struct sockaddr_in> _users;
};
 
 
#endif
 

---

udp_server.cc：

#include "udp_server.hpp"
#include <memory>
#include <cstdlib>
 
static void usage(std::string proc)
{
    std::cout << "\nUsage:" << proc << " port\n" << std::endl;
}
 
// ./udp_server port
//命令行参数，argc是2
//argv[0]/[1]分别是./udp_server/port
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    //std::string ip = argv[1];
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<UdpServer> svr(new UdpServer(port));
    //初始化服务器、启动服务器
    svr->initServer();
    svr->Start();
    return 0;
}

---

udP_client.cc：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <memory>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
#include "thread.hpp"
 
//我们发现:无论是多线程读还是写，用的sock都是一个，sock代表就是文件，UDP是全双工的->可以同时进行收发而不受干扰
 
uint16_t serverport = 0;
std::string serverip;
 
static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " ServerIp ServerPort\n"
              << std::endl;
}
 
// 发送方
static void *udpSend(void *args)
{
    // 拿到sock和线程名name
    int sock = *(int *)((ThreadData *)args)->args_;
    std::string name = ((ThreadData *)args)->name_;
    std::string message;
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server)); // 初始化为0
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    // inet_addr将点分十进制字符串转为4字节，再将4字节主机序列->网络序列
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    // 不断的给对方发送数据
    while (true)
    {
        std::cerr << "请输入你的信息# "; //cerr标准错误，向文件描述符2打印
        std::getline(std::cin, message);
        if (message == "quit")
            break;
        // 当client首次发送消息给服务器的时候，OS会自动给client bind他自己的IP和port
        sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server));
    }
    return nullptr;
}
 
//收消息 
static void *udpRecv(void *args)
{
    int sock = *(int *)((ThreadData *)args)->args_;
    std::string name = ((ThreadData *)args)->name_;
 
    char buffer[1024];
    while (true)
    {
        memset(buffer, 0, sizeof(buffer));
        // 读数据
        struct sockaddr_in temp;
        socklen_t len = sizeof(temp);
        ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << buffer << std::endl;
        }
    }
}
 
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    // 创建客户端套接字
    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0)
    {
        std::cerr << "socket error" << std::endl;
        exit(2);
    }
    serverport = atoi(argv[2]);
    serverip = argv[1];
 
    // 两个线程，一个发送数据，一个接收数据
    std::unique_ptr<Thread> sender(new Thread(1, udpSend, (void *)&sock));
    std::unique_ptr<Thread> recver(new Thread(1, udpRecv, (void *)&sock));
 
    sender->start();
    recver->start();
 
    sender->join();
    recver->join();
 
    close(sock); // 关闭套接字
 
    //   client当然也需要bind
    // 但是一般client不会显示bind，即程序员不需要自己bind
    // client是一个客户端，是被普通人下载安装使用的
    // 如果程序员自己bind了，client就bind了一个固定的port
    // 万一其他客户端提前占用了这个port，该client就不会启动了
    // client一般不需要显示的bind指定port，而是让0S自动随机选择
    // std::string message;
    // struct sockaddr_in server;
    // memset(&server,0,sizeof(server));//初始化为0
    // server.sin_family = AF_INET;
    // server.sin_port = htons(atoi(argv[2]));
    // //inet_addr将点分十进制字符串转为4字节，再将4字节主机序列->网络序列
    // server.sin_addr.s_addr = inet_addr(argv[1]);
 
    // char buffer[1024];
    // while(true)
    // {
    //     //多线程
    //     std::cout << "请输入你的信息# ";
    //     std::getline(std::cin, message);
    //     if(message == "quit")
    //         break;
    //     //当client首次发送消息给服务器的时候，OS会自动给client bind他自己的IP和port
    //     sendto(sock,message.c_str(),message.size(),0,(struct sockaddr*)&server,sizeof(server));
    //     //读数据
    //     struct sockaddr_in temp;
    //     socklen_t len = sizeof(temp);
    //     ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&temp, &len);
    //     if(s > 0)
    //     {
    //         buffer[s] = 0;
    //         std::cout << "server echo# " << buffer << std::endl;
    //     }
    // }
    return 0;
}

---

thread.hpp：

#pragma once
 
#include <iostream>
#include <unistd.h>
#include <vector>
#include <pthread.h>
#include <queue>
#include <string>
#include <cstdio>
 
 
typedef void*(*func_t)(void*); 
 
//设置ThreadData是为了未来创建线程的时候，把名字也传进去
class ThreadData
{
public:
    void* args_;
    std::string name_;
};
 
class Thread
{
public:
    Thread(int num, func_t callback, void* args):func_(callback)
    {
        //构造函数中初始化name_
        char namebuffer[64];
        snprintf(namebuffer, sizeof namebuffer, "thread->%d", num);
        name_ = namebuffer;
 
        tdata_.args_ = args;
        tdata_.name_ = name_;
    }
    //创建线程
    void start()
    {
        pthread_create(&tid_, nullptr, func_, (void*)&tdata_);
    }
    //线程等待
    void join()
    {
        pthread_join(tid_, nullptr);
    }
 
    std::string name()
    {
        return name_;
    }
 
    ~Thread()
    {}
private:
    std::string name_;
    func_t func_;
    ThreadData tdata_;
    pthread_t tid_;
};

---

tcp套接字编程

tcp套接字代码

tcp同样，需要socket先创建套接字：

与udp一样，第一个参数需要传AF_INET，因为是网络通信

第二个参数就与udp不同了，传入的是SOCK_STREAM，代表套接字类型是stream

第三个参数同样默认为0

---

listen函数

因为TCP是面向连接的，当我们正式通信的时候，需要先建立连接，所以就需要用到listen，阿金套接字状态设置为监听状态

函数参数：

第一个参数就是创建好的套接字

第二个参数叫做全链接队列长度

返回值：

成功返回0，失败返回-1，错误码被设置

此时执行完listen函数后，在一个窗口执行./tcp_server 8080后，另一个窗口使用netstat -antp，可以观察到./tcp_server的状态是LISTEN，表示此时的服务器已经运行，且处于监听状态

---

accept函数

accept函数用于获取新连接

函数参数：

第一个参数：是创建好的套接字

第二/三个参数：addr是输出型参数，addrlen是输入输出型参数，在recvfrom中使用方式一样，详细见上面的recvfrom函数

返回值：

成功的话返回一个合法的整数套接字，失败返回-1，错误码被设置

---

read/write函数

在udp中，读取数据使用的是recvfrom函数，而tcp中不使用这个函数，读使用read，写使用write

这里的read和write在读写文件时使用过，网络这里也可以直接使用（也可以使用后面的recv/send函数）

read：

使用方式如下：

注意这里的sizeof(buffer)-1，是将buffer后面的\0减掉了

write：

使用方式如下：

注意这里的strlen算的是buffer里的字符数量，没有减去\0 

---

connect函数

connect是进行连接的函数，connect函数会自动绑定当前客户端的IP和端口，能够进行后续通信

函数参数：

第一个参数：套接字

第二/三个参数：代表想要连接谁，和sendto的后两个参数一样

返回值：

成功返回0，失败返回-1，错误码被设置

---

recv/send函数

send函数也是基于tcp向目标服务器发送消息的

它的前三个参数和write一样， 最后一个flag参数默认设为0即可

同样和recvfrom的前三个参数一样，最后一个flag参数默认设为0即可

---

最终可以通过改变tcp_server.hpp中的原始的server函数，从而实现不同的功能，下面实现了通信、大小写转换、英汉互译等功能，以大小写转换为例，示范：

用户端：

服务端：

---

代码如下：

Threadpool中的Task.hpp改变如下：

#pragma once
 
#include "log.hpp"
#include <iostream>
#include <functional>
#include <string>
 
 
// typedef function<void(int, const std::string&, const uint16_t&)> fun_t;
using fun_t = function<void(int, const std::string&, const uint16_t&, const std::string&)>;
 
class Task
{
public:
    Task()
    {}
 
    Task(int sock,const std::string ip,uint16_t port,fun_t func)
    :_sock(sock),_ip(ip),_port(port),_func(func)
    {}
 
    //仿函数
    void operator()(const std::string& name)
    {
        _func(_sock, _ip, _port, name);
    }
public:
    int _sock;      //套接字
    std::string _ip;//ip
    uint16_t _port; //端口
    fun_t _func;    
};

---

makefile：

.PHONY:all
all:tcp_client tcp_server
 
tcp_client:tcp_client.cc
	g++ -o $@ $^ -std=c++11
tcp_server:tcp_server.cc
	g++ -o $@ $^ -std=c++11 -lpthread
 
.PHONY:clean
clean:
	rm -f tcp_client tcp_server

---

tcp_client.cc：

#include <iostream>
#include <string>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
 
static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " serverIp serverPort\n"
              << std::endl;
}
 
//./tcp_client serverip serverport
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        usage(argv[0]);
        exit(1);
    }
    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);
    bool alive = false;
    int sock = 0;
    std::string line;
    while (true)
    {
        //alive为false，表示需要创建套接字
        if (!alive)
        {
            // 创建套接字
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if (sock < 0) // 创建套接字失败
            {
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
            // client不需要手动bind，需要OS自动进行选择
            // client需要连接别人的能力
            struct sockaddr_in server;
            memset(&server, 0, sizeof(server)); // 置空
            server.sin_family = AF_INET;
            server.sin_port = htons(serverport);
            server.sin_addr.s_addr = inet_addr(serverip.c_str());
 
            // connec进行连接
            if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
            {
                std::cerr << "connect error" << std::endl;
                exit(3);
            }
            // 连接成功
            std::cout << "connect success" << std::endl;
            alive = true;
        }
 
        std::cout << "请输入# ";
        std::getline(std::cin, line);
        if (line == "quit")
            break;
 
        ssize_t ret = send(sock, line.c_str(), line.size(), 0);
        //如果发送成功
        if (ret > 0)
        {
            char buffer[1024];
            ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
            if (s > 0)
            {
                // 读取成功
                buffer[s] = 0; // 当做字符串处理
                std::cout << "server 回显# " << buffer << std::endl;
            }
            else if (s == 0)
            {
                alive = false;
                close(sock);
            }
        }
        //发送失败
        else
        {
            alive = false;
            close(sock);
        }
        // else if (s == 0)
        // {
        //     break;
        // }
        // else
        // {
        //     break;
        // }
    }
    return 0;
}

---

tcp_server.cc：

#include "tcp_server.hpp"
#include <memory>
 
static void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}
 
//./tcp_server port
int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<TcpServer> svr(new TcpServer(port));
    svr->initServer();
    svr->Start();
 
    return 0;
}

---

tcp_server.hpp：

#pragma once
 
#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <cassert>
#include <unordered_map>
#include <memory>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <pthread.h>
#include <ctype.h>
#include "threadpool/log.hpp"
#include "threadpool/lockGuard.hpp"
#include "threadpool/Task.hpp"
#include "threadpool/threadPool.hpp"
#include "threadpool/thread.hpp"
 
// static void service(int sock, const std::string& clientip, const uint16_t& clientport)
// {
//     //echo server
//     char buffer[1024];
//     while(true)
//     {
//         //read && write可以直接使用
//         ssize_t s = read(sock, buffer, sizeof(buffer)-1);
 
//         //read成功
//         if(s > 0)
//         {
//             buffer[s] = 0;//将发过来的数据当做字符串
//             std::cout << clientip << ":" << clientport << "#" << buffer << std::endl;
//         }
//         else if(s == 0) //对端关闭连接
//         {
//             logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
//             break;
//         }
//         else
//         {
//             logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
//             break;
//         }
//         write(sock, buffer, strlen(buffer));
//     }
//     close(sock);
// }
 
static void service(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{
    // echo server
    // 所以，我们一般服务器进程业务处理，如果是从连上，到断开，要一直保持这个链接，长连接
    //
    char buffer[1024];
    while (true)
    {
        // read && write可以直接使用
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
 
        // read成功
        if (s > 0)
        {
            buffer[s] = 0; // 将发过来的数据当做字符串
            std::cout << thread_name << "|" << clientip << ":" << clientport << "#" << buffer << std::endl;
        }
        else if (s == 0) // 对端关闭连接
        {
            logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
            break;
        }
        else
        {
            logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
            break;
        }
        write(sock, buffer, strlen(buffer));
    }
    close(sock);
}
 
// 改为大小写转换的方法
static void change(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{
    // echo server
    // 所以，我们一般服务器进程业务处理，如果是从连上，到断开，要一直保持这个链接，长连接
    //
    char buffer[1024];
    // read && write可以直接使用
    ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
 
    // read成功
    if (s > 0)
    {
        buffer[s] = 0; // 将发过来的数据当做字符串
        std::cout << thread_name << "|" << clientip << ":" << clientport << "#" << buffer << std::endl;
        std::string message;
        char* start = buffer;
        while(*start)
        {
            char c;
            if(islower(*start)) c = toupper(*start);
            else c = *start;
            message.push_back(c);
            start++;
        }
        write(sock, message.c_str(), message.size());
 
    }
    else if (s == 0) // 对端关闭连接
    {
        logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
    }
    else
    {
        logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
    }
    close(sock);
}
 
// 改为英汉互译的方法
static void dictOnline(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{
    // echo server
    // 所以，我们一般服务器进程业务处理，如果是从连上，到断开，要一直保持这个链接，长连接
    char buffer[1024];
    static std::unordered_map<std::string, std::string> dict = {
        {"apple","苹果"},
        {"pencil","铅笔"},
        {"bus","公交车"},
        {"ruler","尺子"}
    };
    // read && write可以直接使用
    ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
 
    // read成功
    if (s > 0)
    {
        buffer[s] = 0; // 将发过来的数据当做字符串
        std::cout << thread_name << "|" << clientip << ":" << clientport << "#" << buffer << std::endl;
        std::string message;
        auto iter = dict.find(buffer);
        if(iter == dict.end())
            message = "我不知道";
        else
            message = iter->second;
        write(sock, message.c_str(), message.size());
    }
    else if (s == 0) // 对端关闭连接
    {
        logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
    }
    else
    {
        logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
    }
    close(sock);
}
 
 
 
// class ThreadDate
// {
// public:
//     int _sock;
//     std::string _ip;
//     uint16_t _port;
// };
 
class TcpServer
{
private:
    const static int gbacklog = 20; // 一般不能太大，也不能太小，后面在进行详细解释
    // 类内会有默认参数this，不符合回调函数的参数类型，所以设置为static的
    //  static void* threadRoutine(void* args)
    //  {
    //      //线程分离，设置分离状态后主线程就不需要再join线程了，线程退出时，自动释放线程资源
    //      pthread_detach(pthread_self());
    //      ThreadDate* td = static_cast<ThreadDate*>(args);
    //      service(td->_sock, td->_ip, td->_port);
    //      delete td;
 
    //     return nullptr;
    // }
public:
    TcpServer(uint16_t port, std::string ip = "")
        : _port(port), _ip(ip), _listensock(-1), _threadpool_ptr(ThreadPool<Task>::getThreadPool())
    {
    }
 
    void initServer()
    {
        // 1. socket创建套接字 进程 + 文件
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (socket < 0)
        {
            logMessage(FATAL, "create socket error,%d:%s", errno, strerror(errno));
            exit(2);
        }
        // 文件描述符012默认打开，所以再创建就是3
        logMessage(NORMAL, "create socket success, _listensock: %d", _listensock);
        // 2. bind  文件 + 网络
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
        // binf失败
        if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "bind error,%d:%s", errno, strerror(errno));
            exit(3);
        }
        // 3.因为TCP是面向连接的，当我们正式通信的时候，需要先建立连接
        if (listen(_listensock, gbacklog) < 0)
        {
            // 创建失败
            logMessage(FATAL, "listen error,%d:%s", errno, strerror(errno));
            exit(4);
        }
        logMessage(NORMAL, "init server success");
    }
 
    void Start()
    {
        _threadpool_ptr->run(); // 运行线程池
        // signal(SIGCHLD, SIG_IGN);//忽略SIG_CHLD信号，子进程退出时会自动释放自己的僵尸状态
        // 服务器需要周而复始的运行，所以while(true)
        while (true)
        {
            // 获取连接
            struct sockaddr_in src;
            socklen_t len = sizeof(src);
            // serversock和_listensock都是套接字，区别如下：
            // serversock(未来进行网络通信服务) vs _listensock(只是获取新连接)
            int serversock = accept(_listensock, (struct sockaddr *)&src, &len);
            if (serversock < 0)
            {
                // 获取连接失败，continue继续获取连接
                logMessage(ERROR, "accept error,%d : %s", errno, strerror(errno));
                continue;
            }
            // 获取连接成功
            uint16_t client_port = ntohs(src.sin_port);
            std::string client_ip = inet_ntoa(src.sin_addr);
            logMessage(NORMAL, "link success, serversock: %d | %s : %d | \n",
                       serversock, client_ip.c_str(), client_port);
            // version 4 -- 线程池版本
            // Task t(serversock, client_ip, client_port, service);
            // Task t(serversock, client_ip, client_port, change);
            Task t(serversock, client_ip, client_port, dictOnline);
            _threadpool_ptr->pushTask(t);
 
            // //version 3 -- 多线程版本
            // ThreadDate* td = new ThreadDate();
            // td->_ip = client_ip;
            // td->_port = client_port;
            // td->_sock = serversock; 
            // pthread_t tid;
            // pthread_create(&tid, nullptr, threadRoutine, td);
            // close(serversock)
 
            // version 2.1 -- 多进程版本 -- 创建子进程(不使用signal)
            //  pid_t id = fork();
            //  assert(id != -1);
            //  if(id == 0)
            //  {
            //      //子进程
            //      close(_listensock);
            //      if(fork() > 0)
            //          exit(0);//子进程本身直接退出
            //      //下面的是孙子进程，孤儿进程，OS领养，OS在孤儿进程退出的时候，由OS自动回收孤儿进程
            //      service(serversock, client_ip, client_port);
            //      exit(0);
            //  }
            //  //父进程
            //  waitpid(id, nullptr, 0);//不会阻塞，因为子进程再创建孙子进程时就exit退出了
            //  close(serversock);
 
            // 开始进行通信服务
            //  version 1.0 -- 单进程循环版本
            // 只能够进行一次处理一个客户端，处理完一个，才能处理下一个客户端
            // 很显然version 1 是不能直接被使用，因为是单进程的
            // 使用service函数实现
            //  service(serversock, client_ip, client_port);
            // version 2.0 -- 多进程版本 -- 创建子进程
            // 让子进程给新的连接提供服务，子进程能够打开父进程曾经打开的文件fd
            //  pid_t id = fork();
            //  assert(id != -1);
            //  if(id == 0)
            //  {
            //      //子进程会继承父进程打开的文件与文件fd
            //      //子进程是来进行提供服务的，所以不需要知道监听socket，所以close掉监听socket
            //      close(_listensock);
            //      //子进程对新的连接提供服务，父进程则继续accept新连接
            //      service(serversock, client_ip, client_port);
            //      exit(0); // 子进程退出后变为僵尸状态
            //  }
            // 父进程
            // 需要等待子进程，但是这里最好不要使用waitpid()，因为这时阻塞等待的，设置为非阻塞也比较麻烦
            // 所以这里采用信号的方式signal，子进程退出会主动向父进程发送SIG_CHLD信号，所以可以忽略SIG_CHLD信号
            // 子进程退出的时候，会自动释放自己的僵尸状态
            // close(serversock);//父进程只需要listensocket，不需要serversock，所以close掉serversock
            // 如果父进程关闭servicesock，会不会影响子进程?
        }
    }
 
    ~TcpServer()
    {
    }
 
private:
    uint16_t _port;  // 端口
    std::string _ip; // IP
    int _listensock; // 监听套接字
 
    std::unique_ptr<ThreadPool<Task>> _threadpool_ptr;
};

以上即为udp、tcp套接字编程的全部内容

---