devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【网络】套接字(socket)编程——UDP版

作者：从前慢现在也慢 | 2024-08-20 11:49:42

赞

踩

【网络】套接字(socket)编程——UDP版

1.socket

1.1.什么是socket

Socket 的中文翻译过来就是“套接字”。

套接字是什么，我们先来看看它的英文含义：插座。

        Socket 就像一个电话插座，负责连通两端的电话，进行点对点通信，让电话可以进行通信，端口就像插座上的孔，端口不能同时被其他进程占用。而我们建立连接就像把插头插在这个插座上，创建一个 Socket 实例开始监听后，这个电话插座就时刻监听着消息的传入，谁拨通我这个“IP 地址和端口”，我就接通谁。

事实上， 

        Socket本身有“插座”的意思，在Linux环境下，用于表示进程间网络通信的特殊文件类型。本质为内核借助缓冲区形成的伪文件。

        换句话说，Socket就是一种特殊的文件，服务器和客户端各自维护一个“Socket文件”，在建立连接打开后，可以向文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。

        在Linux操作系统中，所有对象都被视作文件，这使得文件描述符成为管理这些对象的核心工具。文件描述符是一个用于标识已打开文件的整数索引，通过它，可以进行各种I/O操作。Socket作为一种特殊类型的文件，也遵循这一模式。在创建Socket时，系统会为其分配一个文件描述符，从而允许进程像操作文件一样读写网络数据。这种设计极大地简化了网络编程的复杂性，使得开发者可以专注于应用逻辑而非底层细节。

与管道类似的，Linux系统将其封装成文件的目的是为了统一接口，使得读写套接字和读写文件的操作一致。

        套接字和管道的区别是：

  1. 管道主要应用于本地进程间通信；
  2. 套接字多应用于网络进程间数据的传递；
  3. 套接字的内核实现较为复杂，不宜在学习初期深入学习。

在Linux系统中，我们之前是使用PID来标识进程的，用文件描述符来标识文件的。但是在socket这里，就都换了。 

在TCP/IP协议中，

  1. “IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程。
  2. “IP地址+端口号”就对应一个socket。

=欲建立连接的两个进程必须各自有一个socket来标识，那么这两个socket组成的socket pair就唯一标识一个连接。刚好像插头和插座的连接一样，必须两者一一对应。因此可以用Socket来描述网络连接的一对一关系。

套接字通信原理如下图所示：

在网络通信中，套接字一定是成对出现的。一端的发送缓冲区对应对端的接收缓冲区。我们使用同一个文件描述符来描述“发送缓冲区”和“接收缓冲区”。

         实际上，我们口中的Socket有多层意思，一层意思是特殊的文件，一层意思是表示一种特有的通信模式，还有一层意思是在应用层和传输层之间的一个抽象层，它把 TCP/IP 层复杂的操作抽象为几个简单的接口，供应用层调用实现进程在网络中的通信。

就像下面这样子

TCP/IP协议最早在BSD UNIX上实现，为TCP/IP协议设计的应用层编程接口称为socket API。 

2.socket  API

首先我们来看看

socket 套接字提供了下面这一批常用接口，用于实现网络通信

  1. #include <sys/types.h>
  2. #include <sys/socket.h>
  3.  
  4. // 创建socket文件描述符（TCP/UDP	服务器/客户端）
  5. int socket(int domain, int type, int protocol);
  6.  
  7. // 绑定端口号（TCP/UDP	服务器）
  8. int bind(int socket, const struct sockaddr* address, socklen_t address_len);
  9.  
  10. // 开始监听socket (TCP	服务器)
  11. int listen(int socket, int backlog);
  12.  
  13. // 接收连接请求 (TCP	服务器)
  14. int accept(int socket, struct sockaddr* address, socklen_t* address_len);
  15.  
  16. // 建立连接 (TCP	客户端)
  17. int connect(int sockfd, const struct sockaddr* addr, socklen_t addrlen);

可以看到在这一批 API 中，频繁出现了一个结构体类型 sockaddr，这是个什么东西？

首先我们要明白，

网络通信时，数据发送方、数据接收方需要明确对方的网络地址，而网络的地址的三大要素就是下面这3点：

  1. 协议
  2. ip
  3. 端口

在socket里面这三个参数用一个结构体 sockaddr 来表示。

        先说结论，sockaddr是统一的接口，只用一个接口完成不同套接字（比如IPV4，IPV6）之间的通信问题。

        socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4、IPv6,以及后面要讲的UNIX Domain Socket。然而,各种网络协议的地址格式并不相同。在C语言中如果直接处理就要多出重复的接口，设计成统一的目的是为了设计尽量少的接口，实现面向对象中的静态多态——函数重载。

2.1.sockaddr 和sockaddr_in结构体

        socket 这套网络通信标准隶属于 POSIX 通信标准，该标准的设计初衷就是为了实现 可移植性，程序可以直接在使用该标准的不同机器中运行，但有的机器使用的是网络通信，有的则是使用本地通信，socket 套接字为了能同时兼顾这两种通信方式，提供了 sockaddr 结构体

        由 sockaddr 结构体衍生出了两个不同的结构体：sockaddr_in 网络套接字、sockaddr_un 域间套接字，前者用于网络通信，后者用于本地通信

我们今天不讨论socketaddr_un这个，因为他不是用来网络通信的。 

我们来看看sockaddr和sockaddr_in这两个

sockaddr在头文件#include <sys/socket.h>中定义，sockaddr的缺陷是：sa_data把目标地址和端口信息混在一起了，如下

  1. struct sockaddr {  
  2.      sa_family_t sin_family;//地址族
  3. 　　  char sa_data[14]; //14字节，包含套接字中的目标地址和端口信息               
  4. 　　 }; 

 sockaddr_in在头文件#include<netinet/in.h>或#include <arpa/inet.h>中定义，

该结构体解决了sockaddr的缺陷，把port和addr 分开储存在两个变量中，如下： 

  1. struct sockaddr_in {
  2.      short            sin_family;    // 2 字节 ，地址族，e.g. AF_INET, AF_INET6
  3.      unsigned short   sin_port;      // 2 字节 ，16位TCP/UDP 端口号 e.g. htons(3490)，
  4.      struct in_addr   sin_addr;      // 4 字节 ，32位IP地址
  5.      char             sin_zero[8];   // 8 字节 ，不使用
  6. };
  7. struct in_addr {
  8.      unsigned long s_addr;          // 32位IPV4地址打印的时候可以调用inet_ntoa()函数将其转换为char *类型.
  9. };

         sin_port和sin_addr都必须是网络字节序（NBO），一般可视化的数字都是主机字节序（HBO）。

        注释中标明了属性的含义及其字节大小，这两个结构体一样大，都是16个字节，而且都有family属性，不同的是：

  1. sockaddr用其余14个字节来表示sa_data
  2. 而sockaddr_in把14个字节拆分成sin_port, sin_addr和sin_zero分别表示端口、ip地址。sin_zero用来填充字节使sockaddr_in和sockaddr保持一样大小。

我们上面提到过网络通信时，数据发送方、数据接收方需要明确对方的网络地址，而网络的地址的三大要素就是下面这3点：

  1. 协议
  2. ip
  3. 端口

大家看看sockaddr和sockaddr_in里面也没有这3样东西呢？

 事实上，sockaddr和sockaddr_in包含的数据都是一样的，但他们在使用上有区别：

  • 程序员不应操作sockaddr，sockaddr是给操作系统用的
  • 程序员应使用sockaddr_in来表示地址，sockaddr_in区分了地址和端口，使用更方便。

        此外，  二者大小一样，都是16个字节，即占用的内存大小是一致的，因此可以互相转化。二者是并列结构，指向sockaddr_in结构的指针也可以指向sockaddr。

        所以在网络编程中我们会对sockaddr_in结构体进行操作，使用sockaddr_in来建立所需的信息，先把sockaddr_in变量赋值后，强制类型转换后传入用sockaddr做参数的函数。也就是说sockaddr_in用于socket定义和赋值；sockaddr用于函数参数。

一般的用法为：

        程序员把类型、ip地址、端口填充sockaddr_in结构体，然后强制转换成sockaddr，作为参数传递给系统调用函数 

 3.UDP网络通信程序

接下来接下来实现一批基于 UDP 协议的网络程序，本节只介绍基于IPv4的socket网络编程

3.1.核心功能

分别实现客户端与服务器，客户端向服务器发送消息，服务器收到消息后，回响给客户端，有点类似于 echo 指令

该程序的核心在于 使用 socket 套接字接口，以 UDP 协议的方式实现简单网络通信

3.2.程序结构

程序由server.hpp   server.cc   client.hpp   client.cc 组成，大体框架如下

创建 server.hpp 服务器头文件

  1. #pragma once
  2.  
  3. #include <iostream>
  4.  
  5. namespace nt_server
  6. {
  7.     class UdpServer
  8.     {
  9.     public:
  10.         // 构造
  11.         UdpServer()
  12.         {} 
  13.         // 析构
  14.         ~UdpServer()
  15.         {} 
  16.  
  17.         // 初始化服务器
  18.         void InitServer()
  19.         {}
  20.  
  21.         // 启动服务器
  22.         void StartServer()
  23.         {}
  24.  
  25.     private:
  26.         // 字段
  27.     };
  28. }

 创建 server.cc 服务器源文件

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. int main()
  8. {
  9.     unique_ptr<UdpServer> usvr(new UdpServer());//使用智能指针创建了一个UdeServer对象
  10.  
  11.     // 初始化服务器
  12.     usvr->InitServer();
  13.  
  14.     // 启动服务器
  15.     usvr->StartServer();
  16.  
  17.     return 0;
  18. }

 创建 client.hpp 客户端头文件

  1. #pragma once
  2.  
  3. #include <iostream>
  4.  
  5. namespace nt_client
  6. {
  7.     class UdpClient
  8.     {
  9.     public:
  10.         // 构造
  11.         UdpClient() 
  12.         {} 
  13.         // 析构
  14.         ~UdpClient() 
  15.         {} 
  16.  
  17.         // 初始化客户端
  18.         void InitClient() 
  19.         {}
  20.  
  21.         // 启动客户端
  22.         void StartClient() 
  23.         {}
  24.  
  25.     private:
  26.         // 字段
  27.     };
  28. }

创建 client.cc 客户端源文件

  1. #include <memory>
  2. #include "client.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_client;
  6.  
  7. int main()
  8. {
  9.   unique_ptr<UdpClient> usvr(new UdpClient());
  10.  
  11.   // 初始化客户端
  12.   usvr->InitClient();
  13.   
  14.   // 启动客户端
  15.   usvr->StartClient();
  16.  
  17.   return 0;
  18. }

为了方便后续测试，再添加一个 Makefile 文件

创建 Makefile 文件

  1. .PHONY:all
  2. all:server client
  3.  
  4. server:server.cc
  5. 	g++ -o $@ $^ -std=c++11
  6.  
  7. 	
  8. client:client.cc
  9. 	g++ -o $@ $^ -std=c++11
  10.  
  11. .PHONY:clean
  12. clean:
  13. 	rm -rf server client

 准备工作完成后，接下来着手填充代码内容

3.3.服务端设计

3.3.1.创建套接字——socket函数

创建套接字使用 socket 系统调用接口

        socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述符一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

        正如可以给open的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：

  • domain：这个是协议域（协议簇），决定了socket的地址类型。

常用的有下面

  1. AF_INET：用来产生IPV4 - socket 的协议，使用TCP或UDP来传输，用IPV4的地址
  2. AF_INET6:和上面的差不多，这个是IPV6的
  3. AF_UNIX:本地协议，用在Unix和Linux系统上，一般都是服务端和客户端在同一台机器上时使用。 （要用一个绝对路径名作为地址）。

我们一般使用IPV4的AF_INET 

  • type：指socket类型，有面向连接的套接字（SOCK_STREAM）和面向消息的套接字（SOCK_DGRAM）。

我们看看它的参数

  1. SOCK_STREAM：这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，是用TCP协议来传输的。
  2. SOCK_DGRAM：这个协议是无连接的，固定长度的连接调用。该协议是不可靠的，使用UDP来进行它的连接。
  3. SOCK_SEQPACKET：这个协议是双线路的、可靠的连接，发送固定长度的数据包进行传输。（注（1））必须把整个包完整的接收才能够进行读取。
  4. SOCK_RAW:这个socket类型提供单一的网络访问

其中

  • 面向连接的套接字可以理解成TCP协议，数据稳定、按序传输，不存在数据边界，且收发数据在套接字内部有缓冲，所以服务器和客户端进行I/O操作时并不会马上调用，可能分多次调用；
  • 面向消息的套接字可以看做UDP，特点：快速传输、有数据边界、数据可能丢失、传输数据大小受限。
  • protocol：指计算机间通信中使用的协议信息。
  • protocol一般设置为0，默认协议

一般都可以为0（当protocol为0时，会自动选择type类型对应的默认协议。），如果同一协议簇中存在多个数据传输方式相同的协议，则才用第三个参数。

        常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等。type和protocol并不是可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。

  •  返回值

        socket返回的值是一个文件描述符，SOCKET类型本身也是定义为int的，既然是文件描述符，那么在系统中都当作是文件来对待的，0,1,2分别表示标准输入、标准输出、标准错误。所以其他打开的文件描述符都会大于2, 错误时就返回 -1. 这里INVALID_SOCKET 也被定义为 -1 。

socket函数打开一个网络通讯端口，如果成功的话就像open一样返回一个文件描述符，应用程序可以像读写文件一样read/write在网络上收发数据。 

