Socket编程3个版本

Socket编程预备

数据传输到主机不是是目的吗？因为数据是给人用的。比如：聊天是人在聊天，浏览我网页是人在浏览？ 但是人是怎么看到聊天信息的呢？怎么执行下载任务呢？怎么浏览网页信息呢？通过启动的qq，迅雷，浏览器。 而启动的qq，迅雷，浏览器都是进程。换句话说，进程是人在系统中的代表，只要把数据给进程，人就相当于就拿到了数据。 所以：数据传输到主机不是目的，而是手段。到达主机内部，再交给主机内的进程，才是目的（进程就是人在操作系统中的代表）

1.所以网络通信本质 = 跨主机的进程间通信，网络就充当进程间看到的同一份资源

2.上网只有两类 IO 行为

• 下载：远端主机进程 → 网络 → 本机网卡 → 本机进程内存
• 上传：本机进程内存 → 网卡 → 网络 → 远端主机进程 网络读写，本质属于IO 操作

但是系统中，同时会存在非常多的进程，当数据到达目标主机之后，怎么转发给目标进程？

认识端口号

端口号( port )是传输层协议的内容

 • 端口号是⼀个 2 字节 16 位的整数;

 • 端口号用来标识⼀个进程,告诉操作系统,当前的这个数据要交给哪⼀个进程来处理;

 • ⼀个端口号只能被⼀个进程占用（⼀个进程可以绑定多个端口号）

又IP 地址：定位主机；端口号：定位主机内部的进程。IP地址+端口号能够标识网络上的某⼀台主机的某⼀个进程

端口号范围划分

 • 0 – 1023 :知名端口号,HTTP, FTP, SSH 等这些广为使用的应用层协议,他们的端口号都是固定的.（即我们自己不能使用这些端口号，就像110，120这些电话号码一样，我们不能使用）

 • 1024 – 65535 :操作系统动态分配的端口号.客户端程序的端口号,就是由操作系统从这个范围分配的（客户端不用bind就是随机靠os分配）

PID（进程 ID） vs 端口号

我们之前在学习系统编程的时候,学习了pid可以表示唯⼀ 个进程;此处我们的端口号也是唯⼀表示⼀个进程，那么这两者之间是怎样的关系?

简单理解PID在操作系统内部标识进程；端口是在网络层标识进程

为什么不统一用pid？

解耦

理解： PID 是操作系统内部给程序的 “门牌号”，只本机内核认识； 端口号是网络层面约定的 “对外门牌号”，全世界主机都能识别。‘

认识socket

在前面说了IP 地址：定位主机；端口号：定位主机内部的进程。IP地址+端口号能够标识网络上的某⼀台主机的某⼀个进程。所以socket=IP+端口号

通信的时候，本质是两个互联网进程代表⼈来进行通信，{srcIp，srcPort，dstIp，dstPort} 这样的4元组就能标识互联网中唯⼆的两个进程

传输层的典型代表

传输层是属于内核的，那么我们要通过网络协议栈进行通信，必定调用的是传输层提供的系统调用，来进行的网络通信

这些特性后面再做理解，现在认识即可

网络字节序

我们已经知道,内存中的多字节数据相对于内存地址有大端和小端之分,磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分,网络数据流同样有大端小端之分.那么如何定义网络数据流的地址呢?

• TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节.

• 不管这台主机是大端机还是小端机,都会按照这个TCP/IP规定的网络字节序来发送/接收数据;所以 如果当前发送主机是小端,就需要先将数据转成大端;否则就忽略,直接发送即可;

可以调用以下库函数做网络字节序和主机字节序的转换（就是对IP地址和端口做大小端切换）

uint16_t → 用来存端口号（2 字节）
uint32_t → 用来存放 IP整型地址（4 字节）

小知识：uint32_t：无符号 32 位整数类型（uint16_t同理），但uint32_t ≠ unsigned int，int 长度平台可变，所以就不一定是32位了，只有在int为32位的平台下才会sockaddr结构相等。

uint32_t 强制固定 32 位，跨平台大小统一，网络通信不会出错

