int CSSLClient::SSLRead(void *pBuf, int bufLen)
{
if (NULL == pBuf || bufLen == 0 || NULL == m_pSSL)//
{
return 0;
}
unsigned long reTry = 0;
int ret = 0, err = 0;
int tmpRecvLen = 0;
while((reTry++ < SSL_SOCKET_CONNECT_RETRIES) && tmpRecvLen <= bufLen)
{
if((ret = SSL_read(m_pSSL, (void *)((char *)pBuf + tmpRecvLen), bufLen - tmpRecvLen)) <= 0)
{
err = SSL_get_error(m_pSSL, ret);
if(SSL_ERROR_WANT_READ == err)
{
PUB_Sleep(1); // wait a while
}
else
{
printf("SSL_read Err, Cur read Len:%d Need Len : %d\n", tmpRecvLen, bufLen);
FreeRsource();
return -1;
}
}
else
{
tmpRecvLen += ret;
break;
}
}
return tmpRecvLen;
}
//accept线程,accept的run函数
//return value:0 线程正常
// 1 线程退出时关闭socket失败
// 2 accept出错
int CSWL_ListenProcEx::AcceptThreadRun()
{
SWL_socket_t sClientLinkSock;
struct sockaddr struAddr;
SWL_socklen_t len = sizeof(struAddr);
while(m_bAcceptThreadRun)
{
sClientLinkSock = SWL_Accept(m_SocketListen, (struct sockaddr *)&struAddr, &len);
if(SWL_INVALID_SOCKET == sClientLinkSock)
{
if(SWL_EWOULDBLOCK())
{
#ifdef __CHIP3515__
PUB_Sleep(100);
#else
PUB_Sleep(100);
#endif
continue;
}
else
{
SWL_PrintError(__FILE__, __LINE__);
assert(false);//xg 如果出错，不好处理，退出该线程后，新的客户端就进不来了
return 2;
}
}
m_clientSockInfo.pTcpSock = sClientLinkSock;
struct sockaddr_in * sockAddr = (struct sockaddr_in*)&struAddr;
m_clientSockInfo.dwIP = sockAddr->sin_addr.s_addr;
m_clientSockInfo.nPort = sockAddr->sin_port;
//调用对象构造时注册的回调函数
if (0 != m_pAcceptCallback(&m_clientSockInfo, m_pParam, NULL))
{
SWL_CloseSocket(m_clientSockInfo.pTcpSock);
}
}
if ( 0 != SWL_CloseSocket(m_SocketListen) )
{
return 1;
}
return 0;
}
void CDeviceConnector::WaitForConnect(int timeouts)
{
int count = 0;
while(!m_bConnected && count < timeouts)
{
PUB_Sleep(10);
count += 10;
}
}
SWL_socket_t CSWL_ListenProcEx::CreateIPV4Socket(unsigned short port)
{
SWL_socket_t sockfd = SWL_INVALID_SOCKET;
//创建一个socket，创建的所有的socket都是非阻塞的
sockfd = SWL_CreateSocket(AF_INET, SOCK_STREAM, 0);
if(SWL_INVALID_SOCKET == sockfd)
{
printf("%s:%s:%d, Create socket error\n", __FUNCTION__, __FILE__, __LINE__);
assert(false);
return sockfd;
}
struct sockaddr_in sockaddrIn4;
memset(&sockaddrIn4, 0, sizeof(struct sockaddr_in));
SWL_socklen_t sockAddrLen = sizeof(struct sockaddr_in);
sockaddrIn4.sin_family = AF_INET;
sockaddrIn4.sin_addr.s_addr = htonl(INADDR_ANY);;
sockaddrIn4.sin_port = htons(port); //这里要转成网络序
memset(&(sockaddrIn4.sin_zero), '\0', 8); // zero the rest of the struct
int reuse = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(int));
int iSendBuffer = 256 * 1024;
setsockopt(m_SocketListen, SOL_SOCKET, SO_SNDBUF, (char *)&iSendBuffer, sizeof(int));
int iSendLowat = 128 * 1024;
setsockopt(m_SocketListen, SOL_SOCKET, SO_SNDLOWAT, (char *)&iSendLowat, sizeof(int));
//绑定socket
int iLoop = 0;
while(0 != SWL_Bind(sockfd, (sockaddr*)&sockaddrIn4, sizeof(sockaddr_in)))
{
++iLoop;
if (iLoop < 60)
{
SWL_PrintError(__FILE__,__LINE__);
PUB_Sleep(2000);
}
else
{
SWL_PrintError(__FILE__,__LINE__);
SWL_CloseSocket(sockfd);
sockfd = SWL_INVALID_SOCKET;
break;
}
}
return sockfd;
}
int CSSLClient::SSLWrite(const void * pDataBuf, int dataLen)
{
if (pDataBuf == NULL)
{
printf("SSLWrite pDataBuf NULL\n");
return -1;
}
if (dataLen == 0)
{
printf("SSLWrite dataLen 0\n");
return 0;
}
if (m_pSSL == NULL)
{
printf("SSLWrite m_pssl NULL\n");
return -1;
}
if (m_pSSL->method == NULL || m_pSSL->packet == NULL || m_pSSL->wbio == NULL)
{
printf("m_pssl contains NULL\n");
return -1;
}
unsigned long reTry = 0;
int ret = 0, err = 0;
int tmpSendLen = 0;;
while((reTry++ < SSL_SOCKET_CONNECT_RETRIES) && tmpSendLen != dataLen)
{
if((ret = SSL_write(m_pSSL, (const void *)((char *)pDataBuf + tmpSendLen), dataLen - tmpSendLen)) <= 0)
{
err = SSL_get_error(m_pSSL, ret);
if(SSL_ERROR_WANT_WRITE == err)
{
PUB_Sleep(1); // wait a while
}
else
{
printf("SSL_write Err, Cur Send Len:%d Need Len : %d\n", tmpSendLen, dataLen);
FreeRsource();
return -1;
}
}
else
{
tmpSendLen += ret;
}
}
return tmpSendLen;
}
SWL_socket_t CSWL_ListenProcEx::CreateIPV6Socket(unsigned short port)
{
SWL_socket_t sockfd = SWL_INVALID_SOCKET;
sockfd = SWL_CreateSocket(PF_INET6, SOCK_STREAM, 0);
if (SWL_INVALID_SOCKET == sockfd)
{
printf("%s:%s:%d, Create socket error\n", __FUNCTION__, __FILE__, __LINE__);
assert(false);
return SWL_INVALID_SOCKET;
}
struct sockaddr_in6 sockaddrIn6;
memset(&sockaddrIn6, 0, sizeof(struct sockaddr_in6));
sockaddrIn6.sin6_family = PF_INET6;
sockaddrIn6.sin6_port = htons(port);
//sockaddrIn6.sin6_addr = in6addr_any;
int reuse = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(int));
//reuse = 1;
//setsockopt(sockfd, IPPROTO_IPV6, IPV6_V6ONLY, &reuse, sizeof(int));
//setsockopt(sockfd, IPPROTO_IPV6, 26, &reuse, sizeof(int));
int iLoop = 0;
while(0 != SWL_Bind(sockfd, (sockaddr*)&sockaddrIn6, sizeof(struct sockaddr_in6)))
{
++iLoop;
if (iLoop < 60)
{
SWL_PrintError(__FILE__,__LINE__);
PUB_Sleep(2000);
}
else
{
SWL_PrintError(__FILE__,__LINE__);
SWL_CloseSocket(sockfd);
sockfd = SWL_INVALID_SOCKET;
break;
}
}
return sockfd;
}
int TCPServer::run()
{
int nInterval = 0;
while (m_bThreadRunFlag)
{
//1.epoll接收新连接，处理注册事件业务请求
if (epoll() != VIOLET_SUCCESS)
nInterval += 5000;
else
nInterval += 10;
//2.清理超时连接，利用其epoll的超时时间作为参考，间隔约为30s
if (nInterval > 30000)
{
clearTimeOutConnection();
nInterval= 0;
}
PUB_Sleep(2);
}
return VIOLET_SUCCESS;
}
int CSSLClient::SSLConnect(SWL_socket_t sockfd, bool bVerifyPeer, const char *pHost, const char *pCertFile, \
const char *pPriteKeyFile, const char *pCAPath, const char *pCAFile, const char *pPassWd)
{
s_Lock.Lock();
if (!s_bHasInitial)
{
printf("ssl not initial\n");
s_Lock.UnLock();
return -1;
}
s_Lock.UnLock();
if (pCertFile!=NULL && pPriteKeyFile!=NULL)
{
if (pCAPath)
{
if(SSL_CTX_load_verify_locations(s_SSLCTX, pCAFile, NULL) <= 0)
{
printf("Failed to set CA location...\n");
return -1;
}
}
if (SSL_CTX_use_certificate_file(s_SSLCTX, pCertFile, SSL_FILETYPE_PEM) <= 0)
{
printf("%s %s %d failed\n", __FILE__, __FUNCTION__, __LINE__);
int errNum = ERR_get_error();
printf("%s:%s:%d, ssl connect error:%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_reason_error_string(errNum));
printf("%s:%s:%d, error function=%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_func_error_string(errNum));
return -1;
}
if (pPassWd)
{
SSL_CTX_set_default_passwd_cb_userdata(s_SSLCTX, (void*)pPassWd);
}
if (SSL_CTX_use_PrivateKey_file(s_SSLCTX, pPriteKeyFile, SSL_FILETYPE_PEM) <= 0)
{
printf("%s %s %d failed\n", __FILE__, __FUNCTION__, __LINE__);
int errNum = ERR_get_error();
printf("%s:%s:%d, ssl connect error:%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_reason_error_string(errNum));
printf("%s:%s:%d, error function=%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_func_error_string(errNum));
return -1;
}
if (!SSL_CTX_check_private_key(s_SSLCTX))
{
printf("%s %s %d failed\n", __FILE__, __FUNCTION__, __LINE__);
int errNum = ERR_get_error();
printf("%s:%s:%d, ssl connect error:%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_reason_error_string(errNum));
printf("%s:%s:%d, error function=%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_func_error_string(errNum));
return -1;
}
}
if (NULL == m_pSSL)
{
if (bVerifyPeer)
{
SSL_CTX_set_verify(s_SSLCTX, SSL_VERIFY_PEER, VerifyCallBack);
}
m_pSSL = SSL_new(s_SSLCTX);
if (NULL == m_pSSL)
{
printf("ssl new err\n");
return -1;
}
}
if (1 != SSL_set_fd(m_pSSL, sockfd))
{
int errNum = ERR_get_error();
printf("%s:%s:%d, ssl connect error:%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_reason_error_string(errNum));
printf("%s:%s:%d, error function=%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_func_error_string(errNum));
return -1;
}
SSL_set_connect_state(m_pSSL);
unsigned long reTry = 0;
int ret = 0, err = 0;
while(reTry++ < SSL_SOCKET_CONNECT_RETRIES)
{
if((ret = SSL_connect(m_pSSL)) == 1)
{
break;
}
err = SSL_get_error(m_pSSL, ret);
if(SSL_ERROR_WANT_CONNECT == err || SSL_ERROR_WANT_READ == err || SSL_ERROR_WANT_WRITE == err)
{
PUB_Sleep(10); // wait a while
}
else
{
printf("SSL_connect Err : %d\n", err);
int errNum = ERR_get_error();
printf("%s:%s:%d, ssl connect error:%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_reason_error_string(errNum));
printf("%s:%s:%d, error function=%s\n", __FUNCTION__, __FILE__, __LINE__, ERR_func_error_string(errNum));
FreeRsource();
return -1;
}
}
if (reTry >= SSL_SOCKET_CONNECT_RETRIES)
{
printf("reTry >= SSL_SOCKET_CONNECT_RETRIES\n");
FreeRsource();
return -1;
}
if (pHost)
{
if (PostConnectCheck(m_pSSL, pHost) < 0)
{
return -1;
}
}
return 0;
}
//创建socket,并开始监听端口,创建accept线程，accept线程结束的时候socket被销毁
//return value: 0 成功 1 创建socket失败 2 获取主机名或者获取主机IP地址失败
// 3 绑定socket失败 4 监听失败 5 创建监听线程失败
// 6 已经开始了监听
int CSWL_ListenProcEx::StartListen(unsigned short int nPort)
{
//本函数StartListen的返回结果
int iReturn = 0;
int iLoop = 0;
CPUB_LockAction FunctionLock(&m_ListenLock); //给函数加了锁
//如果已经开始了监听，则直接返回
if (m_bListenStart)
{
iReturn = 6;
goto StartListen_end;
}
#ifdef __CUSTOM_IPV6__
m_SocketListen = CreateIPV6Socket(nPort);
#else
m_SocketListen = CreateIPV4Socket(nPort);
#endif
if (SWL_INVALID_SOCKET == m_SocketListen)
{
iReturn = 1;
goto StartListen_end;
}
//监听
while(0 != SWL_Listen(m_SocketListen, 5/*SOMAXCONN*/))
{
++iLoop;
if (iLoop < 12)
{
SWL_PrintError(__FILE__,__LINE__);
PUB_Sleep(10000);
}
else
{
SWL_PrintError(__FILE__,__LINE__);
iReturn = 4;
goto StartListen_end_close_sock;
}
}
//启动accept的线程
m_AcceptThreadID = PUB_CreateThread(StartAccept, (void *)this, &m_bAcceptThreadRun);
if( PUB_CREATE_THREAD_FAIL == m_AcceptThreadID )
{
PUB_PrintError(__FILE__,__LINE__);
iReturn = 5;
goto StartListen_end_close_sock;
}
//启动监听成功了
iReturn = 0;
m_bListenStart = true;
goto StartListen_end;
//在创建socket后，后面的阶段出错则要把创建的socket销毁
StartListen_end_close_sock:
SWL_CloseSocket(m_SocketListen);
m_SocketListen = SWL_INVALID_SOCKET;
StartListen_end:
return iReturn;
}
int CSWL_ListenProcEx::AcceptThread6Run()
{
SWL_socket_t sClientLinkSock;
struct sockaddr_in6 structAddrIn6;
SWL_socklen_t len = sizeof(structAddrIn6);
memset(&m_clientSockInfo, 0, sizeof(CLIENT_SOCK_INFO));
while(m_bAcceptThreadRun)
{
sClientLinkSock = SWL_Accept(m_SocketListen, (struct sockaddr *)&structAddrIn6, &len);
if(SWL_INVALID_SOCKET == sClientLinkSock)
{
if(SWL_EWOULDBLOCK())
{
#ifdef __CHIP3515__
PUB_Sleep(100);
#else
PUB_Sleep(100);
#endif
continue;
}
else
{
SWL_PrintError(__FILE__, __LINE__);
assert(false);//xg 如果出错，不好处理，退出该线程后，新的客户端就进不来了
return 2;
}
}
m_clientSockInfo.pTcpSock = sClientLinkSock;
//m_clientSockInfo.dwIP = structAddrIn6.sin6_addr;
m_clientSockInfo.nPort = structAddrIn6.sin6_port;
//如果是IPV4的IP地址，记录IP信息。对于IPV6的地址设置为255.255.255.255
unsigned char * pIpAddr = structAddrIn6.sin6_addr.s6_addr;
if (0x00 == pIpAddr[0] && 0x00 == pIpAddr[1] && 0x00 == pIpAddr[2] &&
0x00 == pIpAddr[3] && 0x00 == pIpAddr[4] && 0x00 == pIpAddr[5] &&
0x00 == pIpAddr[6] && 0x00 == pIpAddr[7] && 0x00 == pIpAddr[8] &&
0x00 == pIpAddr[9] && 0xFF == pIpAddr[10] && 0xFF == pIpAddr[11])
{
//表示这是个IPV4的客户端
char * pIp = (char *)&m_clientSockInfo.dwIP;
pIp[0] = pIpAddr[12];
pIp[1] = pIpAddr[13];
pIp[2] = pIpAddr[14];
pIp[3] = pIpAddr[15];
struct in_addr in;
memset(&in, 0, sizeof(struct in_addr));
in.s_addr = m_clientSockInfo.dwIP;
}
else
{
memset(&m_clientSockInfo.dwIP, 0xff, sizeof(m_clientSockInfo.dwIP));
}
printf("%s:%s:%d, get accept for ipv6 client\n", __FUNCTION__, __FILE__, __LINE__);
//调用对象构造时注册的回调函数
if (!m_pAcceptCallback(&m_clientSockInfo, m_pParam, NULL))
{
SWL_CloseSocket(m_clientSockInfo.pTcpSock);
}
}
if ( 0 != SWL_CloseSocket(m_SocketListen) )
{
return 1;
}
return 0;
}
