Appearance

NSocket ​

NSocket类提供套接字的创建与通信，可用于自定义通信协议的实现。

接口返回值说明
Bindvoid绑定IP及端口号
Listenvoid监听
AcceptNSocketPtr接受连接
AcceptAsyncNSocketPtr接受连接异步接口
Receivesize_t接收信息
ReceiveAsyncvoid接收信息异步接口
ReceiveFromsize_t从对应IP及端口号接收信息
ReceiveFromAsyncvoid从对应IP及端口号接收信息异步接口
Sendsize_t发送信息
SendAsyncvoid发送信息异步接口
SendTosize_t发送信息到指定IP及端口号
SendToAsyncvoid发送信息到指定IP及端口号异步接口
Closevoid关闭通信
Connectvoid连接
ConnectAsyncvoid连接异步接口
Shutdownvoid指定方式关闭通信
QueryIPEndPointNIPEndPointPtr查询IP地址
VerifyCertificatevoid证书验证
SSLSocketConnectvoidSSL连接
SSLHandSharkClientvoidSSL客户端握手
SSLHandSharkServervoidSSL服务端握手
SSLHandSharkClientAsyncvoidSSL客户端握手异步接口
SSLHandSharkServerAsyncvoidSSL服务端握手异步接口
SSLReceivesize_tSSL接收信息
SSLReceiveAsyncvoidSSL接收信息异步接口
SSLSendsize_tSSL发送信息
SSLSendAsyncvoidSSL发送信息异步接口
GetSocketOptionbool获取Socket选项值
SetSocketOptionvoid设置Socket选项值

Socket基础通信接口 ​

接口参数描述
void Bind(NIPEndPointPtr endPoint, bool reuseAddress = true);
void Bind(NIPEndPointPtr endPoint, std::error_code& ec, bool reuseAddress = true);		endpoint：绑定的ip及端口号；reuseAddress：地址可重用；ec：错误码Socket的绑定接口
void Listen();
void Listen(int backlog);		backlog：可接受连接的最大数量Socket的监听接口
NSocketPtr Accept();
NSocketPtr Accept(std::error_code& ec);
void AcceptAsync(std::function<void(const std::error_code& ec, NSocketPtr socket)> callback);		ec：错误码；callback：异步接口回调函数Socket接受连接的同步接口与异步接口，连接的套接字，在同步接口中以返回值的形式给出，在异步接口中，以回调函数的参数值给出
size_t Receive(char* buffer, size_t offset, size_t size, ESocketFlags socketFlags, std::error_code& ec);
size_t Receive(char* buffer);		buffer：接收的数据；offset：接收数据的起始偏移量；size：接收的数据量；socketFlags：socket标志位；ec：错误码Socket接收数据的同步与异步接口，Receive系列接口可用于Tcp与Udp
void ReceiveAsync(char* buffer, size_t offset, size_t size, ESocketFlags socketFlags, NTransmitCallback callback);
void ReceiveAsync(char* buffer, NTransmitCallback callback);		buffer：接收的数据；offset：接收数据的起始偏移量；size：接收的数据量；socketFlags：socket标志位；callback：异步接收接口的回调函数Socket接收数据的同步与异步接口，Receive系列接口可用于Tcp与Udp
size_t ReceiveFrom(char* buffer, size_t offset, size_t size, NIPEndPointPtr remote, ESocketFlags socketFlags, std::error_code& ec);
size_t ReceiveFrom(char* buffer, NIPEndPointPtr remote);		buffer：接收的数据；offset：接收数据的起始偏移量；size：接收的数据量；socketFlags：socket标志位；ec：错误码；remote：从remote接收数据Socket接收数据的同步与异步接口，ReceiveFrom系列接口用于Udp
void ReceiveFromAsync(char* buffer, size_t offset, size_t size, NIPEndPointPtr remote, ESocketFlags socketFlags, NTransmitCallback callback);
void ReceiveFromAsync(char* buffer, NIPEndPointPtr remote, NTransmitCallback callback);		buffer：接收的数据；offset：接收数据的起始偏移量；size：接收的数据量；socketFlags：socket标志位；callback：异步接收接口的回调函数；remote：从remote接收数据Socket接收数据的同步与异步接口，ReceiveFrom系列接口用于Udp
size_t Send(char* buffer, size_t offset, size_t size, ESocketFlags socketFlags, std::error_code& ec);
size_t Send(char* buffer);		buffer：发送的数据；offset：发送数据的起始偏移量；size：发送的数据量；socketFlags：socket标志位；ec：错误码Socket发送数据的同步与异步接口，Send系列接口可用于Tcp与Udp
void SendAsync(char* buffer, size_t offset, size_t size, ESocketFlags socketFlags, NTransmitCallback callback);
void SendAsync(char* buffer, NTransmitCallback callback);		buffer：发送的数据；offset：发送数据的起始偏移量；size：发送的数据量；socketFlags：socket标志位；callback：异步发送接口的回调函数Socket发送数据的同步与异步接口，Send系列接口可用于Tcp与Udp
size_t SendTo(char* buffer, size_t offset, size_t size, NIPEndPointPtr remote, ESocketFlags socketFlags, std::error_code& ec);
size_t SendTo(char* buffer, NIPEndPointPtr remote);		buffer：发送的数据；offset：发送数据的起始偏移量；size：发送的数据量；socketFlags：socket标志位；ec：错误码；remote：向remote发送数据Socket发送数据的同步与异步接口，SendTo系列接口用于Udp
void SendToAsync(char* buffer, size_t offset, size_t size, NIPEndPointPtr remote, ESocketFlags socketFlags, NTransmitCallback callback);
void SendToAsync(char* buffer, NIPEndPointPtr remote, NTransmitCallback callback);		buffer：发送的数据；offset：发送数据的起始偏移量；size：发送的数据量；socketFlags：socket标志位；callback：异步发送接口的回调函数；remote：向remote发送数据Socket发送数据的同步与异步接口，SendTo系列接口用于Udp
void Close();
void Close(std::error_code& ec);
void Shutdown(ESocketShutdown how);		ec：错误码；how：以指定方式关闭连接Socket的关闭接口，Close接口实现完全关闭连接，Shutdown实现以指定当时关闭连接
void Connect(NIPEndPointPtr remote);
void Connect(NIPEndPointPtr remote, std::error_code& ec);
void ConnectAsync(NIPEndPointPtr remote, std::function<void(const std::error_code& ec)> callback);		remote：要连接的远端ip及端口号；ec：错误码；callback：异步连接的回调函数；Socket的连接接口，支持同步与异步连接
bool GetSocketOption(ESocketOptionName option);
bool GetSocketOption(ESocketOptionName option, int& timeout);
void SetSocketOption(ESocketOptionName option, bool value);
void SetSocketOption(ESocketOptionName option, bool value, int timeout);
void SetSocketOption(ESocketOptionName option, const std::string& ip);
void SetSocketOption(ESocketOptionName option, const std::string& ip, const std::string& networkInterface);
void SetSocketOption(ESocketOptionName option, const std::string& ip, const std::string& networkInterface, std::error_code& ec);		option：Socket选项；timeout：超时时间；ip：加入或离开多播组的ip；networkInterface：网卡ip设置Socket选项值，包括广播、加入多播组、离开多播组、不允许路由等