记忆技巧：h=host 主机，n=net 网络，s=short (16 位)，l=long (32 位)（eg：htonl就是h（主机）–>n（网络）的转化）

理解Socket 地址结构

首先我们先了解一下两大 IPC 体系区分

• 网络 Socket：跨主机通信；
• 本地 Socket：本机进程通信

Socket 设计者提供统一接口，使用通用基类 struct sockaddr，兼容两种通信场景：

实际写代码时：我们填充专用结构体，强制转换成 struct sockaddr* 传入函数。

struct sockaddr_un:

struct sockaddr_un{
sa_family_t sun_family; // 地址族：AF_UNIX
char sun_path[108]; // 本地文件路径名
};

struct sockaddr_in（简化版本）：

struct sockaddr_in{
sa_family_t sin_family; // 地址族：AF_INET
uint16_t sin_port; // 16位端口号
struct in_addr sin_addr; // 32位IPv4地址
unsigned char sin_zero[8];// 8字节填充，对齐大小，兼容sockaddr
};

真实情况有多层封装

socket常见API：

所以如何区分通信类型？

依靠地址族字段判断：

if(address->sa_family == AF_INET)
{
// 网络通信，强转 sockaddr_in
}
else if(address->sa_family == AF_UNIX)
{
// Unix本地通信，强转 sockaddr_un
}

socket () 函数

int socket(int domain, int type, int protocol);

功能：创建通信端点，在内核生成 socket 对象，返回文件描述符 fd（理解：打开一个网络文件）

参数：

• SOCK_DGRAM：UDP
• SOCK_STREAM：TCP

返回值 成功：返回 socket 文件描述符（int）； 失败：返回 -1，全局变量 errno 保存错误码。

bind () 函数

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

功能：给 socket 文件描述符绑定「地址（IP + 端口）」，给套接字命名，让别人能找到你。（socket() 仅仅创建出一个通信端点（拿到 fd），此时没有端口、没有 IP，外部无法主动连接 / 发数据给它。）

参数：

• sockfd：socket () 创建得到的文件描述符；
• *addr：通用地址结构体指针（sockaddr_in /sockaddr_un 强制转换传入）；
• addrlen：地址结构体占用字节大小

返回值 成功：返回 0； 失败：返回 -1，设置 errno

分场景理解要不要bind：

服务器（必须 bind）：服务器需要固定端口（不会随机变化），这样客户端才能和服务端连接

客户端（一般不用手动 bind）：客户端发起连接时，操作系统自动随机分配临时端口

为什么？手动bind会怎样？

端口被占用问题

假如用了端口6666bind那么在程序异常退出时，其它程序都不能用6666这个端口号，即端口号被占用了

单进程就只能建立一条对外连接（严重限制）

[源 IP + 源端口]—>[目标IP+目标端口]建立1条连接，如果源端口固定，就只能建立1条连接了

sendto 发送数据

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);

参数

返回值

成功：发送的字节数；失败：-1

recvfrom 接收数据

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);

参数

返回值

0：收到多少字节 -1：出错

1.udp sockfd，既可以读，又可以写。UDP 通信，其实是全双工的

全双工：通信双方可以同时收发数据，上行、下行相互独立，互不阻塞

为什么是全双工？

单个 UDP socket 文件描述符同时具备读缓冲区、写缓冲区 内核给每个 UDP 套接字分配两块独立缓冲区：

• 接收缓冲区：存放别人发过来的数据 → recvf

  int inet_aton(const char *strptr, struct in_addr *addrptr);
  rom()读取

• 发送缓冲区：存放你要发出去的数据 → sendto()发送 读写互不干扰。

IP 地址转换函数

知道inet_addr、inet_aton、inet_ntoa有静态覆盖问题，不安全，只能支持IPv4

推荐用下面的2个，支持 IPv4+IPv6，兼容性最强

字符串 IP → 网络字节序

inet_pton

int inet_pton(int family, const char *strptr, void *addrptr);

eg：

网络字节序→ 字符串 IP

inet_ntop

eg：

本地回环地址 127.0.0.1