好了socket函数学完了，接下来在 server.hpp 的 InitServer() 函数中创建套接字，并对创建成功/失败后的结果做打印

server.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <cstring>
  5. #include <cerrno>
  6. #include <cstdlib>
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9.  
  10. namespace nt_server
  11. {
  12.     // 错误码
  13.     enum
  14.     {
  15.         SOCKET_ERR = 1
  16.     };
  17.  
  18.     class UdpServer
  19.     {
  20.     public:
  21.         // 构造
  22.         UdpServer()
  23.         {} 
  24.         // 析构
  25.         ~UdpServer()
  26.         {} 
  27.  
  28.         // 初始化服务器
  29.         void InitServer()
  30.         {
  31.             // 1.创建套接字
  32.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  33.  
  34.             if(sock_ == -1)//创建失败
  35.             {
  36.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  37.                 exit(SOCKET_ERR);
  38.             }
  39.  
  40.             // 创建成功
  41.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  42.         }
  43.  
  44.         // 启动服务器
  45.         void StartServer()
  46.         {}
  47.  
  48.     private:
  49.         int sock_; // 套接字
  50.     };
  51. }

        因为这里是使用 UDP 协议实现的 网络通信，参数1 domain 选择 AF_INET（基于 IPv4 标准），参数2 type 选择 SOCK_DGRAM（数据报传输），参数3设置为 0，可以根据 SOCK_DGRAM 自动推导出使用 UDP 协议

我们运行一下

        文件描述符默认 0、1、2 都已经被占用了，如果再创建文件描述符，会从 3 开始，可以看到，程序运行后，创建的套接字正是 3，证明套接字本质上就是文件描述符，不过它用于描述网络资源

3.3.2.绑定IP地址和端口号——bind函数

bind的英文意思就是捆绑

        服务端用于将把用于通信的地址和端口绑定到socket 上。所以可以猜出，这个函数的参数应该包含：用于通信的 socket 和服务端的 IP 地址和端口号。ip地址和端口号是放在 socketaddr_in 结构体里面的。

 参数： 

  1. - sockfd : 通过socket函数得到的文件描述符 
  2. - addr : 需要绑定的socket地址，这个地址封装了ip和端口号的信息 
  3.  - addrlen : 第二个参数结构体占的内存大小

 参数1没啥好说的，重点在于参数2，因为我们这里是 网络通信，所以使用的是 sockaddr_in 结构体，要想使用该结构体，还得包含下面这两个头文件

  1. #include <netinet/in.h>
  2. #include <arpa/inet.h>

有的人可能又好奇了

  • 这个第2个参数不是const struct sockaddr*吗?为啥要使用sockaddr_in呢？

不记得的朋友去上面看看啊！ 

我们进行网络通信的时候一般的做法是

        程序员把类型、ip地址、端口填充sockaddr_in结构体，然后强制转换成sockaddr，作为参数传递给系统调用函数 

我们需要详细了解一下这个sockaddr_in结构体

  1. struct sockaddr_in {
  2.      short            sin_family;    // 2 字节 ，地址族，e.g. AF_INET, AF_INET6
  3.      unsigned short   sin_port;      // 2 字节 ，16位TCP/UDP 端口号 e.g. htons(3490)，
  4.      struct in_addr   sin_addr;      // 4 字节 ，32位IP地址
  5.      char             sin_zero[8];   // 8 字节 ，不使用
  6. };
  7. struct in_addr {
  8.      unsigned long s_addr;          // 32位IPV4地址打印的时候可以调用inet_ntoa()函数将其转换为char *类型.
  9. };

 sin_port和sin_addr都必须是网络字节序（NBO），一般可视化的数字都是主机字节序（HBO）。

我们需要一个sockaddr_in结构体，再创建1个short类型，一个unsigned short，一个struct in_addr传进去，这样子会不会很清楚？

了解完 sockaddr_in 结构体中的内容后，就可以创建该结构体了，再定义该结构体后，需要清空，确保其中的字段干净可用

将变量置为 0 可用使用 bzero 函数

  1. #include <cstrins> // bzero 函数的头文件
  2.  
  3. struct sockaddr_in local;
  4. bzero(&local, sizeof(local));

获得一个干净可用的 sockaddr_in 结构体后，可以正式绑定 IP 地址 和 端口号 了

server.hpp 服务器头文件 

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <cerrno>
  7. #include <cstdlib>
  8. #include <strings.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <netinet/in.h>
  12. #include <arpa/inet.h>
  13.  
  14. namespace nt_server
  15. {
  16.     // 退出码
  17.     enum
  18.     {
  19.         SOCKET_ERR = 1,
  20.         BIND_ERR
  21.     };
  22.  
  23.     // 端口号默认值
  24.     const uint16_t default_port = 8888;
  25.  
  26.     class UdpServer
  27.     {
  28.     public:
  29.         // 构造
  30.         UdpServer(const std::string ip, const uint16_t port = default_port)
  31.             :port_(port), ip_(ip)
  32.         {} 
  33.         // 析构
  34.         ~UdpServer()
  35.         {} 
  36.  
  37.         // 初始化服务器
  38.         void InitServer()
  39.         {
  40.             // 1.创建套接字
  41.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  42.  
  43.             if(sock_ == -1)
  44.             {
  45.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  46.                 exit(SOCKET_ERR);
  47.             }
  48.  
  49.             // 创建成功
  50.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  51.  
  52.             // 2.绑定IP地址和端口号
  53.             struct sockaddr_in local;
  54.             bzero(&local, sizeof(local)); // 置0
  55.  
  56.             // 填充字段
  57.             local.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  58.             local.sin_port = htons(port_); // 主机序列转为网络序列
  59.             local.sin_addr.s_addr = inet_addr(ip_.c_str()); // 点分十进制转为短整数，再将主机序列转为网络序列
  60.  
  61.             // 绑定IP地址和端口号
  62.             int n = bind(sock_, (const sockaddr*)&local, sizeof(local));
  63.             if(n<0)
  64.             {
  65.                 std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
  66.                 exit(BIND_ERR);
  67.             }
  68.  
  69.             // 绑定成功
  70.             std::cout << "Bind IP&&Port Success" << std::endl;
  71.         }
  72.  
  73.         // 启动服务器
  74.         void StartServer()
  75.         {}
  76.  
  77.     private:
  78.         int sock_; // 套接字
  79.         uint16_t port_; // 端口号
  80.         std::string ip_; // IP地址（后面需要删除）
  81.     };
  82. }

        注：作为服务器，需要确定自己的端口号，我这里设置的是 8888，这个端口号需要来回发送的，这个端口号必须是网络字节序，可以使用 htons 函数

有几点要说明了 

  1. 端口号会在网络里互相转发，需要把主机序列转换为网络序列，可以使用 htons 函数
  2. 需要把点分十进制的字符串，转换为无符号短整数，可以使用 inet_addr 函数，这个函数在进行转换的同时，会将主机序列转换为网络序列（因为IP地址需要在网络里面发送）
  3. 绑定IP地址和端口号这个行为并非直接绑定到当前主机中，而是在当前程序中，将创建的 socket 套接字，与目标IP地址与端口号进行绑定，当程序终止后，这个绑定关系也会随之消失

我们这里先插一个小知识

3.3.2.1.地址转换函数——字符串和struct in_addr互相转换
  • 我们这里为什么要使用字符串来表示IP地址？

首先大部分用户习惯使用的IP是点分十进制的字符串，就像下面这个这样

128.11.3.31

基于IPv4的socket网络编程，sockaddr_in中的成员struct in_addr sin_addr表示32位 的IP 地址，也就是说事实上我们的IP地址就是下面的第3个成员。

  1. ​struct sockaddr_in {
  2.      short            sin_family;    // 2 字节 ，地址族，e.g. AF_INET, AF_INET6
  3.      unsigned short   sin_port;      // 2 字节 ，16位TCP/UDP 端口号 e.g. htons(3490)，
  4.      struct in_addr   sin_addr;      // 4 字节 ，32位IP地址
  5.      char             sin_zero[8];   // 8 字节 ，不使用
  6. };
  7. struct in_addr {
  8.      unsigned long s_addr;          // 32位IPV4地址打印的时候可以调用inet_ntoa()函数将其转换为char *类型.
  9. };

点分十进制的IP地址不好输入，我们往往先用更好输入的字符串来存储IP地址，然后将字符串版的IP地址转换为struct in_addr版的IP地址（也就是点分十进制版的）


        事实上，在网络编程中，经常需要进行点分十进制字符串表示的IP地址和in_addr结构体表示的IP地址之间的转换。以下是一些常用的地址转换函数，它们存放在<arpa/inet.h>头文件中。

  • 1. 字符串转 in_addr 结构体

有很多函数都能做到，这里就举两个，第一个函数就是inet_addr

  1. #include <arpa/inet.h>
  2.  
  3. in_addr_t inet_addr(const char *cp);

该函数将点分十进制的字符串表示的IPv4地址转换为网络字节序的32位整数。返回的是in_addr_t类型，通常用于填充sin_addr.s_addr字段。

示例

  1. const char *ipString = "192.168.1.1";
  2. in_addr_t ipAddress = inet_addr(ipString);

 第二个函数就是inet_pton

  1. #include <arpa/inet.h>
  2.  
  3. int inet_pton(int af, const char *src, void *dst);

 这个函数是更通用的函数，支持IPv4和IPv6地址的转换。第一个参数 af 表示地址族，常用的是 AF_INET（IPv4）和 AF_INET6（IPv6）。第二个参数 src 是输入的字符串表示的IP地址，第三个参数 dst 是输出的二进制表示的IP地址。

示例

  1. #include <arpa/inet.h>
  2.  
  3. struct in_addr ipv4Address;
  4. const char *ipString = "192.168.1.1";
  5. inet_pton(AF_INET, ipString, &(ipv4Address.s_addr));
  • 2. in_addr 结构体转字符串

有很多函数都能做到，这里就举两个，第一个函数是inet_ntoa函数

  1. #include <arpa/inet.h>
  2.  
  3. char *inet_ntoa(struct in_addr in);

该函数将in_addr结构体中的IPv4地址转换为点分十进制的字符串表示。需要注意的是，返回的是指向静态缓冲区的指针，inet_ntoa把结果放到自己内部的一个静态存储区, 这样第二次调用时的结果会覆盖掉上一次的结果。因此不宜多次调用，不能用来多线程。

  • 如果有多个线程调用 inet_ntoa, 是否会出现异常情况呢?
  • 在APUE中, 明确提出inet_ntoa不是线程安全的函数;
  • 在多线程环境下, 推荐使用inet_ntop, 这个函数由调用者提供一个缓冲区保存结果, 可以规避线程安全问 题;

示例：

  1. #include <arpa/inet.h>
  2.  
  3. struct in_addr ipv4Address;
  4. ipv4Address.s_addr = inet_addr("192.168.1.1");
  5. char *ipString = inet_ntoa(ipv4Address);

第二个函数就是inet_ntop

  1. #include <arpa/inet.h>
  2.  
  3. const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

这是一个更通用的函数，支持IPv4和IPv6地址的转换。第一个参数 af 表示地址族，常用的是 AF_INET（IPv4）和 AF_INET6（IPv6）。第二个参数 src 是输入的二进制表示的IP地址。第三个参数 dst 是输出的字符串表示的IP地址的缓冲区。第四个参数 size 是缓冲区的大小。

示例

  1. #include <arpa/inet.h>
  2.  
  3. struct in_addr ipv4Address;
  4. ipv4Address.s_addr = inet_addr("192.168.1.1");
  5. char ipString[INET_ADDRSTRLEN];
  6. inet_ntop(AF_INET, &(ipv4Address.s_addr), ipString, INET_ADDRSTRLEN);

这些地址转换函数是在网络编程中非常实用的工具，它们使得在不同表示之间进行转换变得简单而高效。通过合理使用这些函数，你可以轻松地在字符串表示和二进制表示之间转换IP地址，从而更方便地进行网络编程。

server.cc 服务器源文件

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. int main()
  8. {
  9.     unique_ptr<UdpServer> usvr(new UdpServer("8.134.110.68"));
  10.  
  11.     // 初始化服务器
  12.     usvr->InitServer();
  13.  
  14.     // 启动服务器
  15.     usvr->StartServer();
  16.  
  17.     return 0;
  18. }
  19.

接下来编译并运行程序

 可以发现运行错了

  •  如果运行环境是虚拟机，这个是可以运行起来的，但是我们今天的运行环境是云服务器，云服务器禁止绑定公网IP，因为这个是虚拟化了的，跟我们的机器对不上。
  • 此外，一台机器可能有多张网卡，有多个IP地址，这样子如果只绑定了一个IP，那么只能收到这个IP发来的。 

所以解决方案是在绑定 IP 地址时，让其选择绑定任意可用 IP 地址

这样子有两种方法

第一种方法是服务器端只需要作下面这些改动

  • 不需要为 IP 地址而创建srring类型
  • 构造时也无需传入 IP 地址
  • 绑定 IP 地址时选择 INADDR_ANY，表示绑定任何可用的 IP 地址

