• 网络和Linux网络_2(套接字编程)socket+UDP网络通信代码

    目录

    1. 预备知识

    1.1 源IP地址和目的IP地址

    1.2 端口号port和套接字socket

    1.3 网络通信的本质

    1.4 TCP和UDP协议

    1.5 网络字节序

    2. socket套接字

    2.1 socket创建套接字

    2.2 bind绑定

    2.3 sockaddr结构体

    3. UDP网络编程

    3.1 server的初始化服务器

    3.2 server的数据处理Start

    3.3 客户端udp_client.cc

    3.4 多线程收发数据

    本篇完。

    1. 预备知识

    1.1 源IP地址和目的IP地址

    通过上一篇我们知道，在网络通信中，存在两套地址，一套是IP地址，另一套是MAC地址。

    IP地址：标识计算机在网络中的唯一性。

    而IP地址又分为源IP地址和目的IP地址：

    •  源IP地址：标识网络通信发起方。
    •  目的IP地址：标识网络通信的接收方。

    在网络通信的报文中，其中报头包含着源IP和目的IP。

    1.2 端口号port和套接字socket

    如上图所示，报文从用户A的计算机传送到了用户B的计算机，但是网络通信的目的就是将报文从一台计算机传送到另一台计算机吗？

    将数据从计算机A传送到计算机B是手段，并不是网络通信的目的。

    真正进行通信的是用户A和用户B，也就是计算机A上的某个应用程序和计算机B上的某个应用程序之间在通信。

    网络通信的目的就是让两台计算机上的两个进程在进行通信。

    IP地址可以标识两台计算机的唯一性，但是每台计算机上会存在大量的进程，如何保证计算机A某个进程发送的数据能让计算机B指定的进程接收到呢？

    换句话说，如何标识一台计算机上进程的唯一性呢？

    采用端口号port来标识计算机上进程的唯一性。

    • 端口号是一个2字节16位的整数。
    • 端口号用来标识一个进程，告诉操作系统要把数据交给哪一个进程。
    • 一个端口号只能被一个进程占用。

    现在我们有用来标识计算机在网络中唯一性的IP地址，又有用来标识进程在计算机中唯一性的端口号port。

    •  全网唯一进程 = IP地址(全网主机唯一性) + 端口号port(该主机上进程唯一性)

    socket(套接字) = IP地址 + 端口号port。

    所以要想两个进程间实现通信，必须各自有各自的套接字。

    1.3 网络通信的本质

    网络通信实际上是两台计算机或者多台计算机上的进程之间在通信，和我们之前Linux学习的进程间通信的区别在于进程位于不同的计算机上。

    网络通信的本质：进程间通信。

    • 要实现进程间通信，必须有共享资源，而网络通信中的网络就是共享资源。
    • 网络通信其实就是在做IO，我们上网的所有行为就两种：①把数据发出去。 ②把数据读回来。

    Linux下一切皆文件，所以网络在系统中也是一个"文件"，也有struct结构体，也有文件描述符。

    我们知道，每个进程都有一个pid来标识它在当前计算机上的唯一性，为什么网络中还需要一个端口号port来标识进程的唯一性呢？不能用pid吗？

    在技术实现上是完全可以用pid的，所以就需要考虑为什么不用pid，用了端口号port？：

    • 系统是系统，网络是网络，系统使用pid，网络使用port来标识进程的唯一性，实现了系统与网络的解耦。
    • 不是所有进程都提供网络服务或者网络请求的，但是所有的进程都需要pid，只有需要网络的进程才会分配一个port。
    • 客户端需要能够直接找到服务器的进程，服务器进程的唯一性不能做任何改变。

    比如平时使用的QQ，手机上的QQ都是客户端，打开QQ使用都是在向服务器上的QQ进程发起网络请求，而这个服务器位腾讯公司，服务进程根据用户的网络请求再做出对应的反馈交给用户。

    下载了某个应用程序以后，该程序里就绑定了服务端对应进程的IP地址和端口号。

    所以使用应用程序的时候，就能精准的和服务端上对应的进程进行网络通信。

    服务器的IP地址并不会随意变化，为了保证客户端每次都能找到服务端的进程，服务端的port也不能变化。  

    如果使用pid来代替端口号的话，服务器每重启一次，服务进程的pid值就会改变，客户端就无法找到服务进程了。

    绑定了port的进程PCB会被维护在一个哈希表中，port就是key值，操作系统能够根据key值找到对应的PCB，然后再执行它。

    1.4 TCP和UDP协议

    这两个协议的具体原理和细节在后面会详细讲解，这里仅需要大概了解一下特性即可。

    UDP协议：（User Datagram Protocol 用户数据报协议）。

    • 传输层协议。
    • 不需要通信双方建立连接，直接发生即可。
    • 不可靠传输，可能会发生丢包等问题。
    • 面向数据报。

    TCP协议：（Transmission Control Protocol 传输控制协议）。

    • 传输层协议。
    • 需要通信双方建立连接。
    • 是一种可靠传输，不会发生丢包等问题。
    • 面向字节流。

    可靠和不可靠传输并没有相对的好坏，比如可靠传输付出的代价就比较大，具体这些特点是什么意思，后面会讲解到，这里只需要记住以上内容即可。

    1.5 网络字节序

    计算机分为大端机和小端机，不同的电脑型号就不一样，两台计算机大小端不同，接收到的数据解释出来意义也不同。

    规定：网络中的字节序都采用大端。

    如果你的计算机是大端机，那么就可以直接向网络中发数据和从网络中接收数据，不用做转换。

    如果你的计算机是小端机，那么在向网络中发送数据时，需要先将数据转换成大端，再发送到网络中。从网络中接收下来的数据，需要先转换成小端再使用。

    此时就存在两个问题：

    • 自己的电脑是大端还是小端？还需要自己去判断一下。
    • 如果自己的电脑是小端，需要自己去将数据转换成大端。

    这两个问题虽然我们自己能解决，但是比较繁琐，而且很容易出错，所以操作系统提供了相应的接口来进行大小端转换

    主机和网络的字节序转换函数：

    1. #include  // 必须包含的头文件
    2. // 主机序列转网络序列
    3. uint32_t htonl(uint32_t hostlong); // 将主机上unsigned int类型的数据转换成对应网络字节序
    4. uint16_t htons(uint16_t hostshort); // 将主机上unsigned short类型的数据转换成对应网络字节序
    5.  
    6. // 网络序列转主机序列
    7. uint32_t ntohl(uint32_t netlong); // 将从网络中读取的unsigned int类型的数据转换成当前计算机字节序
    8. uint16_t ntohs(uint16_t netshort); // 将从网络中读取的unsigned short类型的数据转换成当前计算机字节序
    • 这些函数名很好记，h表示host，代表着主机，n表示network，代表着网络，s表示unit16_t，l表示uint32_t。
    • 如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回。
    • 如果主机是大端字节序,这些 函数不做转换,将参数原封不动地返回。

    2. socket套接字

    2.1 socket创建套接字

    man socket：

    返回值 int

    成功返回一个int类型的值，其实就是一个文件描述符sockfd。

    失败返回-1，并且设置错误码errno。

    socket系统调用专门用来创建套接字，在创建的时候指定使用哪种通信协议。看看参数：

    int domain

    这是地址族，用来指定创建的套接字进行的是网络通信还是本地通信。

    该参数可以填上图所示中的任何一个，经常使用的是AF_INET表示使用IPv4的网络套接字进行网络通信

    int type

    这是用来指定socket提供的能力类型，比如是面向字节流还是面向用户数据报。

    该参数可以使用上图中的任何一个，其中常用的是画红色框的是面向字节流和面向用户数据报，也就是TCP和UDP。

    int protocol

    该参数是用来指定具体的协议名的，比如指定TCP或者DUP，但是根据前两个参数就可以确定使用哪个协议了，这个一般设置为0即可。

    2.2 bind绑定

    man 2 bind：

    bind用来将IP地址和端口号port创建的socket套接字绑定，也就是将IP地址和端口号port和系统绑定。

    返回值int

    成功返回0，失败返回-1，并且设置错误码errno。

    int sockfd

    使用socket()返回的文件描述符sockfd，用来指定绑定哪个套接字。

    const struct sockaddr * addr

    struct sockaddr是一个结构体。

    socklen_t addrlen

    这个参数是表示sockaddr结构体大小的，单位是字节，socklen_t本质是unsigned int类型的32位变量。

    其它接口：

    1. // 开始监听socket (TCP, 服务器)
    2. int listen(int socket, int backlog);
    3.  
    4. // 接收请求 (TCP, 服务器)
    5. int accept(int socket, struct sockaddr* address,socklen_t* address_len);
    6.  
    7. // 建立连接 (TCP, 客户端)
    8. int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

    这几个接口的是TCP协议才会用到，后面再详细讲解。

    2.3 sockaddr结构体

    套接字有很多种类型，常见的有三种：

    • 网络套接字：用户跨主机之间的通信，也能支持本地通信。
    • 原始套接字：可以跨过传输层(TCP/UDP)访问底层的数据。
    • 域间套接字：只能在本地通信。

    这些套接字的应用场景完全不同，所以不同种类的套接字就对应一套系统调用接口，所以三套就会对应三套不同的接口。

    网络套接字：

    1. struct sockaddr_in {
    2.     short int sin_family;           // 地址族，一般为AF_INET
    3.     unsigned short int sin_port;    // 端口号，网络字节序
    4.     struct in_addr sin_addr;        // IP地址
    5.     unsigned char sin_zero[8];      // 用于填充，使sizeof(sockaddr_in)等于16
    6. };

    通过sockaddr_in结构体，将IP地址，端口号，以及网络通信AF_INET通过系统调用bind与系统绑定，从而进行网络通信。等下我们写代码用的就是sockaddr_in结构体，用之前先清零，看个接口，man bzero：

    这是一个库函数，需要包含头文件，该函数的作用和memset一样，不同之处在于bzero只能清零，第一个参数是目标地址，第二个参数是要清零的字节数。

    在填充sockaddr_in结构体的时候，将地址类型sin_family填充为AF_INET表示网络通信。

    在填充端口号sin_port的时候，需要使用htons()函数，将主机字节序转换成网络字节序，然后再进行填充。

    域间套接字：

    1. struct sockaddr_un {
    2.     sa_family_t sun_family;       /* AF_UNIX */
    3.     char sun_path[108];    /* 带有路径的文件名 */
    4. };

    sockaddr_un只有域间通信方式AF_UNIX以及域间通信的路径名。

    设计者为了方便使用，无论是网络通信还是域间通信，都使用一套接口，通过设置不同参数来解决所有通信场景。

    sockaddr_in和sockaddr_un是用于网络通信和域间通信两个不同的通信场景，它们的区别就在于结构体起始处的16位地址类型不同，网络通信使用AF_INET，域间通信使用AF_UNIX。

    但由于要使用一套接口，所以此时无论哪种通信，都使用sockaddr结构体。

    • 在填充IP地址，端口号，以及地址类型的时候，仍然是对sockaddr_in进行填充。
    • 在使用bind系统调用时，将sockaddr_in强转成sockaddr类型，在函数内部它会根据前两个字节自行判断是什么类型的通信，然后再强制转回去。

    可以将sockaddr看成是基类，把sockaddr_in和sockaddr_un看出是派生类，此时就构成了多态体系。

    3. UDP网络编程

    网络通信一定是双方的，一端是服务端(Server)接收数据，另一端是客户端(Client)发送数据。

    3.1 server的初始化服务器

    我们在服务端server建个server.hpp，客户端就不建头文件了，把以前的日志拷过来，先放一部分代码：

    Makefile

    1. .PHONY:all
    2. all:udp_client udp_server
    3.  
    4. udp_client:udp_client.cc
    5. 	g++ -o $@ $^ -std=c++11 -lpthread
    6. udp_server:udp_server.cc
    7. 	g++ -o $@ $^ -std=c++11
    8.  
    9. .PHONY:clean
    10. clean:
    11. 	rm -f udp_client udp_server

    log.hpp

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. // 日志是有日志级别的
    10. #define DEBUG   0
    11. #define NORMAL  1
    12. #define WARNING 2
    13. #define ERROR   3
    14. #define FATAL   4
    15.  
    16. const char *gLevelMap[] = {
    17.     "DEBUG",
    18.     "NORMAL",
    19.     "WARNING",
    20.     "ERROR",
    21.     "FATAL"
    22. };
    23.  
    24. #define LOGFILE "./threadpool.log"
    25.  
    26. // 完整的日志功能，至少: 日志等级 时间 支持用户自定义(日志内容, 文件行，文件名)
    27. void logMessage(int level, const char *format, ...)  // 可变参数
    28. {
    29. #ifndef DEBUG_SHOW
    30.     if(level== DEBUG) 
    31.     {
    32.         return;
    33.     }
    34. #endif
    35.     char stdBuffer[1024]; // 标准日志部分
    36.     time_t timestamp = time(nullptr); // 获取时间戳
    37.     // struct tm *localtime = localtime(×tamp); // 转化麻烦就不写了
    38.     snprintf(stdBuffer, sizeof(stdBuffer), "[%s] [%ld] ", gLevelMap[level], timestamp);
    39.  
    40.     char logBuffer[1024]; // 自定义日志部分
    41.     va_list args; // 提取可变参数的 -> #include  了解一下就行
    42.     va_start(args, format);
    43.     // vprintf(format, args);
    44.     vsnprintf(logBuffer, sizeof(logBuffer), format, args);
    45.     va_end(args); // 相当于ap=nullptr
    46.     
    47.     printf("%s%s\n", stdBuffer, logBuffer);
    48.  
    49.     // FILE *fp = fopen(LOGFILE, "a"); // 追加到文件，这里写好了就不演示了
    50.     // fprintf(fp, "%s%s\n", stdBuffer, logBuffer);
    51.     // fclose(fp);
    52. }

    udp_server.hpp（建议复制到VSCode跟着注释看）

    1. #ifndef _UDP_SERVER_HPP
    2. #define _UDP_SERVER_HPP
    3.  
    4. #include "log.hpp"
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include  // 网络四件套
    14. #include 
    15. #include 
    16. #include 
    17.  
    18. #define SIZE 1024
    19.  
    20. class UdpServer
    21. {
    22. public:
    23.     UdpServer(uint16_t port, std::string ip = "") 
    24.         : _port(port)
    25.         , _ip(ip)
    26.         , _sock(-1)
    27.     {}
    28.  
    29.     bool initServer() // 初始化服务器
    30.     {
    31.         // 从这里开始，就是新的系统调用，来完成网络功能
    32.         // 1. 创建套接字（返回值是文件描述符（套接字））
    33.         _sock = socket(AF_INET, SOCK_DGRAM, 0); // 域 + 类型 + 0
    34.         if (_sock < 0) // 创建套接字失败，打印日志并退出
    35.         {
    36.             logMessage(FATAL, "%d:%s", errno, strerror(errno));
    37.             exit(2);
    38.         }
    39.  
    40.         // 2. udp -> bind: 将用户设置的ip和port在内核中和我们当前的进程强关联
    41.         // "192.168.110.132" -> 点分十进制字符串风格的IP地址 -> 给用户看的
    42.         // 上面每一个区域取值范围是[0-255]: 1字节 -> 4个区域，理论上，表示一个IP地址，其实4字节就够了
    43.         // 点分十进制字符串风格的IP地址 <-互相转化-> 4字节
    44.  
    45.         struct sockaddr_in local; // -> 四个字段，有一个字段清零了不用管了
    46.         bzero(&local, sizeof(local)); // 清零结构体
    47.         local.sin_family = AF_INET; // 协议解锁->AF_INET上面sock的第一个参数
    48.  
    49.         // 服务器的IP和端口未来也是要发送给对方主机的 -> 先要将数据发送到网络
    50.         local.sin_port = htons(_port); // 考虑大小端 -> 主机序列转成网络序列，短整数
    51.  
    52.         // 1. 同上，先要将点分十进制字符串风格的IP地址 ->  转成4字节
    53.         // 2. 4字节主机序列 -> 转成网络序列
    54.         // 有一套接口,可以一次帮我们做完这两件事情,,让服务器在工作过程中,可以从任意IP中获取数据->inet_addr
    55.         local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    56.  
    57.         if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    58.         {   // bind: 将ip+prot和进程强关联，参数：套接字 + 清零的结构体 + 结构体字段的长度
    59.             logMessage(FATAL, "%d:%s", errno, strerror(errno)); // 小于零绑定失败就打日志和退出
    60.             exit(3);
    61.         }
    62.  
    63.         logMessage(NORMAL, "init udp server done ... %s", strerror(errno));
    64.         return true;
    65.     }
    66.  
    67.     void Start()
    68.     {}
    69.  
    70.     ~UdpServer()
    71.     {}
    72.  
    73. protected:
    74.     uint16_t _port; // 一个服务器，一般必须需要ip地址和port(16位的整数)
    75.     std::string _ip;
    76.     int _sock;
    77. };
    78.  
    79. #endif

    udp_server.cc

    1. #include "udp_server.hpp"
    2. #include 
    3. #include 
    4.  
    5. static void usage(std::string proc) // usage：使用手册，proc：程序名称
    6. {
    7.     std::cout << "\nUsage: " << proc << " ip port\n" << std::endl;
    8. }
    9.  
    10. // 运行服务端的方式 ./udp_server ip port // 云服务器的问题 bug
    11. int main(int argc, char *argv[])
    12. {
    13.     if(argc != 3)
    14.     {
    15.         usage(argv[0]);
    16.         exit(1);
    17.     }
    18.  
    19.     std::string ip = argv[1];
    20.     uint16_t port = atoi(argv[2]);
    21.     std::unique_ptr svr(new UdpServer(port, ip));
    22.     
    23.     svr->initServer();
    24.     svr->Start();
    25.     return 0;
    26. }

    udp_client.cc

    1. #include 
    2.  
    3. int main()
    4. {
    5.     return 0;
    6. }

    此时就能运行起来了。

    3.2 server的数据处理Start

    在预备工作做好以后，还需启动服务器，服务器进程是一个常驻内存的进程，也就是一个while(1)的死循环，在这个循环中进行网络数据的接收，处理，以及写回数据。

    看看几个用到的接口，man recvfrom：

    上图所示的系统调用recvfrom()用来接收网络中发过来的数据，也就是从套接字中接收。

    • 第一个参数是sockfd，是创建套接字时返回的文件描述符fd。
    • 第二个参数buf是用来存储从网络中读取下来的数据的缓冲区。
    • 第三个参数是buf缓冲区的大小。
    • 第四个参数flags是读取的方式，一般设置为0，即阻塞读取数据。
    • 第五个参数sockaddr* src_addr是一个输出型参数，同样传参sockaddr_in结构体，系统会自动对这个结构体进行填充，可以获取数据的来源，包括发送方的地址类型，端口号port以及IP地址。
    • 返回值ssize_t，返回读取到的数据个数，单位是字节，如果读取失败则返回-1。

    sendto() 函数是向服务器主机发送数据的：

    man sendto：

    • 第一个参数sockfd是创建的套接字的文件描述符。
    • 第二个参数buf是要发送的数据所在的缓冲区。
    • 第三个参数len是要发生的数据个数，以字节为单位。
    • 第四个参数flags是发送方式，一般设置为0，表示阻塞发送。
    • 第五个参数dest_addr是存放服务器IP地址和端口号port的sockaddr_in结构体变量，在传参的时候需要强转为struct sockaddr*。
    • 第六个参数，是第五个参数中结构体变量的大小，以字节为单位。

    上面udp_server.hpp的Start函数：

    1.     void Start()
    2.     {
    3.         // 作为一款网络服务器，永远不退出的
    4.         // 服务器启动-> 常驻进程 -> 永远在内存中存在，除非挂了 -> 小心内存泄漏
    5.         // 目前类似echo server: client给我们发送消息，我们原封不动返回
    6.         char buffer[SIZE];
    7.         while(true)
    8.         {
    9.             //  注意：peer,纯输出型参数
    10.             struct sockaddr_in peer;
    11.             bzero(&peer, sizeof(peer));
    12.             // 输入: peer 缓冲区大小
    13.             // 输出: 实际读到的peer
    14.             socklen_t len = sizeof(peer);
    15.             // start. 读取数据
    16.             ssize_t s = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
    17.             if (s > 0) // 读取数据成功
    18.             {
    19.                 buffer[s] = 0; // 先不考虑协议问题，目前数据当做字符串
    20.                 // 1. 输出发送的数据信息
    21.                 // 2. 输出是谁发送的信息
    22.                 uint16_t cli_port = ntohs(peer.sin_port); // 从网络中来的 -> 网络序列转成主机序列
    23.                 std::string cli_ip = inet_ntoa(peer.sin_addr); // 4字节的网络序列的IP->本主机的字符串风格的IP,方便显示
    24.                 printf("[%s:%d]# %s\n", cli_ip.c_str(), cli_port, buffer);
    25.             }
    26.             // 分析和处理数据，TODO
    27.             // end. 写回数据，类似recvfrom，后两个参数是把数据写给谁
    28.             sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
    29.         }
    30.     }

    编译运行：

    使用指令netstat -nuap可以查看当前服务器上的网络进程，就看见有个17602的服务器运行了。

    至此服务端的工作就做完了，只要客户端发送数据，服务端就可以收到。

    3.3 客户端udp_client.cc

    这里在客户端就不写头文件封装了，根据上面基础，直接放代码：udp_client.cc：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include  // 网络四件套
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. static void usage(std::string proc) // usage：使用手册，proc：程序名称
    11. {
    12.     std::cout << "\nUsage: " << proc << " serverIp serverPort\n" << std::endl;
    13. }
    14.  
    15. // ./udp_client 127.0.0.1 7070
    16. int main(int argc, char *argv[])
    17. {
    18.     if (argc != 3)
    19.     {
    20.         usage(argv[0]);
    21.         exit(1);
    22.     }
    23.     int sock = socket(AF_INET, SOCK_DGRAM, 0); // 域 + 类型 + 0
    24.     if (sock < 0)
    25.     {
    26.         std::cerr << "socket error" << std::endl;
    27.         exit(2);
    28.     }
    29.     // client要不要bind？要，但是一般client不会显示的bind，程序员不会自己bind
    30.     // 因为client是一个客户端 -> 普通人下载安装启动使用的-> 如果程序员自己bind了->
    31.     // client 一定bind了一个固定的ip和port，万一，其他的客户端提前占用了这个port呢？
    32.     // client一般不需要显示的bind指定port，而是让OS自动随机选择(什么时候做的呢？)
    33.     std::string message;
    34.     struct sockaddr_in server;
    35.     memset(&server, 0, sizeof(server));
    36.     server.sin_family = AF_INET; // 协议解锁->AF_INET上面sock的第一个参数
    37.     server.sin_addr.s_addr = inet_addr(argv[1]); 
    38.         // 1.先要将点分十进制字符串风格的IP地址 ->  转成4字节
    39.         // 2. 4字节主机序列 -> 转成网络序列
    40.     server.sin_port = htons(atoi(argv[2])); // 考虑大小端 -> 主机序列转成网络序列，短整数
    41.  
    42.     char buffer[1024];
    43.     while (true)
    44.     {
    45.         std::cerr << "请输入你的信息# "; // 标准错误 2打印
    46.         std::getline(std::cin, message);
    47.         // 下面向服务器发送消息，当client首次发送消息的时候，OS会自动给client bind他的ip和port
    48.         sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server));
    49.  
    50.         if (message == "quit")
    51.             break;
    52.         struct sockaddr_in temp;
    53.         socklen_t len = sizeof(temp);
    54.         ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&temp, &len);
    55.         if (s > 0)
    56.         {
    57.             buffer[s] = 0;
    58.             std::cout << "server echo# " << buffer << std::endl;
    59.         }
    60.     }
    61.  
    62.     close(sock);
    63.     return 0;
    64. }

    运行客户端程序，发送数据，可以看到，客户端新收到的数据中，端口号变了，这是因为客户端的端口号是由操作系统分配的，并不是自己指定的，所以每次运行时端口号都不一样。

    （此时的ip地址已经不能乱传了，上面传的是127.0.0.1是本地环回（client和server发送数据只在本地协议栈中进行数据流动，不会把我们的数据发送到网络中本地网络服务器的测试），常常在server中一般不自己传ip，而是设置成0，可以自己改一改，或者直接传INADDR_ANY即0.0.0.0（可以接收任意ip发来的数据），你把udp_client发给其他人，再链接阿里云的ip，就能收到其他人发的信息了，这里就不演示了）

    还可以改一下udp_server.hpp的Statr，改成传命令的版本：

    1.     void Start()
    2.     {
    3.         // 作为一款网络服务器，永远不退出的
    4.         // 服务器启动-> 常驻进程 -> 永远在内存中存在，除非挂了 -> 小心内存泄漏
    5.         // 目前类似echo server: client给我们发送消息，我们原封不动返回
    6.         char buffer[SIZE];
    7.         while(true)
    8.         {
    9.             //  注意：peer,纯输出型参数
    10.             struct sockaddr_in peer;
    11.             bzero(&peer, sizeof(peer));
    12.             // 输入: peer 缓冲区大小
    13.             // 输出: 实际读到的peer
    14.             socklen_t len = sizeof(peer);
    15.  
    16.             char result[256];
    17.             std::string cmd_echo; // 读取的是指令的话
    18.             // start. 读取数据
    19.             ssize_t s = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
    20.             if (s > 0) // 读取数据成功
    21.             {
    22.                 buffer[s] = 0; // 先不考虑协议问题，目前数据当做字符串
    23.                 // 1. 输出发送的数据信息
    24.                 // 2. 输出是谁发送的信息
    25.                 // uint16_t cli_port = ntohs(peer.sin_port); // 从网络中来的 -> 网络序列转成主机序列
    26.                 // std::string cli_ip = inet_ntoa(peer.sin_addr); // 4字节的网络序列的IP->本主机的字符串风格的IP,方便显示
    27.                 // printf("[%s:%d]# %s\n", cli_ip.c_str(), cli_port, buffer);
    28.  
    29.                 if(strcasestr(buffer, "rm") != nullptr || strcasestr(buffer, "rmdir") != nullptr)
    30.                 {
    31.                     std::string err_message = "被禁止的指令";
    32.                     std::cout << err_message << buffer << std::endl;
    33.                     sendto(_sock, err_message.c_str(), err_message.size(), 0, (struct sockaddr *)&peer, len);
    34.                     continue;
    35.                 }
    36.                 FILE *fp = popen(buffer, "r");
    37.                 if (nullptr == fp)
    38.                 {
    39.                     logMessage(ERROR, "popen: %d:%s", errno, strerror(errno));
    40.                     continue;
    41.                 }
    42.                 while (fgets(result, sizeof(result), fp) != nullptr)
    43.                 {
    44.                     cmd_echo += result;
    45.                 }
    46.                 fclose(fp);
    47.             }
    48.             // 分析和处理数据，TODO
    49.             // end. 写回数据，类似recvfrom，后两个参数是把数据写给谁
    50.             // sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
    51.             sendto(_sock, cmd_echo.c_str(), cmd_echo.size(), 0, (struct sockaddr*)&peer, len);
    52.         }
    53.     }

    到这也和上面做点处理也能让其他人操作你的机器了。

    3.4 多线程收发数据

    在上面的基础上对client.cc改成多线程的，把以前写的thread.hpp拷过来：

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. // typedef std::function fun_t;
    7. typedef void *(*fun_t)(void *); // 定义函数指针->返回值是void*,函数名是fun_t,参数是void*->直接用fun_t
    8.  
    9. class ThreadData // 线程数据
    10. {
    11. public:
    12.     void *_args; // 真实参数
    13.     std::string _name; // 名字
    14. };
    15.  
    16. class Thread // 封装的线程
    17. {
    18. public:
    19.     Thread(int num, fun_t callback, void *args) 
    20.         : _func(callback) // 回调函数
    21.     {
    22.         char nameBuffer[64];
    23.         snprintf(nameBuffer, sizeof(nameBuffer), "Thread-%d", num); // 格式化到nameBuffer
    24.         _name = nameBuffer;
    25.  
    26.         _tdata._args = args; // 线程构造时把参数和名字带给线程数据
    27.         _tdata._name = _name;
    28.     }
    29.     void start() // 启动线程
    30.     {
    31.         pthread_create(&_tid, nullptr, _func, (void*)&_tdata); // 传入线程数据
    32.     }
    33.     void join() // join自己
    34.     {
    35.         pthread_join(_tid, nullptr);
    36.     }
    37.     std::string name() // 返回线程名
    38.     {
    39.         return _name;
    40.     }
    41.     ~Thread() // 析构什么也不做
    42.     {}
    43.  
    44. protected:
    45.     std::string _name; // 线程名字
    46.     pthread_t _tid; // 线程tid
    47.     fun_t _func; // 线程要执行的函数
    48.     ThreadData _tdata; // 线程数据
    49. };

    client.cc

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include  // 网络四件套
    7. #include 
    8. #include 
    9. #include 
    10. #include "thread.hpp"
    11.  
    12. uint16_t serverport = 0;
    13. std::string serverip;
    14.  
    15. static void usage(std::string proc) // usage：使用手册，proc：程序名称
    16. {
    17.     std::cout << "\nUsage: " << proc << " serverIp serverPort\n" << std::endl;
    18. }
    19.  
    20. // 下面的两个接口，一个线程调用一个
    21. // 无论是多线程读还是写，用的sock都是一个，sock代表就是文件，UDP是全双工的-> 可以同时进行收发而不受干扰
    22. static void *udpSend(void *args) // 发送数据
    23. {
    24.     int sock = *(int *)((ThreadData *)args)->_args;
    25.     std::string name = ((ThreadData *)args)->_name;
    26.  
    27.     std::string message;
    28.     struct sockaddr_in server;
    29.     memset(&server, 0, sizeof(server));
    30.     server.sin_family = AF_INET; // 协议解锁->AF_INET上面sock的第一个参数
    31.     server.sin_port = htons(serverport); // serverport和serverip是全局的
    32.     server.sin_addr.s_addr = inet_addr(serverip.c_str());
    33.  
    34.     while (true)
    35.     {
    36.         std::cerr << "请输入你的信息# "; //标准错误 2打印
    37.         std::getline(std::cin, message);
    38.         if (message == "quit")
    39.             break;
    40.         // 当client首次发送消息给服务器的时候，OS会自动给client bind他的IP和PORT
    41.         sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof server);
    42.     }
    43.  
    44.     return nullptr;
    45. }
    46.  
    47. static void *udpRecv(void *args) // 接收数据
    48. {
    49.     int sock = *(int *)((ThreadData *)args)->_args;
    50.     std::string name = ((ThreadData *)args)->_name;
    51.  
    52.     char buffer[1024];
    53.     while (true)
    54.     {
    55.         memset(buffer, 0, sizeof(buffer));
    56.         struct sockaddr_in temp;
    57.         socklen_t len = sizeof(temp);
    58.         ssize_t s = recvfrom(sock, buffer, sizeof buffer, 0, (struct sockaddr *)&temp, &len);
    59.         if (s > 0)
    60.         {
    61.             buffer[s] = 0;
    62.             std::cout  << buffer << std::endl;
    63.         }
    64.     }
    65. }
    66.  
    67. // ./udp_client 127.0.0.1 7070
    68. int main(int argc, char *argv[])
    69. {
    70.     if (argc != 3)
    71.     {
    72.         usage(argv[0]);
    73.         exit(1);
    74.     }
    75.     int sock = socket(AF_INET, SOCK_DGRAM, 0); // 域 + 类型 + 0
    76.     if (sock < 0)
    77.     {
    78.         std::cerr << "socket error" << std::endl;
    79.         exit(2);
    80.     }
    81.     // // client要不要bind？要，但是一般client不会显示的bind，程序员不会自己bind
    82.     // // 因为client是一个客户端 -> 普通人下载安装启动使用的-> 如果程序员自己bind了->
    83.     // // client 一定bind了一个固定的ip和port，万一，其他的客户端提前占用了这个port呢？
    84.     // // client一般不需要显示的bind指定port，而是让OS自动随机选择(什么时候做的呢？)
    85.     // std::string message;
    86.     // struct sockaddr_in server;
    87.     // memset(&server, 0, sizeof(server));
    88.     // server.sin_family = AF_INET; // 协议解锁->AF_INET上面sock的第一个参数
    89.     // server.sin_addr.s_addr = inet_addr(argv[1]); 
    90.     //     // 1.先要将点分十进制字符串风格的IP地址 ->  转成4字节
    91.     //     // 2. 4字节主机序列 -> 转成网络序列
    92.     // server.sin_port = htons(atoi(argv[2])); // 考虑大小端 -> 主机序列转成网络序列，短整数
    93.  
    94.     // char buffer[1024];
    95.     // while (true)
    96.     // {
    97.     //     std::cerr << "请输入你的信息# "; // 标准错误 2打印
    98.     //     std::getline(std::cin, message);
    99.     //     // 下面向服务器发送消息，当client首次发送消息的时候，OS会自动给client bind他的ip和port
    100.     //     sendto(sock, message.c_str(), message.size(), 0, (struct sockaddr *)&server, sizeof(server));
    101.     //     if (message == "quit")
    102.     //         break;
    103.     //     // 下面是接收消息
    104.     //     struct sockaddr_in temp;
    105.     //     socklen_t len = sizeof(temp);
    106.     //     ssize_t s = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&temp, &len);
    107.     //     if (s > 0)
    108.     //     {
    109.     //         buffer[s] = 0;
    110.     //         std::cout << "server echo# " << buffer << std::endl;
    111.     //     }
    112.     // }
    113.  
    114.     // 一个接收的线程，一个读取的线程
    115.     serverport = atoi(argv[2]);
    116.     serverip = argv[1];
    117.     std::unique_ptr sender(new Thread(1, udpSend, (void *)&sock));
    118.     std::unique_ptr recver(new Thread(2, udpRecv, (void *)&sock));
    119.     sender->start();
    120.     recver->start();
    121.  
    122.     sender->join();
    123.     recver->join();
    124.     close(sock);
    125.     return 0;
    126. }

    改一下udp_server.hpp的Start，这里直接放udp_server.hpp了。

    1. #ifndef _UDP_SERVER_HPP
    2. #define _UDP_SERVER_HPP
    3.  
    4. #include "log.hpp"
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include  // 网络四件套
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19.  
    20. #define SIZE 1024
    21.  
    22. class UdpServer
    23. {
    24. public:
    25.     UdpServer(uint16_t port, std::string ip = "") 
    26.         : _port(port)
    27.         , _ip(ip)
    28.         , _sock(-1)
    29.     {}
    30.  
    31.     bool initServer() // 初始化服务器
    32.     {
    33.         // 从这里开始，就是新的系统调用，来完成网络功能
    34.         // 一. 创建套接字（返回值是文件描述符（套接字））
    35.         _sock = socket(AF_INET, SOCK_DGRAM, 0); // 域 + 类型 + 0
    36.         if (_sock < 0) // 创建套接字失败，打印日志并退出
    37.         {
    38.             logMessage(FATAL, "%d:%s", errno, strerror(errno));
    39.             exit(2);
    40.         }
    41.  
    42.         // 二. udp -> bind: 将用户设置的ip和port在内核中和我们当前的进程强关联
    43.         // "192.168.110.132" -> 点分十进制字符串风格的IP地址 -> 给用户看的
    44.         // 上面每一个区域取值范围是[0-255]: 1字节 -> 4个区域，理论上，表示一个IP地址，其实4字节就够了
    45.         // 点分十进制字符串风格的IP地址 <-互相转化-> 4字节
    46.  
    47.         struct sockaddr_in local; // -> bind的第二个参数，四个字段，有一个字段清零了不用管了
    48.         bzero(&local, sizeof(local)); // 清零结构体
    49.         local.sin_family = AF_INET; // 协议解锁->AF_INET上面sock的第一个参数
    50.  
    51.         // 服务器的IP和端口未来也是要发送给对方主机的 -> 先要将数据发送到网络
    52.         local.sin_port = htons(_port); // 考虑大小端 -> 主机序列转成网络序列，短整数
    53.  
    54.         // 1. 同上，先要将点分十进制字符串风格的IP地址 ->  转成4字节
    55.         // 2. 4字节主机序列 -> 转成网络序列
    56.         // 有一套接口inet_addr,可以一次帮我们做完这两件事情,让服务器在工作过程中,可以从任意IP中获取数据->任意IP：INADDR_ANY
    57.         local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    58.  
    59.         if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    60.         {   // bind: 将ip+prot和进程强关联，参数：套接字 + 清零的结构体 + 结构体字段的长度
    61.             logMessage(FATAL, "%d:%s", errno, strerror(errno)); // 小于零绑定失败就打日志和退出
    62.             exit(3);
    63.         }
    64.  
    65.         logMessage(NORMAL, "init udp server done ... %s", strerror(errno));
    66.         return true;
    67.     }
    68.  
    69.     void Start()
    70.     {
    71.         // 作为一款网络服务器，永远不退出的
    72.         // 服务器启动-> 常驻进程 -> 永远在内存中存在，除非挂了 -> 小心内存泄漏
    73.         // 目前类似echo server: client给我们发送消息，我们原封不动返回
    74.         char buffer[SIZE];
    75.         while(true)
    76.         {
    77.             //  注意：peer,纯输出型参数
    78.             struct sockaddr_in peer;
    79.             bzero(&peer, sizeof(peer));
    80.             // 输入: peer 缓冲区大小
    81.             // 输出: 实际读到的peer
    82.             socklen_t len = sizeof(peer);
    83.  
    84.             char result[256];
    85.             char key[64]; // key存ip和port
    86.             std::string cmd_echo; // 读取的是指令的话
    87.             // start. 读取数据
    88.             ssize_t s = recvfrom(_sock, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
    89.             if (s > 0) // 读取数据成功
    90.             {
    91.                 buffer[s] = 0; // 先不考虑协议问题，目前数据当做字符串
    92.                 // 1. 输出发送的数据信息
    93.                 // 2. 输出是谁发送的信息
    94.                 uint16_t cli_port = ntohs(peer.sin_port); // 从网络中来的 -> 网络序列转成主机序列
    95.                 std::string cli_ip = inet_ntoa(peer.sin_addr); // 4字节的网络序列的IP->本主机的字符串风格的IP,方便显示
    96.                 // printf("[%s:%d]# %s\n", cli_ip.c_str(), cli_port, buffer);
    97.  
    98.                 snprintf(key, sizeof(key), "%s-%u", cli_ip.c_str(), cli_port); // 127.0.0.1-8080
    99.                 logMessage(NORMAL, "key: %s", key);
    100.                 auto it = _users.find(key);
    101.                 if (it == _users.end())
    102.                 {
    103.                     logMessage(NORMAL, "add new user : %s", key);
    104.                     _users.insert({key, peer});
    105.                 }
    106.  
    107.                 // // 下面是指令版本
    108.                 // if(strcasestr(buffer, "rm") != nullptr || strcasestr(buffer, "rmdir") != nullptr)
    109.                 // {
    110.                 //     std::string err_message = "被禁止的指令";
    111.                 //     std::cout << err_message << buffer << std::endl;
    112.                 //     sendto(_sock, err_message.c_str(), err_message.size(), 0, (struct sockaddr *)&peer, len);
    113.                 //     continue;
    114.                 // }
    115.                 // FILE *fp = popen(buffer, "r");
    116.                 // if (nullptr == fp)
    117.                 // {
    118.                 //     logMessage(ERROR, "popen: %d:%s", errno, strerror(errno));
    119.                 //     continue;
    120.                 // }
    121.                 // while (fgets(result, sizeof(result), fp) != nullptr)
    122.                 // {
    123.                 //     cmd_echo += result;
    124.                 // }
    125.                 // fclose(fp);
    126.             }
    127.  
    128.             // 分析和处理数据
    129.             // end. 写回数据，类似recvfrom，后两个参数是把数据写给谁
    130.             // sendto(_sock, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
    131.             // sendto(_sock, cmd_echo.c_str(), cmd_echo.size(), 0, (struct sockaddr*)&peer, len);
    132.  
    133.             for (auto &iter : _users)
    134.             {
    135.                 std::string sendMessage = key;
    136.                 sendMessage += "# ";
    137.                 sendMessage += buffer; // 此时消息就类似：127.0.0.1-1234# 你好
    138.                 logMessage(NORMAL, "push message to %s", iter.first.c_str());
    139.                 sendto(_sock, sendMessage.c_str(), sendMessage.size(), 0, (struct sockaddr*)&(iter.second), sizeof(iter.second));
    140.             }
    141.         }
    142.     }
    143.  
    144.     ~UdpServer()
    145.     {
    146.         if (_sock >= 0)
    147.             close(_sock);
    148.     }
    149.  
    150. protected:
    151.     uint16_t _port; // 一个服务器，一般必须需要ip地址和port(16位的整数)
    152.     std::string _ip;
    153.     int _sock;
    154.     std::unordered_mapstruct sockaddr_in> _users; // first存ip和prot，second存消息
    155.     std::queue messageQueue; // 用户层与网络的解耦->多线程->生产者消费者模型(这里就不改了)
    156. };
    157.  
    158. #endif

    顺便把udp_server.cc放出来：

    1. #include "udp_server.hpp"
    2. #include 
    3. #include 
    4.  
    5. static void usage(std::string proc) // usage：使用手册，proc：程序名称
    6. {
    7.     std::cout << "\nUsage: " << proc << " ip port\n" << std::endl;
    8. }
    9.  
    10. // 运行服务端的方式 ./udp_server ip port // 云服务器的问题 bug
    11. int main(int argc, char *argv[])
    12. {
    13.     if(argc != 3)
    14.     {
    15.         usage(argv[0]);
    16.         exit(1);
    17.     }
    18.  
    19.     std::string ip = argv[1];
    20.     uint16_t port = atoi(argv[2]);
    21.     std::unique_ptr svr(new UdpServer(port, ip));
    22.     
    23.     svr->initServer();
    24.     svr->Start();
    25.     return 0;
    26. }

    编译运行：（左边是服务端，中上是A用户发的消息，右上是A用户收到的消息，中下是B用户发的消息，右下是B用户收到的消息）

    如果你把client发给其他人，就能实现类似群聊的效果了。

    本篇完。

    加上代码两万多字了，不过放的代码有重复的，可以自己试着敲一下。

    下一篇：网络和Linux网络_3（套接字编程）TCP网络通信（多个版本）。

  • 相关阅读:
    跳槽面试：如何转换工作场所而不失去优势
    基于Java swing+mysql+eclipse的【水电费管理系统】
    数字工厂中的SCADA（数据采集与监控系统）
    铝合金氩弧焊接工艺个人总结
    Pikachu靶场之XSS漏洞详解
    uniapp 总结篇 （小程序）
    4、python中函数、匿名函数、递归函数
    Kubernetes 之 StatefulSet基本原理
    【Python爬虫】第二课 网络编程基础
    .NET Core Web API 之SignalR
  • 原文地址：https://blog.csdn.net/GRrtx/article/details/133272713