• 特点：仅本机内部通信
• 数据路径：客户端发出的数据不会发送到物理网卡、不会进入局域网，操作系统内核内部转发给本机服务端。
• 使用场景：只限本地调试网络代码，其它主机不能访问。

bind 的三种情况总结

如果服务端显式 bind 了某个特定 IP，客户端访问时必须使用这个 IP，否则连接失败。 例：server bind 10.0.0.6，客户端用127.0.0.1连接 → 访问不通！反过来同样不行

服务端推荐绑定 INADDR_ANY（0.0.0.0）

local.sin_addr.s_addr = INADDR_ANY

含义：监听本机所有网卡上的所有 IP 地址（不是说和能够与所有ip地址bind，只是能够监听到所有ip，可以./udpclient 公网 8080即监听到公网）

不需要手动指定单一 IP，规避上面 “IP 不匹配连不上” 的问题。

指令：netstat -anup

• netstat：查看网络连接、端口监听（旧工具，推荐新版 ss）
• -a：显示所有连接
• -n：数字形式展示
• -u：只查看 UDP 套接字
• -p：显示对应进程 PID、程序名

V1版本

Echo server简单的回显服务器和客户端代码

相关头文件：

#include <sys/types.h> // 基础类型（早期必备，现在很多系统可省略）
#include <sys/socket.h> // socket、bind、listen、accept、connect 函数 + 宏
#include <arpa/inet.h> // sockaddr_in、inet_addr、inet_ntoa、inet_pton
#include <netinet/in.h> // 定义 AF_INET、SOCK_STREAM
#include <unistd.h> // close() 关闭文件描述符
#include <errno.h> // errno 错误码
#include <string.h> // memset 清空结构体

代码实现：

Udpserver.hpp:

#pragma once

#include <iostream>
#include <string>
#include <functional>
#include <strings.h> //bzero

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
using namespace std;
using namespace LogMoudle;
const int defaultid = -1;
using func_t = function<string &(string &)>;

// INADDR_ANY; ; struct sockaddr_in local;
class Udpserver
{
public:
Udpserver(uint16_t port, func_t fun)
: _port(port), _fun(fun), _sockfd(defaultid), _isrunning(false)
{
}
void Init()
{
// 1.创建socket
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
LOG(LogLevel::FATAL) << "socket fail";
exit(2);
}
LOG(LogLevel::INFO) << "socket sucess,socket: " << _sockfd;

// 2.bind
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_port = htons(_port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = INADDR_ANY;
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n < 0)
{
LOG(LogLevel::FATAL) << "bind error";
exit(2);
}
LOG(LogLevel::INFO) << "bind success, sockfd : " << _sockfd;
}

void Start()
{
_isrunning=true;
//我们平时用的程序app都是不会退出的，即都是死循环
while(_isrunning)
{
char buffer[1024];
struct sockaddr_in peer;
bzero(&peer, sizeof(peer));
socklen_t len=sizeof(peer);
//收信息
ssize_t r=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
if(r>0)
{
buffer[r]=0;
uint16_t peer_port=ntohs(peer.sin_port);
string peer_ip=inet_ntoa(peer.sin_addr);
LOG(LogLevel::DEBUG) << "[" << peer_ip << ":" << peer_port<< "]# " << buffer; // 1. 消息内容 2. 谁发的？？
//发信息
string echo_string = "server echo@ ";
echo_string += buffer;
ssize_t s=sendto(_sockfd,echo_string.c_str(),echo_string.size(),0,(struct sockaddr*)&peer,len);
}

}
}

~Udpserver() {}

private:
uint16_t _port;
bool _isrunning;
int _sockfd;
func_t _fun;
};

Udpserver.cc

#include"UdpServer.hpp"
//.udpserver 8080
string&handler(string&s)
{
s="hello"+s;
return s;
}
int main(int argc,char *argv[])
{
Enable_Console_Log_Strategy();
if(argc!=2)
{
std::cerr << "Usage: " << argv[0] << " port" << std::endl;
return 1;
}
unique_ptr<Udpserver>uds=make_unique<Udpserver>(8080,handler);//这里传了handler但是没有使用，只做了server回显的操作
uds->Init();
uds->Start();

return 0;
}