server.hpp 服务器头文件 

  1. class UdpServer
  2. {
  3. public:
  4. 	// 构造
  5. 	UdpServer(const uint16_t port = default_port)
  6. 	    :port_(port)
  7. 	{} 
  8.  
  9. // 初始化服务器
  10. void InitServer()
  11. {
  12.     // ...
  13.     
  14.     // 填充字段
  15.     local.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  16.     local.sin_port = htons(port_); // 主机序列转为网络序列
  17.     // local.sin_addr.s_addr = inet_addr(ip_.c_str()); // 点分十进制转为短整数，再将主机序列转为网络序列
  18.     local.sin_addr.s_addr = INADDR_ANY; // 绑定任何可用IP地址
  19.  
  20. 	// ...
  21. }
  22.  
  23. private:
  24. 	int sock_; // 套接字
  25. 	uint16_t port_; // 端口号
  26. 	// std::string ip_; // 删除
  27. };

此外还有一种方法，我们可以不删除这个string，我们让IP绑定到0.0.0.0，0.0.0.0 表示任意IP地址

  1. #pragma once
  2. //.....
  3. namespace nt_server
  4. {
  5.     // 退出码
  6.     enum
  7.     {
  8.         SOCKET_ERR = 1,
  9.         BIND_ERR
  10.     };
  11.  
  12.     // 端口号默认值
  13.     const uint16_t default_port = 8888;
  14.     const std::string="0.0.0.0";//注意这里
  15.  
  16.     class UdpServer
  17.     {
  18.     public:
  19.         // 构造
  20.         UdpServer(const std::string ip=defaultip, const uint16_t port = default_port)
  21.             :port_(port), ip_(ip)
  22.         {} 
  23.         // 析构
  24.         ~UdpServer()
  25.         {} 
  26.  
  27.         // 初始化服务器
  28.         void InitServer()
  29.         {
  30.            //。。。。
  31.  
  32.             // 2.绑定IP地址和端口号
  33.             struct sockaddr_in local;
  34.             bzero(&local, sizeof(local)); // 置0
  35.  
  36.             // 填充字段
  37.             local.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  38.             local.sin_port = htons(port_); // 主机序列转为网络序列
  39.             local.sin_addr.s_addr = inet_addr(ip_.c_str()); // 点分十进制转为短整数，再将主机序列转为网络序列
  40.  
  41.            //。。。。
  42.         }
  43.  
  44.         // 启动服务器
  45.         void StartServer()
  46.         {}
  47.  
  48.     private:
  49.         int sock_; // 套接字
  50.         uint16_t port_; // 端口号
  51.         std::string ip_; // IP地址
  52.     };
  53. }

这样子就好了

 server.cc 服务器源文件

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. int main()
  8. {
  9.     unique_ptr<UdpServer> usvr(new UdpServer());
  10.  
  11.     // 初始化服务器
  12.     usvr->InitServer();
  13.  
  14.     // 启动服务器
  15.     usvr->StartServer();
  16.  
  17.     return 0;
  18. }

 再次编译并运行程序，可以看到正常运行

 

到目前为止，我们的UDP网络通信程序已经完成了最基本的环境搭建，接下来就是发信息，读消息那些了。

3.3.3.读取信息——recvfrom函数

读取信息使用recvfrom函数

recvfrom() 函数是一个系统调用，用于从套接字接收数据。

该函数通常与无连接的数据报服务（如 UDP）一起使用，但也可以与其他类型的套接字使用。

与简单的 recv() 函数不同，recvfrom() 可以返回数据来源的地址信息。 

我们来看看它的参数

1.  sockfd：一个已打开的套接字的描述符。

2.  buf：一个指针，指向用于存放接收到的数据的缓冲区。

3.  len：缓冲区的大小（以字节为单位）。

4.  flags：控制接收行为的标志，读取方式（阻塞/非阻塞）。通常可以设置为0，但以下是一些可用的标志：

  • MSG_WAITALL：尝试接收全部请求的数据。函数可能会阻塞，直到收到所有数据。
  • MSG_PEEK：查看即将接收的数据，但不从套接字缓冲区中删除它【1】。
  • 其他一些标志还可以影响函数的行为，但在大多数常规应用中很少使用。

前半部分主要用于读取数据，并进行存放，接下来看看后半部分

5.  src_addr：一个指针，指向一个 sockaddr 结构，用于保存发送数据的源地址。

6.  addrlen：一个值-结果参数。开始时，它应该设置为 src_addr 缓冲区的大小。当 recvfrom() 返回时，该值会被修改为实际地址的长度（以字节为单位）。

后面都是用来保存对方的地址信息的！

返回值：

  • 在成功的情况下，recvfrom() 返回接收到的字节数。
  • 如果没有数据可读或套接字已经关闭，那么返回值为0。
  • 出错时，返回 -1，并设置全局变量 errno 以指示错误类型。

使用示例

  1. struct sockaddr_in sender;
  2. socklen_t sender_len = sizeof(sender);
  3. char buffer[1024];
  4.  
  5. int bytes_received = recvfrom(sockfd, buffer, sizeof(buffer), 0,
  6.                               (struct sockaddr*)&sender, &sender_len);
  7. if (bytes_received < 0) {
  8.     perror("recvfrom failed");
  9.     // handle error
  10. }

注意： 因为 recvfrom 函数的参数 src_addr 类型为 sockaddr，需要将 sockaddr_in 类型强转后，再进行传递

server.hpp 服务器头文件 

  1. namespace nt_server
  2. {
  3.     // 退出码
  4.     enum
  5.     {
  6.         SOCKET_ERR = 1,
  7.         BIND_ERR
  8.     };
  9.  
  10.     // 端口号默认值
  11.     const uint16_t default_port = 8888;
  12.  
  13.     class UdpServer
  14.     {
  15.     //.....
  16.  
  17.         // 启动服务器
  18.         void StartServer()
  19.         {
  20.             // 服务器是不断运行的，所以需要使用一个 while(true) 死循环
  21.             char buff[1024]; // 缓冲区
  22.             while (true)
  23.             {
  24.                 // 1. 接收消息
  25.                 struct sockaddr_in peer;      // 客户端结构体
  26.                 socklen_t len = sizeof(peer); // 客户端结构体大小
  27.  
  28.                 // 传入 sizeof(buff) - 1 表示当前传输的是字符串，预留一个位置存储 '\0'
  29.                 // 传入 0 表示当前是阻塞式读取
  30.                 ssize_t n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&peer, &len);
  31.  
  32.                 if (n > 0)
  33.                     buff[n] = '\0';
  34.                 else
  35.                     continue; // 继续读取
  36.  
  37.                 // 2.处理数据
  38.                 std::string clientIp = inet_ntoa(peer.sin_addr); // 获取IP地址
  39.                 uint16_t clientPort = ntohs(peer.sin_port);      // 获取端口号
  40.                 printf("Server get message from [%s:%d]$ %s\n", clientIp.c_str(), clientPort, buff);
  41.  
  42.                 // 3.回响给客户端
  43.                 // ...
  44.             }
  45.         }
  46.  
  47.    //.....
  48.     };
  49. }

到这里也算是完成一小步

3.3.4.发送消息——sendto函数

发送信息使用 sendto 函数

sendto() 函数是一个系统调用，用于发送数据到一个指定的地址。

它经常与无连接的数据报协议，如UDP，一起使用。

不像 send() 函数只能发送数据到一个预先建立连接的远端，sendto() 允许在每次发送操作时指定目的地址。

参数解释：

1.  sockfd：一个已打开的套接字的描述符。

2.  buf：一个指针，指向要发送的数据的缓冲区。

3.  len：要发送的数据的大小（以字节为单位）。

4.  flags：控制发送行为的标志，也就是发送方式（阻塞/非阻塞）。通常可以设置为0。一些可用的标志包括：

  • MSG_CONFIRM：在数据报协议下告诉网络层该数据已经被确认。
  • MSG_DONTROUTE：不查找路由，数据报将只发送到本地网络。
  • 其他标志可以影响函数的行为，但在大多数常规应用中很少使用。

5.  dest_addr：指向 sockaddr 结构的指针，该结构包含目标地址和端口信息。

6.  addrlen：dest_addr 缓冲区的大小（以字节为单位）。

返回值：

  • 成功时，sendto() 返回实际发送的字节数。
  • 出错时，返回 -1 并设置全局变量 errno 以指示错误类型。

例子：

  1. struct sockaddr_in receiver;
  2. receiver.sin_family = AF_INET;
  3. receiver.sin_port = htons(12345);  // Some port number
  4. inet_pton(AF_INET, "192.168.1.1", &receiver.sin_addr);  // Some IP address
  5.  
  6. char message[] = "Hello, World!";
  7. ssize_t bytes_sent = sendto(sockfd, message, sizeof(message), 0,
  8.                             (struct sockaddr*)&receiver, sizeof(receiver));
  9. if (bytes_sent < 0) {
  10.     perror("sendto failed");
  11.     // handle error
  12. }

在这个例子中，我们使用 sendto() 发送一个字符串到指定的IP地址和端口号。如果发送失败，我们打印一个错误消息。

server.hpp 服务器头文件 

  1. //。。。
  2. namespace nt_server
  3. {
  4.     // 退出码
  5.     enum
  6.     {
  7.         SOCKET_ERR = 1,
  8.         BIND_ERR
  9.     };
  10.  
  11.     // 端口号默认值
  12.     const uint16_t default_port = 8888;
  13.  
  14.     class UdpServer
  15.     {
  16.     //.....
  17.  
  18.         // 启动服务器
  19.         void StartServer()
  20.         {
  21.             // 服务器是不断运行的，所以需要使用一个 while(true) 死循环
  22.             char buff[1024]; // 缓冲区
  23.             while (true)
  24.             {
  25.                 // 1. 接收消息
  26.                 struct sockaddr_in peer;      // 客户端结构体
  27.                 socklen_t len = sizeof(peer); // 客户端结构体大小
  28.  
  29.                 // 传入 sizeof(buff) - 1 表示当前传输的是字符串，预留一个位置存储 '\0'
  30.                 // 传入 0 表示当前是阻塞式读取
  31.                 ssize_t n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&peer, &len);
  32.  
  33.                 if (n > 0)
  34.                     buff[n] = '\0';
  35.                 else
  36.                     continue; // 继续读取
  37.  
  38.                 // 2.处理数据
  39.                 std::string clientIp = inet_ntoa(peer.sin_addr); // 获取IP地址
  40.                 uint16_t clientPort = ntohs(peer.sin_port);      // 获取端口号
  41.                 printf("Server get message from [%c:%d]$ %s\n", clientIp.c_str(), clientPort, buff);
  42.  
  43.                 // 3.回响给客户端
  44.                 n = sendto(sock_, buff, strlen(buff), 0, (const struct sockaddr *)&peer, sizeof(peer));
  45.  
  46.                 if (n == -1)
  47.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  48.             }
  49.         }
  50.  
  51.    //.....
  52.     };
  53. }

万事具备后，就可以启动服务器了，可以看到服务器启动后，处于阻塞等待状态，这是因为还没有客户端给我的服务器发信息，所以它就会暂时阻塞

  • 如何证明服务器端正在运行？

可以通过 Linux 中查看网络状态的指令，因为我们这里使用的是 UDP 协议，所以只需要输入下面这条指令，就可以查看有哪些程序正在运行

netstat -nlup

现在服务已经跑起来了，并且如期占用了 8888 端口，接下来就是编写客户端相关代码

注意：0.0.0.0 表示任意IP地址

这个时候我们修改代码 

sever.cc 

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. int main()
  8. {
  9.     unique_ptr<UdpServer> usvr(new UdpServer(80));//使用智能指针创建了一个UdeServer对象
  10.  
  11.     // 初始化服务器
  12.     usvr->InitServer();
  13.  
  14.     // 启动服务器
  15.     usvr->StartServer();
  16.  
  17.     return 0;
  18. }

运行一下 

 

我们去监控面板看看

不让我们绑定啊

        事实上对于端口号的绑定：[0,1023]这个区间的端口号都不要去绑定，这些是系统内定的端口号，一般都有固定的应用层协议使用，比如http:80，https:443…… 这个就像110就代表警察，120是急救，你的电话号码不能是这些吧。此外如果真的想要绑定，那就使用sudo吧！！！

3.3.5.命令行参数改装服务端 

上面的代码中，我们的端口号都是在代码里面指定了的，但是我们不能每次使用的时候都去修改代码吧，我们其实通过命令行参数来指定端口号

server.hpp

  1. //....
  2.    // 退出码
  3.     enum
  4.     {
  5.         SOCKET_ERR = 1,
  6.         BIND_ERR,
  7.         USAGE_ERR
  8.     };
  9. //.....

server.cc

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. void Usage(const char* program)
  8. {
  9.   cout << "Usage:" << endl;
  10.   cout << "\t" << program << "  ServerPort" << endl;
  11. }
  12.  
  13. int main(int argc, char* argv[])
  14. {
  15.   if (argc != 2)
  16.   {
  17.     // 错误的启动方式，提示错误信息
  18.     Usage(argv[0]);
  19.     return USAGE_ERR;
  20.   }
  21.  
  22.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  23.   uint16_t port = stoi(argv[1]);//将字符串转换成端口号
  24.  
  25.     unique_ptr<UdpServer> usvr(new UdpServer(port));//使用智能指针创建了一个UdeServer对象
  26.  
  27.     // 初始化服务器
  28.     usvr->InitServer();
  29.  
  30.     // 启动服务器
  31.     usvr->StartServer();
  32.  
  33.     return 0;
  34. }

 运行一下

很酷吧 

3.4.客户端设计

3.4.1.使用命令行参数指定IP地址和端口号

和服务端不同，客户端在运行时，必须知道服务器的 IP 地址 和 端口号，否则不知道自己该与谁进行通信，所以对于 UdpClient 类来说，ip 和 port 者两个字段是肯定少不了的

