UDP通信的一些小应用

最新推荐文章于 2024-06-13 17:20:22 发布
最新推荐文章于 2024-06-13 17:20:22 发布
阅读量92 收藏
点赞数
分类专栏： Linux 文章标签： udp 网络协议 网络 linux c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JDSZGLLL/article/details/130529639
版权

在线翻译

udpServer.hpp

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


using namespace std;

namespace szg
{
    class udpServer
    {
    public:
        typedef function<void(int, sockaddr_in, string)> func;


        udpServer(func f, const uint16_t port, const uint32_t ip = INADDR_ANY)
        :_port(port), _ip(ip),_func(f)
        {}

        void udpInit()
        {
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if(-1 == _sockfd)
            {
                cerr << "server  socket  failed" << endl;
                exit(1);
            }
            sockaddr_in server_in;
            bzero(&server_in, sizeof(server_in));
            server_in.sin_family = AF_INET;
            server_in.sin_port = htons(_port);
            server_in.sin_addr.s_addr = htonl(_ip);
            int rb = bind(_sockfd, (sockaddr*)&server_in, sizeof(server_in));
            if(rb == -1)
            {
                cerr << "server bind failed" << endl;
                exit(1);
            }
        }

        void run()
        {
            sockaddr_in target_addr;
            bzero(&target_addr, sizeof(target_addr));
            socklen_t len = sizeof(target_addr);
            char rcbuf[1024];
            string massege;
            cout << "server start" << endl;
            while(true)
            {
                ssize_t n = recvfrom(_sockfd, rcbuf, sizeof(rcbuf) - 1, 0, (sockaddr*)&target_addr, &len);
                if(n > 0)
                {
                    rcbuf[n] = 0;
                    cout << inet_ntoa(target_addr.sin_addr) << "{"  << target_addr.sin_port << "}" << rcbuf << endl;
                    massege = rcbuf;
                    _func(_sockfd, target_addr, massege);
                }

            }
        }


        ~udpServer()
        {}
    private:
        int _sockfd;
        uint16_t _port;
        uint32_t _ip;
        func _func;
    };
}

udpServer.cc

#include"udpServer.hpp"
#include<memory>
#include<map>
#include<fstream>

map<string, string> dict;

void loadDict()
{
    ifstream in("./dict.txt", ios::binary);
    string massage;
    while(in >> massage)
    {
        size_t n = massage.find(":");
        if(n == string::npos)
            continue;
        dict[string(massage.begin(), massage.begin() + n)] = massage.substr(n + 1);
    }
    in.close();
}

void translate(int sockfd, sockaddr_in target, string s)
{
    string respone;
    target.sin_family = AF_INET;
    if(dict.find(s) == dict.end())
    {
        respone = "unknow";
    }
    else
    {
        respone = dict[s];
    }
    ssize_t n = sendto(sockfd, respone.c_str(), respone.size(), 0, (sockaddr*)&target, sizeof(target));
}

int main(int args, char* argv[])
{
    if(args != 2)
    {
        cerr << "please input port" << endl << endl;
        exit(1);
    }
    loadDict();
    cout << " load sucess" << endl;
    unique_ptr<szg::udpServer> server(new szg::udpServer(translate, (uint16_t)atoi(argv[1])));
    server->udpInit();
    server->run();
    return 0;
}

udpClient.hpp

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

using namespace std;

namespace szg
{
    class udpClient
    {
    public:
        udpClient(const uint32_t ip, const uint16_t port)
        :_ip(ip), _port(port) 
        {}

        void Init()
        {
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if(-1 == _sockfd)
            {
                cerr << "client  socket  failed" << endl;
                exit(1);
            }
            cout << "init success" << endl;
        }