UdpClient.hpp:
 

#include <iostream>
#include <string>
#include <functional>
#include <strings.h> //bzero
#include<string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
using namespace LogMoudle;
class Udpclient
{
public:
Udpclient(string &ip, int port)
: _sockfd(-1), _server_ip(ip), _server_port(port)
{
}
~Udpclient() {}
void Init()
{
// socket
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
LOG(LogLevel::FATAL) << "socket fail";
exit(2);
}
LOG(LogLevel::INFO) << "socket sucess,socket: " << _sockfd;
// bind,客户端不用手动bind，os自动分配端口号
}
void Start()
{
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(_server_ip.c_str());
server.sin_port = htons(_server_port);
while (true)
{
string buffer;
cout << "Please Enter#" << endl;
getline(cin, buffer);
// 发送
ssize_t s = sendto(_sockfd, buffer.c_str(), buffer.size(), 0, (struct sockaddr *)&server, sizeof(server));
(void)s;
//收信息
char buffer2[1024];
struct sockaddr_in peer;
socklen_t len=sizeof(peer);
ssize_t r=recvfrom(_sockfd,buffer2,sizeof(buffer2)-1,0,(struct sockaddr*)&peer,&len);
if(r>0)
{
buffer2[r]=0;
cout<<buffer2<<endl;
}

}
}

private:
string _server_ip;
int _server_port;
int _sockfd;
};

UdpClient.cc:

#include"UdpClient.hpp"
//./udpclient ip port

int main(int argc,char *argv[])
{
Enable_Console_Log_Strategy();

if(argc!=3)
{
cerr<<"Usage:./udpclient ip port"<<endl;
return 1;
}
string server_ip=argv[1];
int server_port=stoi(argv[2]);
unique_ptr<Udpclient>udc=make_unique<Udpclient>(server_ip,server_port);
udc->Init();
udc->Start();

return 0;
}

makefile:

.PHONY:all
all:udpclient udpserver

udpclient:UdpClient.cc
g++ -o $@ $^ -std=c++17 #-static
udpserver:UdpServer.cc
g++ -o $@ $^ -std=c++17

.PHONY:clean
clean:
rm -f udpclient udpserver

V2:翻译版

Dict.hpp:

#pragma once

#include <iostream>
#include <fstream>
#include <string>
#include <unordered_map>
#include "Log.hpp"
#include "InetAddr.hpp"

const std::string defaultdict = "./dictionary.txt";
const std::string sep = ": ";

using namespace LogMoudle;
class Diet
{
public:
Diet(const string &path = defaultdict)
: _dict_path(path)
{
}
bool LoadDict()
{
ifstream in(_dict_path);
if (!in.is_open())
{
LOG(LogLevel::DEBUG) << "打开字典: " << _dict_path << " 错误";
return false;
}
string line;
while (getline(in, line))
{
auto pos = line.find(sep);
if (pos == string::npos)
{
LOG(LogLevel::WARNING) << "解析" << line << "失败";
continue;
}
string enlish = line.substr(0, pos);
string chinese = line.substr(pos + 2);
if (enlish.empty() || chinese.empty())
{
LOG(LogLevel::WARNING) << "没有有效内容" << line;
continue;
}
_dict.insert({enlish, chinese});
LOG(LogLevel::DEBUG) << "加载:" << line;
}
in.close();
return true;
}
string Translate(const string &word, InetAddr &client)
{
auto iter = _dict.find(word);
if (iter == _dict.end())
{
LOG(LogLevel::DEBUG) << "进入到了翻译模块, [" << client.Ip()<< " : " << client.Port() << "]# " << word << "->None";
return "None";
}
LOG(LogLevel::DEBUG) << "进入到了翻译模块, [" << client.Ip()<< " : " << client.Port() << "]# " << word << "->" << iter->second;
return iter->second;
}
~Diet() {}

private:
string _dict_path;
unordered_map<string, string> _dict;
};

InetAddr.hpp:

#pragma once
#include <iostream>
#include <string>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;
class InetAddr
{
public:
InetAddr(struct sockaddr_in &addr)
: _addr(addr)
{
_port = ntohs(_addr.sin_port);
_ip = inet_ntoa(_addr.sin_addr);
}
string Ip()
{
return _ip;
}
uint16_t Port()
{
return _port;
}
string StringAddr()
{
return _ip+":"+to_string(_port);
}
~InetAddr() {}

private:
sockaddr_in _addr;

uint16_t _port;
string _ip;
};

UdpsServer.cc:

#include"UdpServer.hpp"
#include"Dict.hpp"
//.udpserver 8080

int main(int argc,char *argv[])
{
Enable_Console_Log_Strategy();
if(argc!=2)
{
std::cerr << "Usage: " << argv[0] << " port" << std::endl;
return 1;
}
//
Diet d;
d.LoadDict();
auto handler=[&d](const string&word,InetAddr&cli){return d.Translate(word,cli);};
//2个模块连接的关键！！！
unique_ptr<Udpserver>uds=make_unique<Udpserver>(8080,handler);
uds->Init();
uds->Start();

return 0;
}

UdpServer.hpp:

#pragma once

#include <iostream>
#include <string>
#include <functional>
#include <strings.h> //bzero

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
#include"InetAddr.hpp"

using namespace std;
using namespace LogMoudle;
const int defaultid = -1;
using func_t = function<std::string(const std::string&, InetAddr&)>;
// INADDR_ANY; ; struct sockaddr_in local;
class Udpserver
{
public:
Udpserver(uint16_t port, func_t fun)
: _port(port), _fun(fun), _sockfd(defaultid), _isrunning(false)
{
}
void Init()
{
// 1.创建socket
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
LOG(LogLevel::FATAL) << "socket fail";
exit(2);
}
LOG(LogLevel::INFO) << "socket sucess,socket: " << _sockfd;

// 2.bind
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_port = htons(_port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = INADDR_ANY;
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n < 0)
{
LOG(LogLevel::FATAL) << "bind error";
exit(2);
}
LOG(LogLevel::INFO) << "bind success, sockfd : " << _sockfd;
}

void Start()
{
_isrunning=true;
//我们平时用的程序app都是不会退出的，即都是死循环
while(_isrunning)
{
char buffer[1024];
struct sockaddr_in peer;
bzero(&peer, sizeof(peer));
socklen_t len=sizeof(peer);
//收信息
ssize_t r=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
if(r>0)
{
InetAddr client(peer);
buffer[r]=0;
string result=_fun(buffer,client);

ssize_t s=sendto(_sockfd,result.c_str(),result.size(),0,(struct sockaddr*)&peer,len);
}

}
}

~Udpserver() {}

private:
uint16_t _port;
bool _isrunning;
int _sockfd;
func_t _fun;
};

UdpClient.cc:

#include"UdpClient.hpp"
//./udpclient ip port