client.hpp 客户端头文件

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5.  
  6. namespace nt_client
  7. {
  8.      // 退出码
  9.     enum
  10.     {
  11.         USAGE_ERR=3
  12.     };
  13.  
  14.     class UdpClient
  15.     {
  16.     public:
  17.         // 构造
  18.         UdpClient(const std::string& ip, uint16_t port)
  19.             :server_ip_(ip), server_port_(port)
  20.         {} 
  21.         
  22.         // 析构
  23.         ~UdpClient() 
  24.         {} 
  25.  
  26.         // 初始化客户端
  27.         void InitClient() 
  28.         {}
  29.  
  30.         // 启动客户端
  31.         void StartClient() 
  32.         {}
  33.  
  34.     private:
  35.         std::string server_ip_; // 服务器IP地址
  36.         uint16_t server_port_; // 服务器端口号
  37.     };
  38. }

这两个参数由用户主动传输，这里就需要 命令行参数 相关知识了，在启动客户端时，需要以 ./client serverIp serverPort 的方式运行，否则就报错，并提示相关错误信息

client.cc 客户端源文件

  1. #include <iostream>
  2. #include <memory>
  3. #include "client.hpp"
  4.  
  5. using namespace std;
  6. using namespace nt_client;
  7.  
  8. void Usage(const char* program)
  9. {
  10.   cout << "Usage:" << endl;
  11.   cout << "\t" << program << " ServerIP ServerPort" << endl;
  12. }
  13.  
  14. int main(int argc, char* argv[])
  15. {
  16.   if (argc != 3)
  17.   {
  18.     // 错误的启动方式，提示错误信息
  19.     Usage(argv[0]);
  20.     return USAGE_ERR;
  21.   }
  22.  
  23.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  24.   std::string ip = argv[1];
  25.   uint16_t port = stoi(argv[2]);
  26.  
  27.   unique_ptr<UdpClient> usvr(new UdpClient(ip, port));
  28.  
  29.   // 初始化客户端
  30.   usvr->InitClient();
  31.  
  32.   // 启动客户端
  33.   usvr->StartClient();
  34.  
  35.   return 0;
  36. }

如此一来，只有正确的输入 [./client ServerIP ServerPort] 才能启动程序，否则不让程序运行，倒逼客户端启动时，提供服务器的 IP 地址 和 端口号

3.4.2.初始化客户端 

        初始化客户端时，同样需要创建 socket 套接字，不同于服务器的是 客户端不需要自己手动绑定（bind） IP 地址与端口号

        这是因为客户端手动指明（bind） 端口号 存在隐患：如果恰好有两个程序使用了同一个端口，会导致其中一方的客户端直接绑定失败，无法运行，将绑定 端口号 这个行为交给 OS 自动执行（首次传输数据时自动 bind），可以避免这种冲突的出现

  • 为什么服务器要自己手动指定端口号，并进行绑定（bind）？

        这是因为服务器的端口不能随意改变，并且这是要公布给广大客户端看的，同一家公司在部署服务时，会对端口号的使用情况进行管理，可以直接避免端口号冲突

        客户端在启动前，需要先知晓服务器的 sockaddr_in 结构体信息，可以利用已知的 IP 地址 和 端口号 构建 ，这个就像，顾客必须得知道哪里会提供服务吧！！！

综上所述，在初始化客户端时，需要创建好套接字和初始化服务器的 sockaddr_in 结构体信息

也就是说

  1. 客户端需要bind吗？需要，只不过不需要用户显示的bind!一般有os自主随机选择，
  2. 一个端口号只能被1个进程bind，对server是如此，对client也是如此。
  3. 其实clinent的port是多少不重要，只要能保证主机上的唯一性就可以。
  4. 系统什么时候给我bind呢？首次发送数据的时候。

client.hpp 客户端头文件

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <cerrno>
  7. #include <cstdlib>
  8. #include <strings.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <netinet/in.h>
  12. #include <arpa/inet.h>
  13. #include "err.hpp"
  14.  
  15. namespace nt_client
  16. {
  17.      // 退出码
  18.     enum
  19.     {
  20.         SOCKET_ERR = 1,
  21.         BIND_ERR,
  22.         USAGE_ERR
  23.     };
  24.  
  25.     class UdpClient
  26.     {
  27.     public:
  28.         // 构造
  29.         UdpClient(const std::string& ip, uint16_t port)
  30.             :server_ip_(ip), server_port_(port)
  31.         {} 
  32.  
  33.         // 析构
  34.         ~UdpClient() 
  35.         {} 
  36.  
  37.         // 初始化客户端
  38.         void InitClient() 
  39.         {
  40.             // 1.创建套接字
  41.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  42.  
  43.             if(sock_ == -1)
  44.             {
  45.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  46.                 exit(SOCKET_ERR);
  47.             }
  48.  
  49.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  50.  
  51.             // 2.构建服务器的 sockaddr_in 结构体信息
  52.             bzero(&svr_, sizeof(svr_));
  53.             svr_.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  54.             svr_.sin_addr.s_addr = inet_addr(server_ip_.c_str()); // 绑定服务器IP地址
  55.             svr_.sin_port = htons(server_port_); // 绑定服务器端口号
  56.  
  57.             //注意这里就不要自己去手动绑定了，os会在我们第一次发送消息的时候自动绑定
  58.         }
  59.  
  60.         // 启动客户端
  61.         void StartClient() 
  62.         {}
  63.  
  64.     private:
  65.         std::string server_ip_; // 服务器IP地址
  66.         uint16_t server_port_; // 服务器端口号
  67.         int sock_;
  68.         struct sockaddr_in svr_; // 服务器的sockadder_in结构体信息
  69.     };
  70. }

如此一来，客户端就可以利用该 sockaddr_in 结构体，与目标主机进行通信了

3.4.2.通信

接下来就是客户端向服务器发送消息，消息由用户主动输入，使用的是 sendto 函数

发送消息步骤

  1. 用户输入消息
  2. 传入缓冲区、服务器相关参数，使用 sendto 函数发送消息
  3. 消息发送后，客户端等待服务器回响消息

接收消息步骤：

  1. 创建缓冲区
  2. 接收信息，判断是否接收成功
  3. 处理信息

注：同服务器一样，客户端也需要不断运行

client.hpp

  1. // 启动客户端
  2. void StartClient() 
  3. {
  4.     char buff[1024];
  5.  
  6.     while(true)
  7.     {
  8.         // 1.发送消息
  9.         std::string msg;
  10.         std::cout << "Input Message# ";
  11.         std::getline(std::cin, msg);
  12.  
  13.         ssize_t n = sendto(sock_, msg.c_str(), msg.size(), 0, (const struct sockaddr*)&svr_, sizeof(svr_));
  14.  
  15.         if(n == -1)
  16.         {
  17.             std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  18.             continue; // 重新输入消息并发送
  19.         }
  20.  
  21.         // 2.接收消息
  22.         socklen_t len = sizeof(svr_); // 创建一个变量，因为接下来的参数需要传左值
  23.         n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&svr_, &len);
  24.  
  25.         if(n > 0)
  26.             buff[n] = '\0';
  27.         else
  28.             continue;
  29.  
  30.         // 可以再次获取IP地址与端口号
  31.         std::string ip = inet_ntoa(svr_.sin_addr);
  32.         uint16_t port = ntohs(svr_.sin_port);
  33.  
  34.         printf("Client get message from [%s:%d]# %s\n",ip.c_str(), port, buff);
  35.     }
  36. }
  37.

到现在已经大功告成了，我们马上去运行

3.5.运行的一些问题

服务端必须先启动

我们去另外一个机器下面运行发现

 

我们发现已经建立成功了

我们现在来启动用户端 

那么问题来了，我们用户端怎么知道服务端的IP呢?

大家知道网络呢吧！！我们去上网搜索一下百度的官网，

这个网址的本质就是IP地址，也就是说，服务端提供自己的服务的时候，会把IP也一并公布出来

所以客户端是知道服务端的IP地址的，我们直接填自己的公网IP地址即可

注：127.0.0.1 表示本地环回（通常用于测试网络程序），因为我当前的服务器和客户端都是在同一机器上运行的，所以就可以使用该 IP 地址，当然直接使用服务器的公网 IP 地址也是可以的

我们运行一下

 

我们发现都没有反应啊

这其实不是代码的问题，这是环境的问题，我的云服务器（我的环境）的udp的端口没有开放

3.5.1.防火墙开放端口

打开防火墙

sudo systemctl start firewalld.service

 关闭防火墙

sudo systemctl stop firewalld.service

查看防火墙状态

sudo firewall-cmd --state

开放TCP端口

  1. sudo firewall-cmd --zone=public --add-port=80/tcp --permanent    # 开放TCP 80端口
  2. sudo firewall-cmd --zone=public --add-port=443/tcp --permanent    # 开放TCP 443端口
  3. sudo firewall-cmd --zone=public --add-port=3306/tcp --permanent    # 开放TCP 3306端口
  4. sudo firewall-cmd --zone=public --add-port=6379/tcp --permanent    # 开放TCP 6379端口

关闭TCP端口

  1. sudo firewall-cmd --zone=public --remove-port=80/tcp --permanent   #关闭TCP 5672端口
  2. sudo firewall-cmd --zone=public --remove-port=443/tcp --permanent   #关闭TCP 443端口
  3. sudo firewall-cmd --zone=public --remove-port=3306/tcp --permanent   #关闭TCP 3306端口
  4. sudo firewall-cmd --zone=public --remove-port=6379/tcp --permanent   #关闭TCP 6379端口

开放udp端口

sudo firewall-cmd --zone=public --add-port=9595/udp --permanent    # 开放UDP 9595端口

关闭UDP端口

sudo firewall-cmd --zone=public --remove-port=9595/udp --permanent   #关闭UDP 9595端口

查看监听的TCP端口

netstat -ntlp

查看监听的UDP端口

netstat -nulp

 配置生效——修改完配置后一定要来一句，不然就白设置了！！！

sudo firewall-cmd --reload

查看所有开放的端口

sudo firewall-cmd --list-port

检测UDP的特定端口是否开放

sudo firewall-cmd --query-port=8877/udp  检测8877端口是否开放

检测TCP的特定端口是否开放

sudo firewall-cmd --query-port=8877/tcp  检测8877端口是否开放

注意上面部分操作是要sudo权限的

  • （1）TCP和UDP的端口号范围都是0~65535。
  • （2）0~1023的端口号被预留给一些特定的服务和应用程序使用，例如HTTP服务使用的端口号是80，HTTPS服务使用的端口号是443，FTP服务使用的端口号是21等等。这些端口号被称为“知名端口”或“系统端口”。
  • （3）1024~49151的端口号被称为“注册端口”或“用户端口”，这些端口号可以被一些应用程序使用，但是不会与系统端口冲突。
  • （4）49152~65535的端口号被称为“动态端口”或“私有端口”，这些端口号可以被应用程序动态地分配使用。

好了我们现在来开放我们的8877窗口

 我们去看看它有没有开放

没有啊，这是因为我们还没有让我们的配置生效

好了，目前我们已经把8877端口开放了，接下来就是使用这个开放的端口了。

 我们看看8877没有被占用

我们直接绑定8877

绑定成功了啊

  我们输入信息看看

还是不通过！！！！！

     虽然通过CentOs 7系统的的「防火墙」开放了对应的端口号，任然无法访问端口号对应的应用程序，后面了解到原来还需要设置云服务器的「安全组规则」，开放相应的端口权限，服务端的接口才能真正开放。

3.5.2.设置云服务器安全组

华为云服务器开放端口的具体步骤：

步骤1：登录华为云官网

步骤2：点击主页右上角的控制台  

步骤3：进去之后点击安全组

步骤4，进去之后点击我们的实例 

注意是点击我们的云服务器配置的那个实例

步骤5，点击入方向规则

步骤 6：点击添加规则

步骤7：按照下面这样子填 

注意：

  • 0.0.0.0/0表示任意IP地址。
  • 如果我们想开放8000-10000等其他区间也是可以的。

我们发现已经成功了

 3.5.3.启动

到现在我们总算是完成所有步骤了

完美啊！！！！！

这个时候网络通信已经完成了，我们可以保持服务端一直开启，然后多台云服务器启动client程序，然后就能发给服务端了，服务器这个时候就像是一个多人聊天室了

3.6.源代码

