/**
@brief 큐 버퍼에서 새로운 패킷을 뽑아낸다.. 패킷이 도착하지 않았으면 FALSE를 리턴한다
*/
BOOL XENetworkConnection::PumpPacket( XPacket *pOutPacket, xtError* pOut )
{
// 패킷펌핑하고 있을때 다른 스레드가 이 커넥션을 사용하지 못하게 막는다.
//
BOOL bRet = FALSE;
{
// 최초 읽은 4바이트는 패킷의 총 길이다
if( m_qBuffer.size() >= sizeof(DWORD) ) { // 큐버퍼에 최소4바이트가 모여 패킷길이를 알수 있게 되었다
if( m_sizePacket == 0 ) {
m_sizePacket = m_qBuffer.PopDWORD(); // 큐에서 4바이트를 꺼낸다.
if( XBREAK( m_sizePacket > 0xffff /*|| m_sizePacket <= 4*/) ) {
m_sizePacket = 0;
// 정상적이지 않은 패킷이 날아왔음. 접속끊어야 함.
m_qBuffer.clear();
DoDisconnect(); // 즉시 접속을 끊어라.
// 에러 핸들러 호출
*pOut = xERR_PACKET_SIZE_TO_LARGE;
OnError( xERR_PACKET_SIZE_TO_LARGE, m_sizePacket );
return FALSE;
}
}
}
if( XBREAK( m_sizePacket > 0xffff ) ) { // 뭔가 잘못된 경우다
m_sizePacket = 0;
*pOut = xERR_PACKET_SIZE_TO_LARGE;
return FALSE;
}
// 패킷 하나가 완전히 도착하면 패킷 아카이브를 만든다
if( m_sizePacket > 0 && (DWORD)m_qBuffer.Size() >= m_sizePacket ) // 필요한 패킷양 이상이 큐에 쌓였다
{
if( pOutPacket->IsOverBuffer( m_sizePacket ) ) {
pOutPacket->ReAllocBuffer( m_sizePacket + 16 ); // 안전을 위해 16바이트 더 늘임.
}
int popSize = m_qBuffer.PopBlock( pOutPacket->GetBufferPacket()
, pOutPacket->GetMaxBufferSize()
, m_sizePacket ); // 큐에서 sizePacket만큼 pop시킨다
if( XBREAK( popSize == 0 ) )
{
// 패킷에 담는데 에러가 남 접속끊어야 함.
m_qBuffer.clear();
// SetbDestroy( TRUE );
DoDisconnect();
*pOut = xERR_ERROR;
OnError( xERR_PACKET_SIZE_TO_LARGE, m_sizePacket );
return FALSE;
}
pOutPacket->SetPacketLength( m_sizePacket ); // 완성된 패킷이 준비되었다
#ifdef _XCRYPT_PACKET
pOutPacket->IsCryptThenSetFlag(); // 암호화 된 메모리인지 플래그를 세팅한다.
#endif
m_sizePacket = 0;
bRet = TRUE;
}
}
//
if( bRet ) {
*pOut = xERR_NOERROR;
}
return bRet;
}
void
NetGameClient::ExecFrame()
{
if (local_player) {
if (local_player->GetObjID() == 0) {
SendJoinRequest();
}
else if (active) {
// check health of server:
NetPeer* server_peer = link->FindPeer(server_id);
if (server_peer && (NetLayer::GetUTC() - server_peer->LastReceiveTime() > 15)) {
NetMsg net_disco(0, NET_DISCONNECT, 0, 0, 0);
DoDisconnect(&net_disco);
}
// if server is still there,
else if (server_peer) {
// check if any old join announcements still need to be processed:
ListIter<NetJoinAnnounce> iter = join_backlog;
while (++iter) {
NetJoinAnnounce* join_ann = iter.value();
if (DoJoinBacklog(join_ann)) {
iter.removeItem();
delete join_ann;
}
}
}
}
}
NetGame::ExecFrame();
}
// 다수의 워커스레드에서 해당 커넥션(소켓)으로부터 데이타를 받으면 호출됨
bool XEWinConnectionInServer::tRecvData( DWORD readbytes )
{
bool bOk = true;
do {
// if( IsDisconnected() == TRUE ) // 이런경우가 있음(언젠진 모름)
// break;
// if( IsDestroy() )
// break;
// 이전에 m_Buffer에 받았던데이타가 아직 큐에 밀어넣지 못한채로 또 불렸다.
// 받은 데이터를 큐에 밀어넣음.
int bytePushed = XENetworkConnection::PushBlock( m_Buffer, readbytes ); // 최적화를 위해 만듬. 큐에 하나씩 보내지않고 뭉탱이로 보냄
const int sizeQ = GetSizeQueue();
if( sizeQ > GetsizeMaxQ() )
SetsizeMaxQ( sizeQ );
// 만약 큐가 꽉차서 더이상 못밀어 넣었다면?
// 큐는 넉넉하게 잡아놔야겠지만 그것마저 꽉 채울정도라면 비정상으로 보고 끊어야 하지 않을까 싶다.
// 일단은 로그라도 남겨야 한다.
// 밀어넣은데이타와 실제 푸쉬된 데이타의 크기가 다르면 에러.
// XBREAKF( bytePushed != readbytes, "bytePushed(%d) != readBytes(%d): ip=%s",
// bytePushed, readbytes, m_szIP );
if( bytePushed != readbytes ) {
OnError( XENetworkConnection::xERR_Q_IS_FULL, sizeQ );
DoDisconnect();
bOk = false;
}
// m_bFlush = TRUE;
} while(0);
return bOk;
}
//------------------------------------------------------------------*
HRESULT CFCMessageSessionThread::ConnectThread()
{
HRESULT hr = CoGetInterfaceAndReleaseStream(m_pMsgSessionStream, IID__FCMessageSessionNotificationInternal,
(void **)&m_pMsgSession);
m_pMsgSessionStream = NULL;
if (FAILED(hr))
return hr;
while(!m_bShutdownRequest) {
hr = DoConnect();
if (FAILED(hr)) {
m_pMsgSession->OnStateChanged(m_cookie, interrupted, hr);
WaitForSingleObject(m_hShutdownRequest, 20000);
continue;
}
m_pMsgSession->OnStateChanged(m_cookie, RW_established, S_OK);
while (!m_bShutdownRequest) {
if (WAIT_TIMEOUT == WaitForSingleObject(m_hShutdownRequest, 10000)) {
hr = DoCheckConnection();
if (FAILED(hr)) {
m_pMsgSession->OnStateChanged(m_cookie, interrupted, hr);
break;
}
}
}
}
DoDisconnect();
m_pMsgSession->Release();
m_pMsgSession = NULL;
return S_OK;
}
void CNetworkLayerTestDlg::OnBnClickedButtonDisconnect()
{
TRY_CATCH
DoDisconnect();
CATCH_LOG("CNetworkLayerTestDlg::OnBnClickedButtonDisconnect")
}
int CExchangeServer::Disconnect()
{
// if (IsConnected())
// {
return DoDisconnect();
// }
// return -1; //0 on success, != 0 otherwise
}
/**
@brief
*/
void XEWinConnectionInServer::ProcessHeartBeat()
{
// XLOCK_OBJ;
//////////////////////////////////////////////////////////////////////////
if( m_modeHeartBeat == xHB_READY ) {
if( m_timerHeartBeat.IsOff() )
m_timerHeartBeat.Set( 10.f );
// x초 기다리고 요청패킷을 보내본다.
if( m_timerHeartBeat.IsOver() ) {
// 확인패킷 보내고 10초짜리 타이머 돌린다. 10초안에 응답이 안오면 이 커넥트는 끊는다.
// 아이폰에서 테스트할때 와이파이에서 3G로 바꿔서 연결끊어졌는데 소켓으로 데이타는 계속 날아가는
// 현상 있었음. 클라가보내는 응답도 받아야 할듯?
XPacket ar((ID)XE::xXEPK_REQUEST_HB);
Send( ar );
if( IsDisconnected() == FALSE ) {
m_modeHeartBeat = xHB_REQUEST;
float secNotResponse = 40.f; // 디폴트
if( XEOption::sGet() ) {
auto sec = XEOption::sGet()->GetParam().GetFloat( "sec_not_response" );
if( sec > 0 ) {
secNotResponse = sec;
} else {
CONSOLE( "경고: ini에 sec_not_response값이 정해지지 않았음. 디폴트 40초로 합니다." );
}
}
m_timerHeartBeat.Set( secNotResponse );
}
}
} else
//////////////////////////////////////////////////////////////////////////
if( m_modeHeartBeat == xHB_REQUEST ) {
// 기다리는중.
if( m_timerHeartBeat.IsOver() ) {
#if defined(_DEBUG) && !defined(_XNOT_BREAK)
m_modeHeartBeat = xHB_READY;
m_timerHeartBeat.Off();
// DoDisconnect(); // 디버그 모드에서 끊김 테스트를 위해..
#else
// 응답이 없으므로 이 커넥션은 끊는다.
#if _DEV_LEVEL <= DLV_DEV_EXTERNAL
auto spUser = GetspUser();
if( spUser ) {
CONSOLE("응답이 없는 소켓이 발견되어 연결을 끊습니다: ip=%s, idAcc=%d", m_szIP, spUser->GetidUser() );
} else {
CONSOLE("응답이 없는 소켓이 발견되어 연결을 끊습니다: %s", m_szIP );
}
#endif
OnFireConnectBefore(); // 서버에서 자르기 전에 이벤트 핸들러.
DoDisconnect();
m_timerHeartBeat.Off();
#endif // not debug
}
}// else
}
//------------------------------------------------------------------*
HRESULT CFCMessageSessionThread::DoConnect()
{
HRESULT hr;
if (m_pMessage != NULL)
return S_OK;
TrcPrint(TRC_INTERFACE, _T("MsgSession: DoConnect(%s)\n"),(LPCTSTR) m_pRawMsgSession->m_strMachineName);
hr = ConnectToOnlineServer(&m_pMessage);
if (FAILED(hr))
return hr;
if (m_pMessage == NULL)
return E_FAIL;
hr = m_pMessage->QueryInterface(IID_IConnection,(void**)&m_pCheckConnection);
if (FAILED(hr))
return hr;
hr = Login();
if (FAILED(hr)) {
DoDisconnect();
return hr;
}
hr = AtlAdvise(m_pMessage, GetUnknown(), IID__ICERemoteMessageEvent, &m_dwMsgNotifyCookie);
if (FAILED(hr)) {
DoDisconnect();
return hr;
}
hr = m_pMessage->Connect(m_lKey);
if (FAILED(hr)) {
TRACE(_T("MsgSession::Connected callback: error while trying to connect to message source; 0x%08X\n"), hr);
TrcPrint(TRC_ERROR, _T("MsgSession::Connected callback: error while trying to connect to message source; 0x%08X\n"), hr);
DoDisconnect();
return hr;
}
return hr;
}
// 새 유저객체를 만들어 유저매니저에 넣는다.
XSPUserBase XEWinSocketSvr::CreateAddToUserMng( XSPWinConnInServer spConnect, XSPDBAcc spAccount )
{
// 커넥션이 끊긴채로 왔으면 생성하지 않는다.
// 커넥션이 생성되고 메인스레드의 Process에서 XUser가 연결되기까지
// 아주 잠깐동안의 시간이 있는데 이시간동안 만약 접속이 끊기면 유저 등록을 취소해야한다.
if( spConnect->IsDisconnected() ) {
// 드문경우라서 로그를 한번 남겨봄. 너무 자주나오면 없앰.
//#if _DEV_LEVEL <= DLV_DEV_EXTERNAL
CONSOLE_THIS( "connect", "pConnect is disconnected. ip=%s", spConnect->GetszIP() );
//#endif
return nullptr;
}
XBREAK( m_pUserMng == nullptr );
// 유저 생성
auto spNewUser = CreateUser( spConnect ); // virtual
// 아마도 메모리풀 꽉참? 혹은 CreateUser미구현?
if( XBREAK( spNewUser == nullptr ) )
return nullptr;
spNewUser->SetspDBAccount( spAccount );
// 유저매니저에 넣는다.
// 넣기전 중복체크
const ID idUser = spNewUser->GetidUser();
{
auto spExist = m_pUserMng->GetspUserFromidAcc( idUser );
if( spExist ) {
#if _DEV_LEVEL <= DLV_DEV_EXTERNAL
CONSOLE( "중복접속 계정: idAcc=%d", spExist->GetidUser() );
#endif
spExist->DoDisconnect(); // 일단 먼저 끊고
spExist->DoDestroy(); // 커넥션 삭제되도록 파괴 메시지
m_pUserMng->DelUser( spExist ); // 기존유저에게 이벤트핸들링 호출하고 리스트에서 삭제
spExist.reset();
}
}
// 새 유저객체 등록
auto bSuccess = m_pUserMng->Add( spNewUser );
//
// if( XBREAK( bSuccess == false ) ) {
// spNewUser = nullptr;
// }
if( XASSERT( bSuccess ) ) {
spConnect->SetspUser( spNewUser ); // 커넥션에 유저를 붙인다.
// idAcc로 커넥션 찾는 맵에 등록.
auto pMap = &m_Logined.m_shoMapByidAcc.GetSharedObj();
(*pMap)[ spAccount->GetidAccount() ] = spConnect;
m_Logined.m_shoMapByidAcc.ReleaseSharedObj();
spNewUser->OnLogined(); // 유저객체로 핸들러를 날려준다.
} else {
spNewUser = nullptr;
}
return spNewUser;
}
//------------------------------------------------------------------*
HRESULT COPCConnection::ConnectThread()
{
while (!m_bShutdownRequest) {
if (!m_bConnected) {
HRESULT hr = DoConnect();
if (FAILED(hr)) {
Sleep(5000);
}
}
if (m_bConnected) {
HRESULT hr = DoWorkItem();
if (FAILED(hr)) {
DoDisconnect();
Sleep(5000);
}
}
Sleep(1000);
}
if (m_bConnected)
DoDisconnect();
return S_OK;
}
void
NetGame::Recv()
{
NetMsg* msg = link->GetMessage();
while (msg) {
if (active) {
// For Debug Convenience:
// NetPlayer* player = FindPlayerByNetID(msg->NetID());
switch (msg->Type()) {
case NET_JOIN_REQUEST: DoJoinRequest(msg); break;
case NET_JOIN_ANNOUNCE: DoJoinAnnounce(msg); break;
case NET_QUIT_REQUEST: DoQuitRequest(msg); break;
case NET_QUIT_ANNOUNCE: DoQuitAnnounce(msg); break;
case NET_GAME_OVER: DoGameOver(msg); break;
case NET_DISCONNECT: DoDisconnect(msg); break;
case NET_OBJ_LOC: DoObjLoc(msg); break;
case NET_OBJ_DAMAGE: DoObjDamage(msg); break;
case NET_OBJ_KILL: DoObjKill(msg); break;
case NET_OBJ_SPAWN: DoObjSpawn(msg); break;
case NET_OBJ_HYPER: DoObjHyper(msg); break;
case NET_OBJ_TARGET: DoObjTarget(msg); break;
case NET_OBJ_EMCON: DoObjEmcon(msg); break;
case NET_SYS_DAMAGE: DoSysDamage(msg); break;
case NET_SYS_STATUS: DoSysStatus(msg); break;
case NET_ELEM_CREATE: DoElemCreate(msg); break;
case NET_ELEM_REQUEST: DoElemRequest(msg); break;
case NET_SHIP_LAUNCH: DoShipLaunch(msg); break;
case NET_NAV_DATA: DoNavData(msg); break;
case NET_NAV_DELETE: DoNavDelete(msg); break;
case NET_WEP_TRIGGER: DoWepTrigger(msg); break;
case NET_WEP_RELEASE: DoWepRelease(msg); break;
case NET_WEP_DESTROY: DoWepDestroy(msg); break;
case NET_COMM_MESSAGE: DoCommMsg(msg); break;
case NET_CHAT_MESSAGE: DoChatMsg(msg); break;
case NET_SELF_DESTRUCT: DoSelfDestruct(msg); break;
}
}
delete msg;
msg = link->GetMessage();
}
}
void MOB_Connection::handle_read_body(const boost::system::error_code& error)
{
if (error)
{
printf("WARN: %s",error.message().c_str());
call_MOB_OnDisconnect(__FUNCTION__,0);
return;
}
if(!m_pPlugin->MOB_OnReadPacket(m_pDataBuff_Read, m_PPacketHeader_Read.data_length))
{
DoDisconnect("MOB_Connection::handle_read_body MOB_OnReadPacket",0);
return;
}
this->read_socket();
}
int main(int argc, char **argv) {
char data[512];
char host[4];
init(argc, argv);
pthread_mutex_init(&client_lock, NULL);
pthread_create(&data_thread, NULL, DataSender, NULL);
while (true) {
char type;
char client;
int direction;
int port;
if (Listen(data))
continue;
ParseMessage(data, &type, &client);
switch(type) {
case CONNECT:
ParseConnect(data, host, &port, &client);
pthread_mutex_lock(&client_lock);
DoConnect(host, port);
pthread_mutex_unlock(&client_lock);
break;
case DISCONNECT:
pthread_mutex_lock(&client_lock);
DoDisconnect(client);
pthread_mutex_unlock(&client_lock);
break;
case ENGINE:
ParseEngine(data, &direction);
DoEngine(client, direction);
break;
case TURN:
ParseTurn(data, &direction);
DoTurn(client, direction);
break;
default:
fprintf(stderr, "Unknown message:\t%d\n", &type);
break;
}
}
}
void EvtConnectionTestCase::SinkTest()
{
// Let the sink be destroyed before the sources
// An event used below
wxTestEvent evt;
// Connect two event handlers to one sink
wxEvtHandler eh1, eh2;
gs_psrc1 = &eh1;
gs_psrc2 = &eh2;
{
wxTestSink ts;
CPPUNIT_ASSERT( !ts.GetFirst() );
DoConnect(eh1, eh2, ts);
DoDisconnect(eh1, eh2, ts);
DoConnect(eh1, eh2, ts);
// Fire events
evt.SetEventObject(&eh1);
eh1.ProcessEvent(evt);
evt.SetEventObject(&eh2);
eh2.ProcessEvent(evt);
// Make sure they were processed correctly
CPPUNIT_ASSERT_EQUAL( 0x00010001, gs_value );
}
// Fire events again, should be no sink connected now
gs_value = 0;
evt.SetEventObject(&eh1);
eh1.ProcessEvent( evt );
evt.SetEventObject(&eh2);
eh2.ProcessEvent( evt );
// Make sure no processing happened
CPPUNIT_ASSERT_EQUAL( 0, gs_value );
}
void DisconnectRas(int Notify)
{
RASCONN *RasConn;
int Num;
if(m_hDll != NULL)
{
if((Num = GetCurConnections(&RasConn)) != -1)
{
if(Num > 0)
{
if((Notify == NO) ||
(DialogBox(GetFtpInst(), MAKEINTRESOURCE(rasnotify_dlg), GetMainHwnd(), ExeEscDialogProc) == YES))
{
DoDisconnect(RasConn, Num);
}
}
free(RasConn);
}
}
return;
}
void PVAuthorEngineNodeUtility::NodeCommandCompleted(const PVMFCmdResp& aResponse)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_STACK_TRACE,
(0, "PVAuthorEngineNodeUtility::NodeCommandCompleted"));
if (iCmdQueue.empty())
{
LOG_ERR((0, "PVAuthorEngineNodeUtility::NodeCommandCompleted: Error - Empty command queue"));
PVMFAsyncEvent event(PVMFErrorEvent, PVMFFailure, NULL, NULL);
iObserver->NodeUtilErrorEvent(event);
return;
}
PVAENodeUtilCmd cmd = iCmdQueue[0];
if (aResponse.GetCmdStatus() != PVMFSuccess)
{
PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR,
(0, "PVAuthorEngineNodeUtility::NodeCommandCompleted: Command failed - context=0x%x, status=0x%x",
aResponse.GetContext(), aResponse.GetCmdStatus()));
CompleteUtilityCmd(cmd, aResponse.GetCmdStatus());
return;
}
PVMFStatus status = PVMFSuccess;
switch (cmd.iType)
{
case PVAENU_CMD_CONNECT:
status = CompleteConnect(cmd, aResponse);
break;
case PVAENU_CMD_DISCONNECT:
status = DoDisconnect(cmd);
break;
case PVAENU_CMD_QUERY_UUID:
status = PVMFSuccess;
break;
case PVAENU_CMD_QUERY_INTERFACE:
status = CompleteQueryInterface(cmd);
break;
case PVAENU_CMD_INIT:
status = CompleteStateTransition(cmd, EPVMFNodeInitialized);
break;
case PVAENU_CMD_PREPARE:
status = CompleteStateTransition(cmd, EPVMFNodePrepared);
break;
case PVAENU_CMD_START:
status = CompleteStateTransition(cmd, EPVMFNodeStarted);
break;
case PVAENU_CMD_PAUSE:
status = CompleteStateTransition(cmd, EPVMFNodePaused);
break;
case PVAENU_CMD_STOP:
case PVAENU_CMD_FLUSH:
status = CompleteStateTransition(cmd, EPVMFNodePrepared);
break;
case PVAENU_CMD_RESET:
status = CompleteStateTransition(cmd, EPVMFNodeCreated);
break;
default:
status = PVMFFailure;
break;
}
if (status != PVMFPending)
{
CompleteUtilityCmd(cmd, status);
}
else if (iCmdQueue.size() == 1) { // kick off the execution of the command
RunIfNotReady();
}
}
void MOB_Connection::handle_read(const boost::system::error_code& error, size_t bytes_transferred)
{
if (error)
{
jWARN("WARN: %s\n",error.message().c_str());
jWARN("> category=%s , value=%d\n", error.category().name() ,error.value());
call_MOB_OnDisconnect("socket out error",0);
return;
}
const int iSIZE_m_pDataBuff_Readed = nMOB::BUFFER_SIZE*8;
const int iHEADER_SIZE= sizeof(int);
if((bytes_transferred + m_iReadedSize) >= iSIZE_m_pDataBuff_Readed )
{
DoDisconnect(("socket out if((bytes_transferred+ m_iReadedSize)>= iSIZE_m_pDataBuff_Readed)"),0);
return;
}
memcpy(m_pDataBuff_Readed+m_iReadedSize,m_pDataBuff_Read,bytes_transferred);
m_iReadedSize+=bytes_transferred;
if(m_iReadedSize<= iHEADER_SIZE)
{
_async_read_some();
return;
}
char* pBody = m_pDataBuff_Readed;
int iLengthBody=0;
memcpy(&iLengthBody , pBody, iHEADER_SIZE);
pBody+=iHEADER_SIZE;
if(iLengthBody<=0 || (iLengthBody>=(BUFFER_SIZE-iHEADER_SIZE) ) )
{
DoDisconnect(("socket out error if(iLengthBody<=0 || (iLengthBody>=(BUFFER_SIZE-iHEADER_SIZE) ) )"),0);
return;
}
if(iLengthBody > (m_iReadedSize-iHEADER_SIZE) )
{
// 바디가 iLengthBody만큼 못읽었으모.
_async_read_some();
return;
}
size_t iStayReadedSize = m_iReadedSize;
try
{
for(;;)
{
if(!m_pPlugin->MOB_OnReadPacket(pBody, iLengthBody))
{
DoDisconnect(__FUNCTION__,0);
return;
}
iStayReadedSize -= (iLengthBody+iHEADER_SIZE);
if(iStayReadedSize<=0)
{
m_iReadedSize=0;
break;
}
jWARN(_T("data뭉쳐서왔다."));
if(iStayReadedSize<= iHEADER_SIZE)
{
memmove(m_pDataBuff_Readed, pBody, iStayReadedSize);
m_iReadedSize=iStayReadedSize;
break;
}
//파싱할 패킷이 남았다.
pBody = pBody+iLengthBody;
memcpy(&iLengthBody,pBody,iHEADER_SIZE);
if(iLengthBody > (int)(iStayReadedSize-iHEADER_SIZE ) ) //아직 바디 데이타가 완성안되었으모.
{
memmove(m_pDataBuff_Readed, pBody, iLengthBody);
m_iReadedSize=iLengthBody;
break;
}
pBody+=iHEADER_SIZE;
}//for(;;)
_async_read_some();
}
catch (...)
{
DoDisconnect("MOB_Connection::handle_read try",0);
}
}
void XEUser::DoDisconnect()
{
auto spConn = m_spConnect.lock();
spConn->DoDisconnect();
}
void PVAuthorEngineNodeUtility::Run()
{
LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: Enter"));
if (iCmdQueue.empty())
return;
PVAENodeUtilCmd cmd = iCmdQueue[0];
if (cmd.iNodes.empty())
{
LOG_ERR((0, "PVAuthorEngineNodeUtility::Run: Error - cmd.iNodes is empty"));
CompleteUtilityCmd(cmd, PVMFFailure);
return;
}
PVMFStatus status = PVMFFailure;
LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: cmd.iType=%d", cmd.iType));
switch (cmd.iType)
{
case PVAENU_CMD_CONNECT:
status = DoConnect(cmd);
break;
case PVAENU_CMD_DISCONNECT:
status = DoDisconnect(cmd);
break;
case PVAENU_CMD_QUERY_UUID:
status = DoQueryUuid(cmd);
break;
case PVAENU_CMD_QUERY_INTERFACE:
status = DoQueryInterface(cmd);
break;
case PVAENU_CMD_INIT:
status = DoInit(cmd);
break;
case PVAENU_CMD_PREPARE:
status = DoPrepare(cmd);
break;
case PVAENU_CMD_START:
status = DoStart(cmd);
break;
case PVAENU_CMD_PAUSE:
status = DoPause(cmd);
break;
case PVAENU_CMD_STOP:
status = DoStop(cmd);
break;
case PVAENU_CMD_FLUSH:
status = DoFlush(cmd);
break;
case PVAENU_CMD_RESET:
status = DoReset(cmd);
break;
default:
status = PVMFFailure;
break;
}
if (status != PVMFPending)
CompleteUtilityCmd(cmd, status);
LOG_STACK_TRACE((0, "PVAuthorEngineNodeUtility::Run: Exit"));
}
int ConnectRas(int Dialup, int UseThis, int Notify, char *Name)
{
RASDIALDLG DlgParam;
RASCONN *RasConn;
int i;
int Num;
int Sts;
int DoDial;
RASDIALPARAMS Param;
BOOL Flg;
OSVERSIONINFO VerInfo;
Sts = SUCCESS;
if(Dialup == YES)
{
if(m_hDll != NULL)
{
/* 現在の接続を確認 */
DoDial = 1;
if((Num = GetCurConnections(&RasConn)) != -1)
{
if(Num > 0)
{
DoDial = 0;
if(UseThis == YES)
{
DoDial = 2;
for(i = 0; i < Num; i++)
{
if(_mbscmp(RasConn[i].szEntryName, Name) == 0)
DoDial = 0;
}
if(DoDial == 2)
{
if((Notify == NO) ||
(DialogBox(GetFtpInst(), MAKEINTRESOURCE(rasreconnect_dlg), GetMainHwnd(), ExeEscDialogProc) == YES))
{
DoDisconnect(RasConn, Num);
}
else
DoDial = 0;
}
}
}
free(RasConn);
}
if(DoDial != 0)
{
/* 接続する */
SetTaskMsg(MSGJPN221);
Sts = FAIL;
Num = 0;
VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if(GetVersionEx(&VerInfo) == TRUE)
{
if(VerInfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
Num = 1;
}
if(Num == 1)
{
if(m_hDll2 != NULL)
{
/* Windows NT */
DlgParam.dwSize = sizeof(RASDIALDLG);
DlgParam.hwndOwner = GetMainHwnd();
DlgParam.dwFlags = 0;
DlgParam.dwSubEntry = 0;
DlgParam.reserved = 0;
DlgParam.reserved2 = 0;
if((*m_RasDialDlg)(NULL, Name, NULL, &DlgParam) != 0)
Sts = SUCCESS;
}
else
SetTaskMsg(MSGJPN222);
}
else
{
/* Windows 95,98 */
Param.dwSize = sizeof(RASDIALPARAMS);
strcpy(Param.szEntryName, Name);
Flg = TRUE;
Sts = (*m_RasGetEntryDialParams)(NULL, &Param, &Flg);
strcpy(Param.szPhoneNumber, "");
if(((strlen(Param.szUserName) != 0) && (strlen(Param.szPassword) != 0)) ||
(DialogBoxParam(GetFtpInst(), MAKEINTRESOURCE(dial_password_dlg), GetMainHwnd(), (DLGPROC)DialPassCallBackProc, (LPARAM)&Param) == YES))
{
if(DialogBoxParam(GetFtpInst(), MAKEINTRESOURCE(dial_dlg), GetMainHwnd(), (DLGPROC)DialCallBackProc, (LPARAM)&Param) == YES)
Sts = SUCCESS;
}
}
}
}
}
return(Sts);
}
void XEWinSocketSvr::WorkThread()
{
unsigned long readbytes;
unsigned long dwCompKey;
// OVERLAPPED * pOverlap;
XE::xOVERLAPPED* pOverlap = nullptr;
while( 1 ) {
// 클라이언트로부터 데이타가 오길 기다림
BOOL bRet = GetQueuedCompletionStatus( m_hIOCP, &readbytes, &dwCompKey, (LPOVERLAPPED*)&pOverlap, INFINITE );
// TODO:
#pragma message("리턴값처리 제대로 할것. ")
if( bRet == FALSE ) {
auto err = GetLastError();
TCHAR* szMsg = nullptr;
FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER
, nullptr
, err
, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT)
, (TCHAR*)&szMsg
, 0
, nullptr );
if( pOverlap == nullptr ) {
return;
} else {
if( readbytes ) {
// 패킷을 dequeue했지만 실패한I/O에 대한 dequeue였다.
} else {
// 클라이언트 소켓 close
}
}
} else {
if( pOverlap == nullptr )
return;
}
const auto typeEvent = pOverlap->typeEvent;
if( bRet == FALSE && pOverlap == nullptr ) {
return;
}
// 어떤 커넥션으로부터 데이타가 도착함.
// 어떤 클라이언트 연결로부터 왔는지 알아냄
ID idConnect = (ID)dwCompKey;
// 해당 커넥션객체를 찾음.
auto spConnect = FindspConnect( idConnect ); // 스레드안전
//
if( spConnect ) {
XAUTO_LOCK3( spConnect );
//
if( readbytes != 0 ) {
#if _DEV_LEVEL <= DLV_DEV_EXTERNAL
if( spConnect->IsDisconnected() ) {
CONSOLE( "connect", "끊어진 소켓에서 IOCP발생" );
}
#endif
// 받은 데이터를 큐에 밀어넣음
// 접속되고 곧바로 recv가 온다면 커넥션객체에 채 XUser가 붙기도 전에 이게 호출될수도 있음.
// 그러므로 그런패킷은 일단 커넥션 큐안에 쌓아둬야 한다.
if( !spConnect->IsDisconnected() && !spConnect->IsbDestroy() ) {
if( typeEvent == 1 ) { // send의 완료는 따로 처리할것이 없음.
// send
continue;
// spConnect->SendData( )
}
else {
// recv
spConnect->tRecvData( readbytes );
#if _DEV_LEVEL <= DLV_OPEN_BETA
const int sizeQ = spConnect->GetSizeQueue();
// 최대 큐크기 표시용
if( sizeQ > m_sizeMaxQ )
m_sizeMaxQ = sizeQ;
#endif
// 비동기 recv를 큐에 올림
spConnect->tWSARecv();
}
}
} else {
// 접속 끊김
// 서버의 다른데서 소켓닫으면 여기로 들어오나?
spConnect->Set_bConnected( FALSE ); // 연결해제 플래그만 켜고 실제 삭제처리는 메인스레드에서.
if( bRet && pOverlap == nullptr ) {
spConnect->DoDisconnect();
return;
}
BTRACE( "disconnected:%s", GetszName() );
continue; // 끊긴 커넥션이므로 더이상 처리안해도 된다.
} // if( readbytes == 0 ) { // 접속 끊김
} else {
#if (_DEV_LEVEL <= DLV_DEV_EXTERNAL) && !defined(_XBOT)
CONSOLE( "이미 삭제되거나 없는 연결에서 데이타가 도착했습니다." );
#endif
} // if( pConn ) {
Sleep( m_msecSleepRecv );
} // while(1)
} // WorkThread()
// 접속해제 요청이 들어온 커넥션을 끊음.
void XClientConnection::RecvDisconnectMe( XPacket& ar )
{
DoDisconnect();
}
// 클라이언트로부터 패킷을 받음.
BOOL XClientConnection::ProcessPacket(DWORD idPacket, ID idKey, XPacket& p)
{
TRACE( "recv packet: %d - \n", idPacket );
int retv = 1;
if ( idPacket == xCL2GS_ACCOUNT_REQ_LOGIN )
RecvLogin(p);
else {
auto pUser = SafeCast<XGameUser*>(GetspUser().get());
if (XBREAK(pUser == nullptr)) {
CONSOLE("idPacket=%d, idConnect=0x%08x", idPacket, GetidConnect());
OnInvalidVerify();
// DoDisconnect();
return FALSE;
}
switch (idPacket)
{
// case xCL2GS_ACCOUNT_REQ_LOGIN: RecvLogin(p); break;
//case xCL2GS_ACCOUNT_NICKNAME_DUPLICATE: retv = pUser->RecvAccountNickNameDuplicate(p); break;
//case xCL2GS_ACCOUNT_NAME_DUPLICATE: retv = pUser->RecvAccountNameDuplicate(p); break;
case xCL2GS_ACCOUNT_NAME_REGIST: retv = pUser->RecvAccountNameRegist(p); break;
// case xCL2GS_ACCOUNT_LOGIN_FROM_ID: retv = pUser->RecvAccountNameLogin(p); break;
case xCL2GS_ACCOUNT_NICKNAME_CHANGE: retv = pUser->RecvAccountNickNameChange(p); break;
case xCL2GS_LOBBY_SPOT_RECON: retv = pUser->RecvSpotRecon(p); break;
case xCL2GS_LOBBY_SPOT_ATTACK: retv = pUser->RecvSpotAttack(p); break;
case xCL2GS_INGAME_REQ_FINISH_BATTLE: retv = pUser->RecvReqFinishBattle2(p); break;
case xCL2GS_LOBBY_SPOT_COLLECT: retv = pUser->RecvSpotCollect(p); break;
case xCL2GS_LOBBY_OPEN_CLOUD: retv = pUser->RecvOpenCloud(p); break;
// case xCL2GS_LOBBY_ADD_HERO_EXP: retv = pUser->RecvAddHeroExp(p); break; //영웅 정보가 변경 되었습니다.
case xCL2GS_LOBBY_CHANGE_HERO_LEGION: retv = pUser->RecvChageHeroLegion(p); break;
case xCL2GS_LOBBY_CHANGE_HERO_EQUIPMENT:retv = pUser->RecvChageHeroEquip(p); break;
case xCL2GS_LOBBY_SUMMON_HERO: retv = pUser->RecvSummonHero(p); break;
case xCL2GS_LOBBY_NEW_SQUAD: retv = pUser->RecvNewSquad(p); break;
case xCL2GS_LOBBY_MOVE_SQUAD: retv = pUser->RecvMoveSquad(p); break;
case xCL2GS_LOBBY_CHANGE_SQUAD: retv = pUser->RecvChangeSquad(p); break;
case xCL2GS_LOBBY_ITEM_SHOP_LIST_CASH: retv = pUser->RecvItemSellList(p); break;
// case xCL2GS_LOBBY_ITEM_SHOP_LIST_TIME: retv = pUser->RecvItemSellList(p); break; ///< 시간 만료 아이템 상점 판매 목록
case xCL2GS_LOBBY_ITEM_BUY: retv = pUser->RecvBuyItem(p); break; ///< 아이템 구매
case xCL2GS_LOBBY_ITEM_SELL: retv = pUser->RecvSellItem(p); break; ///< 아이템 상점에 판매
case xCL2GS_LOBBY_ITEM_SPENT: retv = pUser->RecvItemSpent(p); break; ///< 아이템 사용
case xCL2GS_LOBBY_INVENTORY_EXPAND: retv = pUser->RecvInventoryExpand(p); break; ///< 인벤토리 확장
case xCL2GS_CAMP_REWARD: retv = pUser->RecvCampaignReward( p ); break;
case xCL2GS_TRAIN_HERO_BY_GOLD: retv = pUser->RecvTrainHeroByGold( p ); break;
case xCL2GS_INIT_ABIL: retv = pUser->RecvInitAbil( p ); break;
// #ifdef _INAPP_GOOGLE
case xCL2GS_LOBBY_CASH_ITEM_BUY_PAYLOAD:retv = pUser->RecvCashItemBuyPayload(p); break; ///< Inapp 구글플레이_payload
case xCL2GS_LOBBY_CASH_ITEM_BUY_IAP: retv = pUser->RecvBuyCashtemIAP(p); break; ///< Inapp 구글플레이
//#endif
// #ifdef _INAPP_APPLE
// case xCL2GS_LOBBY_CASH_ITEM_BUY_IAP_IOS:retv = pUser->RecvCashItemBuyApple(p); break; ///< Inapp 구매_애플
// #endif
case xCL2GS_CHEAT: retv = pUser->RecvCheat(p); break;
case xCL2GS_CHEAT_CREATE_ITEM: retv = pUser->RecvCheatCreateItem(p); break;
case xCL2GS_LOBBY_POST_INFO: pUser->RecvPostInfoRequest(p); break; //클라이언트 우편함 정보 요청
//case xCL2GS_LOBBY_POST_READ: pUser->RecvPostReadRequest(p); break; //클라이언트 우편함 읽음.(상대편에게 알려 줄까 말까?)
case xCL2GS_LOBBY_POST_GETITEM_ALL: pUser->RecvPostItemGetRequestAll(p); break; //클라이언트 우편물 수령요청
//case xCL2GS_LOBBY_POST_DELETE: pUser->RecvPostDeleteRequest(p); break; //클라이언트 우편물 삭제 요청
case xCL2GS_LOBBY_TRADE: retv = pUser->RecvTrade(p); break;
case xCL2GS_LOBBY_CHANGE_SCALP_TO_BOOK: retv = pUser->RecvChangeScalpToBook(p); break;
// case xCL2GS_LOOBY_UPGRADE_SQUAD: retv = pUser->RecvUpgradeSquad(p); break;
case xCL2GS_LOBBY_RELEASE_HERO: retv = pUser->RecvReleaseHero(p); break;
// case xCL2GS_LOBBY_LEVELUP_SKILL: retv = pUser->RecvLevelUpSkill(p); break;
case xCL2GS_LOBBY_RANKING_INFO: retv = pUser->RecvRankingInfo(p); break; // pUser->SendSubscribePackage(); break;//pUser->Cheat_AddPostInfo(); break;
case xCL2GS_LOBBY_CASH_TRADE_CALL: retv = pUser->RecvTradeCashCall(p); break; // 캐쉬로 무역상 호출.
// case xCL2GS_LOBBY_TIME_TRADE_CALL: retv = pUser->RecvTradeTimeCall(p); break; // 시간으로 무역상 호출.
case xCL2GS_PROMOTION_HERO: retv = pUser->RecvPromotionHero( p ); break;
case xCL2GS_SUMMON_HERO_BY_PIECE: retv = pUser->RecvSummonHeroByPiece( p ); break;
case xCL2GS_UI_ACTION: retv = pUser->RecvUIAction( p ); break;
case xCL2GS_LOBBY_GUILD_INFO: retv = pUser->RecvGuildInfo(p); break;
// case xCL2GS_LOBBY_GUILD_ALL_INFO: retv = pUser->RecvAllGuildInfo(p); break;
case xCL2GS_LOBBY_GUILD_CREATE: retv = pUser->RecvGuildCreate(p); break;
case xCL2GS_LOBBY_GUILD_CHANEGE_OPTION: retv = pUser->RecvGuildChangeOption(p); break;
case xCL2GS_LOBBY_GUILD_CHANEGE_CONTEXT:retv = pUser->RecvGuildChangeContext(p);break;
case xCL2GS_LOBBY_GUILD_CHANGE_MEMBER: retv = pUser->RecvGuildChangeMemberInfo(p); break;
case xCL2GS_LOBBY_GUILD_JOIN_REQ: retv = pUser->RecvGuildJoinReq(p); break;
case xCL2GS_LOBBY_GUILD_JOIN_ACCEPT: retv = pUser->RecvGuildJoinAccept(p); break;
case xCL2GS_LOBBY_GUILD_OUT: retv = pUser->RecvGuildOut(p); break;
case xCL2GS_LOBBY_GUILD_KICK: retv = pUser->RecvGuildKick(p); break;
case xCL2GS_LOBBY_GUILD_BUY_ITEM: retv = pUser->RecvBuyGuildItem( p ); break;
case xCL2GS_QUEST_REQUEST_REWARD: retv = pUser->RecvReqQuestReward(p); break;
case xCL2GS_LOBBY_SPOT_TOUCH: retv = pUser->RecvSpotTouch(p); break;
case xCL2GS_CAMP_CLICK_STAGE: retv = pUser->RecvClickStageInCampaign(p); break;
case xCL2GS_TECH_RESEARCH: retv = pUser->RecvResearch(p); break;
case xCL2GS_TECH_LOCK_FREE: retv = pUser->RecvAbilLockFree(p); break;
case xCL2GS_TECH_RESEARCH_COMPLETE_NOW: retv = pUser->RecvResearchCompleteNow(p); break;
case xCL2GS_RESEARCH_COMPLETE: retv = pUser->RecvCheckResearchComplete(p); break;
case xCL2GS_LOBBY_REGEN_SPOT: retv = pUser->RecvRegenSpot(p); break;
case xCL2GS_LOBBY_REMATCH_SPOT: retv = pUser->RecvReMatchSpot(p); break;
case xCL2GS_INGAME_SULFUR_RETREAT: retv = pUser->RecvSulfurRetreat(p); break;
case xCL2GS_INGAME_BATTLE_START: retv = pUser->RecvBattleStart(p); break;
case xCL2GS_LOBBY_WITHDRAW_MANDRAKE: retv = pUser->RecvWithdrawMandrake(p); break;
// case xCL2GS_TRAIN_HERO: retv = pUser->RecvTrainHero(p); break;
case xCL2GS_CHECK_TRAIN_COMPLETE: retv = pUser->RecvCheckTrainComplete(p); break;
case xCL2GS_CHANGE_HELLO_MSG: retv = pUser->RecvChangeHelloMsg( p ); break;
case xCL2GS_UNLOCK_TRAINING_SLOT: retv = pUser->RecvUnlockTrainingSlot( p ); break;
// case xCL2GS_TRAIN_COMPLETE_TOUCH: retv = pUser->RecvLevelupConfirm(p); break;
case xCL2GS_AP_CHECK_TIMEOVER: retv = pUser->RecvCheckAPTimeOver( p ); break;
case xCL2GS_ACCEPT_LEVELUP: retv = pUser->RecvAccepLevelUp( p ); break;
case xCL2GS_BIT_FLAG_TUTORIAL: retv = pUser->RecvFlagTutorial( p ); break;
case xCL2GS_TECH_UNLOCK_UNIT: retv = pUser->RecvUnlockUnit( p ); break;
case xCL2GS_FILL_AP: retv = pUser->RecvSendReqFillAP( p ); break;
case xCL2GS_TRAIN_COMPLETE_QUICK: retv = pUser->RecvTrainCompleteQuick( p ); break;
case xCL2GS_CLICK_FOG_SQUAD: retv = pUser->RecvClickFogSquad( p ); break;
case xCL2GS_CHECK_UNLOCK_UNIT: retv = pUser->RecvCheckUnlockUnit( p ); break;
case xCL2GS_TOUCH_SQUAD_IN_READY: retv = pUser->RecvTouchSquadInReadyScene( p ); break;
case xCL2GS_CONTROL_SQUAD_IN_BATTLE: retv = pUser->RecvControlSquadInBattle( p ); break;
case xCL2GS_CHECK_ENCOUNTER_LOG: retv = pUser->RecvCheckEncounterLog( p ); break;
case xCL2GS_GOTO_HOME: retv = pUser->RecvGotoHome( p ); break;
case xCL2GS_ACCOUNT_REGISTER_FACEBOOK: retv = pUser->RecvRegisterFacebook( p ); break;
// case xCL2GS_OPEN_GUILD_RAID: retv = pUser->RecvSendReqGuildRaidOpen( p ); break;
case xCL2GS_END_SEQ: retv = pUser->RecvEndSeq( p ); break;
case xCL2GS_REGIST_PUSHMSG: pUser->RecvPushMsgRegist(p); break;
case xCL2GS_UNREGIST_PUSHMSG: pUser->RecvPushMsgUnRegist(p); break;
case xCL2GS_PUSH_GCM_REGIST_ID: retv = pUser->RecvGCMResistId( p ); break;
case xCL2GS_LOBBY: pUser->Cheat_AddPostInfo(); break; //임시 패킷.( 서버 테스트용으로만 사용합니다. 사용을 자재해주세요.)
case xCL2GS_PAYMENT_ASSET: retv = pUser->RecvPaymentAssetByGem( p ); break;
case xCL2GS_PRIVATE_RAID_ENTER_LIST: retv = pUser->RecvPrivateRaidEnterList( p ); break;
case xCL2GS_SPOT_UPDATE_FOR_BATTLE: retv = pUser->RecvUpdateSpotForBattle( p ); break;
case xCL2GS_ENTER_READY_SCENE: retv = pUser->RecvEnterReadyScene( p ); break;
case xCL2GS_SYNC: retv = pUser->RecvSync( p ); break;
case xCL2GS_SHOW_ADS: retv = pUser->RecvShowAdsVideo( p ); break;
case xCL2GS_FINISH_SHOW_ADS: retv = pUser->RecvDidFinishShowAdsVideo( p ); break;
case xCL2GS_POST_DELETE: retv = pUser->RecvPostDelete( p ); break;
case xCL2GS_MEDAL_CLICK_STAGE: retv = pUser->RecvClickStageInMedal( p ); break;
case xCL2GS_HERO_CLICK_STAGE: retv = pUser->RecvClickStageInHero( p ); break;
case xCL2GS_GUILD_RAID_CLICK_STAGE: retv = pUser->RecvClickStageInGuildRaid( p ); break;
case xCL2GS_REQ_EQUIP: retv = pUser->RecvSyncEquip( p ); break;
default:
// 알수없는 패킷이 날아왔다.
XBREAKF(1, "unknown packet 0x%8x", idPacket);
{
DoDisconnect();
return FALSE;
}
break;
}
}
TRACE( "recv packet: end\n" );
// 불량 패킷 보내서 0을 리턴한 유저는 즉각 끊어버린다.
if( retv == 0 )
OnInvalidVerify();
return TRUE;
}
END_DECLS
void do_syscall (Thread * current)
{
#define p_regs (current->u_reg)
switch (p_regs[8]) {
case SYS_CHANNEL_CREATE:
p_regs[0] = DoChannelCreate();
break;
case SYS_CHANNEL_DESTROY:
p_regs[0] = DoChannelDestroy(p_regs[0]);
break;
case SYS_CONNECT:
p_regs[0] = DoConnect(p_regs[0], p_regs[1]);
break;
case SYS_DISCONNECT:
p_regs[0] = DoDisconnect(p_regs[0]);
break;
case SYS_MSGSEND:
p_regs[0] = DoMessageSend(
(Connection_t)p_regs[0],
(void *)p_regs[1],
(size_t)p_regs[2],
(void *)p_regs[3],
(size_t)p_regs[4]
);
break;
case SYS_MSGSENDV:
p_regs[0] = DoMessageSendV(
(Connection_t)p_regs[0],
(struct iovec const *)p_regs[1],
(size_t)p_regs[2],
(struct iovec const *)p_regs[3],
(size_t)p_regs[4]
);
break;
case SYS_MSGRECV:
p_regs[0] = DoMessageReceive(
(Channel_t)p_regs[0],
(uintptr_t *)p_regs[1],
(void *)p_regs[2],
(size_t)p_regs[3]
);
break;
case SYS_MSGRECVV:
p_regs[0] = DoMessageReceiveV(
(Channel_t)p_regs[0],
(uintptr_t *)p_regs[1],
(struct iovec const *)p_regs[2],
(size_t)p_regs[3]
);
case SYS_MSGGETLEN:
p_regs[0] = DoMessageGetLength(p_regs[0]);
break;
case SYS_MSGREAD:
p_regs[0] = DoMessageRead(
(uintptr_t)p_regs[0],
(size_t)p_regs[1],
(void *)p_regs[2],
(size_t)p_regs[3]
);
break;
case SYS_MSGREADV:
p_regs[0] = DoMessageReadV(
(uintptr_t)p_regs[0],
(size_t)p_regs[1],
(struct iovec const *)p_regs[2],
(size_t)p_regs[3]
);
break;
case SYS_MSGREPLY:
p_regs[0] = DoMessageReply(
(uintptr_t)p_regs[0],
p_regs[1],
(void *)p_regs[2],
(size_t)p_regs[3]
);
break;
case SYS_MSGREPLYV:
p_regs[0] = DoMessageReplyV(
(uintptr_t)p_regs[0],
p_regs[1],
(struct iovec const *)p_regs[2],
(size_t)p_regs[3]
);
break;
default:
p_regs[0] = -ERROR_NO_SYS;
break;
}
}
/**
@brief
*/
void XEWinConnectionInServer::Process( void )
{
XPROF_OBJ_AUTO();
// XWinSocketSvr::Process()에서 커넥션별로 락걸어서 들어오고 있음.
// XLOCK_OBJ;
// 소켓이 끊어졌으면 더이상 돌필요 없다.
// if( m_Socket == 0 ) //
// return;
// 쌓인 패킷 다 뽑아낼때까지 락걸어두자 패킷 계속오면 계속 못빠져나올수도...
if( !GetbDestroy() ) {
// 만약 커넥션 프로세스도 멀티스레드에서 돌아가면 이거 전체를 락걸어야 한다.
// 자동연결해제 옵션이 있으면 허트비트 처리
if( GetbAutoDisconnect() ) {
XPROF_OBJ("ProcessHeartBeat");
ProcessHeartBeat();
}
//////////////////////////////////////////////////////////////////////////
{
XPROF_OBJ( "PumpPacket" );
XENetworkConnection::xtError err = XENetworkConnection::xERR_NOERROR;
XPacket p( true );
// while( PumpPacket( &p ) ) {
// 패킷 한번만 뽑고 넘어감.
auto bPump = PumpPacket( &p, &err );
if( bPump ) {
XPROF_OBJ( "ProcessPacket" );
#ifdef _XCRYPT_PACKET
BOOL bOk = FALSE;
if( m_pSocketSvr->GetbEncryption() ) {
bOk = p.DoDecrypto( m_pSocketSvr );
}
#endif
DWORD idPacket;
p >> idPacket;
ID idKey;
p >> idKey;
// 예약된 패킷 처리
if( idPacket == XE::xXEPK_RESPONSE_HB ) {
#ifdef _DEBUG
// CONSOLE("recv heart beat");
#endif
// 응답이 왔으므로 다시 대기상태로...
m_timerHeartBeat.Off();
m_modeHeartBeat = xHB_READY;
}
else {
p._SetidPacket( idPacket );
BOOL result = ProcessPacket( idPacket, idKey, p );
if( result == FALSE ) { // virtual call
// 패킷 처리에 실패함. 접속 끊어야 함.
// 일단 커넥션만 끊음.
DoDisconnect();
// break;
}
}
p.Clear();
} else {
if( err != XENetworkConnection::xERR_NOERROR ) {
CONSOLE( "%s:PumpPacket실패:ip=%s", __TFUNC__, m_szIP );
}
}
}
} // bDestroy
void ConnMgr::AskForHelp(_TCHAR *szMsg)
{
int RetCode = MessageBox(0, szMsg, _T("出错啦"), MB_RETRYCANCEL);
if (RetCode != IDRETRY)
DoDisconnect();
}