int main(int argc,char *argv[])
{
Enable_Console_Log_Strategy();

if(argc!=3)
{
cerr<<"Usage:./udpclient ip port"<<endl;
return 1;
}
string server_ip=argv[1];
int server_port=stoi(argv[2]);
unique_ptr<Udpclient>udc=make_unique<Udpclient>(server_ip,server_port);
udc->Init();
udc->Start();

UdpClient.hpp:

#include <iostream>
#include <string>
#include <functional>
#include <strings.h> //bzero
#include<string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
using namespace LogMoudle;
class Udpclient
{
public:
Udpclient(string &ip, int port)
: _sockfd(-1), _server_ip(ip), _server_port(port)
{
}
~Udpclient() {}
void Init()
{
// socket
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
LOG(LogLevel::FATAL) << "socket fail";
exit(2);
}
LOG(LogLevel::INFO) << "socket sucess,socket: " << _sockfd;
// bind,客户端不用手动bind，os自动分配端口号
}
void Start()
{
struct sockaddr_in server;
memset(&server,0,sizeof(server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(_server_ip.c_str());
server.sin_port = htons(_server_port);
while (true)
{
string buffer;
cout << "Please Enter#" << endl;
getline(cin, buffer);
// 发送
ssize_t s = sendto(_sockfd, buffer.c_str(), buffer.size(), 0, (struct sockaddr *)&server, sizeof(server));
(void)s;
//收信息
char buffer2[1024];
struct sockaddr_in peer;
socklen_t len=sizeof(peer);
ssize_t r=recvfrom(_sockfd,buffer2,sizeof(buffer2)-1,0,(struct sockaddr*)&peer,&len);
if(r>0)
{
buffer2[r]=0;
cout<<buffer2<<endl;
}

}
}

private:
string _server_ip;
int _server_port;
int _sockfd;
};

V3：群聊版

InetAddr.hpp:

#pragma once
#include <iostream>
#include <string>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
using namespace std;
class InetAddr
{
public:
InetAddr(struct sockaddr_in &addr)
: _addr(addr)
{
_port = ntohs(_addr.sin_port);
_ip = inet_ntoa(_addr.sin_addr);
}
string Ip()
{
return _ip;
}
uint16_t Port()
{
return _port;
}
string StringAddr()
{
return "["+_ip+":"+to_string(_port)+"]";
}
bool operator==(const InetAddr&addr)
{
return addr._ip == _ip && addr._port == _port;
}
struct sockaddr_in NetAddr()
{
return _addr;
}
~InetAddr() {}

private:
sockaddr_in _addr;

uint16_t _port;
string _ip;
};

Route.hpp:

#pragma once
#include <iostream>
#include <string>
#include <vector>
#include "InetAddr.hpp"
#include "Log.hpp"
using namespace LogMoudle;
class Route
{
private:
bool IsExist(InetAddr &peer)
{
for (auto &user : _online_user)
{
if (user == peer)
{
return true;
}
}
return false;
}
void AddUser(InetAddr &peer)
{
LOG(LogLevel::INFO) << "新增一个在线用户" << peer.StringAddr();
_online_user.push_back(peer);
}
void DeleteUser(InetAddr &peer)
{
for (auto iter = _online_user.begin(); iter != _online_user.end(); iter++)
{
if (*iter == peer)
{
LOG(LogLevel::INFO) << "删除一个在线用户" << peer.StringAddr() << "成功";
_online_user.erase(iter);
break;
}
}
}

public:
Route() {}
void MessageRoute(int sockfd, string &message, InetAddr &peer)
{
LockGuard guard(_mutex);
if (!IsExist(peer))
{
AddUser(peer);
}
string send_message = peer.StringAddr() + "#" + message;
for (auto &user : _online_user)
{
// sendto(sockfd, send_message.c_str(), send_message.size(), 0, (struct sockaddr *)&(user.NetAddr()), sizeof(user.NetAddr()));
// user.NetAddr() 是成员函数调用，返回值是临时对象（右值 rvalue）。
// 不能对临时对象直接取地址 &
struct sockaddr_in peer_addr = user.NetAddr();
sendto(sockfd, send_message.c_str(), send_message.size(), 0,
(struct sockaddr *)&peer_addr, sizeof(peer_addr));
}
if (message == "QUIT")
{
LOG(LogLevel::INFO) << "删除一个在线用户: " << peer.StringAddr();
DeleteUser(peer);
}
}
~Route() {}

private:
vector<InetAddr> _online_user;
Mutex _mutex;//说到底_online_user还是一个全局共享的，有些线程在删除有些在添加需要锁保护
};

UdpServer.hpp:

#pragma once

#include <iostream>
#include <string>
#include <functional>
#include <strings.h> //bzero

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "Log.hpp"
#include"InetAddr.hpp"

using namespace std;
using namespace LogMoudle;
const int defaultid = -1;
using func_t2 = std::function<void(int sockfd, const std::string&, InetAddr&)>;

class Udpserver
{
public:
Udpserver(uint16_t port, func_t2 fun)
: _port(port), _fun(fun), _sockfd(defaultid), _isrunning(false)
{
}
void Init()
{
// 1.创建socket
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
LOG(LogLevel::FATAL) << "socket fail";
exit(2);
}
LOG(LogLevel::INFO) << "socket sucess,socket: " << _sockfd;

// 2.bind
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_port = htons(_port);
local.sin_family = AF_INET;
local.sin_addr.s_addr = INADDR_ANY;
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n < 0)
{
LOG(LogLevel::FATAL) << "bind error";
exit(2);
}
LOG(LogLevel::INFO) << "bind success, sockfd : " << _sockfd;
}

void Start()
{
_isrunning=true;
//我们平时用的程序app都是不会退出的，即都是死循环
while(_isrunning)
{
char buffer[1024];
struct sockaddr_in peer;
bzero(&peer, sizeof(peer));
socklen_t len=sizeof(peer);
//收信息
ssize_t r=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
if(r>0)
{
InetAddr client(peer);
buffer[r]=0;
_fun(_sockfd,buffer,client);//buffer是const char*

}

}
}

~Udpserver() {}

private:
uint16_t _port;
bool _isrunning;
int _sockfd;
func_t2 _fun;
};