        void Run()
        {
            sockaddr_in target;
            target.sin_family = AF_INET;
            target.sin_addr.s_addr = htonl(_ip);
            target.sin_port = htons(_port);
            char rcbuf[1024];
            socklen_t len = sizeof(target);
            while(true)
            {
                string massage;
                printf("Enter#");
                fflush(stdout);
                getline(cin, massage);
                if(massage.size() == 0)
                {
                    continue;
                }
                ssize_t n = sendto(_sockfd, massage.c_str(), massage.size(), 0, (sockaddr*)&target, sizeof(target));
                if(n == -1)
                {
                    cerr << "client send failed" << endl;
                }
                n = recvfrom(_sockfd, rcbuf, sizeof(rcbuf) - 1, 0, (sockaddr*)&target, &len);
                if(n > 0)
                {
                    rcbuf[n] = 0;
                    cout << rcbuf << endl;
                }

            }
        }


        ~udpClient()
        {}

    private:
        uint32_t _ip;
        uint16_t _port;
        int _sockfd;
    };


}

udpClient.cc

#include"udpClient.hpp"
#include<memory>

int main(int args, char* argv[])
{
    if(args != 3)
    {
        cerr << "please input #  ip  and  port " << endl;
        exit(1);
    }
    uint32_t ip = inet_addr(argv[1]);
    ip = ntohl(ip);
    unique_ptr<szg::udpClient> client(new szg::udpClient(ip, (uint16_t)atoi(argv[2])));
    client->Init();
    client->Run();
    return 0;
}

minishall

想要完成一个命令行解释器，就只需要将translate函数改为miniShall就可以了。

void miniShall(int sockfd, sockaddr_in target, string s)
{
    char buf[1024] = {0};
    target.sin_family = AF_INET;
    string respone;
    FILE* pfd = popen(s.c_str(), "r");
    if(pfd == nullptr)
    {
        cout << "cmd cannot find" << endl;
    }
    while(fgets(buf, sizeof(buf), pfd))
    {
        respone += buf;
    }
    fclose(pfd);
    ssize_t n = sendto(sockfd, respone.c_str(), respone.size(), 0, (sockaddr*)&target, sizeof(target));
    buf[0] = 0;
}

简单聊天室

udpServer.hpp

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


using namespace std;

namespace szg
{
    class udpServer
    {
    public:
        typedef function<void(int, sockaddr_in, string)> func;


        udpServer(func f, const uint16_t port, const uint32_t ip = INADDR_ANY)
        :_port(port), _ip(ip),_func(f)
        {}

        void udpInit()
        {
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if(-1 == _sockfd)
            {
                cerr << "server  socket  failed" << endl;
                exit(1);
            }
            sockaddr_in server_in;
            bzero(&server_in, sizeof(server_in));
            server_in.sin_family = AF_INET;
            server_in.sin_port = htons(_port);
            server_in.sin_addr.s_addr = htonl(_ip);
            int rb = bind(_sockfd, (sockaddr*)&server_in, sizeof(server_in));
            if(rb == -1)
            {
                cerr << "server bind failed" << endl;
                exit(1);
            }
        }

        void run()
        {
            sockaddr_in target_addr;
            bzero(&target_addr, sizeof(target_addr));
            socklen_t len = sizeof(target_addr);
            char rcbuf[1024];
            string massege;
            cout << "server start" << endl;
            while(true)
            {
                ssize_t n = recvfrom(_sockfd, rcbuf, sizeof(rcbuf) - 1, 0, (sockaddr*)&target_addr, &len);
                if(n > 0)
                {
                    rcbuf[n] = 0;
                    cout << inet_ntoa(target_addr.sin_addr) << "{"  << target_addr.sin_port << "}" << rcbuf << endl;
                    massege = rcbuf;
                    _func(_sockfd, target_addr, massege);
                }

            }
        }


        ~udpServer()
        {}
    private:
        int _sockfd;
        uint16_t _port;
        uint32_t _ip;
        func _func;
    };
}

udpClient.hpp

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

using namespace std;

namespace szg
{
    class udpClient
    {
    public:
        udpClient(const uint32_t ip, const uint16_t port)
        :_ip(ip), _port(port) 
        {}

        void Init()
        {
            _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
            if(-1 == _sockfd)
            {
                cerr << "client  socket  failed" << endl;
                exit(1);
            }
            cout << "init success" << endl;
        }

