【网络编程】UDP简单实现翻译软件与网络聊天室-Toy模板网

这篇具有很好参考价值的文章主要介绍了【网络编程】UDP简单实现翻译软件与网络聊天室。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、引入

在上一章【网络编程】demo版UDP网络服务器实现实现了客户端和服务端之间的数据的发送与接收，上一章我们是直接让服务端把接收到的数据打印出来。【网络编程】UDP简单实现翻译软件与网络聊天室
但是服务端并不是只接收到数据就完了，它还要处理任务。
所以我们可以在服务端设置一个回调函数：

typedef std::function<void(std::string, uint16_t, std::string)> func_t;

用来处理接收到的信息。

二、翻译软件实现

2.1 加载字典

要实现客户端发送一个单词，接收到服务端翻译的结果。
那么首先需要把英语和汉语加载进unordered_map词典中。

static std::unordered_map<std::string, std::string> Dict;

从文件中把数据加载进词典中：
【网络编程】UDP简单实现翻译软件与网络聊天室

const std::string path = "./Dict.txt";

static std::unordered_map<std::string, std::string> Dict;

// 分割字符串
static bool cutstring(std::string s, std::string *key, std::string *val)
{
    size_t pos = s.find(":");
    if(pos == std::string::npos)
    {
        return false;
    }
    *key = s.substr(0, pos);
    *val = s.substr(pos + 1);
    return true;
}

static void InitDict()
{
    std::ifstream ifs(path);
    if(!ifs.is_open())// 打开失败
    {
        std::cout << "ifstream open fail" << std::endl;
        exit(1);
    }
    std::string sline;
    std::string key, val;
    while(getline(ifs, sline))// 按行读取
    {
        if(cutstring(sline, &key, &val))
        {
            Dict.insert({key, val});
        }
        else
        {
            std::cout << "cutstring fail" << std::endl;
            exit(1);
        }
    }
    ifs.close();
    std::cout << "Dict Load Success\n";
}

2.2 处理数据并传递给用户端

接下来处理数据并且要把处理的结果反馈给用户端。

处理数据比较简单：

std::string res;
auto it = Dict.find(msg);
if(it == Dict.end())
{
    res = "not find";
}
else
{
    res = it->second;
}

接下来要把res发送给客户端，经过前面的学习sendto需要构建一个结构体表示要传给谁。
构建完结构体使用sendto的时候发现要有文件描述符，所以调用回调函数的时候要把_sockfd传递进去。

// 回调方法
void handler(int _sockfd, std::string ip, uint16_t port, std::string msg)
{
    std::string res;
    auto it = Dict.find(msg);
    if(it == Dict.end())
    {
        res = "not find";
    }
    else
    {
        res = it->second;
    }
    struct sockaddr_in si;
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(port);
    si.sin_addr.s_addr = inet_addr(ip.c_str());
    sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
}

2.3 客户端获取结果

// 获取结果
char buf[1024];
sockaddr_in tmp;
socklen_t tmplen = sizeof tmp;
size_t n = recvfrom(_sockfd, buf, sizeof buf - 1, 0, (struct sockaddr*)&tmp, &tmplen);
if(n > 0) buf[n] = 0;
std::cout << "翻译结果：" << buf << "\n";

2.4 结果

客户端：
【网络编程】UDP简单实现翻译软件与网络聊天室
服务端：

2.5 执行命名功能

现在我们可以做一个小小的改动，不让服务端做翻译了，而是处理任务，例如我们发送pwd，他要返回服务端此时的路径。
这里其他的逻辑都不用变，只需要修改回调函数即可。

介绍一个命令行解析接口：
popen

#include <stdio.h>

FILE *popen(const char *command, const char *type);

int pclose(FILE *stream);

先回忆一下之前手写的建议shell【linux】进程控制详述，我们首先要命令行分割，把每个选项都提取出来，然后fork创建子进程再程序替换。
而这个函数包含了上述的所有功能，并且还多了一个创建管道的功能。
参数介绍：

command：传递进来的字符串，比如 ls -a -l
type：以什么方式打开文件（r/w/a）
比方说现在以r只读方式打开，就直接从管道中提取出结果。

void execcommand(int _sockfd, std::string ip, uint16_t port, std::string msg)
{
    std::string res;
    FILE* fp = popen(msg.c_str(), "r");
    if(fp == nullptr) res = msg + " execute fail";
    else
    {
        char line[1024];
        while(fgets(line, sizeof line, fp))
        {
            res += line;
        }
    }
    pclose(fp);
    struct sockaddr_in si;
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(port);
    si.sin_addr.s_addr = inet_addr(ip.c_str());
    sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
}