server.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <cerrno>
  7. #include <cstdlib>
  8. #include <strings.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <netinet/in.h>
  12. #include <arpa/inet.h>
  13.  
  14. namespace nt_server
  15. {
  16.     // 退出码
  17.     enum
  18.     {
  19.         SOCKET_ERR = 1,
  20.         BIND_ERR,
  21.         USAGE_ERR
  22.     };
  23.  
  24.     // 端口号默认值
  25.     const uint16_t default_port = 8888;
  26.     
  27.  
  28.     class UdpServer
  29.     {
  30.     public:
  31.         // 构造
  32.         UdpServer(const uint16_t port = default_port) : port_(port)
  33.         {
  34.         }
  35.         // 析构
  36.         ~UdpServer()
  37.         {
  38.         }
  39.  
  40.         // 初始化服务器
  41.         void InitServer()
  42.         {
  43.             // 1.创建套接字
  44.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  45.  
  46.             if (sock_ == -1)
  47.             {
  48.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  49.                 exit(SOCKET_ERR);
  50.             }
  51.  
  52.             // 创建成功
  53.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  54.  
  55.             // 2.绑定IP地址和端口号
  56.             struct sockaddr_in local;
  57.             bzero(&local, sizeof(local)); // 置0
  58.  
  59.             // 填充字段
  60.             local.sin_family = AF_INET;         // 设置为网络通信（PF_INET 也行）
  61.             local.sin_port = htons(port_);      // 主机序列转为网络序列
  62.              // local.sin_addr.s_addr = inet_addr(ip_.c_str()); // 点分十进制转为短整数，再将主机序列转为网络序列
  63.             local.sin_addr.s_addr = INADDR_ANY; // 绑定任何可用IP地址
  64.  
  65.             // 绑定IP地址和端口号
  66.             int n = bind(sock_, (const sockaddr *)&local, sizeof(local));
  67.             if (n < 0)
  68.             {
  69.                 std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
  70.                 exit(BIND_ERR);
  71.             }
  72.  
  73.             // 绑定成功
  74.             std::cout << "Bind IP&&Port Success" << std::endl;
  75.         }
  76.  
  77.         // 启动服务器
  78.         void StartServer()
  79.         {
  80.             // 服务器是不断运行的，所以需要使用一个 while(true) 死循环
  81.             char buff[1024]; // 缓冲区
  82.             while (true)
  83.             {
  84.                 // 1. 接收消息
  85.                 struct sockaddr_in peer;      // 客户端结构体
  86.                 socklen_t len = sizeof(peer); // 客户端结构体大小
  87.  
  88.  
  89.                 // 传入 sizeof(buff) - 1 表示当前传输的是字符串，预留一个位置存储 '\0'
  90.                 // 传入 0 表示当前是阻塞式读取
  91.                 ssize_t n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&peer, &len);
  92.  
  93.                 if (n > 0)
  94.                     buff[n] = '\0';
  95.                 else
  96.                     continue; // 继续读取
  97.  
  98.                 // 2.处理数据
  99.                 std::string clientIp = inet_ntoa(peer.sin_addr); // 获取IP地址
  100.                 uint16_t clientPort = ntohs(peer.sin_port);      // 获取端口号
  101.                 printf("Server get message from [%s:%d]$ %s\n", clientIp.c_str(), clientPort, buff);
  102.  
  103.                 // 3.回响给客户端
  104.                 n = sendto(sock_, buff, strlen(buff), 0, (const struct sockaddr *)&peer, sizeof(peer));
  105.  
  106.                 if (n == -1)
  107.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  108.             }
  109.         }
  110.  
  111.     private:
  112.         int sock_;      // 套接字
  113.         uint16_t port_; // 端口号
  114.     };
  115. }

server.cc

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. void Usage(const char* program)
  8. {
  9.   cout << "Usage:" << endl;
  10.   cout << "\t" << program << "  ServerPort" << endl;
  11. }
  12.  
  13. int main(int argc, char* argv[])
  14. {
  15.   if (argc != 2)
  16.   {
  17.     // 错误的启动方式，提示错误信息
  18.     Usage(argv[0]);
  19.     return USAGE_ERR;
  20.   }
  21.  
  22.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  23.   uint16_t port = stoi(argv[1]);//将字符串转换成端口号
  24.  
  25.     unique_ptr<UdpServer> usvr(new UdpServer(port));//使用智能指针创建了一个UdeServer对象
  26.  
  27.     // 初始化服务器
  28.     usvr->InitServer();
  29.  
  30.     // 启动服务器
  31.     usvr->StartServer();
  32.  
  33.     return 0;
  34. }

client.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <cerrno>
  7. #include <cstdlib>
  8. #include <strings.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <netinet/in.h>
  12. #include <arpa/inet.h>
  13.  
  14. namespace nt_client
  15. {
  16.     // 退出码
  17.     enum
  18.     {
  19.         SOCKET_ERR = 1,
  20.         BIND_ERR,
  21.         USAGE_ERR
  22.     };
  23.  
  24.   class UdpClient
  25.     {
  26.     public:
  27.         // 构造
  28.         UdpClient(const std::string& ip, uint16_t port)
  29.             :server_ip_(ip), server_port_(port)
  30.         {} 
  31.  
  32.         // 析构
  33.         ~UdpClient() 
  34.         {} 
  35.  
  36.         // 初始化客户端
  37.         void InitClient() 
  38.         {
  39.             // 1.创建套接字
  40.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  41.  
  42.             if(sock_ == -1)
  43.             {
  44.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  45.                 exit(SOCKET_ERR);
  46.             }
  47.  
  48.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  49.  
  50.             // 2.构建服务器的 sockaddr_in 结构体信息
  51.             bzero(&svr_, sizeof(svr_));
  52.             svr_.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  53.             svr_.sin_addr.s_addr = inet_addr(server_ip_.c_str()); // 绑定服务器IP地址
  54.             svr_.sin_port = htons(server_port_); // 绑定服务器端口号
  55.         }
  56.  
  57.         // 启动客户端
  58. void StartClient() 
  59. {
  60.     char buff[1024];
  61.  
  62.     while(true)
  63.     {
  64.         // 1.发送消息
  65.         std::string msg;
  66.         std::cout << "Input Message# ";
  67.         std::getline(std::cin, msg);
  68.  
  69.         ssize_t n = sendto(sock_, msg.c_str(), msg.size(), 0, (const struct sockaddr*)&svr_, sizeof(svr_));
  70.  
  71.         if(n == -1)
  72.         {
  73.             std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  74.             continue; // 重新输入消息并发送
  75.         }
  76.  
  77.         // 2.接收消息
  78.         socklen_t len = sizeof(svr_); // 创建一个变量，因为接下来的参数需要传左值
  79.         n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&svr_, &len);
  80.  
  81.         if(n > 0)
  82.             buff[n] = '\0';
  83.         else
  84.             continue;
  85.  
  86.         // 可以再次获取IP地址与端口号
  87.         std::string ip = inet_ntoa(svr_.sin_addr);
  88.         uint16_t port = ntohs(svr_.sin_port);
  89.  
  90.         printf("Client get message from [%s:%d]# %s\n",ip.c_str(), port, buff);
  91.     }
  92. }
  93.  
  94.  
  95.     private:
  96.         std::string server_ip_; // 服务器IP地址
  97.         uint16_t server_port_;  // 服务器端口号
  98.         int sock_;
  99.         struct sockaddr_in svr_; // 服务器的sockadder_in结构体信息
  100.     };
  101. }

client.cc

  1. #include <iostream>
  2. #include <memory>
  3. #include "client.hpp"
  4.  
  5. using namespace std;
  6. using namespace nt_client;
  7.  
  8. void Usage(const char* program)
  9. {
  10.   cout << "Usage:" << endl;
  11.   cout << "\t" << program << " ServerIP ServerPort" << endl;
  12. }
  13.  
  14. int main(int argc, char* argv[])
  15. {
  16.   if (argc != 3)
  17.   {
  18.     // 错误的启动方式，提示错误信息
  19.     Usage(argv[0]);
  20.     return USAGE_ERR;
  21.   }
  22.  
  23.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  24.   std::string ip = argv[1];
  25.   uint16_t port = stoi(argv[2]);
  26.  
  27.   unique_ptr<UdpClient> usvr(new UdpClient(ip, port));
  28.  
  29.   // 初始化客户端
  30.   usvr->InitClient();
  31.  
  32.   // 启动客户端
  33.   usvr->StartClient();
  34.  
  35.   return 0;
  36. }

makefile

  1. .PHONY:all
  2. all:server client
  3.  
  4. server:server.cc
  5. 	g++ -o $@ $^ -std=c++11
  6.  
  7. 	
  8. client:client.cc
  9. 	g++ -o $@ $^ -std=c++11
  10.  
  11. .PHONY:clean
  12. clean:
  13. 	rm -rf server client

怎么样？收获很多吧！！ 

4.代码解耦

        我们发现，这个网络环境搭建和我们消息处理的代码（即使我们上面没有提供消息处理业务）的耦合度太高了，我们能不能将这个网络环境搭建和我们这个聊天服务的代码进行解耦呢？

        基于模块化处理的思想，将服务器中处理消息的函数与启动服务的函数解耦，由程序员传入指定的回调函数，服务器在启动时，只需要传入对应的业务处理函数（回调函数）即可

        这个时候就得使用C++11的function包装器了

4.1.C++function包装器

我来带大家现学现用，function定义在functional头文件中

        function包装器是一种函数包装器，也叫做适配器。它可以对可调用对象进行包装，C++中的function本质就是一个类模板。

我们看些例子

  1. int f(int a, int b)
  2. {
  3. 	return a + b;
  4. }
  5.  
  6. struct Functor
  7. {
  8. public:
  9. 	int operator()(int a, int b)
  10. 	{
  11. 		return a + b;
  12. 	}
  13. };
  14.  
  15. class Plus
  16. {
  17. public:
  18. 	static int plusi(int a, int b)
  19. 	{
  20. 		return a + b;
  21. 	}
  22.  
  23. 	double plusd(double a, double b)
  24. 	{
  25. 		return a + b;
  26. 	}
  27. };
  28.  
  29. int main()
  30. {
  31. 	// 1、包装函数指针（函数名）
  32. 	function<int(int, int)> func1 = f;
  33. 	cout << func1(1, 2) << endl;
  34.  
  35. 	// 2、包装仿函数（函数对象）
  36. 	function<int(int, int)> func2 = Functor();
  37. 	cout << func2(1, 2) << endl;
  38.  
  39. 	// 3、包装lambda表达式
  40. 	function<int(int, int)> func3 = [](int a, int b) {return a + b; };
  41. 	cout << func3(1, 2) << endl;
  42.  
  43. 	// 4、包装静态成员函数
  44. 	function<int(int, int)> func4 = &Plus::plusi; // &可省略
  45. 	cout << func4(1, 2) << endl;
  46.  
  47. 	// 5、包装类的非静态成员函数
  48. 	function<double(Plus, double, double)> func5 = &Plus::plusd; // &不可省略
  49. 	cout << func5(Plus(), 1.1, 2.2) << endl;
  50.  
  51. 	return 0;
  52. }
  53.  
  54.
  1. 包装时指明返回值类型和各形参类型，然后可调用对象赋值给function包装器即可，包装后function对象就可以像普通函数一样使用了。
  2. 取静态成员函数的地址可以不用取地址运算符 & ，但取非静态成员函数地址使用 & 。
  3. 包装费静态的成员函数需要注意，非静态成员函数的第一个参数是隐藏this指针，因此在包装时需要指明第一个形参的类型为类的类型。

好了，相信大家会用了 ，如果想详细了解的话可以去：http://t.csdnimg.cn/SRoDV

4.2.分离网络通信和消息处理业务

server.hpp 服务器头文件

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <functional>//注意这个
  6. #include <cstring>
  7. #include <cerrno>
  8. #include <cstdlib>
  9. #include <strings.h>
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <netinet/in.h>
  13. #include <arpa/inet.h>
  14.  
  15. namespace nt_server
  16. {
  17.  
  18.         // 退出码
  19.     enum
  20.     {
  21.         SOCKET_ERR = 1,
  22.         BIND_ERR,
  23.         USAGE_ERR
  24.     };
  25.  
  26.  
  27.     // 端口号默认值
  28.     const uint16_t default_port = 8888;
  29.  
  30.     using func_t = std::function<std::string(std::string)>; 
  31. // 可以简单的理解为func_t是一个参数为string，返回值同样为string的函数的类型
  32.  
  33.     class UdpServer
  34.     {
  35.     public:
  36.  
  37.         // 构造
  38.         UdpServer(const func_t& func, uint16_t port = default_port)//注意这里的func_t
  39.             :port_(port)
  40.             ,serverHandle_(func)
  41. //注意serverHandle_的类型已经是一个func_t,就是一个一个参数为string，返回值同样为string的函数的类型
  42.         {}
  43.  
  44.         // 析构
  45.         ~UdpServer()
  46.         {} 
  47.  
  48.         // 初始化服务器
  49.         void InitServer()
  50.         {
  51.             // 1.创建套接字
  52.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  53.  
  54.             if(sock_ == -1)
  55.             {
  56.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  57.                 exit(SOCKET_ERR);
  58.             }
  59.  
  60.             // 创建成功
  61.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  62.  
  63.             // 2.绑定IP地址和端口号
  64.             struct sockaddr_in local;
  65.             bzero(&local, sizeof(local)); // 置0
  66.  
  67.             // 填充字段
  68.             local.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  69.             local.sin_port = htons(port_); // 主机序列转为网络序列
  70.             // local.sin_addr.s_addr = inet_addr(ip_.c_str()); // 点分十进制转为短整数，再将主机序列转为网络序列
  71.             local.sin_addr.s_addr = INADDR_ANY; // 绑定任何可用IP地址
  72.  
  73.             // 绑定IP地址和端口号
  74.             if(bind(sock_, (const sockaddr*)&local, sizeof(local)))
  75.             {
  76.                 std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
  77.                 exit(BIND_ERR);
  78.             }
  79.  
  80.             // 绑定成功
  81.             std::cout << "Bind IP&&Port Success" << std::endl;
  82.         }
  83.  
  84.         // 启动服务器
  85.         void StartServer()
  86.         {
  87.             // 服务器是不断运行的，所以需要使用一个 while(true) 死循环
  88.             char buff[1024]; // 缓冲区
  89.             while(true)
  90.             {
  91.                 // 1. 接收消息
  92.                 struct sockaddr_in peer; // 客户端结构体
  93.                 socklen_t len = sizeof(peer); // 客户端结构体大小
  94.  
  95.                 // 传入 sizeof(buff) - 1 表示当前传输的是字符串，预留一个位置存储 '\0'
  96.                 // 传入 0 表示当前是阻塞式读取
  97.                 ssize_t n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&peer, &len);
  98.  
  99.                 if(n > 0)
  100.                     buff[n] = '\0';
  101.                 else
  102.                     continue; // 继续读取
  103.  
  104.                 // 2.处理数据
  105.                 std::string clientIp = inet_ntoa(peer.sin_addr); // 获取IP地址
  106.                 uint16_t clientPort = ntohs(peer.sin_port); // 获取端口号
  107.                 printf("Server get message from [%s:%d]$ %s\n",clientIp.c_str(), clientPort, buff);
  108.  
  109.                 // 获取业务处理后的结果
  110.                     
  111.                 std::string respond = serverHandle_(buff);
  112.         //特别注意这里，业务处理的代码已经放到了这个serverHandle_这个函数了，
  113.         //而这个serverHandle_的函数是不在这个类里面，是在类外面了，
  114.         //是在创建这个class UdpServer时就指定好了的
  115.  
  116.  
  117.                 // 3.回响给客户端
  118.                 n = sendto(sock_, respond.c_str(), respond.size(), 0, (const struct sockaddr*)&peer, sizeof(peer));
  119.  
  120.  
  121.                 if(n == -1)
  122.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  123.             }
  124.         }
  125.  
  126.     private:
  127.         int sock_; // 套接字
  128.         uint16_t port_; // 端口号
  129.         func_t serverHandle_; // 业务处理函数（回调函数）
  130.     };
  131. }