        static void* ReadRoute(void* u)
        {
            pthread_detach(pthread_self());
            udpClient* uc = static_cast<udpClient*>(u);
            char rcbuf[1024];
            sockaddr_in peer;
            bzero(&peer, sizeof(peer));
            socklen_t len = sizeof(peer);
            while(true)
            {
                ssize_t n = recvfrom(uc->_sockfd, rcbuf, sizeof(rcbuf) - 1, 0, (sockaddr*)&peer, &len);
                if(n > 0)
                {
                    rcbuf[n] = 0;
                    cout << rcbuf << endl;
                }
            }
        }

        void Run()
        {
            sockaddr_in target;
            target.sin_family = AF_INET;
            target.sin_addr.s_addr = htonl(_ip);
            target.sin_port = htons(_port);
            pthread_t pt;
            int ret = pthread_create(&pt, nullptr, ReadRoute, (void*)this);
            while(true)
            {
                string massage;
                fprintf(stderr, "Enter#");
                fflush(stderr);
                getline(cin, massage);
                if(massage.size() == 0)
                {
                    continue;
                }
                ssize_t n = sendto(_sockfd, massage.c_str(), massage.size(), 0, (sockaddr*)&target, sizeof(target));
                if(n == -1)
                {
                    cerr << "client send failed" << endl;
                }
            }
        }


        ~udpClient()
        {}

    private:
        uint32_t _ip;
        uint16_t _port;
        int _sockfd;
    };


}

OnlineUsers.hpp

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

using namespace std;


namespace szg
{
    class OnlineUsers
    {
    public:

        void adduser(sockaddr_in peer)
        {
            string name = inet_ntoa(peer.sin_addr);
            name += "#" + to_string(ntohs(peer.sin_port));
            if(users.count(name) == 0)
            {
                users[name] = peer;
                cout << name << " : online" << endl; 

            }
        }

        void offline(sockaddr_in peer)
        {
            string name = inet_ntoa(peer.sin_addr);
            name += "#" + to_string(ntohs(peer.sin_port));
            if(users.count(name) > 0)
            {
                users.erase(name);
            }
        }

        bool is_online(sockaddr_in peer)
        {
            string name = inet_ntoa(peer.sin_addr);
            name += "#" + to_string(ntohs(peer.sin_port));
            if(users.count(name) > 0)
            {
                return true;
            }
            return false;
        }

        void BroadCastMassage(int sockfd, string massage)
        {
            socklen_t len = sizeof(sockaddr_in);
            for(auto& e : users)
            {
                sendto(sockfd, massage.c_str(), massage.size(), 0, (sockaddr*)&e.second, len);
            }
        }


    private:
        unordered_map<string, sockaddr_in> users;
    };


}

udpServer.cc

#include"udpServer.hpp"
#include"OnlineUser.hpp"
#include<memory>
#include<map>
#include<fstream>
#include<stdio.h>

map<string, string> dict;
szg::OnlineUsers users;

void loadDict()
{
    ifstream in("./dict.txt", ios::binary);
    string massage;
    while(in >> massage)
    {
        size_t n = massage.find(":");
        if(n == string::npos)
            continue;
        dict[string(massage.begin(), massage.begin() + n)] = massage.substr(n + 1);
    }
    in.close();
}


void translate(int sockfd, sockaddr_in target, string s)
{
    string respone;
    target.sin_family = AF_INET;
    if(dict.find(s) == dict.end())
    {
        respone = "unknow";
    }
    else
    {
        respone = dict[s];
    }
    ssize_t n = sendto(sockfd, respone.c_str(), respone.size(), 0, (sockaddr*)&target, sizeof(target));
}


void miniShall(int sockfd, sockaddr_in target, string s)
{
    char buf[1024] = {0};
    target.sin_family = AF_INET;
    string respone;
    FILE* pfd = popen(s.c_str(), "r");
    if(pfd == nullptr)
    {
        cout << "cmd cannot find" << endl;
    }
    while(fgets(buf, sizeof(buf), pfd))
    {
        respone += buf;
    }
    fclose(pfd);
    ssize_t n = sendto(sockfd, respone.c_str(), respone.size(), 0, (sockaddr*)&target, sizeof(target));
    buf[0] = 0;
}


