目录
[UdpServer(uint16_t port) 的实现](#UdpServer(uint16_t port) 的实现)
[~UdpServer() 的实现](#~UdpServer() 的实现)
[void InitServer() 的实现](#void InitServer() 的实现)
[void Start() 的实现](#void Start() 的实现)
0.前言
1.目标:使用UDP协议实现客户端程序和服务器端程序之间的通信。
2.功能:客户端给服务器发送什么消息,服务器端就给客户端响应什么消息。
3.效果:
客户端效果:当用户根据提示Please Enter# 输入消息之后,按下回车键,发送给服务器端,立马就收到了服务器端发送过来的相同的消息。
服务器端效果:服务器端接收到客户端发送过来的消息之后,会打印客户端的ip地址和端口号,以及用户发送过来的数据。服务器端给客户端发送的消息并不会在服务器端显示。
1.前置知识
网络通信的大致流程
客户端想要将信息发送到服务器端主机,客户端用户在客户端主机的应用层输入的数据,必须要自顶向下贯穿TCP/IP网络协议栈,并封装每一层的协议报头, 然后到达物理层的设备,然后通过物理的介质将信息传输到服务器端主机的物理层的设备 ,然后将信息**自底向上贯穿TCP/IP协议栈,进行解包和分用,**将客户端用户输入的信息传输到服务器端应用层的程序。
服务器端主机给客户端主机发送的信息也是如此。
如果你想要更加细致的研究这个过程可以参考这篇文章 :文章链接https://blog.csdn.net/D5486789_/article/details/142029716?spm=1001.2014.3001.5501
IP地址
什么是IP地址呢?我们可以这样理解。假如A主机想要将信息发送到B主机,但是在整个网络中的主机数量非常多,所以A主机必须要知道那一台主机是B主机,这个时候,就可以给每一台主机一个编号,用户在网络中标识唯一的一台主机,这个编号就是IP地址。由于历史发展的原因,IP地址有IPV4和IPV6两个版本,但我们主要使用IPV4。
IPv4地址由32位二进制数组成,通常用点分十进制的方式来表示,即每组8位二进制数转换成一个十进制数,并用点(.)分隔,例如192.168.1.1。
端口号(port)
什么是端口号呢?我们可以这样理解。当A主机已经有能力通过IP地址在网络中如此众多的主机中找到B主机,并将信息发送到B主机在物理层的设备上,此时消息需要自底向上贯穿TCP/IP协议栈交付到B主机的应用层,但是B主机应用层启动的软件程序可能不止一个 ,发送的消息到底要交付给哪一个软件程序呢?所以,A主机还需要有能力将发送给B主机的信息正确的交付给B主机中对应的软件程序。这个时候可以给每个启动的软件程序一个编号,用于唯一的标识一个启动的软件程序,这个编号就是端口号。
端口号是一个16位的数字,范围从0到65535。 其中,一些端口号被预留给特定的服务或应用程序,这些端口号被称为"知名端口号"或"系统端口号"。例如,HTTP服务通常使用端口号80,HTTPS服务通常使用端口号443,FTP服务使用端口号21等。这些知名端口号在Internet上被广泛认可和使用,使得客户端可以很容易地找到并连接到相应的服务。客户端程序的端口号在1024之后随便选。
如果你有操作系统的知识的话,你就知道我上面所说的软件程序就是操作系统中的进程,但是标识系统中唯一的一个进程不是有进程PID吗?为什么还要端口号呢?
我们可以这样理解:
**用户使用角度:**用户访问服务器端的服务程序的时候,需要知道该服务的IP地址和端口号,并且用户一旦认定了这个IP地址和端口号,当用户再次想访问对应的服务的时候,输入的还是这个IP地址和端口号,所以这就要求服务端程序所在主机的IP地址和自己的端口号是不能改变的;但是进程PID不同,每次启动同一个程序时,系统分配给进程的PID是会变化的,所以在网络通信中不能使用进程PID来唯一标识唯一的一个进程。
从操作系统的角度: 进程PID是属于操作系统中进程管理的范畴,网络通信是数据操作系统中网络管理的范畴,不同的模块之间最好是低耦合的,一层变化不会影响另一层。所以,操作系统中网络管理模块需要有独属于自己的,用于唯一的标识一个进程的设计,这个设计就是端口号。
总结: 不同的两台主机之间通信,必须要提前知道对方的IP地址和端口号,这样才能在整个错综复杂的网络中有目的的找到对方,并将信息准确的交付给对方启动的应用程序。
客户端如何得知服务器端的IP地址和端口号?
客户端需要知道服务器端的IP地址和端口号,那客户端是如何得知服务器端的IP地址和端口号的呢?
我们可以设想一下,开发人员开发出一个应用服务之后,要如何让别人来访问自己开发出的应用服务呢?是不是需要提前告诉用户呢?只有提前告诉用户,用户才知道访问对应的服务需要输入特定的IP地址和端口号。
但是IP地址和端口号太难记忆了,不方便用户使用,于是,便有了域名。比如,当我们想要买东西时,我们就可以在浏览器输入 www.taobao.com,浏览器就会将用户输入的域名解析成为指定的IP地址和端口号。
所以,客户端要想得知服务器端的IP地址和端口号,一定是商业公司提前做了宣传。
服务器端如何得知客户端的IP地址和端口号?
那服务器端是如何得知客户端的IP地址和端口号的呢?
我们可以这样理解:当用户输入指定的IP地址和端口号之后,用户输入的信息在自定向下贯穿TCP/IP协议栈的时候,不是会进行封装吗?这个过程就会将用户所使用的主机的IP地址和该主机上客户端程序的端口号也封装进用户发送的数据中,形成一个数据包,当服务器端拿到这个数据包时,就能知道客户端的IP地址和端口号。
所以,服务器端之所以能知道客户端的IP地址和端口号,是客户端发送给服务器端的。
好了,有了上面这些知识,我们就可以编写代码了。但是还有一些网络通信的基础知识在 "实现代码" 部分讲解。
2.实现代码
注意,在使用网络编程相关接口时,我们需要包含这四个头文件
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
代码模块的设计
客户端只需要实现UdpClient.cc,服务器端需要实现UdpServer.hpp、Main.cc。
服务器端代码
服务器类代码总览:
成员说明
成员变量说明:
在整个服务器类中,成员变量我们设计三个,分别是_sockfd、_port。
_sockfd:这是一个文件描述符,服务器端程序在进行网络通信的过程中,接收的数据从该文件描述符所关联的文件中拿;发送的数据,通过该文件描述符所关联的文件发送。
_port:这是服务器端程序所使用的端口号,是我们开发人员给手动的给服务器端程序绑定的。
成员函数说明:
在真个服务器类中一共四个成员函数,分别是 UdpServer(uint16_t port)、 ~UdpServer()、 void InitServer()、 void Start()。
UdpServer(uint16_t port):构造函数,负责成员变量的初始化,将_port 初始化为我们开发人员给服务器端程序指定的port;port是在启动服务器端程序时,我们自己指定的。
~UdpServer():析构函数,负责成员变量的释放,但并没有成员变量管理资源,所以不需要写啥。
void InitServer():该成员函数负责初始化服务器端程序,也就是为网络通信做必要的准备。比如:创建套接字,绑定端口号。
void Start():该成员函数负责启动服务器,当调用这个函数之后,我们的服务器端程序就可以进行消息的收和发了。
成员实现
成员实现部分,我们主要实现成员函数。
UdpServer(uint16_t port) 的实现
_sockfd我们先初始化为defaultfd,这是我们定义的const 静态全局变量,也就是-1。
_port 成员变量初始化为port,port 是需要我们在启动服务器端程序时手动输入的。
_isrunnig 大家不用管,不影响。
UdpServer(uint16_t port)
: _sockfd(defaultfd)
, _port(port)
, _isrunning(false)
{}
~UdpServer() 的实现
额,这个嘛,确实没啥要析构的,使用默认的就可以。
~UdpServer()
{}
void InitServer() 的实现
这个成员方法的实现我们分为两步,第一步为创建udp socket套接字,第二步为绑定本地信息和网络信息。
先看看代码:后面有非常详细的解释。
void InitServer()
{
// 1. 创建udp socket 套接字
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd < 0)
{
LOG(FATAL, "socket error, %s, %d\n", strerror(errno), errno);
exit(SOCKET_ERROR);
}
LOG(INFO, "socket create success, sockfd: %d\n", _sockfd);
// 填充sockaddr_in结构
struct sockaddr_in local;
bzero(&local, sizeof(local)); //将该字段全部清空为0.
local.sin_family = AF_INET;
local.sin_port = htons(_port);
local.sin_addr.s_addr = INADDR_ANY; // htonl(INADDR_ANY);
// 2.bind sockfd和网络信息(IP + Port)
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n < 0)
{
LOG(FATAL, "bind error, %s, %d\n", strerror(errno), errno);
exit(BIND_ERROR);
}
LOG(INFO, "socket bind success\n");
}
第一步解释:
我们首先创建udp socket。大家可以这样理解,服务器端的程序需要进行消息的收和发,收消息一定是该主机的物理层的网络设备先收到,也就是网卡,网卡收到的消息要放在哪里呢?在回答这个问题之前,我们需要先明确一点 "Linux下一切皆文件",硬件也是一种文件。所以操作系统要为网卡分配一个收发消息的缓冲区,用来存放收到的消息和发送的消息。再简单一点理解就是,创建udp socket,相当于把网卡打开了,就可以通过网卡收发消息了。
第一步实现:
实现第一步需要使用这个函数:
**函数功能:**通过制定的协议创建用于网络通信的文件。
**第一个参数:**domain 表明我们要进行何种通信,是本地通信,还是网络通信,我们实现的是网络通信,所以将domain设置为 AF_INET即可。
**第二个参数:**type 指定了套接字的类型,是面向数据报的套接字类型还是面向字节流的套接字类型,UDP是面向数据报的通信协议,所以我们将其设置为SOCK_DGRAM即可。
**第三个参数:**protocol 用于指定特定的协议,但是前两个参数已经表明我们要使用UDP协议了,所以设置为0即可。
返回类型:
**失败时:**返回-1,并设置错误码。
成功时: 返回新创建的文件描述符。这个文件描述符后续会被用于其他套接字函数,如**
bind()
、listen()
、accept()
、connect()
、send()
、recv()
**等,这也是我们设计一个_sockfd 成员变量的原因。
第二步解释:前面我们说过,socket函数返回值是一个文件描述符,与该文件描述符所关联的文件用于该主机在网络通信中收发数据;可是,光光有一个收发数据的文件,还是远远不够的,还需要将该文件和主机的网络信息(比如IP地址,端口号等)关联起来,这样,客户端就能通过指定的IP地址和端口号,找到提供服务的服务端程序,并向该程序用于网络通信的文件中发送数据。服务器端向客户端发送消息也是如此。
第二步实现:
实现这一步需要使用bind函数:
**函数功能:**将通信主机的本地信息(sockfd)和网络信息关联起来。
**第一个参数:**sockfd 是我们需要关联的文件描述符。
第二个参数: struct sockaddr 中包含本机的网络信息。
第三个参数: 这个参数指定了
addr
参数所指向的结构的长度。对于sockaddr_in
,这个长度通常是sizeof(struct sockaddr_in)
说明一下:
addr的类型是 struct sockaddr,但实际上addr的类型是 struct sockaddr_in。这是因为,socket编程不仅可以用于网络通信(使用struct sockaddr_in结构),还可以用于本地通信(使用struct sockaddr_un结构),还有其他通信......通信方式这么多,操作系统的开发者就要多开发几套通信接口给用户使用,不仅仅开发的人头疼,使用的人也头疼。于是,操作系统的开发人员便想到一种方案,提供统一的接口,用户想要进行那种通信,就传入特定的参数即可,该函数内部自动做解析,判断用户要进行何种通信。也就是说,为了统一接口的使用,设计了struct sockaddr 类型。
需要注意的是,这个参数是一个结构体类型,所以我们需要先填充结构体中的字段之后,再将该结构体对象作为参数传递进去。struct sockaddr_in结构中的字段如下所示:
struct sockaddr_in { sa_family_t sin_family; // 地址族,对于 IPv4 来说,这个值总是 AF_INET uint16_t sin_port; // 端口号,网络字节顺序 struct in_addr sin_addr; // IPv4 地址,网络字节顺序 }; // 其中,struct in_addr 结构体定义如下: struct in_addr { uint32_t s_addr; // IPv4 地址,网络字节顺序 };
sin_family:我们设置为AF_INET,表示要进行网络通信。
sin_port:表示我们给该服务器端程序绑定的端口号。
sin_addr:表示该服务器端程序所在主机的IP地址。
htons和htonl函数的介绍:
**函数功能:**将主机序列转换成网络序列。
由于历史发展的原因,产生了大端机和小端机,大端机和小端机之间可能也要进行通信,数据需要经过网络,那么数据在网络中是大端序列还是小端序列呢?为了解决这个问题,网络中的序列被规定为大端序列,小端机发送的数据要经过网络就需要转化成网络序列,也就是大端序列,大端机发送的数据已经是大端的了,就不需要进行转化了。
对于IP地址,在主机中显示的时候,显示出来的是 点分十进制的IP地址, 但是,在网络中传输的时候,为了节省空间,往往被设计为四字节的IP地址。
所以我们发送的端口号 需要转换成网络序列,需要使用htons函数,表示将一个16位的整数转换成网络序列。
发送的IP地址 需要转换成四字节的IP ,同时也需要转换成网络序列,需要使用htonl函数,这一个函数会帮我们完成这两步事情。
这句代码是什么意思呢?------ local.sin_addr.s_addr = INADDR_ANY;
我们将 local.sin_addr.s_addr 设置为INADDR_ANY,这是为什么呢?因为如果我们指定了服务器端的IP地址,客户端只能通过特定的IP地址来访问这个服务端程序, 也就是说 这个服务端程序只能通过绑定的IP地址来访问;但是一台主机不止一个IP地址,可能有公网IP,内网IP,不同的IP需要提供给不同的用户使用,需要保证用户使用该主机的不同IP地址能访问到指定的服务端程序。所以我们将服务器端的IP地址绑定为0,在代码实现方面,库当中将INADDR_ANY定义为0,并且0 的大端序列和小端序列是相同的。
void Start() 的实现
当我们完成服务器端程序网络通信的初始化工作之后,我们的服务器端程序就可以通信了,这段代码也体现了我们这个通信程序的功能 ------ 接收客户端的消息,给客户端返回同样的消息。
先看代码再解释:
void Start()
{
// 一直运行,直到管理者不想运行了, 服务器都是死循环
// UDP是面向数据报的协议
while (true)
{
char buffer[1024];
struct sockaddr_in peer;
socklen_t len = sizeof(peer); // 必须初始化成为sizeof(peer)
// 1. 我们要让server先收数据
ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
if (n > 0)
{
buffer[n] = 0;
LOG(DEBUG, "get message: %s\n", buffer);
// 2. 我们要将server收到的数据,发回给对方
sendto(_sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len);
}
}
}
先介绍基于UDP协议进行网络通信的两个函数:
我们的程序是基于UDP协议进行通信的,UDP协议是面向数据报的协议,所以我们不能使用一般的文件读写接口从基于UDP网络通信的文件中读写数据,而要使用UDP协议的网络通信读写接口 ------ recvfrom和sendto。
recvfrom:
函数功能:从指定的网络通信文件中读取数据。
参数说明:
1.sockfd表明我们要从那个文件中读。
2.buf是一个输出型参数,表明我们读取的数据放到哪里。
3.len表明我们要读取多长的数据。
4.flags是一个标志位,表示我们以什么方式读,通常设为0。
5.src_addr 表明发送数据方的网络信息( 比如:发送方的IP地址和端口号信息。),也就是说要知道是谁给我发的消息。
6.addrlen 是指向一个整数的指针,该整数在调用前应该包含
src_addr
指向的结构体的大小;在调用后,它将包含实际写入src_addr
的字节数。**返回值:**该函数执行成功的返回值表示接收到的字节数。如果连接已正常终止,则返回0。如果发生错误,则返回-1,并设置相应的errno来指示错误的类型。
sendto:
函数功能:通过指定的网络通信文件发送数据。
参数介绍:
1.sockfd表示我们要通过哪个通信文件发送数据。
2.buf 表示我们要发送的数据在内存中存储的位置。
3.len 表明我们要发送多长的数据。
4.flags 表明我们要以什么方式发送数据。
5.dest_addr 表明**接收数据方的网络信息,**也就是说要把数据发送给谁。
6.addrlen 表明dest_addr所指向的对象的大小。
**返回值:**如果发送成功,则返回发送的字节数(可能小于请求发送的字节数,如果发送缓冲区空间不足或网络限制)。如果发生错误,则返回-1,并设置errno来指示错误的类型。
代码解释:
作为服务器端程序,肯定是需要一直运行的,这样才能确保客户随时随地都能访问,所以是在一个死循环中,直到管理者不想让这个程序执行了。
服务器端程序肯定是要先接收消息的,所以我们使用recvfrom这个函数将接收到的信息存放在buffer这个缓冲区中,同时通过输出型参数 struct sockaddr_in peer 获取发送方的IP地址和端口号,如果接收消息成功,立马通过sendto函数将存放在buffer中的数据发送给对方,因为我们通过输出型参数获取到了发送方的网络信息,所以我们同样可以使用这个网络信息将数据发回给对方。
至此,服务器端的代码就编写完毕了。
客户端代码
当我们在启动客户端程序的时候,要使用这样的命令 ./udpclient 127.0.0.1 8888,这样的命令,其中127.0.0.1是服务器端的IP地址,8888是服务器端程序的端口号。Usage函数帮我们检查启动客户端程序的格式是否正确。
补充:127.0.0.1是本地环回IP,主要用于测试。
第一步:创建UDP socket。客户端程序的第一步还是创建基于UDP协议通信的套接字,也就是创建自己用于该服务中进行网络通信的文件。创建的方式和服务器端一模一样。
第二步:绑定客户端的本地信息和网络信息。(特别注意)客户端需不需要绑定客户端的本地信息和网络信息呢?答案是要,但是,不能够由我们开发人员在代码中手动的绑定,比如:你写的客户端程序绑定端口号为8888,我写的客户端程序也绑定端口号为8888,但是用户主机上的一个端口号只能唯一标识一个进程。所以客户端程序的端口号不能手动绑定, 只能由用户主机上的操作系统自动分配。所以这一步我们什么也不需要做!
接下来的工作就和在服务器端程序中的差不多了,客户端程序也是在死循环中跑的,只能让用户手动的退出。客户端程序通过sendto接口向客户端发送数据,通过recvfrom接口接收客户端发过来的数据。
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
<< std::endl;
}
// ./udpclient serverip serverport
int main(int argc, char *argv[])
{
if (argc != 3)
{
Usage(argv[0]);
exit(1);
}
std::string serverip = argv[1];
uint16_t serverport = std::stoi(argv[2]);
// 1. 创建socket
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd < 0)
{
std::cerr << "socket error" << std::endl;
}
// 构建目标主机的socket信息
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
server.sin_addr.s_addr = inet_addr(serverip.c_str());
std::string message;
// 2. 直接通信即可
while(true)
{
std::cout << "Please Enter# ";
std::getline(std::cin, message);
sendto(sockfd, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof(server));
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
char buffer[1024];
ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
if(n > 0)
{
buffer[n] = 0;
std::cout << "server echo# " << buffer << std::endl;
}
}
return 0;
}
至此,就可以完成客户端和服务器端的通信了。
3.程序拓展
我们写的服务器端代码中,接收到用户的信息之后,直接就返回相同的信息;那我们能不能改变服务器端的返回逻辑呢?针对客户端的不同信息,给客户响应不同的结果,这一点可以通过回调函数实现,读者可以自行拓展。
4.源代码附录
客户端代码
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
<< std::endl;
}
int main(int argc, char *argv[])
{
if (argc != 3)
{
Usage(argv[0]);
exit(1);
}
std::string serverip = argv[1];
uint16_t serverport = std::stoi(argv[2]);
// 1. 创建socket
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd < 0)
{
std::cerr << "socket error" << std::endl;
}
// 构建目标主机的socket信息
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
server.sin_addr.s_addr = inet_addr(serverip.c_str());
std::string message;
// 2. 直接通信即可
while(true)
{
std::cout << "Please Enter# ";
std::getline(std::cin, message);
sendto(sockfd, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof(server));
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
char buffer[1024];
ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
if(n > 0)
{
buffer[n] = 0;
std::cout << "server echo# " << buffer << std::endl;
}
}
return 0;
}
服务器端代码
#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
enum
{
SOCKET_ERROR = 1,
BIND_ERROR,
USAGE_ERROR
};
const static int defaultfd = -1;
class UdpServer
{
public:
UdpServer(uint16_t port)
: _sockfd(defaultfd)
, _port(port)
, _isrunning(false)
{}
void InitServer()
{
// 1. 创建udp socket 套接字 --- 必须要做的
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd < 0)
{
LOG(FATAL, "socket error, %s, %d\n", strerror(errno), errno);
exit(SOCKET_ERROR);
}
LOG(INFO, "socket create success, sockfd: %d\n", _sockfd);
// 2.0 填充sockaddr_in结构
struct sockaddr_in local; // struct sockaddr_in 系统提供的数据类型。local是变量,用户栈上开辟空间。int a = 100; a = 20;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
local.sin_port = htons(_port); // port要经过网络传输给对面,先到网络,_port:主机序列-> 主机序列,转成网络序列
// a. 字符串风格的点分十进制的IP地址转成 4 字节IP
// b. 主机序列,转成网络序列
// in_addr_t inet_addr(const char *cp) -> 同时完成 a & b
// local.sin_addr.s_addr = inet_addr(_ip.c_str()); // "192.168.3.1" -> 字符串风格的点分十进制的IP地址 -> 4字节IP
local.sin_addr.s_addr = INADDR_ANY; // htonl(INADDR_ANY);
// 2.1 bind sockfd和网络信息(IP(?) + Port)
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n < 0)
{
LOG(FATAL, "bind error, %s, %d\n", strerror(errno), errno);
exit(BIND_ERROR);
}
LOG(INFO, "socket bind success\n");
}
void Start()
{
while (true)
{
char buffer[1024];
struct sockaddr_in peer;
socklen_t len = sizeof(peer); // 必须初始化成为sizeof(peer)
// 1. 我们要让server先收数据
ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
if (n > 0)
{
buffer[n] = 0;
LOG(DEBUG, "get message: %s\n", buffer);
// 2. 我们要将server收到的数据,发回给对方
sendto(_sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len);
}
}
_isrunning = false;
}
~UdpServer()
{}
private:
int _sockfd;
uint16_t _port; // 服务器所用的端口号
};
服务端启动逻辑代码(main.cc)
#include <iostream>
#include <memory>
#include "UdpServer.hpp"
void Usage(std::string proc)
{
std::cout << "Usage:\n\t" << proc << " local_port\n" << std::endl;
}
// ./udpserver port
int main(int argc, char *argv[])
{
if(argc != 2)
{
Usage(argv[0]);
exit(USAGE_ERROR);
}
uint16_t port = std::stoi(argv[1]);
std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(port);
usvr->InitServer();
usvr->Start();
return 0;
}