示例代码：

cpp
void tcpclient::ConnectAsync()
{   
	//创建套接字
    auto socket = NNetWorkManager::CreateSocket(EAddressFamily::InterNetwork, ESocketType::Stream, EProtocolType::Tcp);
	NIPEndPointPtr endPoint1 = NNetWorkManager::CreateIPEndPoint(“127.0.0.1”, 8080);
	//异步连接接口
    socket->ConnectAsync(endPoint1, std::bind(&tcpclient::ConnetcHandle, this, std::placeholders::_1));
}
void tcpclient::ConnetcHandle(const std::error_code& ec)
{
	//异步连接回调函数
    if (!ec)
    {
        LogEngine("tcpclient::ConnetcHandle success");
    }
    else
    {
        LogEngine("tcpclient::ConnetcHandle error: %s", ec.message().c_str());
    }
}
void tcpclient::RecvMsg()
{        
	//异步接收
	char buffer[512] = { '0' };
    socket->ReceiveAsync(buffer, 0, 512, ESocketFlags::SF_None, std::bind(&tcpclient::RecvHandle, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
}
//异步接收回调函数
void tcpclient::RecvHandle(char* buffer, size_t& offset, size_t& size, const std::error_code& ec)
{
    if (!ec)
    {
        if (socket.IsValid())
        {
			//将接收的信息异步发送
            socket->SendAsync(buffer, 0, size, ESocketFlags::SF_None, std::bind(&tcpclient::SendHandle, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
        }
    }
    else
    {
        LogEngine("TcpServer::RecvHandle error: %s", ec.message().c_str());
    }
}
//异步发送回调函数
void tcpclient::SendHandle(char* buffer, size_t& offset, size_t& size, const std::error_code& ec)
{
    if (!ec)
    {
        LogEngine("TcpServer::RecvHandle success: %s", buffer);
    }
    else
    {
        LogEngine("TcpServer::RecvHandle error: %s", ec.message().c_str());
    }
}

基于SSL的Socket通信 ​

接口参数描述
NIPEndPointPtr QueryIPEndPoint(std::string& host, const std::string& service, std::error_code& ec);host：基于host查询对应ip；service：基于“http”或“https”进行查询；ec：错误码ip查询接口
void VerifyCertificate(const std::string& host);host：基于host进行证书认证；认证接口
void SSLSocketConnect(NIPEndPointPtr endpoint, std::error_code& ec);endPoint：要连接的IP及端口号；ec：错误码SSL连接接口
void SSLHandShakeClient(std::error_code& ec);
void SSLHandShakeServer(std::error_code& ec);		ec：错误码SSL握手接口
void SSLHandShakeClientAsync(std::function<void(const std::error_code&)> callback);
void SSLHandShakeServerAsync(std::function<void(const std::error_code&)> callback);		callback：异步握手回调接口SSL异步握手接口
size_t SSLReceive(char* buffer, size_t offset, size_t size, std::error_code& ec);
size_t SSLReceive(char* buffer);		buffer：接收的数据；offset：接收数据的起始偏移量；size：接收的数据量；ec：错误码SSL接收接口
void SSLReceiveAsync(char* buffer, size_t offset, size_t size, NTransmitCallback callback);
void SSLReceiveAsync(char* buffer, NTransmitCallback callback);		buffer：接收的数据；offset：接收数据的起始偏移量；size：接收的数据量；callback：异步接收的回调函数SSL异步接收接口
size_t SSLSend(char* buffer, size_t offset, size_t size, std::error_code& ec);
size_t SSLSend(char* buffer);		buffer：发送的数据；offset：发送数据的起始偏移量；size：发送的数据量；ec：错误码SSL发送接口
void SSLSendAsync(char* buffer, size_t offset, size_t size, NTransmitCallback callback);
void SSLSendAsync(char* buffer, NTransmitCallback callback);		buffer：发送的数据；offset：发送数据的起始偏移量；size：发送的数据量；callback：异步发送的回调函数SSL异步发送接口