void chatcast(int sockfd, sockaddr_in target, string s)
{
    string respone;
    if(users.is_online(target))
    {
        respone = inet_ntoa(target.sin_addr);
        respone += "-";
        respone += to_string(ntohs(target.sin_port));
        respone += "#";
        if(s == string("offline"))
        {
            respone += "offline";
            users.BroadCastMassage(sockfd, respone);
            users.offline(target);
        }
        else
        {
            respone += s;

            users.BroadCastMassage(sockfd, respone);
        }

    }
    else if(s == string("online"))
    {
        users.adduser(target);
        respone += "online";
        users.BroadCastMassage(sockfd, respone);
    }
    else
    {
        respone = "please to be online";
        ssize_t n = sendto(sockfd, respone.c_str(), respone.size(), 0, (sockaddr*)&target, sizeof(target));
    }

}


int main(int args, char* argv[])
{
    if(args != 2)
    {
        cerr << "please input port" << endl << endl;
        exit(1);
    }
    //loadDict();
    //cout << " load sucess" << endl;
    unique_ptr<szg::udpServer> server(new szg::udpServer(chatcast, (uint16_t)atoi(argv[1])));
    server->udpInit();
    server->run();
    return 0;
}

udpClient.cc

#include"udpClient.hpp"
#include<memory>

int main(int args, char* argv[])
{
    if(args != 3)
    {
        cerr << "please input #  ip  and  port " << endl;
        exit(1);
    }
    uint32_t ip = inet_addr(argv[1]);
    ip = ntohl(ip);
    unique_ptr<szg::udpClient> client(new szg::udpClient(ip, (uint16_t)atoi(argv[2])));
    client->Init();
    client->Run();
    return 0;
}

