UDP编程接口基本使用¶

class UdpServer
{
public:
    UdpServer()
    {
    }

    // 启动服务器
    void start()
    {
    }

    // 停止服务器
    void stop()
    {
    }

    ~UdpServer()
    {
    }

private:
};

class UdpServer
{
public:
    UdpServer()
        : _socketfd(-1)
    {
        // 创建服务器套接字
        _socketfd = socket(AF_INET, SOCK_DGRAM, 0);
    }

    // ...

private:
    int _socketfd; // 套接字文件描述符
};

// 错误码枚举类
enum class errorNumber
{
    ServerSocketFail = 1, // 创建套接字失败
};

class UdpServer
{
public:
    UdpServer()
        : _socketfd(-1)
    {
        // 创建服务器套接字
        _socketfd = socket(AF_INET, SOCK_DGRAM, 0);

        if (_socketfd < 0)
        {
            LOG(LogLevel::FATAL) << "服务器启动异常：" << strerror(errno);
            exit(static_cast<int>(errorNumber::ServerSocketFail));
        }

        LOG(LogLevel::INFO) << "服务器启动成功：" << _socketfd;
    }

    // ...

private:
    int _socketfd; // 套接字文件描述符
};

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

// 错误码枚举类
enum class ErrorNumber
{
    // ...
    BindSocketFail,       // 绑定失败
};

// 默认端口和IP地址
const std::string default_ip = "127.0.0.1";
const uint16_t default_port = 8080;

class UdpServer
{
public:
    UdpServer(const std::string &ip = default_ip, uint16_t port = default_port)
        : // ... 
        , _ip(ip), _port(port)
    {
        // ...

        // 绑定端口号和IP地址
        struct sockaddr_in saddrIn;

        saddrIn.sin_family = AF_INET;
        saddrIn.sin_port = htons(_port);
        saddrIn.sin_addr.s_addr = inet_addr(_ip.c_str());

        // 使用reinterpret_cast强制类型转换
        int ret = bind(_socketfd, reinterpret_cast<const sockaddr *>(&saddrIn), sizeof(sockaddr_in));

        if (ret < 0)
        {
            LOG(LogLevel::FATAL) << "Bind error" << strerror(errno);
            exit(static_cast<int>(ErrorNumber::BindSocketFail));
        }

        LOG(LogLevel::INFO) << "Bind success";
    }

    // ...

private:
    // ...
    uint16_t _port;  // 端口号
    std::string _ip; // 点分十进制IP地址
};

// 启动服务器
void start()
{
    if (!_isRunning)
    {
        _isRunning = true;
        while (true)
        {
        }
    }
}

// 启动服务器
void start()
{
    if (!_isRunning)
    {
        _isRunning = true;
        while (true)
        {
            // 1. 接收客户端信息
            char buffer[1024] = {0};
            struct sockaddr_in peer;
            socklen_t length = sizeof(peer);
            // sizeof(buffer) - 1留下一个位置存放\0
            ssize_t ret = recvfrom(_socketfd, buffer, sizeof(buffer) - 1, 0, reinterpret_cast<struct sockaddr *>(&peer), &length);

            if (ret > 0)
            {
                struct sockaddr_in temp = static_cast<struct sockaddr_in>(peer);

                // 1.1 打印信息
                LOG(LogLevel::INFO) << buffer;
            }
        }
    }
}

// ...
struct sockaddr_in temp = reinterpret_cast<struct sockaddr_in>(peer);

// 1.1 打印信息
LOG(LogLevel::INFO) << "Client: " 
                    << inet_ntoa(temp.sin_addr) << ":" 
                    << ntohs(temp.sin_port) 
                    << " send: " << buffer;
// ...

// 2. 回应客户端
ssize_t n = sendto(_socketfd, buffer, sizeof(buffer), 0, reinterpret_cast<const struct sockaddr *>(&temp), sizeof(temp));

if (n > 0)
{
    // 2.1 打印回复信息
    LOG(LogLevel::INFO) << "Server received: "
                        << buffer
                        << ", and send to: "
                        << inet_ntoa(temp.sin_addr) << ":"
                        << ntohs(temp.sin_port);
}

class UdpClient
{
public:
    UdpClient()
    {
    }

    // 启动客户端
    void start()
    {
    }

    // 结束客户端
    void stop()
    {
    }

    ~UdpClient()
    {
    }

private:
};

enum class ErrorNumber
{
    ClientSocketFail = 1, // 创建套接字失败
};

class UdpClient
{
public:
    UdpClient()
        : _socketfd(-1)
    {
        _socketfd = socket(AF_INET, SOCK_DGRAM, 0);

        if (_socketfd < 0)
        {
            LOG(LogLevel::FATAL) << "Client initiate error: " << strerror(errno);

            exit(static_cast<int>(ErrorNumber::ClientSocketFail));
        }

        LOG(LogLevel::INFO) << "Client initiated: " << _socketfd;
    }

    // ...

private:
    int _socketfd; // 套接字文件描述符
};

// 启动客户端
void start()
{
    if (!_isRunning)
    {
        _isRunning = true;
        while (true)
        {
        }
    }
}

