int CClientAmxController::onAuthenticationRequest(int nSocket, int nCommand, int nSequence, const void *szBody)
{
const char *charRequestBodyData = reinterpret_cast<const char *>(szBody);
_log(LOG_TAG" onAuthenticationRequest() body: %s", charRequestBodyData);
JSONObject reqJson(charRequestBodyData);
if (!reqJson.isValid())
{
_log(LOG_TAG" onAuthenticationRequest() This is not JSON");
response(getSocketfd(), nCommand, STATUS_RINVBODY, nSequence, NULL);
return TRUE;
}
std::string reqToken = reqJson.getString("TOKEN", "");
std::string reqId = reqJson.getString("ID", "");
reqJson.release();
if (reqToken.empty() || reqId.empty())
{
_log(LOG_TAG" onAuthenticationRequest() Missed something in JSON");
response(getSocketfd(), nCommand, STATUS_RINVJSON, nSequence, NULL);
return TRUE;
}
int64_t now = HiddenUtility::unixTimeMilli();
bool authOk = validateToken(reqId, reqToken, now);
std::stringstream respSs;
respSs << "{\"ID\":\"" << reqId << "\",\"AUTH\":\"";
if (authOk)
{
_log(LOG_TAG_COLORED" onAuthenticationRequest() `%s` w/ token `%s` PASSED on validation",
reqId.c_str(), reqToken.c_str());
respSs << "y";
}
else
{
_log(LOG_TAG_COLORED" onAuthenticationRequest() `%s` w/ token `%s` FAILED on validation",
reqId.c_str(), reqToken.c_str());
respSs << "n";
}
respSs << "\"}";
response(getSocketfd(), nCommand, STATUS_ROK, nSequence, respSs.str().c_str());
return TRUE;
}
int CSocketClient::start(int nSocketType, const char* cszAddr, short nPort,
int nStyle)
{
if (AF_UNIX == nSocketType)
{
setDomainSocketPath(cszAddr);
}
else if (AF_INET == nSocketType)
{
if (-1 == setInetSocket(cszAddr, nPort))
{
_DBG("set INET socket address & port fail");
return -1;
}
}
if (-1 != createSocket(nSocketType, nStyle))
{
if (SOCK_STREAM == nStyle)
{
if (-1 == connectServer())
{
socketClose();
return -1;
}
}
_DBG("[Socket Client] Socket connect success");
return getSocketfd();
}
return -1;
}
int CClientAmxController::startClient(int msqKey)
{
_log(LOG_TAG" Connecting to AMX controller validation service %s:%d",
serverIp.c_str(), validationPort);
int nRet = connectWithCallback(serverIp.c_str(), validationPort, msqKey,
[](CATcpClient *caller, pthread_t msgRecvTid, pthread_t pktRecvTid) -> void
{
pthread_setname_np(msgRecvTid, "AmxMsgRecv");
pthread_setname_np(pktRecvTid, "AmxPktRecv");
});
if (nRet < 0)
{
_log(LOG_TAG" startClient() Connecting to AMX controller FAILED");
return FALSE;
}
tokenCache.clear();
nRet = request(getSocketfd(), bind_request, STATUS_ROK, getSequence(), NULL);
if (nRet < 0)
{
_log(LOG_TAG" startClient() Binding to AMX controller FAILED");
return FALSE;
}
// enquireLinkYo starts in onResponse(), when binding response is received
return TRUE;
}
int CSocketClient::start(int nSocketType, const char* cszAddr, short nPort, int nStyle)
{
if ( AF_UNIX == nSocketType )
{
setDomainSocketPath( cszAddr );
}
else if ( AF_INET == nSocketType )
{
if ( -1 == setInetSocket( cszAddr, nPort ) )
{
_DBG( "set INET socket address & port fail" );
return -1;
}
}
if ( -1 != createSocket( nSocketType, nStyle ) )
{
if ( SOCK_STREAM == nStyle )
{
if ( -1 == connectServer() )
{
socketClose();
return -1;
}
}
if ( -1 != externalEvent.m_nMsgId )
{
if ( -1 == initMessage( externalEvent.m_nMsgId ) )
{
throwException( "socket client create message id fail" );
}
else
{
threadHandler->createThread( threadMessageReceive, this );
threadHandler->createThread( threadSocketRecvHandler, this );
}
}
_DBG( "[Socket Client] Socket connect success, FD:%d", getSocketfd() );
return getSocketfd();
}
return -1;
}
void CClientAmxController::stopClient()
{
if (enquireLinkYo != nullptr)
{
enquireLinkYo->stop();
}
if (!isValidSocketFD())
{
_log(LOG_TAG" stopClient() socket fd is not valid, quit stopping");
return;
}
// server don't response to unbind_request
// receiving unbind_response while destructing CCmpClient may cause segmentation fault
request(getSocketfd(), unbind_request, STATUS_ROK, getSequence(), NULL);
stop();
}
int CSocketServer::start(int nSocketType, const char* cszAddr, short nPort, int nStyle)
{
int nMsgId = -1;
if (-1 != externalEvent.m_nMsgId)
{
nMsgId = initMessage(externalEvent.m_nMsgId);
}
else
{
nMsgId = initMessage(m_nInternalFilter);
}
if (-1 == nMsgId)
{
throwException("socket server create message id fail");
return -1;
}
threadHandler->createThread(threadSocketMessageReceive, this);
if (AF_UNIX == nSocketType)
{
setDomainSocketPath(cszAddr);
}
else if (AF_INET == nSocketType)
{
if (-1 == setInetSocket(cszAddr, nPort))
{
_DBG("set INET socket address & port fail");
return -1;
}
}
if (-1 != createSocket(nSocketType, nStyle))
{
if (-1 != socketBind())
{
if (SOCK_STREAM == nStyle)
{
if (-1 == socketListen(BACKLOG))
{
perror("socket listen");
socketClose();
return -1;
}
threadHandler->createThread(threadSocketAccept, this);
}
else if (SOCK_DGRAM == nStyle)
{
if (udpClientData)
delete udpClientData;
udpClientData = new CDataHandler<struct sockaddr_in>;
clientHandler(getSocketfd());
}
return 0;
}
else
{
socketClose();
}
}
return -1;
}
int CSocketServer::runClientHandler(int nClientFD)
{
int nFD;
int result;
char pBuf[BUF_SIZE];
void* pvBuf = pBuf;
char szTmp[16];
/**
* clientSockaddr is used for UDP server send packet to client.
*/
struct sockaddr_in *clientSockaddr;
clientSockaddr = new struct sockaddr_in;
while (1)
{
memset(pBuf, 0, sizeof(pBuf));
result = socketrecv(nClientFD, &pvBuf, clientSockaddr);
if (0 >= result)
{
if (externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_DBG("[Socket Server] socket close client: %d", nClientFD);
break;
}
if (nClientFD == getSocketfd())
{
/**
* UDP server receive packet
*/
nFD = ntohs(clientSockaddr->sin_port);
memset(szTmp, 0, sizeof(szTmp));
sprintf(szTmp, "%d", nFD);
udpClientData->setData(szTmp, *clientSockaddr);
}
else
{
nFD = nClientFD;
}
if (externalEvent.isValid())
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventRecvCommand, nFD, result, pBuf);
}
else
{
sendMessage(m_nInternalFilter, EVENT_COMMAND_SOCKET_SERVER_RECEIVE, nFD, result, pBuf);
}
}
delete clientSockaddr;
sendMessage(m_nInternalFilter, EVENT_COMMAND_THREAD_EXIT, threadHandler->getThreadID(), 0, NULL);
threadHandler->threadSleep(1);
threadHandler->threadExit();
return 0;
}
int CSocketServer::start(int nSocketType, const char* cszAddr, short nPort, int nStyle)
{
int nMsgId = -1;
if(-1 != externalEvent.m_nMsgId)
{
nMsgId = initMessage(externalEvent.m_nMsgId, "CSocketServer");
}
else
{
nMsgId = initMessage(m_nInternalFilter, "CSocketServer");
}
if(-1 == nMsgId)
{
_log("[CSocketServer] Init Message Queue Fail");
return -1;
}
if(0 != munRunThreadId)
{
threadHandler->threadCancel(munRunThreadId);
threadHandler->threadJoin(munRunThreadId);
munRunThreadId = 0;
}
threadHandler->createThread(threadServerMessageReceive, this);
if( AF_UNIX == nSocketType)
{
setDomainSocketPath(cszAddr);
}
else if( AF_INET == nSocketType)
{
if(-1 == setInetSocket(cszAddr, nPort))
{
_log("set INET socket address & port fail");
return -1;
}
}
if(-1 != createSocket(nSocketType, nStyle))
{
if(-1 != socketBind())
{
if( SOCK_STREAM == nStyle)
{
if(-1 == socketListen( BACKLOG))
{
perror("socket listen");
socketClose();
return -1;
}
threadHandler->createThread(threadServerSocketAccept, this);
}
else if( SOCK_DGRAM == nStyle)
{
if(udpClientData)
delete udpClientData;
udpClientData = new CDataHandler<struct sockaddr_in>;
dataHandler(getSocketfd());
}
return 0;
}
else
{
socketClose();
}
}
return -1;
}
int CSocketServer::runCMPHandler(int nClientFD)
{
int nFD;
int result = 0;
char szTmp[16];
int nTotalLen = 0;
int nBodyLen = 0;
int nCommand = generic_nack;
int nSequence = 0;
CMP_PACKET cmpPacket;
void* pHeader = &cmpPacket.cmpHeader;
void* pBody;
CMP_HEADER cmpHeader;
//void *pHeaderResp = &cmpHeader;
int nCommandResp;
/**
* clientSockaddr is used for UDP server send packet to client.
*/
struct sockaddr_in *clientSockaddr;
clientSockaddr = new struct sockaddr_in;
if(externalEvent.isValid() && -1 != externalEvent.m_nEventConnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventConnect, nClientFD, 0, 0);
}
mapClientThread[nClientFD] = threadHandler->getThreadID();
while(1)
{
memset(&cmpPacket, 0, sizeof(cmpPacket));
result = socketrecv(nClientFD, sizeof(CMP_HEADER), &pHeader, clientSockaddr);
if(sizeof(CMP_HEADER) == result)
{
nTotalLen = ntohl(cmpPacket.cmpHeader.command_length);
nCommand = ntohl(cmpPacket.cmpHeader.command_id);
nSequence = ntohl(cmpPacket.cmpHeader.sequence_number);
memset(&cmpHeader, 0, sizeof(CMP_HEADER));
nCommandResp = generic_nack | nCommand;
cmpHeader.command_id = htonl(nCommandResp);
cmpHeader.command_status = htonl( STATUS_ROK);
cmpHeader.sequence_number = htonl(nSequence);
cmpHeader.command_length = htonl(sizeof(CMP_HEADER));
if( enquire_link_request == nCommand)
{
socketSend(nClientFD, &cmpHeader, sizeof(CMP_HEADER));
continue;
}
nBodyLen = nTotalLen - sizeof(CMP_HEADER);
if(static_cast<int>(nTotalLen) > MAX_SIZE - 1)
{
cmpPacket.cmpBodyUnlimit.cmpdata = new char[nBodyLen + 1];
pBody = cmpPacket.cmpBodyUnlimit.cmpdata;
result = socketrecv(nClientFD, nBodyLen, &pBody, clientSockaddr);
if(result == nBodyLen)
{
ServerReceive(nClientFD, static_cast<int>(nTotalLen), &cmpPacket);
continue;
}
else
{
socketSend(nClientFD, "Invalid Packet\r\n", strlen("Invalid Packet\r\n"));
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_log("[Socket Server] socket close client: %d , packet length error: %d != %d", nClientFD, nBodyLen,
result);
break;
}
}
else
{
pBody = &cmpPacket.cmpBody;
}
if(0 < nBodyLen)
{
result = socketrecv(nClientFD, nBodyLen, &pBody, clientSockaddr);
if(result != nBodyLen)
{
socketSend(nClientFD, "Invalid Packet\r\n", strlen("Invalid Packet\r\n"));
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_log("[Socket Server] socket close client: %d , packet length error: %d != %d", nClientFD, nBodyLen,
result);
break;
}
}
if(access_log_request == nCommand)
{
socketSend(nClientFD, &cmpHeader, sizeof(CMP_HEADER));
}
}
else if(0 >= result)
{
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
break;
}
else
{
socketSend(nClientFD, "Control Center: Please use CMP to communicate\r\n",
strlen("Control Center: Please use CMP to communicate\r\n"));
_log("[Socket Server] Send Message: Please use CMP to communicate");
if(externalEvent.isValid() && -1 != externalEvent.m_nEventDisconnect)
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventDisconnect, nClientFD, 0, 0);
}
socketClose(nClientFD);
_log("[Socket Server] socket close client: %d , packet header length error: %d", nClientFD, result);
break;
}
if(nClientFD == getSocketfd())
{
/**
* UDP server receive packet,record client information
*/
nFD = ntohs(clientSockaddr->sin_port);
memset(szTmp, 0, sizeof(szTmp));
sprintf(szTmp, "%d", nFD);
udpClientData->setData(szTmp, *clientSockaddr);
}
else
{
nFD = nClientFD;
}
switch(mnPacketHandle)
{
case PK_MSQ:
if(externalEvent.isValid())
{
sendMessage(externalEvent.m_nEventFilter, externalEvent.m_nEventRecvCommand, nFD, nTotalLen,
&cmpPacket);
}
else
{
sendMessage(m_nInternalFilter, EVENT_COMMAND_SOCKET_SERVER_RECEIVE, nFD, nTotalLen, &cmpPacket);
}
break;
case PK_ASYNC:
ServerReceive(nFD, nTotalLen, &cmpPacket);
break;
}
} // while
mapClientThread.erase(nClientFD);
delete clientSockaddr;
sendMessage(m_nInternalFilter, EVENT_COMMAND_THREAD_EXIT, threadHandler->getThreadID(), 0, NULL);
threadHandler->threadSleep(1);
threadHandler->threadExit();
return 0;
}