JDSZGLLL
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
UDP通信协议详解
qq_45829112的博客
02-09 5026
中文名 用户数据报协议 英文名 User Datagram Protocol 基础 IP数据包服务上增加一点功能 类别 传输层协议 特点 无连接、不可靠、快速传输 用途 发送IP数据包 如右图所所示为udp协议的基本信息 UDP(User Datagram Protocol)用户数据报协议，非连接的协议，传输数据之前源...
图形化UDP发包小工具
weixin_56319791的博客
10-14 5047
图形化UDP包发送小工具
安卓：UDP通信
A125679880的博客
08-06 3081
UDP（User Datagram Protocol）是一种无连接的传输协议，它在网络通信中常用于实时应用程序，例如音频、视频流传输和在线游戏。与TCP（Transmission Control Protocol）相比，UDP具有更低的开销和更高的传输速度，但不提供可靠性和错误检测功能。网络通信的三要素：（1）、IPIP地址（Internet Protocol Address）是用于在网络中标识和定位设备的一组数字。它是互联网通信所必需的基本元素之一，用于确定数据包在网络中的传输路径。
Qt中的UDP通信
龙木南的博客
10-30 2953
Qt中的UDP通信
Qt简单实现UDP通信
热门推荐
qq_43686329的博客
09-17 2万+
Qt简单实现UDP通信 标签（空格分隔）： udp通信、Qt 一、UDP简介 1）UDP（User Datagram Protocol,用户数据报协议） UDP是一个轻量级、不可靠、面向数据报的、无连接的传输层协议，多用于可靠性要求不严格，不是非常重要的传输，如直播、视频会议等等。 Qt中QUdpSocket类继承自QAbstractSocket,用来发送和接收UDP数据报，”Socket”即套接字，套接字即IP地址+端口号。其中IP地址指定了网络中的一台主机，二端口号则指定了该主机上的一个应用程
UDP通信流程.doc
11-15
在 UDP 通信流程中，应用层是整个流程的开始。首先，需要创建一个 UDP 套接字，并绑定在 UDP 端口上。绑定过程中，需要编写一个函数来处理这个 UDP 套接字接收到的数据报文，并将这个函数作为 udp_bind() 的参数。在...
QTUDP通信Demo
11-09
使用Qt写的UDPDemo，另外在博客中有详细的知识讲解，从零开发B/S机架应用程序（三）-UDP
Qt UDP通信demo
11-27
通过一个实例，介绍如何实现基于UDP协议的广播应用，它由UDP服务器和UDP客户端两部分组成。 UDP方式下客户端并不与服务器建立连接，它只负责调用发送函数向服务器发送数据报。相同，服务器也不从客户端接收连接，只...
Socket网络TCP/UDP通信调试工具
05-19
SocketTool调试工具官方版是一款网络TCP/UDP通信调试工具。SocketTool调试工具最新版可以有效地帮助网络管理员检测各种网络通信状永久，集成了TCP服务器/客户端、UDP服务器/客户端和UDP广播/组播等功能。SocketTool...
QT实现基于线程的UDP通信+亲测可用
08-31
基于窗口部件的UDP通信实现，虽然简单易用，但是窗口部件主要的工作是负责处理大量的用户界面信息，当有耗时的处理过程时，会影响数据的接收，造成丢帧。这里使用的是独立的线程负责网络数据的发送和接收，再通过...
SpringCloud 网关配置websocket
feiz3020的专栏
06-07 852
this.websocket = new WebSocket(process.env.VUE_APP_WS_URL + '/orderWebsocket') // 创建WebSocket连接。this.websocket.onclose = this.onWebSocketClose // WebSocket连接关闭时的处理函数。VUE_APP_WS_URL = 'wss://域名.com/websocket/ws/'this.websocket.close() // 关闭WebSocket连接。
JAVAEE值之网络原理(1)_用户数据报协议(UDP)、概念、特点、结构、代码实例
2301_80653026的博客
06-11 1367
UDP工作在传输层，用于程序之间传输数据的。数据一般包含：文件类型，视频类型，jpg图片等。UDP特点：无连接、不可靠、面向数据报、全双工。
计算机网络 —— 网络层（CIDR）
qq_67693066的博客
06-09 1202
计算机网络 —— 网络层 （CIDR）
✊构建浏览器工作原理知识体系（网络协议篇）
坚信万物皆可切的切图仔
06-11 737
正如上面所说，为了保证数据的可靠传输和顺序传输，以及进行流量和拥塞控制，发送请求之前需要先建立TCP连接。Socket：由 IP 地址和端口号组成序列号：用来解决乱序问题等窗口大小：用来做流量控制所以在发送请求之前，客户端和服务端需要先相互发送TCP报文学如逆水行舟，不进则退～加油吧少年👊👊👊先看后赞，养成习惯👍点个关注，不要迷路🪤。
nginx配置WebSocket参数wss连接
Good Luck
06-07 352
2、在default.conf中配置。
计算机网络：数据链路层 - 扩展的以太网
盒马的博客
06-09 1233
讲解计算机网络中的以太网扩展问题，包括集线器，交换机，以及自学习算法
计算机网络：网络层 - IPv4地址
盒马的博客
06-11 1051
讲解计算机网络的IPv4地址，包括其发展的三个阶段：分类编址，划分子网，无分类编址
【计算机网络】个人学习笔记——第五章 运输层：TCP&UDP&三次握手、四次挥手&TCP的可靠传输原理&TCP的拥塞控制与流量控制
发布一些个人学习笔记，分享一些可能在安全学习道路上遇到的问题、心得，一起学习一起进步
06-10 1097
计算机网络第五章运输层的个人学习笔记，本章的重点是TCP协议及其有关工作原理。主要包括：TCP协议，UDP协议，TCP协议的连接建立过程（三次握手与四次挥手），TCP可靠传输的实现原理，TCP协议的流量控制与拥塞控制
实时通信websocket和sse
最新发布
Z_Joker_J的博客
06-13 196
是一个JavaScript库，用于处理服务器发送的事件（Server-Sent Events，简称SSE）。它提供了一个简单易用的API，使得客户端可以与服务器进行实时通信。这个库主要用于浏览器环境。安装依赖npm install @microsoft/fetch-event-source。
codesys udp通信
06-23
UDP通信在工业自动化应用中常用于高速数据通信和实时控制。 在CODESYS中使用UDP通信，需要使用串行通信库（Serial Communication Library）和网络库（Network Library）。使用串行通信库可以实现串口通信，而网络库...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JDSZGLLL

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值