c++简单的UDP客户端+服务端

udp client

//udpclient.h
#ifndef UDP_CLIENT_H_
#define UDP_CLIENT_H_
 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
 
#define MAX_READ_LINE 1600
 
class CUDPClient
{
public:
    CUDPClient();
    ~CUDPClient();
 
    int Init(const char * szServerIP,  int nServerPort);
    int SendData(uint8_t *pData, int nLen);
 
private:
    int socket_fd = -1;
    int recv_len = -1;
 
    struct sockaddr_in u_sockaddr;
};
 
#endif//UDP_CLIENT_H_

//udpclient.cpp
#include "udpclient.h"
 
CUDPClient::CUDPClient()
{
 
}
 
CUDPClient::~CUDPClient()
{
 
}
 
 int  CUDPClient::Init(const char * szServerIP,  int nServerPort)
 {
    socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (socket_fd < 0) {
        LOG_E("socket error: {} errno : {}", strerror(errno), errno);
        return -1;
    }
 
    //初始化sockaddr_in结构体
    memset(&u_sockaddr, 0, sizeof(struct sockaddr_in));
    u_sockaddr.sin_family = AF_INET;
    u_sockaddr.sin_port = htons(nServerPort);
    inet_pton(AF_INET, szServerIP, &u_sockaddr.sin_addr);
 
    LOG_I("init udp success. IP={} port={}",szServerIP, nServerPort);
 
    return 0;
 }
 
int  CUDPClient::SendData(uint8_t *pData, int nLen)
{
    //向server发送数据
    if(sendto(socket_fd, pData, nLen, 0, (struct sockaddr *) &u_sockaddr, sizeof(struct sockaddr_in)) < 0){
        LOG_E("send message error: {} errno : {}", strerror(errno), errno);
        return -1;
    }
 
    LOG_ACTIVE(100,  "send udp len={}", nLen);
 
    return 0;
}

udp server

//udpserver.h
#ifndef UDP_SERVER_H_
#define UDP_SERVER_H_
 
#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <string.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
#define MAX_READ_LINE 1500
 
 
typedef void (*udp_data_callback)(unsigned char* data, int len, void *userdata);
 
class CUDPServer
{
public:
    CUDPServer();
    ~CUDPServer();
 
    int Init(int nPort);
    void Uninit();
 
    void SetDataCB(udp_data_callback cb, void *pUserData); 
 
    int RecvData();
 
private:
    struct sockaddr_in u_sockaddr;
    udp_data_callback m_UdpCallback;
    void *m_pUserData = nullptr;
 
    int server_fd = -1;
    uint8_t *m_pBuffer = nullptr;
    bool m_bInited = false;
};
 
#endif//UDP_SERVER_H_

//udpserver.cpp
#include "udpserver.h"
 
CUDPServer::CUDPServer()
{
 
}
 
CUDPServer::~CUDPServer()
{
    Uninit();
}
 
int CUDPServer::Init(int nPort)
{
    //初始化sockaddr_in结构体
    memset(&u_sockaddr, 0, sizeof(u_sockaddr));      //bzero(&u_sockaddr,sizeof(u_sockaddr));
    u_sockaddr.sin_family = AF_INET;
    u_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    u_sockaddr.sin_port = htons(nPort);
 
     //创建server端的socket套接字
     server_fd = socket(AF_INET,  SOCK_DGRAM, 0);
    if (server_fd < 0) {
        LOG_E(" socket error {} errno: {}" , strerror(errno), errno);
       return -1;
    }
 
    int flag = 1;
    if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&flag, sizeof(flag)) < 0)
    {
        LOG_E("setsockopt error {} errno: {} nPort:{}" , strerror(errno), errno, nPort);
        return -1;
    }
    LOG_I("setsockopt success. port={}", nPort);
 
    //绑定
    int ret = bind(server_fd,(struct sockaddr *) &u_sockaddr,sizeof(u_sockaddr));
    if (ret < 0) {
        LOG_E("bind socket error {} errno: {} nPort:{}" , strerror(errno), errno, nPort);
        return -1;
    }
 
    LOG_I("bind socket success. port={}", nPort);
 
    if(!m_pBuffer)
    {
        m_pBuffer = new uint8_t[MAX_READ_LINE];
    }
 
    return 0;  
}
 
void CUDPServer::Uninit()
{
    if(m_pBuffer)
    {
        delete[] m_pBuffer;
        m_pBuffer = nullptr;
    }
 
    m_UdpCallback = nullptr;
 
    if(server_fd>=0)
    { 
        close(server_fd);
        server_fd = -1;
    }
}
 
void CUDPServer::SetDataCB(udp_data_callback cb, void *pUserData)
{
    m_UdpCallback = cb;
    m_pUserData = pUserData;
}
 
 int CUDPServer::RecvData()
 {
    if(!m_bInited)
    {
        Init(8888);
        m_bInited = true;
    }
 
     socklen_t socklen = sizeof(u_sockaddr);
    //读取客户端数据到buff中
    int recv_len = recvfrom(server_fd, m_pBuffer, MAX_READ_LINE, 0, (struct sockaddr *)&u_sockaddr, &socklen);
    if (recv_len < 0) {
        LOG_E("recv_len = {}  server_fd={} error {} errno: {} ", recv_len, server_fd, strerror(errno), errno);
        return -1;
    }
 
    LOG_ACTIVE(500, "recv : buff={}", recv_len);
 
    if(m_UdpCallback)
    {
        m_UdpCallback(m_pBuffer, recv_len, m_pUserData);
    }
 
    return recv_len;
 }