我们得特别注意下面这几处地方

  1. //...
  2. #include <functional>//注意这个
  3.  
  4. //...
  5. namespace nt_server
  6. {
  7.     //..
  8.  
  9.     using func_t = std::function<std::string(std::string)>; 
  10. // 可以简单的理解为func_t是一个参数为string，返回值同样为string的函数的类型
  11.  
  12.     class UdpServer
  13.     {
  14.     public:
  15.  
  16.         // 构造
  17.         UdpServer(const func_t& func, uint16_t port = default_port)//注意这里的func_t
  18.             :port_(port)
  19.             ,serverHandle_(func)
  20. //注意serverHandle_的类型已经是一个func_t,就是一个一个参数为string，返回值同样为string的函数的类型
  21.         {}
  22.  
  23.         // 析构
  24.         ~UdpServer()
  25.         {} 
  26.  
  27.         // 初始化服务器
  28.         void InitServer()
  29.         {
  30.             //...
  31.         }
  32.  
  33.         // 启动服务器
  34.         void StartServer()
  35.         {
  36.            //...
  37.                 // 获取业务处理后的结果
  38.                 std::string respond = serverHandle_(buff);
  39.         //特别注意这里，业务处理的代码已经放到了这个serverHandle_这个函数了，
  40.         //而这个serverHandle_的函数是不在这个类里面，是在类外面了，
  41.         //是在创建这个class UdpServer时就指定好了的
  42.  
  43.             }
  44.         }
  45.     private:
  46.         //...
  47.         func_t serverHandle_; // 业务处理函数（回调函数）
  48.     };
  49. }

我们把消息处理业务分离了出来。 

 server.cc

  1. #include <memory> // 智能指针相关头文件
  2. #include "server.hpp"
  3.  
  4. using namespace std;
  5. using namespace nt_server;
  6.  
  7. void Usage(const char* program)
  8. {
  9.   cout << "Usage:" << endl;
  10.   cout << "\t" << program << "  ServerPort" << endl;
  11. }
  12.  
  13. //消息处理业务
  14. // 大写转小写（英文字母）
  15. std::string UpToLow(const std::string& resquest)
  16. {
  17.     std::string ret(resquest);
  18.  
  19.     for(auto &rc : ret)
  20.     {
  21.         if(isupper(rc))
  22.             rc += 32;
  23.     }
  24.  
  25.     return ret;
  26. }
  27.  
  28. int main(int argc, char* argv[])
  29. {
  30.   if (argc != 2)
  31.   {
  32.     // 错误的启动方式，提示错误信息
  33.     Usage(argv[0]);
  34.     return USAGE_ERR;
  35.   }
  36.  
  37.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  38.   uint16_t port = stoi(argv[1]);//将字符串转换成端口号
  39.  
  40.     unique_ptr<UdpServer> usvr(new UdpServer(UpToLow,port));
  41.  
  42.     // 初始化服务器
  43.     usvr->InitServer();
  44.  
  45.     // 启动服务器
  46.     usvr->StartServer();
  47.  
  48.     return 0;
  49. }

 我们将消息处理业务设定为将消息从大写转小写。

我们运行一下看看

解耦很成功！！！ 

好，这个只是进行了字符串的转换处理

5.远程bash

服务端提供的服务，可以千变万化，例如我们可以提供命令服务，实现一个远程的bash

5.1.popen和pclose

bash 指令是如何执行的？

  1. 接收指令（字符串）
  2. 对指令进行分割，构成有效信息
  3. 创建子进程，执行进程替换
  4. 子进程运行结束后，父进程回收僵尸进程
  5. 输入特殊指令时的处理

这样子做太复杂了

其实Linux系统专门有这样一个系统调用接口——popen 函数

功能：

        popen()函数通过先创建一个管道，然后调用 fork 产生一个子进程，让子进程执行shell中的command命令。popen()建立的管道会连到子进程的标准输出设备(stdin)或标准输入设备(stdout)，然后返回一个文件指针。随后进程便可利用此文件指针来读取子进程的输出设备或是写入到子进程的标准输入设备中。

        这个函数做了这些事：创建管道、创建子进程、执行指令、将执行结果以 FILE* 的形式返回

参数：

1.   command:要执行的命令。

2.   type:

  • 如果 type 为r，则将子进程的标准输出（stdout）连接到返回的的文件指针。
  • 如果 type 为 w，则将子进程的标准输入（stdin）连接到返回的的文件指针。

返回值：

  • 调用成功就返回一个文件指针，如果此函数内部在调用 fork() 或 pipe() 失败，或者不能分配内存将返回NULL。

此外有打开就有关闭——pclose函数

  • 功能：关闭popen()函数打开的文件，

  • 参数：文件指针

  • 返回值：调用成功就返回0，否则返回非0。

我们可以看一个例子

在下面的例子中，我们使用 popen() 函数打开一个进程并执行 ls -l 命令，然后将其输出作为文本流读取并打印到屏幕上。最后，我们使用 pclose() 函数关闭进程和文件指针。

  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5.     FILE* fp = popen("ls -l", "r");//将执行结果以 FILE* 的形式返回
  6.     if (!fp)
  7.     {
  8.         perror("popen fail: ");
  9.     }
  10.     
  11.     char buf[1024];
  12.     while (fgets(buf, sizeof(buf), fp) != NULL)//将执行结果存到了buf里面
  13.     {
  14.         printf("%s", buf);
  15.     }
  16.     
  17.     pclose(fp);
  18.     return 0;
  19. }

5.2.实现远程bash 

ExecCommand() 业务处理函数 — 位于 server.cc 服务器源文件

  1. // 远程 bash
  2. std::string ExecCommand(const std::string& request)
  3. {
  4.     // 1.安全检查
  5.     // ...
  6.  
  7.     // 2.获取执行结果
  8.     FILE* fp = popen(request.c_str(), "r");//将执行结果以 FILE* 的形式返回
  9.     if(fp == NULL)
  10.         return "Can't execute command!";
  11.  
  12.     // 3.将结果读取至字符串中
  13.     std::string ret;
  14.     char buffline[1024]; // 行缓冲区
  15.     while (fgets(buffline, sizeof(buffline), fp) != NULL)//将执行结果存到buffline里面
  16.     {
  17.         // 将每一行结果，添加至 ret 中
  18.         ret += buffline;
  19.     }
  20.  
  21.     // 4.关闭文件流
  22.     fclose(fp);
  23.  
  24.     // 5.返回最终执行结果
  25.     return ret;
  26. }

此时需要考虑一个问题：如果别人输入的是敏感指令（比如 rm -rf *）怎么办？

  • 敏感操作包含这些：kill 发送信号终止进程、mv 移动文件、rm 删除文件、while :; do 死循环、shutdown 关机等等

答案当然是直接拦截，不让别人执行敏感操作，毕竟 Linux 默认可没有回收站，所以我们还需要考虑安全检查

在执行用户传入的指令前，先对指令中的子串进行扫描，如果发现敏感操作，就直接返回，不再执行后续操作

  1. // 安全检查
  2. bool checkSafe(const std::string& comm)
  3. {
  4.     // 构建安全检查组
  5.     std::vector<std::string> unsafeComms{"kill", "mv", "rm", "while :; do", "shutdown"};
  6.  
  7.     // 查找 comm 中是否包含安全检查组中的字段
  8.     for(auto &str : unsafeComms)
  9.     {
  10.         // 如果找到了，就说明存在不安全的操作
  11.         if(comm.find(str) != std::string::npos)
  12.             return false;
  13.     }
  14.  
  15.     return true;
  16. }

        将 checkSafe 安全检查函数整合进 ExecCommand 业务处理函数中，同时在构建 UdpServer 对象时，传入该业务处理函数对象，编译并运行程序

server.cc

  1. #include <string>
  2. #include <vector>
  3. #include <memory> // 智能指针相关头文件
  4. #include <cstdio>
  5. #include "server.hpp"
  6.  
  7. using namespace std;
  8. using namespace nt_server;
  9.  
  10. // 安全检查
  11. bool checkSafe(const std::string& comm)
  12. {
  13.     // 构建安全检查组
  14.     std::vector<std::string> unsafeComms{"kill", "mv", "rm", "while :; do", "shutdown"};
  15.  
  16.     // 查找 comm 中是否包含安全检查组中的字段
  17.     for(auto &str : unsafeComms)
  18.     {
  19.         // 如果找到了，就说明存在不安全的操作
  20.         if(comm.find(str) != std::string::npos)
  21.             return false;
  22.     }
  23.  
  24.     return true;
  25. }
  26.  
  27. // 远程 bash
  28. std::string ExecCommand(const std::string& request)
  29. {
  30.     // 1.安全检查
  31.     if(!checkSafe(request))
  32.         return "Non-safety instructions, refusal to execute!";
  33.  
  34.     // 2.获取执行结果
  35.     FILE* fp = popen(request.c_str(), "r");
  36.     if(fp == NULL)
  37.         return "Can't execute command!";
  38.  
  39.     // 3.将结果读取至字符串中
  40.     std::string ret;
  41.     char buffline[1024]; // 行缓冲区
  42.     while (fgets(buffline, sizeof(buffline), fp) != NULL)
  43.     {
  44.         // 将每一行结果，添加至 ret 中
  45.         ret += buffline;
  46.     }
  47.  
  48.     // 4.关闭文件流
  49.     fclose(fp);
  50.  
  51.     // 5.返回最终执行结果
  52.     return ret;
  53. }
  54.  
  55. void Usage(const char* program)
  56. {
  57.   cout << "Usage:" << endl;
  58.   cout << "\t" << program << "  ServerPort" << endl;
  59. }
  60.  
  61. int main(int argc, char* argv[])
  62. {
  63.   if (argc != 2)
  64.   {
  65.     // 错误的启动方式，提示错误信息
  66.     Usage(argv[0]);
  67.     return USAGE_ERR;
  68.   }
  69.  
  70.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  71.   uint16_t port = stoi(argv[1]);//将字符串转换成端口号
  72.  
  73.     unique_ptr<UdpServer> usvr(new UdpServer(ExecCommand,port));
  74.  
  75.     // 初始化服务器
  76.     usvr->InitServer();
  77.  
  78.     // 启动服务器
  79.     usvr->StartServer();
  80.  
  81.     return 0;
  82. }
  83.

可以看到，输入安全指令时，可以正常获取结果，如果输入的是非安全指令，会直接拒绝执行

诸如 cd 这种指令称为 内建命令，是需要特殊处理的，所以这里才会执行失败

这样子就完成一个简易的远程bash啦！！！！！ 

        这里其实就是想告诉大家，我们在Xshell和云服务器的工作原理是：我们的Xshell就相当于我们的client端，我们的云服务器相当于我们的server端，我们的云服务器开放一个端口让我们去访问，我们在Xshell输入指令，但是指令的运行是在很远的另外一台服务器，服务器通过网络来将结果打印到我们的Xshell里面而已

我们可以去看看这个开放的端口

就是上面那个323 

 5.3.windows和Linux联动

        我们说过每款操作系统是不一样的，但是每款操作系统的网络协议栈必须是一样的，所以Linux的套接字和Windows的套接字是一样的！！！也就是说，我们可以在windows环境下面基本可以运行这代码，只不过windows里的数据类型和Linux有点区别

 接下来我要简单的修改一下代码，让我们的Linux端充当一个服务器，让windows下充当一个客户端

我们打开vs2022

由于Linux端的代码和windows端的代码有点不一样，我们需要稍微做一点修改