class UdpClient
{
public:
    UdpClient(const std::string ip = default_ip, uint16_t port = default_port)
        : //...
        , _ip(ip)
        , _port(port)
    {
        // ...
    }

    // ...

private:
    // ...
    std::string _ip; // 服务器IP地址
    uint16_t _port;  // 服务器端口号
    // ...
};

// 1. 向服务器发送数据
struct sockaddr_in local;
bzero(&local, 0);
local.sin_family = AF_INET;
local.sin_port = htons(_port);
local.sin_addr.s_addr = inet_addr(_ip.c_str());

// 1.1 读取输入信息
std::string message;
getline(std::cin, message);

// 1.2 发送数据
ssize_t ret = sendto(_socketfd, message.c_str(), message.size(), 0, reinterpret_cast<const struct sockaddr *>(&local), sizeof(local));

if (ret < 0)
    LOG(LogLevel::WARNING) << "客户端未发送成功";

// 2. 回显服务器的信息
struct sockaddr_in temp;
socklen_t length = sizeof(temp);
char buffer[1024] = {0};
ssize_t n = recvfrom(_socketfd, buffer, sizeof(buffer) - 1, 0, reinterpret_cast<struct sockaddr *>(&temp), &length);

if (n > 0)
    LOG(LogLevel::INFO) << "收到服务器信息：" << buffer;

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

using namespace UdpServerModule;

int main(int argc, char *argv[])
{
    // 创建UdpServerModule对象
    std::shared_ptr<UdpServer> udp_server;
    if (argc == 1)
    {
        udp_server = std::make_shared<UdpServer>();
    }
    else if (argc == 3)
    {
        std::string ip = argv[1];
        uint16_t port = std::stoi(argv[2]);
        udp_server = std::make_shared<UdpServer>(ip, port);
    }

    udp_server->start();

    return 0;
}

#include <iostream>
#include <cstdio>
#include <thread>
#include <string>
#include <cstdlib>

// 引入Windows网络编程相关的库
#include <WinSock2.h>
#include <Windows.h>

// 用特定的编译器警告，警告代码4996通常与使用被微软标记为"不安全"或"已弃用"的函数相关
#pragma warning(disable : 4996) 

// 告诉编译器链接Windows Socket 2库
// 相当于在项目设置中手动添加这个库作为依赖项ws2_32.lib包含了Windows平台下所有网络编程相关的函数实现
#pragma comment(lib, "ws2_32.lib")

std::string serverip = "";  // 填写云服务器IP地址
uint16_t serverport = 8888; // 填写云服务中服务端端口号

int main()
{
    WSADATA wsd;
    WSAStartup(MAKEWORD(2, 2), &wsd);

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    SOCKET sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == SOCKET_ERROR)
    {
        std::cout << "socker error" << std::endl;
        return 1;
    }
    std::string message;
    char buffer[1024];
    while (true)
    {
        std::cout << "Please Enter@ ";
        std::getline(std::cin, message);
        if(message.empty()) continue;
        sendto(sockfd, message.c_str(), (int)message.size(), 0, (struct sockaddr *)&server, sizeof(server));
        struct sockaddr_in temp;
        int len = sizeof(temp);
        int s = recvfrom(sockfd, buffer, 1023, 0, (struct sockaddr *)&temp, &len);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << buffer << std::endl;
        }
    }

    closesocket(sockfd);
    WSACleanup();
    return 0;
}

// 文件errors.hpp中
#pragma once

// 错误码枚举类
enum class ErrorNumber
{
    SocketFail = 1, // 创建套接字失败（供服务端和客户端使用）
    BindSocketFail, // 绑定失败（供服务端使用）
};

class SockAddrIn
{
    // 无参构造
    SockAddrIn()
    {
    }

    // 根据指定的sockaddr_in对象进行构造
    SockAddrIn(const struct sockaddr_in &s)
        : _s_addr_in(s)
    {
    }

    // 根据具体端口构造
    SockAddrIn(uint16_t port)
        : _port(port)
    {
        // 内部通过传入的端口对sockaddr_in对象进行初始化
    }

    // 根据端口和IP地址构造
    SockAddrIn(uint16_t port, std::string ip)
        : _ip(ip), _port(port)
    {

    }

    // 返回IP地址
    std::string getIp()
    {
        return _ip;
    }

    // 返回端口号
    uint16_t getPort()
    {
        return _port;
    }

    ~SockAddrIn()
    {
    }

private:
    struct sockaddr_in _s_addr_in;
    std::string _ip;
    uint16_t _port;
};

private:
    // 大端转换为本地端口值
    void NetPort2Local()
    {
        _port = ntohs(_s_addr_in.sin_port);
    }

    // 将IP地址转换为小端字节序并按照点分十进制存储
    void NetIP2Local()
    {
        char buffer[1024] = {0};
        const char *ip = inet_ntop(AF_INET, &_s_addr_in.sin_addr, buffer, sizeof(buffer));
        _ip = buffer;
    }

// 重载&
struct sockaddr *operator&()
{
    return reinterpret_cast<struct sockaddr *>(&_s_addr_in);
}

// 获取struct sockaddr_in对象长度
socklen_t getLength()
{
    return sizeof(_s_addr_in);
}