void Dispatcher::run()
{
while(1)
{
TCPSocket* speaker = multiListener->listenToSocket(10);
if(speaker!=NULL)
{
int cmd;
speaker->recv((char*)&cmd,4);
cmd = ntohl(cmd);
switch(cmd)
{
case SESSION_ESTABLISHED:
cout<<"connected";
break;
case OPEN_SESSION_WITH_PEER:
{string dest = ReceiveMsg(speaker);
ConnectRequest(speaker->destIpAndPort(),dest);}
break;
case USER_LIST:
sendUserList(speaker);
break;
case ROOM_LIST:
sendRoomList(speaker);
break;
case MEMBERS_LIST:
{string room = ReceiveMsg(speaker);
sendMembersList(speaker,room);}
break;
case CREATE_CHAT:
SetActiveChat(speaker->destIpAndPort());
break;
case CLOSE_CHAT:
CloseUserChat(speaker->destIpAndPort());
break;
case CLOSE_SESSION_WITH_PEER:
closePeer(speaker->destIpAndPort());
break;
default:
break;
}
}
}
}
bool SjOscModule::Start(SjVisImpl* impl, bool justContinue)
{
if( m_oscWindow == NULL )
{
m_impl = impl;
m_showFlags = g_tools->m_config->Read(wxT("player/oscflags"), SJ_OSC_SHOW_DEFAULT);
m_oscWindow = new SjOscWindow(this, impl->GetWindow());
if( m_oscWindow )
{
ReceiveMsg(IDMODMSG_TRACK_ON_AIR_CHANGED);
m_forceSpectrAnim= !justContinue;
m_forceOscAnim = !justContinue;
wxRect visRect = impl->GetRendererClientRect();
m_oscWindow->SetSize(visRect);
m_oscWindow->Show();
return TRUE;
}
}
return FALSE;
}
bool Connection::ReceiveMsg(string &sMsg)
{
bool r = ReceiveMsg();
if (r)
{
sMsg = string(mBuffer + sizeof(unsigned int));
}
return r;
}
int CRoleDBThread::Run()
{
int iRet = 0;
int iCodeLen = 0;
SHandleResult stMsgHandleResult;
while (true)
{
//process all msg
while (true)
{
iRet = ReceiveMsg(iCodeLen);
//receive one msg
if (0 == iRet)
{
iRet = m_stProtocolEngine.Decode((unsigned char*)m_szCodeBuf, iCodeLen, &m_stGameMsg);
//decode success
if (0 == iRet)
{
DEBUG_THREAD(m_iThreadIdx, "Receive code OK, Uin = %u, Msg = %d\n",
m_stGameMsg.m_stmsghead().m_uin(),
m_stGameMsg.m_stmsghead().m_uimsgid());
stMsgHandleResult.iNeedResponse = 0;
stMsgHandleResult.stResponseMsg.Clear();
iRet = ProcessMsg(stMsgHandleResult);
if (0 == iRet)
{
// 不需要回复
if (!stMsgHandleResult.iNeedResponse)
{
continue;
}
iRet = EncodeAndSendMsg(stMsgHandleResult);
if (iRet != 0)
{
TRACE_THREAD(m_iThreadIdx, "Error: encode and push fail. rt:%d\n", iRet);
}
}
}
}
else
{
//no msg in
break;
}
}
usleep(APP_ROLEDB_MAX_SLEEP_USEC);
}
return 0;
}
ACE_THR_FUNC_RETURN KSGateway::bcc_svr_loop_proc(void *arg)
{
KSG_BCC_Config_t *config = static_cast<KSG_BCC_Config_t*>(arg);
ACE_ASSERT(config!=NULL);
int ret;
char err_msg[1024];
KSG_BCC_Svr_Handler *handler = KSG_BCC_Svr_Handler::create_new_handler();
KSG_BCC_Svr_Handler *req_handler;
while(config->bcc_running)
{
ret = ReceiveMsg(handler->get_handler(),err_msg,sizeof(err_msg) -1);
switch(ret)
{
case -1:
KsgGetGateway()->sleep_and_test(config->bcc_intval*2);
continue;
case -2:
ACE_DEBUG((LM_ERROR,"处理失败[%s]",err_msg));
break;
case -3:
ACE_DEBUG((LM_ERROR,"解包错误"));
break;
case 0:
case 1:
case 2:
case 3:
// 处理请求
req_handler = handler;
handler = KSG_BCC_Svr_Handler::create_new_handler();
// 压入任务队列等待处理业务
if(do_process_bcc_task(req_handler))
{
//ACE_DEBUG((LM_ERROR,"处理BCC请求错误!"));
KSG_BCC_Svr_Handler::free_handler(req_handler);
}
break;
default:
break;
}
KsgGetGateway()->sleep_and_test(config->bcc_intval);
}
KSG_BCC_Svr_Handler::free_handler(handler);
return (ACE_THR_FUNC_RETURN)(0);
}
void ServiceClient(int client_sock){
SnifferQuery query;
int32_t data_size=0;
SnifferResponse response;
std::string input_msg_str;
input_msg_str.clear();
char *rx_buffer;
data_size=ReceiveMsg(client_sock,&rx_buffer);
if(data_size==-1){
return;
}
input_msg_str.append(rx_buffer, data_size);
if(!query.ParseFromString(input_msg_str)){
DEBUG_PRINTERR("Error parsing query\n");
delete [] rx_buffer;
return;
}
DEBUG_PRINT("Query:\n"
"\tData size=: %d\n"
"\tMessage: %s\n",data_size,query.DebugString().data());
ProcessQuery(&query,&response);
data_size=response.ByteSize();
char *tx_buffer=new char[data_size];
response.SerializeToArray((void*)tx_buffer,data_size);
DEBUG_PRINT("response:\n"
"\tData size=: %d\n"
"\tMessage: %s\n",data_size,response.DebugString().data());
if(SendMsg(client_sock,tx_buffer,data_size)==-1){
delete [] rx_buffer;
delete [] tx_buffer;
return;
}
delete [] rx_buffer;
delete [] tx_buffer;
}
BOOL DoAuthentication (SOCKET s)
{
BOOL fDone = FALSE;
DWORD cbOut = 0;
DWORD cbIn = 0;
PBYTE pInBuf;
PBYTE pOutBuf;
if(!(pInBuf = (PBYTE) malloc(cbMaxMessage)))
{
MyHandleError("Memory allocation ");
}
if(!(pOutBuf = (PBYTE) malloc(cbMaxMessage)))
{
MyHandleError("Memory allocation ");
}
cbOut = cbMaxMessage;
if (!GenClientContext (
NULL,
0,
pOutBuf,
&cbOut,
&fDone,
TargetName,
hCred,
hcText
))
{
return(FALSE);
}
if (!SendMsg (s, pOutBuf, cbOut ))
{
MyHandleError("Send message failed ");
}
while (!fDone)
{
if (!ReceiveMsg (
s,
pInBuf,
cbMaxMessage,
&cbIn))
{
MyHandleError("Receive message failed ");
}
cbOut = cbMaxMessage;
if (!GenClientContext (
pInBuf,
cbIn,
pOutBuf,
&cbOut,
&fDone,
TargetName,
hCred,
hcText))
{
MyHandleError("GenClientContext failed");
}
if (!SendMsg (
s,
pOutBuf,
cbOut))
{
MyHandleError("Send message 2 failed ");
}
}
free(pInBuf);
free(pOutBuf);
return(TRUE);
}
bool doAuthentication(
SOCKET aSocket,
CredHandle* aphCred,
SecHandle* aphContext)
{
std::vector<BYTE> vInBuffer(c_dwMaxMessage, 0);
std::vector<BYTE> vOutBuffer(c_dwMaxMessage, 0);
DWORD dwIn = 0;
DWORD dwOut = c_dwMaxMessage;
bool fDone = false;
bool fResult = genClientContext(
NULL,
0,
&vOutBuffer[0],
&dwOut,
&fDone,
"192.168.2.40",
aphCred,
aphContext);
if(!fResult)
{
std::cout << "error in first genClientContext\n";
return false;
}
if(!SendMsg(aSocket, &vOutBuffer[0], dwOut))
{
std::cout << "cannot send message = " <<
::GetLastError() << '\n';
return false;
}
while(!fDone)
{
if(!ReceiveMsg(aSocket, &vInBuffer[0], c_dwMaxMessage, &dwIn))
{
std::cout << "cannot receive message = " <<
::GetLastError() << '\n';
return false;
}
dwOut = c_dwMaxMessage;
fResult = genClientContext(
&vInBuffer[0],
dwIn,
&vOutBuffer[0],
&dwOut,
&fDone,
"192.168.2.40",
aphCred,
aphContext);
if(!fResult)
{
std::cout << "error in genClientContext\n";
return false;
}
if(!SendMsg(aSocket, &vOutBuffer[0], dwOut))
{
std::cout << "cannot send message in cycle = " <<
::GetLastError() << '\n';
return false;
}
}
return true;
}
bool receiveEncrypted(
SOCKET aSocket,
void* apMessage,
size_t aszBufferSize,
size_t& aszRecieved,
long* aplDecryptReturn = NULL)
{
size_t szTotalSize = getStreamSizes().cbHeader
+ getStreamSizes().cbMaximumMessage
+ getStreamSizes().cbTrailer;
std::vector<BYTE> vBuffer(szTotalSize, 0);
SecBufferDesc bufferDesc = {0};
SecBuffer secBuff[4] = {0};
bufferDesc.cBuffers = 4;
bufferDesc.pBuffers = secBuff;
size_t szRawRead = 0;
SECURITY_STATUS ssResult = SEC_E_INCOMPLETE_MESSAGE;
while(ssResult == SEC_E_INCOMPLETE_MESSAGE)
{
DWORD dwRead = 0;
bool fResult = ReceiveMsg(
aSocket,
&vBuffer[0],
szTotalSize - szRawRead,
&dwRead);
if(!fResult)
{
std::cout << "cannot receive message\n";
return false;
}
szRawRead += dwRead;
secBuff[0].BufferType = SECBUFFER_DATA;
secBuff[0].cbBuffer = szRawRead;
secBuff[0].pvBuffer = &vBuffer[0];
secBuff[1].BufferType = SECBUFFER_EMPTY;
secBuff[1].cbBuffer = 0;
secBuff[1].pvBuffer = NULL;
secBuff[2].BufferType = SECBUFFER_EMPTY;
secBuff[2].cbBuffer = 0;
secBuff[2].pvBuffer = NULL;
secBuff[3].BufferType = SECBUFFER_EMPTY;
secBuff[3].cbBuffer = 0;
secBuff[3].pvBuffer = NULL;
ULONG ulQop = 0;
ssResult = ::DecryptMessage(
&g_hContext,
&bufferDesc,
0,
&ulQop);
}
if(ssResult != SEC_E_OK)
{
// TODO: remake this
// SEC_I_CONTEXT_EXPIRED - shutdown
// SEC_I_RENEGOTIATE - need to renegotate
if(aplDecryptReturn &&
(ssResult == SEC_I_CONTEXT_EXPIRED ||
ssResult == SEC_I_RENEGOTIATE))
{
*aplDecryptReturn = ssResult;
return true;
}
else
{
if(aplDecryptReturn)
*aplDecryptReturn = ssResult;
std::cout << std::hex <<
"Error in ::DecryptMessage = " << ssResult << '\n';
return false;
}
}
aszRecieved = min(aszBufferSize, secBuff[1].cbBuffer);
memcpy(apMessage, secBuff[1].pvBuffer, aszRecieved);
return true;
}