client.hpp

  1. #pragma once
  2.  
  3. #pragma warning (disable:4996)
  4.  
  5. #include <iostream>
  6. #include <string>
  7. #include <cstring>
  8. #include <cerrno>
  9. #include <cstdlib>
  10. #include <string.h>
  11. #include <sys/types.h>
  12. #include<winsock2.h>
  13. #pragma comment(lib,"ws2_32.lib")
  14.  
  15. namespace nt_client
  16. {
  17.     // 退出码
  18.     enum
  19.     {
  20.         SOCKET_ERR = 1,
  21.         BIND_ERR,
  22.         USAGE_ERR
  23.     };
  24.  
  25.     
  26.  
  27.     class UdpClient
  28.     {
  29.     public:
  30.         // 构造
  31.         UdpClient(const std::string& ip, uint16_t port)
  32.             :server_ip_(ip), server_port_(port)
  33.         {}
  34.  
  35.         // 析构
  36.         ~UdpClient()
  37.         {}
  38.  
  39.         // 初始化客户端
  40.         void InitClient()
  41.         {
  42.             // 1.创建套接字
  43.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  44.  
  45.             if (sock_ == -1)
  46.             {
  47.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  48.                 exit(SOCKET_ERR);
  49.             }
  50.  
  51.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  52.  
  53.             // 2.构建服务器的 sockaddr_in 结构体信息
  54.             memset(&svr_,0, sizeof(svr_));
  55.             svr_.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  56.             svr_.sin_addr.s_addr = inet_addr(server_ip_.c_str()); // 绑定服务器IP地址
  57.             svr_.sin_port = htons(server_port_); // 绑定服务器端口号
  58.         }
  59.  
  60.         // 启动客户端
  61.         void StartClient()
  62.         {
  63.             char buff[1024];
  64.  
  65.             while (true)
  66.             {
  67.                 // 1.发送消息
  68.                 std::string msg;
  69.                 std::cout << "Input Message# ";
  70.                 std::getline(std::cin, msg);
  71.  
  72.                int n = sendto(sock_, msg.c_str(), msg.size(), 0, (const struct sockaddr*)&svr_, sizeof(svr_));
  73.  
  74.                 if (n == -1)
  75.                 {
  76.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  77.                     continue; // 重新输入消息并发送
  78.                 }
  79.  
  80.                 // 2.接收消息
  81.                 int len = sizeof(svr_); // 创建一个变量，因为接下来的参数需要传左值
  82.                 n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&svr_, &len);
  83.  
  84.                 if (n > 0)
  85.                     buff[n] = '\0';
  86.                 else
  87.                     continue;
  88.  
  89.                 // 可以再次获取IP地址与端口号
  90.                 std::string ip = inet_ntoa(svr_.sin_addr);
  91.                 uint16_t port = ntohs(svr_.sin_port);
  92.  
  93.                 printf("Client get message from [%s:%d]# %s\n", ip.c_str(), port, buff);
  94.             }
  95.         }
  96.  
  97.  
  98.     private:
  99.         std::string server_ip_; // 服务器IP地址
  100.         uint16_t server_port_;  // 服务器端口号
  101.         SOCKET sock_;
  102.         struct sockaddr_in svr_; // 服务器的sockadder_in结构体信息
  103.     };
  104. }

 client.cpp

  1. #define _CRT_SECURE_NO_WARNINGS
  2.  
  3. /*客户端*/
  4. #include<memory>
  5. #include"udp_client.h"
  6.  
  7.  
  8. using namespace std;
  9. using namespace nt_client;
  10.  
  11. #define SERVER_IP "127.0.0.1" // 服务器IP地址:指要连接的服务器的地址
  12. #define SERVER_PORT 8877 // 服务器端口号
  13.  
  14.  
  15. int main() {
  16.  
  17.     // 初始化Winsock库
  18.     WSADATA wsaData;
  19.     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
  20.         printf("WSAStartup failed!\n");
  21.         return -1;
  22.     }
  23.  
  24.     unique_ptr<UdpClient> usvr(new UdpClient(SERVER_IP, SERVER_PORT));
  25.  
  26.     // 初始化客户端
  27.     usvr->InitClient();
  28.  
  29.     // 启动客户端
  30.     usvr->StartClient();
  31.  
  32.   
  33.  
  34.     // 清理Winsock库
  35.     WSACleanup();
  36.  
  37.     return 0;
  38. }

我们打开浏览器

完美通信了

这里我只是想说明我们的windows和Linux的网络协议栈是一样的

6.多人聊天室

6.1.单线程版本

        这是基于 UDP 协议实现的最后一个网络程序，主要功能是 构建一个多人聊天室，当某个用户发送消息时，其他用户可以立即收到，形成一个群聊

在这个程序中，服务器扮演了一个接收消息和分发消息的中间角色，将消息发送给已知的用户主机

 首先我们需要明确一些问题，我们服务端怎么知道客户端的位置？

  • 其实服务端在接受客户端的信息的时候就已经有它的信息了

但是我们的用户不只有1个，我们必须得把它们的信息管理起来，我们必须弄一张用户列表来记录我们的在线用户信息，这里我们使用unordered_map，不知道的可以去http://t.csdnimg.cn/SJH7p

server.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <functional>//注意这个
  6. #include <cstring>
  7. #include <cerrno>
  8. #include <cstdlib>
  9. #include <strings.h>
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <netinet/in.h>
  13. #include <arpa/inet.h>
  14. #include<unordered_map>
  15.  
  16. namespace nt_server
  17. {
  18.  
  19.         // 退出码
  20.     enum
  21.     {
  22.         SOCKET_ERR = 1,
  23.         BIND_ERR,
  24.         USAGE_ERR
  25.     };
  26.  
  27.  
  28.     // 端口号默认值
  29.     const uint16_t default_port = 8888;
  30.  
  31.     using func_t = std::function<std::string(std::string)>; 
  32. // 可以简单的理解为func_t是一个参数为string，返回值同样为string的函数的类型
  33.  
  34.     class UdpServer
  35.     {
  36.     public:
  37.  
  38.         // 构造
  39.         UdpServer(const func_t& func, uint16_t port = default_port)//注意这里的func_t
  40.             :port_(port)
  41.             ,serverHandle_(func)
  42. //注意serverHandle_的类型已经是一个func_t,就是一个一个参数为string，返回值同样为string的函数的类型
  43.         {}
  44.  
  45.         // 析构
  46.         ~UdpServer()
  47.         {} 
  48.  
  49.         // 初始化服务器
  50.         void InitServer()
  51.         {
  52.             // 1.创建套接字
  53.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  54.  
  55.             if(sock_ == -1)
  56.             {
  57.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  58.                 exit(SOCKET_ERR);
  59.             }
  60.  
  61.             // 创建成功
  62.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  63.  
  64.             // 2.绑定IP地址和端口号
  65.             struct sockaddr_in local;
  66.             bzero(&local, sizeof(local)); // 置0
  67.  
  68.             // 填充字段
  69.             local.sin_family = AF_INET; // 设置为网络通信（PF_INET 也行）
  70.             local.sin_port = htons(port_); // 主机序列转为网络序列
  71.             // local.sin_addr.s_addr = inet_addr(ip_.c_str()); // 点分十进制转为短整数，再将主机序列转为网络序列
  72.             local.sin_addr.s_addr = INADDR_ANY; // 绑定任何可用IP地址
  73.  
  74.             // 绑定IP地址和端口号
  75.             if(bind(sock_, (const sockaddr*)&local, sizeof(local)))
  76.             {
  77.                 std::cout << "Bind IP&&Port Fail: " << strerror(errno) << std::endl;
  78.                 exit(BIND_ERR);
  79.             }
  80.  
  81.             // 绑定成功
  82.             std::cout << "Bind IP&&Port Success" << std::endl;
  83.         }
  84.  
  85.         //检测是不是新用户
  86.         void CheckUser(const struct sockaddr_in & client,const std::string clientIp_,uint16_t clientPort_)
  87.         {
  88.             auto iter= online_user_.find(clientIp_);
  89.             if(iter==online_user_.end())
  90.             {
  91.                 online_user_.insert({clientIp_,client});
  92.                 std::cout<<"["<<clientIp_<<":"<<clientPort_<<"] add to oniline user."<<std::endl;
  93.             }
  94.         }
  95.  
  96.         //广播给所有人
  97.         void Broadcast(const std::string& respond,const std::string clientIp_,uint16_t clientPort_)
  98.         {
  99.             for(const auto&usr :online_user_)
  100.             {
  101.                 std::string message="[";
  102.                 message+=clientIp_;
  103.                 message+=" : ";
  104.                 message+=std::to_string(clientPort_);
  105.                 message+="]#";
  106.                 message+=respond;
  107.                 
  108.                 int z = sendto(sock_, respond.c_str(), respond.size(), 0, (const sockaddr*)&usr.second, sizeof(usr.second));
  109.                 if(z == -1)
  110.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  111.             }
  112.  
  113.         }
  114.  
  115.         // 启动服务器
  116.         void StartServer()
  117.         {
  118.             // 服务器是不断运行的，所以需要使用一个 while(true) 死循环
  119.             char buff[1024]; // 缓冲区
  120.             while(true)
  121.             {
  122.                 // 1. 接收消息
  123.                 struct sockaddr_in client; // 客户端结构体
  124.                 socklen_t len = sizeof(client); // 客户端结构体大小
  125.  
  126.                 // 传入 sizeof(buff) - 1 表示当前传输的是字符串，预留一个位置存储 '\0'
  127.                 // 传入 0 表示当前是阻塞式读取
  128.                 ssize_t n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&client, &len);
  129.  
  130.                 if(n > 0)
  131.                     buff[n] = '\0';
  132.                 else
  133.                     continue; // 继续读取
  134.  
  135.                 // 2.处理数据
  136.                  std::string clientIp = inet_ntoa(client.sin_addr); // 获取用户的IP地址
  137.             uint16_t clientPort = ntohs(client.sin_port);      // 获取端口号
  138.  
  139.                 //2.1.判断是不是新用户，如果是就加入，如果不是就什么也不做
  140.                 CheckUser(client,clientIp,clientPort); 
  141.                 
  142.  
  143.                 //2.2 对数据进行业务处理，并获取业务处理后的结果
  144.                 std::string respond = serverHandle_(buff);
  145.                 //特别注意这里，业务处理的代码已经放到了这个serverHandle_这个函数了，
  146.  
  147.                 // 3.回响给所有在线客户端
  148.                 Broadcast(respond,clientIp,clientPort);  
  149.             }
  150.         }
  151.  
  152.     private:
  153.         int sock_; // 套接字
  154.         uint16_t port_; // 端口号
  155.         func_t serverHandle_; // 业务处理函数（回调函数）
  156.         std::unordered_map<std::string,struct sockaddr_in> online_user_;//在线用户列表
  157.     };
  158. }

其他都没有变化

server.cc 

  1. #include <string>
  2. #include <vector>
  3. #include <memory> // 智能指针相关头文件
  4. #include <cstdio>
  5. #include "server.hpp"
  6.  
  7. using namespace std;
  8. using namespace nt_server;
  9.  
  10. //业务处理函数
  11. std::string ExecCommand(const std::string& request)
  12. {
  13.     
  14.     return request;
  15. }
  16.  
  17. void Usage(const char* program)
  18. {
  19.   cout << "Usage:" << endl;
  20.   cout << "\t" << program << "  ServerPort" << endl;
  21. }
  22.  
  23. int main(int argc, char* argv[])
  24. {
  25.   if (argc != 2)
  26.   {
  27.     // 错误的启动方式，提示错误信息
  28.     Usage(argv[0]);
  29.     return USAGE_ERR;
  30.   }
  31.  
  32.   //命令行参数都是字符串，我们需要将其转换成对应的类型
  33.   uint16_t port = stoi(argv[1]);//将字符串转换成端口号
  34.  
  35.     unique_ptr<UdpServer> usvr(new UdpServer(ExecCommand,port));
  36.  
  37.     // 初始化服务器
  38.     usvr->InitServer();
  39.  
  40.     // 启动服务器
  41.     usvr->StartServer();
  42.  
  43.     return 0;
  44. }

 我们运行一下

到这里我们还是感觉挺正常的，我们接着往下看 

我们再运行一下我们在windows上面写的client程序

 

有没有发现，我们第二个客户发消息过去，第二个客户只收到了它自己的消息，第一个客户也没有反应

但是我们继续让第一个客户发消息，我们却惊奇的发现这次收到的消息居然是第二个用户第一次发的消息！！！！

 这是为什么呢？

这是因为我们仔细观察一下我们的client端代码，

  1.         // 启动客户端
  2. void StartClient() 
  3. {
  4.     char buff[1024];
  5.     while(true)
  6.     {
  7.         // 1.发送消息
  8.         std::string msg;
  9.         std::cout << "Input Message# ";
  10.         std::getline(std::cin, msg);
  11.        ......
  12.         n = recvfrom(sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&svr_, &len);
  13.      .....   
  14.     }
  15. }

每获取完一次消息，就立马要去输入，如果我们不输入，那么这个getline函数输入会阻塞这个进程的运行啊。 

那么就有2种解决方法，客户端的代码

  1. 用其他不阻塞的函数替换getline，比如getch()和kbhit()函数
  2. 将客户端的代码从单线程版改成多线程版本，一个线程输入，一个线程获取信息

注意： 我们创建的是UDP套接字，它是全双工的，也就是说它是可以同时读和写的。

那么话不多说我们就用多线程来修改一下

6.2.多线程版本

6.1.1.C++11类内使用多线程

        有很多时候，我们希望可以在C++类里面对那些比较耗时的函数使用多线程技术，但是熟悉C++对象语法的人应该知道，C++类的成员函数的函数指针不能直接做为参数传到pthread_create,主要因为是C++成员函数指针带有类命名空间，同时成员函数末尾是会被C++编译器加上可以接收对象地址的this指针参数。

因此需要将成员函数做一定的转化，将其转化为不被编译器加上this指针，而由我们自己来为该函数维护"this"指针即可。

        只需将类内的线程函数变化为static函数，但是static函数就不能直接访问到我们类内的私有数据，不要忘了这个线程函数的void*参数，我们可以把this指针作为参数传给它，然后就能通过这个this指针来访问到我们的类内的私有数据

