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;
}