UdpServer.cc:

#include "UdpServer.hpp"
#include "Route.hpp"
#include "ThreadPool.hpp"
#include<memory>
//.udpserver 8080
using namespace ThreadPoolModule;
using task_t = function<void()>;
int main(int argc, char *argv[])
{
Enable_Console_Log_Strategy();
if (argc != 2)
{
std::cerr << "Usage: " << argv[0] << " port" << std::endl;
return 1;
}
//
uint16_t port = stoi(argv[1]);

Enable_Console_Log_Strategy();
auto tp = ThreadPool<task_t>::GetInstance();
Route r;
//最关键的地方，不同模块之间的连接
unique_ptr<Udpserver> usvr = make_unique<Udpserver>(port,[&r,&tp](int sockfd,const string &message, InetAddr&peer){
task_t t=std::bind(&Route::MessageRoute,&r,sockfd,message,peer);
tp->Enqueue(t);
//std::bind( 函数地址, 对象指针, 参数1, 参数2, 参数3 … );
//成员函数要this指针，并且Route::MessageRoute不是地址要加&和普通函数不一样
});
usvr->Init();
usvr->Start();

return 0;
}

UdpClient.cc:

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

#include"pthread.hpp"
//./udpclient ip port
using namespace ThreadModlue;
string server_ip;
int server_port;
uint16_t sockfd;
int id;
void Send()
{
while (1)
{
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(server_ip.c_str());
server.sin_port = htons(server_port);

const std::string online = "inline";
sendto(sockfd, online.c_str(), online.size(), 0, (struct sockaddr *)&server, sizeof(server));

while (true)
{
string buffer;
cout << "Please Enter#" ;
getline(cin, buffer);
// 发送
ssize_t s = sendto(sockfd, buffer.c_str(), buffer.size(), 0, (struct sockaddr *)&server, sizeof(server));
(void)s;
if (buffer == "QUIT")
{
pthread_cancel(id);
break;
}
}
}
}
void Recv()
{
while (true)
{
char buffer[1024];
struct sockaddr_in peer;
socklen_t len = sizeof(peer);
int m = recvfrom(sockfd, buffer, sizeof(buffer) – 1, 0, (struct sockaddr *)&peer, &len);
if (m > 0)
{
buffer[m] = 0;
std::cerr << buffer << std::endl; // 为什么要用cerr因为对应2号文件，即只会显示收到的信息，不会出现，tty看当前处于哪一个终端
//"Please Enter#"
}
}

}
int main(int argc, char *argv[])
{
Enable_Console_Log_Strategy();

if (argc != 3)
{
cerr << "Usage:./udpclient ip port" << endl;
return 1;
}
// 1. 创建socket
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
std::cerr << "socket error" << std::endl;
return 2;
}
server_ip = argv[1];
server_port = stoi(argv[2]);

// 2. 创建线程，为什么要创建2个线程，因为只有一个线程的话先发信息如果没有发的话就会一直卡住，不会收到信息

Thread recver(Recv);
Thread sender(Send);

recver.Start();
sender.Start();

id = recver.Id();

recver.Join();
sender.Join();

return 0;
}