client.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <cerrno>
  7. #include <cstdlib>
  8. #include <strings.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <netinet/in.h>
  12. #include <pthread.h>
  13. #include <unistd.h>
  14. #include <arpa/inet.h>
  15. #include<functional>
  16.  
  17. namespace nt_client
  18. {
  19.     // 退出码
  20.     enum
  21.     {
  22.         SOCKET_ERR = 1,
  23.         BIND_ERR,
  24.         USAGE_ERR
  25.     };
  26.  
  27.     class UdpClient
  28.     {
  29.     public:
  30.      // 构造
  31.         UdpClient(const std::string &ip, uint16_t port)
  32.             : server_ip_(ip), server_port_(port)
  33.         {
  34.         }
  35.  
  36.         // 析构
  37.         ~UdpClient()
  38.         {
  39.         }
  40.  
  41.         
  42.         static void *send_message(void *argc)//传进来的是this指针
  43.         {
  44.             UdpClient*_this =(UdpClient*)argc;//强制转换为类指针
  45.  
  46.             char buff[1024];
  47.             while (1)
  48.             {
  49.                 // 1.发送消息
  50.                 std::string msg;
  51.                 std::cout << "Input Message# ";
  52.                 std::getline(std::cin, msg);
  53.  
  54.                 ssize_t n = sendto(_this->sock_, msg.c_str(), msg.size(), 0, (const struct sockaddr *)&_this->svr_, sizeof(_this->svr_));
  55.  
  56.                 if (n == -1)
  57.                 {
  58.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  59.                     continue; // 重新输入消息并发送
  60.                 }
  61.             }
  62.                 return (void*)0;
  63.         }
  64.  
  65.         static void *recv_message(void *argc)//传进来的是this指针
  66.         {
  67.             UdpClient*_this =(UdpClient*)argc;
  68.  
  69.             char buff[1024];
  70.             while (1)
  71.             {
  72.                 // 2.接收消息
  73.                 socklen_t len = sizeof(_this->svr_); // 创建一个变量，因为接下来的参数需要传左值
  74.                 int n = recvfrom(_this->sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr *)&_this->svr_, &len);
  75.  
  76.                 if (n > 0)
  77.                     buff[n] = '\0';
  78.                 else
  79.                     continue;
  80.  
  81.                 // 可以再次获取IP地址与端口号
  82.                 std::string ip = inet_ntoa(_this->svr_.sin_addr);
  83.                 uint16_t port = ntohs(_this->svr_.sin_port);
  84.  
  85.                 printf("Client get message from [%s:%d]# %s\n", ip.c_str(), port, buff);
  86.             }
  87.                 return (void*)0;
  88.         }
  89.  
  90.  
  91.         // 初始化客户端
  92.         void InitClient()
  93.         {
  94.             // 1.创建套接字
  95.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  96.  
  97.             if (sock_ == -1)
  98.             {
  99.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  100.                 exit(SOCKET_ERR);
  101.             }
  102.  
  103.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  104.  
  105.             // 2.构建服务器的 sockaddr_in 结构体信息
  106.             bzero(&svr_, sizeof(svr_));
  107.             svr_.sin_family = AF_INET;                            // 设置为网络通信（PF_INET 也行）
  108.             svr_.sin_addr.s_addr = inet_addr(server_ip_.c_str()); // 绑定服务器IP地址
  109.             svr_.sin_port = htons(server_port_);                  // 绑定服务器端口号
  110.         }
  111.  
  112.         // 启动客户端
  113.         void StartClient()
  114.         {
  115.             pthread_t recv, sender;
  116.             //只需将类内的线程函数变化为static函数，但是static函数就不能直接访问到我们类内的私有数据，
  117.             //不要忘了这个线程函数的void*参数，我们可以把this指针作为参数传给它，
  118.             //然后就能通过这个this指针来访问到我们的类内的私有数据
  119.             pthread_create(&recv, nullptr, recv_message, (void*)this);
  120.             pthread_create(&sender, nullptr, send_message, (void*)this);
  121.  
  122.             pthread_join(recv,nullptr);
  123.             pthread_join(sender,nullptr);
  124.         }
  125.  
  126.     private:
  127.         std::string server_ip_; // 服务器IP地址
  128.         uint16_t server_port_;  // 服务器端口号
  129.         int sock_;//套接字描述符
  130.         struct sockaddr_in svr_; // 服务器的sockadder_in结构体信息
  131.     };
  132. }

client.cc保持不变

makefile

  1. .PHONY:all
  2. all:server client
  3.  
  4. server:server.cc
  5. 	g++ -o $@ $^ -std=c++11 -lpthread
  6.  
  7. 	
  8. client:client.cc
  9. 	g++ -o $@ $^ -std=c++11 -lpthread
  10.  
  11. .PHONY:clean
  12. clean:
  13. 	rm -rf server client

6.1.2.C++11多线程功能 

这里需要简单的使用一下C++11的多线程功能

大家跟我简单学一下就行

  1. #include <iostream>
  2. #include <thread>    //必须包含<thread>头文件
  3.  
  4. void threadFunctionA()
  5. {
  6. 	std::cout << "Run New thread: 1" << std::endl;
  7. }
  8. void threadFunctionB(int n)
  9. {
  10. 	std::cout << "Run New thread: "<< n << std::endl;
  11. }
  12.  
  13. int main()
  14. {
  15. 	std::cout << "Run Main Thread" << std::endl;
  16.  
  17. 	std::thread newThread1(threadFunctionA);
  18. 	std::thread newThread2(threadFunctionB,2);
  19.  
  20. 	newThread1.join();
  21. 	newThread2.join();
  22.  
  23. 	return 0;
  24. }
  1. //result
  2. Run Main Thread
  3. Run New thread: 1
  4. Run New thread: 2

 上述示例中，我们创建了两个线程newThread1和newThread2，使用函数threadFunctionA()和threadFunctionB()作为线程的执行函数，并使用join()函数等待线程执行完成。

windows端client.h代码

  1. #pragma once
  2.  
  3. #pragma warning (disable:4996)
  4.  
  5. #include <iostream>
  6. #include <string>
  7. #include <cstring>
  8. #include <cerrno>
  9. #include <cstdlib>
  10. #include <string.h>
  11. #include <sys/types.h>
  12. #include<winsock2.h>
  13. #include <thread>
  14. #pragma comment(lib,"ws2_32.lib")
  15.  
  16. namespace nt_client
  17. {
  18.     // 退出码
  19.     enum
  20.     {
  21.         SOCKET_ERR = 1,
  22.         BIND_ERR,
  23.         USAGE_ERR
  24.     };
  25.  
  26.     class UdpClient
  27.     {
  28.     public:
  29.         // 构造
  30.         UdpClient(const std::string& ip, uint16_t port)
  31.             : server_ip_(ip), server_port_(port)
  32.         {
  33.         }
  34.  
  35.         // 析构
  36.         ~UdpClient()
  37.         {
  38.         }
  39.  
  40.  
  41.         static void* send_message(void* argc)//传进来的是this指针
  42.         {
  43.             UdpClient* _this = (UdpClient*)argc;//强制转换为类指针
  44.  
  45.             char buff[1024];
  46.             while (1)
  47.             {
  48.                 // 1.发送消息
  49.                 std::string msg;
  50.                 std::cout << "Input Message# ";
  51.                 std::getline(std::cin, msg);
  52.  
  53.                 int n = sendto(_this->sock_, msg.c_str(), msg.size(), 0, (const struct sockaddr*)&_this->svr_, sizeof(_this->svr_));
  54.  
  55.                 if (n == -1)
  56.                 {
  57.                     std::cout << "Send Message Fail: " << strerror(errno) << std::endl;
  58.                     continue; // 重新输入消息并发送
  59.                 }
  60.             }
  61.             return (void*)0;
  62.         }
  63.  
  64.         static void* recv_message(void* argc)//传进来的是this指针
  65.         {
  66.             UdpClient* _this = (UdpClient*)argc;
  67.  
  68.             char buff[1024];
  69.             while (1)
  70.             {
  71.                 // 2.接收消息
  72.                 int len = sizeof(_this->svr_); // 创建一个变量，因为接下来的参数需要传左值
  73.                 int n = recvfrom(_this->sock_, buff, sizeof(buff) - 1, 0, (struct sockaddr*)&_this->svr_, &len);
  74.  
  75.                 if (n > 0)
  76.                     buff[n] = '\0';
  77.                 else
  78.                     continue;
  79.  
  80.                 // 可以再次获取IP地址与端口号
  81.                 std::string ip = inet_ntoa(_this->svr_.sin_addr);
  82.                 uint16_t port = ntohs(_this->svr_.sin_port);
  83.  
  84.                 printf("Client get message from [%s:%d]# %s\n", ip.c_str(), port, buff);
  85.             }
  86.             return (void*)0;
  87.         }
  88.  
  89.  
  90.         // 初始化客户端
  91.         void InitClient()
  92.         {
  93.             // 1.创建套接字
  94.             sock_ = socket(AF_INET, SOCK_DGRAM, 0);
  95.  
  96.             if (sock_ == -1)
  97.             {
  98.                 std::cout << "Create Socket Fail: " << strerror(errno) << std::endl;
  99.                 exit(SOCKET_ERR);
  100.             }
  101.  
  102.             std::cout << "Create Success Socket: " << sock_ << std::endl;
  103.  
  104.             // 2.构建服务器的 sockaddr_in 结构体信息
  105.             memset(&svr_,0, sizeof(svr_));
  106.             svr_.sin_family = AF_INET;                            // 设置为网络通信（PF_INET 也行）
  107.             svr_.sin_addr.s_addr = inet_addr(server_ip_.c_str()); // 绑定服务器IP地址
  108.             svr_.sin_port = htons(server_port_);                  // 绑定服务器端口号
  109.         }
  110.  
  111.         // 启动客户端
  112.         void StartClient()
  113.         {
  114.         
  115.             //只需将类内的线程函数变化为static函数，但是static函数就不能直接访问到我们类内的私有数据，
  116.             //不要忘了这个线程函数的void*参数，我们可以把this指针作为参数传给它，
  117.             //然后就能通过这个this指针来访问到我们的类内的私有数据
  118.             std::thread rec(recv_message, (void*)this);
  119.             std::thread sen(send_message, (void*)this);
  120.  
  121.             rec.join();
  122.             sen.join();
  123.         }
  124.  
  125.     private:
  126.         std::string server_ip_; // 服务器IP地址
  127.         uint16_t server_port_;  // 服务器端口号
  128.         int sock_;//套接字描述符
  129.         struct sockaddr_in svr_; // 服务器的sockadder_in结构体信息
  130.     };
  131. }

 我们运行起来看看

这样子客户端就能进行一个群聊了。 

这回就完全没有什么问题了，但是它这个输入和输出混在一起了，客户体验感不好。

6.3.分离输入输出

 我们知道Linux下一切皆是文件，那么我们的终端也是文件，我们一个账号可以被多个终端同时登录，就像下面这样子

那Linux是怎么区分的呢？

其实在/dev/pts这个目录里面就记录了登录这个账号的终端

 

 我们可以做下面这些测试

 

 

        我们发现往0立马写没有反应，往1写是左边那个终端，往2写是右边这个终端 ，我们可以让它当作我们的消息的输出区，我们可以使用open来打开这个文件然后往里面写入

我们写一个测试代码

  1. #include<iostream>
  2. #include<unistd.h>
  3. #include<sys/types.h>
  4. #include<sys/stat.h>
  5. #include<fcntl.h>
  6.  
  7. std::string termial="/dev/pts/1";
  8.  
  9. int main()
  10. {
  11.     int fd=open(termial.c_str(),O_WRONLY);
  12.     if(fd<0)
  13.     {
  14.         std::cout<<"open error"<<std::endl;
  15.         return 1;
  16.     }
  17.  
  18.     dup2(fd,1);//重定向
  19.  
  20.     std::cout<<"hello world"<<std::endl;
  21.  
  22.     close(fd);
  23. }

我们发现在右边的终端运行这个程序，真的打印到左边这个终端来了。

client.hpp

  1. .....
  2. static void *recv_message(void *argc)//传进来的是this指针
  3.         {
  4.             .......
  5.                 
  6.                 std::cerr<<"Client get message from ["<<ip.c_str()<<":"<<port<<"]#"<<buff<<std::endl;
  7.             //注意这个cerr！！！
  8.             }
  9.                 return (void*)0;
  10.         }

我们运行看看

 

很好啊！！！输入和输出就分离了 

6.5.上线通知在线用户

我们聊天要看看对方在不在线！！！

client.hpp

  1.   static void *send_message(void *argc)//传进来的是this指针
  2.         {
  3.             UdpClient*_this =(UdpClient*)argc;//强制转换为类指针
  4.             
  5.             std::string msg1=自己的IP;
  6.             msg1+="comming....";
  7.             sendto(_this->sock_, msg1.c_str(), msg1.size(), 0, (const struct sockaddr *)&_this->svr_, sizeof(_this->svr_));
  8.  
  9.             char buff[1024];
  10.             while (1)
  11.             {
  12.                 //。。。
  13.             }
  14.                 return (void*)0;
  15.         }

这样子你一上线，就会通知大家！！！

        至此基于 UDP 协议实现的多个网络程序都已经编写完成了，尤其是 多人聊天室，如果加上简单的图形化界面（比如 EasyX、EGE），就是一个简易版的 QQ 群聊

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号