客户端：
【网络编程】UDP简单实现翻译软件与网络聊天室
服务端：

三、网络聊天室实现

聊天室是什么远离呢？我们发送消息会进过服务端的转发，让每个在线的客户端都能看到发送的消息，这样就实现了群聊。

每个客户端发送一个online表示上线了，服务端就会把所有的数据都发送给上线的客户端。

所以首先我们先要把所有的用户管理起来。

3.1 管理用户

对于每个用户我们用IP和port来标识唯一性。

class User 
{
public:
    User(const std::string& ip, const uint16_t& port)
        : _ip(ip)
        , _port(port)
    {}
public:
    std::string _ip;
    uint16_t _port;
};

对于每个用户我们可以用哈希表来管理：

class OnlineUsers
{
public:
    void adduser(const std::string& ip, const uint16_t& port)
    {
        std::string id = ip + "@" + std::to_string(port);
        users.insert({id, User(ip, port)});
    }

    void deluser(const std::string& ip, const uint16_t& port)
    {
        std::string id = ip + "@" + std::to_string(port);
        users.erase(id);
    }

    bool isonline(const std::string& ip, const uint16_t& port)
    {
        std::string id = ip + "@" + std::to_string(port);
        return users.find(id) != users.end();
    }
private:
    std::unordered_map<std::string, User> users;
};

在回调函数中，如果收到的消息是online，就把用户添加进哈希表。如果是offline，就从哈希表中删除。

if(msg == "online") onlinemap.adduser(ip, port);
if(msg == "offline") onlinemap.deluser(ip, port);

3.2 发送消息

我们要发送消息其实就是给哈希表中所有的用户都sendto消息。在这之前要先判断是否在线：

void groupmsg(int _sockfd, std::string ip, uint16_t port, std::string msg)
{
    if(msg == "online") onlinemap.adduser(ip, port);
    if(!onlinemap.isonline(ip, port))// 不在线
    {
        struct sockaddr_in si;
        bzero(&si, sizeof si);
        si.sin_family = AF_INET;
        si.sin_port = htons(port);
        si.sin_addr.s_addr = inet_addr(ip.c_str());
        std::string res = "你还没有上线，请先上线";
        sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
        return;
    }
    // 广播消息
}

现在要广播消息，那么就在OnlineUsers类中增加一个广播消息的成员函数。
它的参数要包含_sockfd, msg，还要有是谁发送的(ip, port)。

void broadmsg(int _sockfd, const std::string& msg, std::string ip, uint16_t port)
{
    for(auto& e : users)
    {
        struct sockaddr_in si;
        bzero(&si, sizeof si);
        si.sin_family = AF_INET;
        si.sin_port = htons(e.second._port);
        si.sin_addr.s_addr = inet_addr(e.second._ip.c_str());
        std::string res = ip + "@" + std::to_string(port) + "# ";
        res += msg;
        sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
    }
}

3.3 多线程处理

因为客户端不能立即收到消息打印出来（阻塞停留在接收消息），为了解决这个问题我们可以使用多线程，一个线程专门接收消息，一个线程专门发送消息。

那么我们可以让主线程负责发送消息，子线程负责接收消息。

static void* getmsg(void *args)
{
    pthread_detach(pthread_self());
    int sockfd = *(static_cast<int*>(args));
    while(1)
    {
        char buf[1024];
        sockaddr_in tmp;
        socklen_t tmplen = sizeof tmp;
        size_t n = recvfrom(sockfd, buf, sizeof buf - 1, 0, (struct sockaddr*)&tmp, &tmplen);
        if(n > 0) buf[n] = 0;
        std::cout << buf << "\n";
    }
}

void start()
{
    pthread_create(&_get, nullptr, getmsg, (void*)&_sockfd);
    struct sockaddr_in si;
    bzero(&si, sizeof(si));
    si.sin_family = AF_INET;
    si.sin_addr.s_addr = inet_addr(_serverip.c_str());
    si.sin_port = htons(_serverport);
    std::string msg;
    while(1)
    {
        std::cout << "Please input: ";
        std::cin >> msg;
        sendto(_sockfd, msg.c_str(), msg.size(), 0, (struct sockaddr*)&si, sizeof si);
    }
}

3.4 结果

服务端：
【网络编程】UDP简单实现翻译软件与网络聊天室
客户端：

