💁♂️个人主页 :进击的荆棘
👇作者其它专栏:
| 🧮数据结构与算法 | 《数据结构与算法》 |
| 算法 | 《算法》 |
| C++ | 《C++》 |
| 🐧Linux | 《Linux系统》《Linux网络》 |
| MySQL | 《MySQL》 |
目录
1.V1 Echo Server
2.V2 DictServer
3.V3 简单聊天室
4.附录
1.V1 Echo Server
简单的回显服务器和客户端代码
UdpServer.hpp
#pragma once
#include <sys/socket.h>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include "Log.hpp"
using namespace LogModule;
using func_t=std::function<std::string(const std::string&)>;
const int defaultfd = -1;
class UdpServer
{
public:
// UdpServer(uint16_t port, const std::string ip)
UdpServer(uint16_t port,func_t func)
: _sockfd(defaultfd), _port(port), _isrunnig(false),_func(func)
{
}
void Init()
{
// 打开网络文件
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
Log(Level::FATAL) << "socket error";
exit(1);
}
Log(Level::DEBUG) << "socket success";
// 将ip和端口号绑定到一起
// 填充sockaddr_in结构体
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
// 端口号
local.sin_port = htons(_port);
// ip地址转换 本地->网络序列 从“点分十进制”-> uint32_t
// local.sin_addr.s_addr = inet_addr(_ip.c_str());
local.sin_addr.s_addr=INADDR_ANY;
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n == -1)
{
Log(Level::FATAL) << "bind error";
exit(2);
}
Log(Level::INFO) << "bind success,sockfd:" << _sockfd;
}
void Start()
{
_isrunnig = true;
while (_isrunnig)
{
char buffer[1024];
struct sockaddr_in remo;
socklen_t len = sizeof(remo);
int n = recvfrom(_sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&remo, &len);
if (n > 0)
{
buffer[n] = 0;
int remo_port=ntohs(remo.sin_port);
std::string remo_ip=inet_ntoa(remo.sin_addr);
Log(Level::DEBUG)<<"["<<remo_ip<<":"<<remo_port<<"]#"<<buffer;
// std::string message = "server echo:";
// message += buffer;
std::string ret=_func(buffer);
sendto(_sockfd, ret.c_str(), ret.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
}
}
}
~UdpServer() {}
private:
int _sockfd;
uint16_t _port;
// std::string _ip;
bool _isrunnig;
func_t _func;
};
UdpClient.cc
#include <iostream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <cstring>
#include <netinet/in.h>
// ./udpclient ip port
int main(const int argc, const char *argv[])
{
if (argc != 3)
{
std::cerr << "Usage: " <<argv[0]<<"ip port"<<std::endl;
exit(1);
}
std::string server_ip = argv[1];
int server_port = std::stoi(argv[2]);
// 创建套接字
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
// 将ip和端口号绑定
// 但client不需要显示bind,因为只要确保能唯一标识一个进程就行
// OS知道ip,首次使用bind时,会动态分配端口号
struct sockaddr_in remo;
memset(&remo, 0, sizeof(remo));
remo.sin_family = AF_INET;
remo.sin_addr.s_addr = inet_addr(server_ip.c_str());
remo.sin_port = htons(server_port);
while (true)
{
std::cout << "Please enter:";
std::string input;
getline(std::cin, input);
int n = sendto(sockfd, input.c_str(), input.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
(void)n;
char buffer[1024];
socklen_t len = sizeof(remo);
int m = recvfrom(sockfd, buffer, sizeof(buffer), 0, (struct sockaddr *)&remo, &len);
if (m > 0)
{
buffer[m] = 0;
std::cout << buffer << std::endl;
}
}
return 0;
}
注:
client端不用显示bind
2.V2 DictServer
实现一个简单的英译汉网络字典
dictionary.txt
banana: 香蕉
orange: 橙子
grape: 葡萄
watermelon: 西瓜
strawberry: 草莓
peach: 桃子
pear: 梨
lemon: 柠檬
mango: 芒果
cherry: 樱桃
car: 汽车
bicycle: 自行车
train: 火车
hello:
: 你好
airplane: 飞机
book: 书
computer: 电脑
phone: 电话
water: 水
fire: 火
mountain: 山
Dict.hpp
#pragma once
#include <string>
#include <fstream>
#include <unordered_map>
#include "Addr.hpp"
#include "Log.hpp"
using namespace LogModule;
const std::string defaultdict="./dictionary.txt";
const std::string spe=": ";
class Dict{
public:
Dict(const std::string &path=defaultdict):_dict_path(path)
{}
void Load(){
std::ifstream in(_dict_path);
if(!in.is_open()){
Log(Level::DEBUG)<<"打开字典错误";
exit(1);
}
std::string line;
while(std::getline(in,line)){
int pos=line.find(spe);
if(pos==std::string::npos){
Log(Level::WARNING)<<"不符合规格,"<<line;
continue;
}
std::string english=line.substr(0,pos);
std::string chinese=line.substr(pos+spe.size());
//若中文或英文为空也不符合规格
if(english.empty()||chinese.empty()){
Log(Level::WARNING)<<"不符合规格"<<line;
continue;
}
_dict.insert(std::make_pair(english,chinese));
Log(Level::INFO)<<"加载"<<line<<" 成功";
}
in.close();
}
std::string Translate(const std::string &word,Addr &client){
auto iter=_dict.find(word);
if(iter==_dict.end()){
Log(Level::INFO)<<"找不到:"<<word;
return "NONE";
}
Log(Level::INFO)<<"开始翻译:["<<client.Ip()<<":"<<client.Port()<<"]"<<word;
return iter->second;
}
~Dict(){}
private:
std::string _dict_path;
std::unordered_map<std::string,std::string> _dict;
};
UdpServer.hpp
#pragma once
#include <sys/socket.h>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include "Log.hpp"
#include "Addr.hpp"
using namespace LogModule;
using func_t=std::function<std::string(const std::string&,Addr &)>;
const int defaultfd = -1;
class UdpServer
{
public:
// UdpServer(uint16_t port, const std::string ip)
UdpServer(uint16_t port,func_t func)
: _sockfd(defaultfd), _port(port), _isrunnig(false),_func(func)
{
}
void Init()
{
// 打开网络文件
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
Log(Level::FATAL) << "socket error";
exit(1);
}
Log(Level::DEBUG) << "socket success";
// 将ip和端口号绑定到一起
// 填充sockaddr_in结构体
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
// 端口号
local.sin_port = htons(_port);
// ip地址转换 本地->网络序列 从“点分十进制”-> uint32_t
// local.sin_addr.s_addr = inet_addr(_ip.c_str());
local.sin_addr.s_addr=INADDR_ANY;
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n == -1)
{
Log(Level::FATAL) << "bind error";
exit(2);
}
Log(Level::INFO) << "bind success,sockfd:" << _sockfd;
}
void Start()
{
_isrunnig = true;
while (_isrunnig)
{
char buffer[1024]={0};
struct sockaddr_in remo;
socklen_t len = sizeof(remo);
int n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr *)&remo, &len);
if (n > 0)
{
buffer[n] = 0;
Addr peer(remo);
Log(Level::DEBUG)<<"["<<peer.Ip()<<":"<<peer.Port()<<"]#"<<buffer;
// std::string message = "server echo:";
// message += buffer;
std::string ret=_func(buffer,peer);
sendto(_sockfd, ret.c_str(), ret.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
}
}
}
~UdpServer() {}
private:
int _sockfd;
uint16_t _port;
// std::string _ip;
bool _isrunnig;
func_t _func;
};
UdpServer.cc
#include <iostream>
#include <memory>
#include "UdpServer.hpp"
#include "Dict.hpp"
std::string defaulthandler(const std::string &message){
std::string ret="hello ";
ret+=message;
return ret;
}
// ./udpserver port
int main(const int argc, const char *argv[])
{
if (argc != 2)
{
std::cerr << "Usage: " << argv[0] << " port" << std::endl;
exit(1);
}
// std::string ip = argv[1];
int port = std::stoi(argv[1]);
Dict r;
r.Load();
std::unique_ptr<UdpServer> up = std::make_unique<UdpServer>(port,[&r](const std::string &word,Addr &client)->std::string{
return r.Translate(word,client);
});
up->Init();
up->Start();
return 0;
}
UdpClient.cc
#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <cstring>
#include <netinet/in.h>
// ./udpclient ip port
int main(const int argc, const char *argv[])
{
if (argc != 3)
{
std::cerr << "Usage: " <<argv[0]<<"ip port"<<std::endl;
exit(1);
}
std::string server_ip = argv[1];
int server_port = std::stoi(argv[2]);
// 创建套接字
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
// 将ip和端口号绑定
// 但client不需要显示bind,因为只要确保能唯一标识一个进程就行
// OS知道ip,首次使用bind时,会动态分配端口号
struct sockaddr_in remo;
memset(&remo, 0, sizeof(remo));
remo.sin_family = AF_INET;
remo.sin_addr.s_addr = inet_addr(server_ip.c_str());
remo.sin_port = htons(server_port);
while (true)
{
std::string input;
std::cout << "Please enter#";
std::getline(std::cin, input);
//排除输入空行的情况
if(input.empty()) continue;
int n = sendto(sockfd, input.c_str(), input.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
(void)n;
char buffer[1024]={0};
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::cout << buffer << std::endl;
}
}
return 0;
}
Addr.hpp
#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
class Addr
{
public:
Addr(struct sockaddr_in addr) : _addr(addr)
{
_ip=inet_ntoa(_addr.sin_addr);
_port=ntohs(addr.sin_port);
}
std::string Ip() { return _ip; }
uint16_t Port() { return _port; }
~Addr() {}
private:
struct sockaddr_in _addr;
std::string _ip;
uint16_t _port;
};
3.V3 简单聊天室
Router.hpp
#pragma once
#include <vector>
#include "ThreadPool.hpp"
#include "Addr.hpp"
using namespace ThreadPoolModule;
class Router
{
private:
bool IsExist(Addr &peer)
{
for (auto user : _online_user)
{
if (peer == user)
{
return true;
}
}
return false;
}
void AddUser(Addr &peer)
{
// 只有不存在时才会添加
_online_user.push_back(peer);
Log(Level::INFO) << "添加用户成功," << peer.StringAddr();
}
void DeleteUser(Addr &peer)
{
// 只有用户存在时,才能删除
for (auto iter = _online_user.begin(); iter != _online_user.end(); iter++)
{
if (*iter == peer)
{
_online_user.erase(iter);
break;
}
}
Log(Level::INFO)<<"删除用户成功,"<<peer.StringAddr();
}
public:
void Message(int sockfd, const std::string &message,Addr &peer)
{
if (!IsExist(peer))
{
AddUser(peer);
}
// ip:port# message
std::string ret = "["+peer.StringAddr() + "] " + message;
//转发给所有用户
for(auto user:_online_user)
sendto(sockfd, ret.c_str(), ret.size(), 0, (const struct sockaddr *)&(user.NetAddr()), sizeof(user.NetAddr()));
if (message == "QUIT")
{
DeleteUser(peer);
}
}
private:
std::vector<Addr> _online_user;
};
UdpServer.hpp
#pragma once
#include <sys/socket.h>
#include <string>
#include <strings.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include "Log.hpp"
#include "Addr.hpp"
using namespace LogModule;
using func_t=std::function<void(int,const std::string&,Addr &)>;
const int defaultfd = -1;
class UdpServer
{
public:
// UdpServer(uint16_t port, const std::string ip)
UdpServer(uint16_t port,func_t func)
: _sockfd(defaultfd), _port(port), _isrunnig(false),_func(func)
{
}
void Init()
{
// 打开网络文件
_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (_sockfd == -1)
{
Log(Level::FATAL) << "socket error";
exit(1);
}
Log(Level::DEBUG) << "socket success";
// 将ip和端口号绑定到一起
// 填充sockaddr_in结构体
struct sockaddr_in local;
bzero(&local, sizeof(local));
local.sin_family = AF_INET;
// 端口号
local.sin_port = htons(_port);
// ip地址转换 本地->网络序列 从“点分十进制”-> uint32_t
// local.sin_addr.s_addr = inet_addr(_ip.c_str());
local.sin_addr.s_addr=INADDR_ANY;
int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
if (n == -1)
{
Log(Level::FATAL) << "bind error";
exit(2);
}
Log(Level::INFO) << "bind success,sockfd:" << _sockfd;
}
void Start()
{
_isrunnig = true;
while (_isrunnig)
{
char buffer[1024]={0};
struct sockaddr_in remo;
socklen_t len = sizeof(remo);
int n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr *)&remo, &len);
if (n > 0)
{
buffer[n] = 0;
Addr peer(remo);
Log(Level::DEBUG)<<"["<<peer.Ip()<<":"<<peer.Port()<<"]#"<<buffer;
// std::string message = "server echo:";
// message += buffer;
_func(_sockfd,buffer,peer);
// sendto(_sockfd, ret.c_str(), ret.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
}
}
}
~UdpServer() {}
private:
int _sockfd;
uint16_t _port;
// std::string _ip;
bool _isrunnig;
func_t _func;
};
Addr.hpp
#pragma once
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string>
class Addr
{
public:
Addr(struct sockaddr_in addr) : _addr(addr)
{
//这种转化方式不安全,因为这个ip的地址被存在静态区,若使用多个转化,则地址会全一样
// _ip=inet_ntoa(_addr.sin_addr);
char ipbuffer[64];
inet_ntop(AF_INET,&_addr.sin_addr,ipbuffer,sizeof(ipbuffer));
_port=ntohs(addr.sin_port);
}
//主机转网络
Addr(std::string ip,uint16_t port):_ip(ip),_port(port)
{
memset(&_addr,0,sizeof(_addr));
_addr.sin_family=AF_INET;
_addr.sin_port=htons(_port);
inet_pton(AF_INET,_ip.c_str(),&_addr.sin_addr);
}
std::string Ip() { return _ip; }
uint16_t Port() { return _port; }
const struct sockaddr_in& NetAddr(){
return _addr;
}
const std::string StringAddr(){
return _ip+":"+std::to_string(_port);
}
bool operator==(const Addr& peer){
return peer._ip==_ip&&peer._port==_port;
}
~Addr() {}
private:
struct sockaddr_in _addr;
std::string _ip;
uint16_t _port;
};
●重载==,方便对是否是同一个用户进行比较
UdpServer.cc
#include <iostream>
#include <memory>
#include "UdpServer.hpp"
#include "Router.hpp"
using task_t=std::function<void()>;
std::string defaulthandler(const std::string &message){
std::string ret="hello ";
ret+=message;
return ret;
}
// ./udpserver port
int main(const int argc, const char *argv[])
{
if (argc != 2)
{
std::cerr << "Usage: " << argv[0] << " port" << std::endl;
exit(1);
}
// std::string ip = argv[1];
int port = std::stoi(argv[1]);
//设置路由
Router r;
auto tp=ThreadPool<task_t>::GetInstance();
std::unique_ptr<UdpServer> up=std::make_unique<UdpServer>(port,[&r,&tp](int sockfd,const std::string &message,Addr &peer){
task_t t=std::bind(&Router::Message,&r,sockfd,message,peer);
tp->EnQueue(t);
});
// std::unique_ptr<UdpServer> up = std::make_unique<UdpServer>(port,[&r](int sockfd,const std::string& message,Addr &peer){
// r.Message(sockfd,message,peer);
// });
up->Init();
up->Start();
return 0;
}
UdpClient.cc
#include <iostream>
#include <string>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <cstring>
#include <netinet/in.h>
#include "Thread.hpp"
using namespace ThreadModule;
int sockfd = -1;
std::string server_ip;
uint16_t server_port = 0;
pthread_t id;
void Recv()
{
while (true)
{
char buffer[1024] = {0};
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;
}
}
}
void Sendto()
{
struct sockaddr_in remo;
memset(&remo, 0, sizeof(remo));
remo.sin_family = AF_INET;
remo.sin_addr.s_addr = inet_addr(server_ip.c_str());
remo.sin_port = htons(server_port);
// 上线自动发送online
const std::string defaultmessage = "online";
sendto(sockfd, defaultmessage.c_str(), defaultmessage.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
while (true)
{
std::string input;
std::cout << "Please enter#";
std::getline(std::cin, input);
// 排除输入空行的情况
if (input.empty())
continue;
int n = sendto(sockfd, input.c_str(), input.size(), 0, (struct sockaddr *)&remo, sizeof(remo));
(void)n;
if (input == "QUIT")
{
pthread_cancel(id);
break;
}
}
}
// ./udpclient ip port
int main(const int argc, const char *argv[])
{
if (argc != 3)
{
std::cerr << "Usage: " << argv[0] << "ip port" << std::endl;
exit(1);
}
server_ip = argv[1];
server_port = std::stoi(argv[2]);
// 创建套接字
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
// 将ip和端口号绑定
// 但client不需要显示bind,因为只要确保能唯一标识一个进程就行
// OS知道ip,首次使用bind时,会动态分配端口号
Thread recv(Recv);
Thread sendto(Sendto);
recv.Start();
sendto.Start();
id = recv.GetId();
recv.Join();
sendto.Join();
return 0;
}
●UDP协议支持全双工,一个sockfd,既可以读取,有可以写入,对于客户端和服务端同样如此
●多线程客户端,同时读取和写入

4.附录
4.1地址转换函数
以下为IPv4的socket网络编程,sockaddr_in中的成员struct in_addr sin_addr表示32位的IP地址
但是我们通常用点分十进制的字符串表示IP地址,以下函数可以在字符串表示和in_addr表示之间转换
字符串转in_addr的函数:

in_addr转字符串的函数

其中inet_pton和inet_ntop不仅可以转换IPv4的in_addr,还可以转换IPv6的in6_addr,因此函数接口是void* addrptr
代码示例:

4.2关于inet_ntoa
inet_ntoa函数返回了一个char *,很显然是这个函数自己在内部为我们申请了一块内存来保存ip的结果。那么是否需要调用者手动释放呢?

man手册上说,inet_ntoa函数,是把这个结果放在了静态存储区,这个时候不需要我们手动释放
那么,若我们多次调用这个函数,会有什么结果?

运行结果如下:

因为inet_ntoa把结果放在自己内部的一个静态存储区,这样第二次调用的时候的结果会覆盖掉上一次的结果:
●若有多个线程调用inet_ntoa,是否会出现异常情况?
●在APUE中,明确提出inet_ntoa不是线程安全的函数
●但是在centos7上测试,并没有出现问题,可能是内部的实现加了互斥锁
●多线程环境下,推荐使用inet_ntop,这个函数由调用者提供一个缓冲区保存结果,可以规避线程安全问题
多线程调用inet_ntoa:
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <pthread.h>
void *Func1(void *p)
{
struct sockaddr_in *addr = (struct sockaddr_in *)p;
while (1)
{
char *ptr = inet_ntoa(addr->sin_addr);
printf("addr1: %s\n", ptr);
}
return NULL;
}
void *Func2(void *p)
{
struct sockaddr_in *addr = (struct sockaddr_in *)p;
while (1)
{
char *ptr = inet_ntoa(addr->sin_addr);
printf("addr2: %s\n", ptr);
}
return NULL;
}
int main()
{
pthread_t tid1 = 0;
struct sockaddr_in addr1;
struct sockaddr_in addr2;
addr1.sin_addr.s_addr = 0;
addr2.sin_addr.s_addr = 0xffffffff;
pthread_create(&tid1, NULL, Func1, &addr1);
pthread_t tid2 = 0;
pthread_create(&tid2, NULL, Func2, &addr2);
pthread_join(tid1, NULL);
pthread_join(tid2, NULL);
return 0;
}
4.3remove_if样例
#include <iostream>
#include <list>
#include <memory>
#include <algorithm>
int main()
{
std::list<std::shared_ptr<int>> ls;
ls.push_back(std::make_shared<int>(1));
ls.push_back(std::make_shared<int>(2));
ls.push_back(std::make_shared<int>(3));
ls.push_back(std::make_shared<int>(4));
ls.push_back(std::make_shared<int>(4));
ls.push_back(std::make_shared<int>(4));
ls.push_back(std::make_shared<int>(5));
ls.push_back(std::make_shared<int>(6));
for (auto &v : ls)
{
std::cout << *v << std::endl;
}
std::cout << "aa: " << ls.size() << std::endl;
std::cout << "\n";
// int a = 3;
int a = 4;
auto pos = remove_if(ls.begin(), ls.end(), [&a](const std::shared_ptr<int> &elem) -> bool{
return a == *elem;
});
ls.erase(pos, ls.end());
std::cout << "aa: " << ls.size() << std::endl;
for (auto &v : ls)
{
std::cout << *v << std::endl;
}
return 0;
}
// remove_if()并不会实际移除序列[start, end)中的元素; 如果在⼀个容器上应⽤remove_if(),
//容器的⻓度并不会改变, 所有的元素都还在容器⾥⾯(但是逻辑上已经⽆法访问).
//remove_if() 将所有应该移除的元素都移动到容器尾部并返回⼀个分界的迭代器.为了实际移除元素,
// 你必须对容器⾃⾏调⽤erase() 以擦除需要移除的元素
转载自 CSDN-专业IT技术社区
原文链接:https://blog.csdn.net/2501_93697341/article/details/170817473




