1. 前言
最先使用udp进行socket编程，最直接的原因就是因为udp简单，方便我们快速熟悉socket各种系统调用
我们一共会完成三份代码，第一份我们会实现两台主机之间的简单聊天系统；第二份在第一份的前提下，我们加上一个翻译的业务，当client向server发送一个英文单词，server会给client返回该单词的中文意思；第三份在第一份的前提下，实现简单的群聊系统
2. udp_echo_server
首先，使用socket函数创建socket文件，socket函数返回一个文件描述符fd，这里可以简单认为是打开网卡
shell
#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
# domain -> AF_INET
# type -> SOCK_DGRAM
# protocol -> 0其次，我们知道服务器启动时一定要与某个端口号绑定，未来客户端要拿着服务器的IP地址和port访问服务器
使用bind函数将服务器的IP地址和port绑定到内核当中
其中，绑定IP地址和port时需要将主机序列转为网络序列，这里有现成的接口直接使用
shell
#include <sys/types.h
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
#include <arpa/inet.h>
uint16_t htons(uint16_t hostshort); # 将16位的port主机序列转网络序列
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
in_addr_t inet_addr(const char *cp);
# 1. 将字符串类型的ip地址转结构化类型
# 2. 将ip地址主机序列转网络序列
c++
void Initialize()
{
// 1. 创建socket文件
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(_sockfd < 0)
{
LOG(FATAL, "create sockfd error");
exit(1);
}
LOG(DEBUG, "create sockfd success, sockfd:%d", _sockfd);
// 2.bind
struct sockaddr_in local;
socklen_t len = sizeof(local);
local.sin_family = AF_INET;
local.sin_port = htons(_localport);
local.sin_addr.s_addr = inet_addr(_localip.c_str());
int n = bind(_sockfd, (const struct sockaddr*)&local, len);
if(n < 0)
{
LOG(FATAL, "bind error");
exit(1);
}
LOG(DEBUG, "bind success");
}服务器运行起来后，从sockfd中读取数据，对于udp，读写不能使用read/write，应当使用recvfrom/sendto函数；接收到客户端的消息后，我们将客户端发送的消息打印出来，再发送回去
c++
#include <sys/types.h>
#include <sys/socket.h>
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
# flags -> 默认为0
# dest_addr -> 要发送的主机
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
# src_addr -> 谁发送，将来也要向对方发送
c++
void Start()
{
_isrunning = true;
while(_isrunning)
{
char buffer[1024] = { 0 };
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
if(n > 0)
{
buffer[n] = '\0';
std::cout << "[client echo]#" << buffer << std::endl;
sendto(_sockfd, buffer, sizeof(buffer)-1, 0, (const struct sockaddr*)&peer, len);
}
else
{
break;
}
}
_isrunning = false;
}对于客户端，第一步同样需要创建socket文件，但与服务器不同，客户端也需要绑定IP地址和port到内核，但不需要显示绑定，当客户端第一次发送数据是，由OS自动绑定
这是因为服务器是每个公司所有的，由公司选择IP地址和port，但我们的手机、电脑上有很多软件的客户端，如果是绑定指定的port，其他软件的客户端也要绑定同一个port时会发生冲突；因此客户端的IP地址和port由OS系统随机绑定，后面会验证客户端确实绑定了
客户端拿着服务器的IP地址和port，向服务器发送数据，再等待服务器回应，将回应打印
这里就需要提前知道服务器的IP地址和port，所以，我们使用命令行参数的方式将服务器的IP地址和port交给客户端
而服务器我们指定IP地址和port
c++
int main()
{
std::string ip = "127.0.0.1"; # 本地环回
uint16_t port = 8888;
std::unique_ptr<UdpServer> udp_server = std::make_unique<UdpServer>(ip, port);
udp_server->Initialize();
udp_server->Start();
return 0;
}
c++
int main(int argc, char* argv[])
{
if(argc != 3)
{
std::cout << "Usage:" << argv[0] << " serverip serverport" << std::endl;
exit(0);
}
std::string serverip = argv[1];
uint16_t serverport = std::stoi(argv[2]);
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if(sockfd < 0)
{
std::cout << "create socket error";
exit(1);
}
std::cout << "create socket success" << std::endl;
// client需要绑定 ip和port，但不需要显示绑定
// 当第一次发送数据时，OS会自动绑定
struct sockaddr_in server;
socklen_t len = sizeof(server);
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
server.sin_addr.s_addr = inet_addr(serverip.c_str());
while(true)
{
std::string line;
std::cout << "please enter->";
getline(std::cin, line);
ssize_t n = sendto(sockfd, line.c_str(), line.size(), 0, (const struct sockaddr*)&server, len);
if(n > 0)
{
char buffer[1024] = { 0 };
struct sockaddr_in temp;
socklen_t length = sizeof(temp);
ssize_t m = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&temp, &length);
if(m > 0)
{
buffer[m] = '\0';
std::cout << buffer << std::endl;
}
else
{
break;
}
}
}
close(sockfd);
return 0;
}现在我们来通信试试
上面代码中服务器绑定的是本地环回的IP地址(127.0.0.1)，数据经过网络协议栈发送给自身主机，在向上交付；如果是绑定自身云服务器的公网IP地址呢？
经过测试，我们绑定失败，需要注意的是，不推荐在云服务器下自身的公网IP地址 ，并且，也不推荐服务器绑定一个指定的IP地址，因为服务器可能有多张网卡，就有多个IP地址，如果只指定一个IP地址绑定，那么就只会收到指定IP地址发送的数据；因此服务器的IP地址建议设置为INADDR_ANY，表示绑定了任意IP，这样只要是发送到该主机下的数据就都能收到
我们再将服务器稍加修改，也使用命令行参数的方式绑定port
c++
int main(int argc, char* argv[])
{
if(argc != 2)
{
std::cout << "Usage:" << argv[0] << " port" << std::endl;
exit(0);
}
uint16_t port = std::stoi(argv[1]);
std::unique_ptr<UdpServer> udp_server = std::make_unique<UdpServer>(port);
udp_server->Initialize();
udp_server->Start();
return 0;
}我们再来证明客户端确实是由OS帮我们绑定了IP地址和port
服务器一定收到了客户端的信息
shell
char *inet_ntoa(struct in_addr in); # 将网络序列的结构化的ip地址转成字符串类型的ip地址
uint16_t ntohs(uint16_t netshort); # 将port由网络序列转成主机序列
c++
void Start()
{
_isrunning = true;
while(_isrunning)
{
char buffer[1024] = { 0 };
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
if(n > 0)
{
buffer[n] = '\0';
InetAddr addr(peer);
std::cout << addr.AddrStr().c_str() << buffer << std::endl;
sendto(_sockfd, buffer, sizeof(buffer)-1, 0, (const struct sockaddr*)&peer, len);
}
else
{
break;
}
}
_isrunning = false;
}
为了方便IP地址port的打印，将IP地址和port封装
c++
class InetAddr
{
protected:
void ToHost()
{
_ip = inet_ntoa(_addr.sin_addr);
_port = ntohs(_addr.sin_port);
}
public:
InetAddr(const struct sockaddr_in &addr)
: _addr(addr)
{
ToHost();
}
std::string Ip()
{
return _ip;
}
uint16_t Port()
{
return _port;
}
std::string AddrStr()
{
return "[" + _ip + ":" + std::to_string(_port) + "]";
}
~InetAddr()
{
}
protected:
std::string _ip;
uint16_t _port;
struct sockaddr_in _addr;
};这样，我们的第一份udp_echo_server代码就完成了
完整代码：[Practice/Lesson1/1. udp_echo_server · baiyahua/Linux - 码云 - 开源中国 (gitee.com)](https://gitee.com/baiyahua/linux/tree/master/Practice/Lesson1/1. udp_echo_server)
3. dict_server
现在，我们想在上面的代码上加上翻译业务，当客户端给服务器输入一个英文单词，服务器给客户端返回该英文单词的中文
同时，我们希望udp服务器只负责读取和发送数据，也就是IO，而业务逻辑交给另外的模块处理，做到IO逻辑与业务逻辑解耦
这就需要我们将处理英文单词的方法以函数指针的方式交给udp服务器，当udp服务器收到英文单词时，回调该方法，将结果再发送回客户端
c++
using service_t = std::function<std::string(const std::string&)>;
// ....
class UdpServer
{
// ...
UdpServer(service_t service, uint16_t port = glocalport)
:_sockfd(gsockfd)
,_localport(port)
,_isrunning(false)
,_service(service)
{}
void Start()
{
_isrunning = true;
while(_isrunning)
{
char buffer[1024] = { 0 };
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
if(n > 0)
{
buffer[n] = '\0';
std::string result = _service(buffer);
sendto(_sockfd, result.c_str(), result.size(), 0, (const struct sockaddr*)&peer, len);
}
else
{
break;
}
}
_isrunning = false;
}
// ....
service_t _service;
};而在单词处理的模块，将字典文件用unordered_map的结构存放，遍历查找
c++
const std::string sep = ": ";
class Dict
{
protected:
void LoadDict()
{
std::ifstream in(_dict_path.c_str());
if(!in.is_open())
{
LOG(FATAL, "open %s error", _dict_path.c_str());
exit(1);
}
std::string line;
while(getline(in, line))
{
if(line.empty()) continue;
size_t pos = line.find(sep);
if(pos == std::string::npos) continue;
std::string key = line.substr(0, pos);
if(key.empty()) continue;
std::string value = line.substr(pos+sep.size());
if(value.empty()) continue;
_dict[key] = value;
LOG(DEBUG, "load %s success", line.c_str());
}
LOG(DEBUG, "load dict done....");
}
public:
Dict(const std::string &path)
:_dict_path(path)
{
LoadDict();
}
std::string Translate(const std::string &word)
{
for(auto &[x, y] : _dict)
if(x == word) return y;
return "None";
}
~Dict()
{}
protected:
std::unordered_map<std::string, std::string> _dict;
std::string _dict_path;
};在udp服务器的调用中，将Dict::Translate作为方法传给udp服务器
c++
int main(int argc, char* argv[])
{
if(argc != 2)
{
std::cout << "Usage:" << argv[0] << " port" << std::endl;
exit(0);
}
uint16_t port = std::stoi(argv[1]);
Dict dict("./dict.txt");
service_t translate = std::bind(&Dict::Translate, &dict, std::placeholders::_1);
std::unique_ptr<UdpServer> udp_server = std::make_unique<UdpServer>(translate, port);
udp_server->Initialize();
udp_server->Start();
return 0;
}
Practice/Lesson1/2. dict_server · baiyahua/Linux - 码云 - 开源中国 (gitee.com)\](https://gitee.com/baiyahua/linux/tree/master/Practice/Lesson1/2. dict_server)
## 4. `chat_server`
在第一份代码的基础上，我们想实现一个简单的群聊系统，`udp`服务器只负责IO，将收到的数据交给消息转发模块，消息转发模块根据在线用户列表转发给每一个在线的人(包括发送信息的人)
要想IO逻辑与业务逻辑解耦，就需要给`udp`服务器传递消息转发的函数指针，当服务器拿到数据时，去回调方法
而我们的消息转发模块，就是根据在线用户列表依次转发消息
```c++
#include "InetAddr.hpp"
#include "Log.hpp"
#include