这里因为只有一个终端所以打印的比较混乱，但是能看到现象就行，如果想要优化就可以把输出的数据重定向到管道文件中，再打开一个终端读取管道，这样就可以实现发送和获取两个窗口。文章来源地址https://www.toymoban.com/news/detail-448893.html

四、源码

//UDPClient.hpp
#pragma once 
#include <iostream>
#include <string>
#include <cerrno>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <strings.h>
#include <netinet/in.h>
#include <string.h>
#include <cassert>
#include <pthread.h>

class UDPClient
{
public:
    UDPClient(const std::string& serverip, const uint16_t& port)
        : _serverip(serverip)
        , _serverport(port)
        , _sockfd(-1)
    {}

    void InitClient()
    {
        // 创建套接字
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if(_sockfd == -1)
        {
            std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;
            exit(1);
        }
    }

    static void* getmsg(void *args)
    {
        pthread_detach(pthread_self());
        int sockfd = *(static_cast<int*>(args));
        while(1)
        {
            char buf[1024];
            sockaddr_in tmp;
            socklen_t tmplen = sizeof tmp;
            size_t n = recvfrom(sockfd, buf, sizeof buf - 1, 0, (struct sockaddr*)&tmp, &tmplen);
            if(n > 0) buf[n] = 0;
            std::cout << buf << "\n";
        }
    }

    void start()
    {
        pthread_create(&_get, nullptr, getmsg, (void*)&_sockfd);
        struct sockaddr_in si;
        bzero(&si, sizeof(si));
        si.sin_family = AF_INET;
        si.sin_addr.s_addr = inet_addr(_serverip.c_str());
        si.sin_port = htons(_serverport);
        std::string msg;
        while(1)
        {
            std::cout << "Please input: ";
            std::cin >> msg;
            sendto(_sockfd, msg.c_str(), msg.size(), 0, (struct sockaddr*)&si, sizeof si);
        }
    }
private:
    uint16_t _serverport;
    std::string _serverip;
    int _sockfd;
    pthread_t _get;
};

// UDPClient.cc
#include "UDPClient.hpp"
#include <memory>

int main(int argc, char* argv[])
{
    if(argc != 3)
    {
        std::cout << "incorrect number of parameters" << std::endl;
        exit(1);
    }
    std::string ip = argv[1];
    uint16_t port = atoi(argv[2]);
    std::unique_ptr<UDPClient> ptr(new UDPClient(ip, port));
    ptr->InitClient();
    ptr->start();
    return 0;
}

// UDPServer.hpp
#pragma once 
#include <iostream>
#include <string>
#include <cerrno>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <strings.h>
#include <netinet/in.h>
#include <string.h>
#include <cassert>
#include <functional>

static const std::string defaultip = "0.0.0.0";// 默认IP

typedef std::function<void(int, std::string, uint16_t, std::string)> func_t;

class UDPServer
{
public:
    UDPServer(const func_t& func, const uint16_t& port, const std::string ip = defaultip)
        : _port(port)
        , _ip(ip)
        , _sockfd(-1)
        , _func(func)
    {}

    void InitServer()
    {
        // 创建套接字
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if(_sockfd == -1)
        {
            std::cerr << "socket error" << errno << " : " << strerror(errno) << std::endl;
            exit(1);
        }
        // 绑定IP与port
        struct sockaddr_in si;
        bzero(&si, sizeof si);
        si.sin_family = AF_INET;// 协议家族
        si.sin_port = htons(_port);// 端口号,注意大小端问题
        // si.sin_addr.s_addr = inet_addr(_ip.c_str());// ip
        si.sin_addr.s_addr = INADDR_ANY;
        // 绑定
        int n = bind(_sockfd, (struct sockaddr*)&si, sizeof si);
        assert(n != -1);
    }

    void start()
    {
        char buf[1024];
        while(1)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof peer;
            ssize_t s = recvfrom(_sockfd, buf, sizeof(buf) - 1, 0, (struct sockaddr*)&peer, &len);
            if(s > 0)
            {
                buf[s] = 0;// 结尾
                std::string cip = inet_ntoa(peer.sin_addr);
                uint16_t cport = ntohs(peer.sin_port);
                std::string msg = buf;
                //std::cout << "[" << cip << "@" << cport << "]# " << msg << std::endl;
                _func(_sockfd, cip, cport, msg);
            }
        }
    }
private:
    uint16_t _port;
    std::string _ip;
    int _sockfd;
    func_t _func;
};


// UDPServer.cc
#include "UDPServer.hpp"
#include "users.hpp"
#include <memory>
#include <cstdio>
#include <unordered_map>
#include <fstream>

const std::string path = "./Dict.txt";

static std::unordered_map<std::string, std::string> Dict;

// 分割字符串
static bool cutstring(std::string s, std::string *key, std::string *val)
{
    size_t pos = s.find(":");
    if(pos == std::string::npos)
    {
        return false;
    }
    *key = s.substr(0, pos);
    *val = s.substr(pos + 1);
    return true;
}

static void InitDict()
{
    std::ifstream ifs(path);
    if(!ifs.is_open())// 打开失败
    {
        std::cout << "ifstream open fail" << std::endl;
        exit(1);
    }
    std::string sline;
    std::string key, val;
    while(getline(ifs, sline))// 按行读取
    {
        if(cutstring(sline, &key, &val))
        {
            Dict.insert({key, val});
        }
        else
        {
            std::cout << "cutstring fail" << std::endl;
            exit(1);
        }
    }
    ifs.close();
    std::cout << "Dict Load Success\n";
}

// 回调方法
void handler(int _sockfd, std::string ip, uint16_t port, std::string msg)
{
    std::string res;
    auto it = Dict.find(msg);
    if(it == Dict.end())
    {
        res = "not find";
    }
    else
    {
        res = it->second;
    }
    struct sockaddr_in si;
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(port);
    si.sin_addr.s_addr = inet_addr(ip.c_str());
    sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
}

void execcommand(int _sockfd, std::string ip, uint16_t port, std::string msg)
{
    std::string res;
    FILE* fp = popen(msg.c_str(), "r");
    if(fp == nullptr) res = msg + " execute fail";
    else
    {
        char line[1024];
        while(fgets(line, sizeof line, fp))
        {
            res += line;
        }
    }
    pclose(fp);
    struct sockaddr_in si;
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(port);
    si.sin_addr.s_addr = inet_addr(ip.c_str());
    sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
}

OnlineUsers onlinemap;

void groupmsg(int _sockfd, std::string ip, uint16_t port, std::string msg)
{
    if(msg == "online") onlinemap.adduser(ip, port);
    if(msg == "offline") onlinemap.deluser(ip, port);
    if(!onlinemap.isonline(ip, port))// 不在线
    {
        struct sockaddr_in si;
        bzero(&si, sizeof si);
        si.sin_family = AF_INET;
        si.sin_port = htons(port);
        si.sin_addr.s_addr = inet_addr(ip.c_str());
        std::string res = "你还没有上线，请先上线";
        sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
        return;
    }
    // 广播消息
    onlinemap.broadmsg(_sockfd, msg, ip, port);
}


int main(int argc, char* argv[])
{
    if(argc != 2)
    {
        std::cout << "incorrect number of parameters" << std::endl;
        exit(1);
    }
    //InitDict();
    uint16_t port = atoi(argv[1]);
    std::unique_ptr<UDPServer> ptr(new UDPServer(groupmsg, port));
    ptr->InitServer();
    ptr->start();
    return 0;
}

// users.hpp
#pragma once

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

class User 
{
public:
    User(const std::string& ip, const uint16_t& port)
        : _ip(ip)
        , _port(port)
    {}
public:
    std::string _ip;
    uint16_t _port;
};

class OnlineUsers
{
public:
    void adduser(const std::string& ip, const uint16_t& port)
    {
        std::string id = ip + "@" + std::to_string(port);
        users.insert({id, User(ip, port)});
    }

    void deluser(const std::string& ip, const uint16_t& port)
    {
        std::string id = ip + "@" + std::to_string(port);
        users.erase(id);
    }

    bool isonline(const std::string& ip, const uint16_t& port)
    {
        std::string id = ip + "@" + std::to_string(port);
        return users.find(id) != users.end();
    }

    void broadmsg(int _sockfd, const std::string& msg, std::string ip, uint16_t port)
    {
        for(auto& e : users)
        {
            struct sockaddr_in si;
            bzero(&si, sizeof si);
            si.sin_family = AF_INET;
            si.sin_port = htons(e.second._port);
            si.sin_addr.s_addr = inet_addr(e.second._ip.c_str());
            std::string res = ip + "@" + std::to_string(port) + "# ";
            res += msg;
            sendto(_sockfd, res.c_str(), res.size(), 0, (struct sockaddr*)&si, sizeof si);
        }
    }
private:
    std::unordered_map<std::string, User> users;
};