//--------------------------------------------------------------------------------------
void TScRecommutationClient_SlaveImpl::BeginDonor(TDescRecvSession* pDesc)
{
THeaderBeginDonor* pHeader = (THeaderBeginDonor*)pDesc->data;
NeedContextByClientKeyForSlave(pHeader->id_client, true);
if(Context()==NULL)
{
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScRecommutationClient_SlaveImpl::BeginDonor() Context()==NULL.\n");
BL_FIX_BUG();
return;
}
//--------------------------------------------
Context()->SetClientKey(pHeader->id_client);
Context()->SetRoleAsDonor();// роль Донора
// начало сценария
if(Begin()==false)
{
// генерация ошибки
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScRecommutationClient_SlaveImpl::BeginDonor() scenario is not active.\n");
BL_FIX_BUG();
return;
}
// сформировать пакет далее для Клиента
TBreakPacket bp;
THeaderBeginClient h;
h.id_client = Context()->GetClientKey();
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientSlave(), bp);
SetTimeWaitForNow();
}
//---------------------------------------------------------------------------
void TTestControlTank::Send()
{
lockQtSend();
//----------------------------
UpdateAngle();
TBreakPacket bp;
bp.PushFront((char*)mDesc.get(), sizeof(TDesc));
TDevTool_Share::TComponent* pComponent = TDevTool_Share::Singleton()->GetComponent();
PrototypeMMOBaseServer* pBS = (PrototypeMMOBaseServer*)pComponent->mNet.Base;
std::list<unsigned int> listKey;
//###
// рассылка всем клиентам
PrototypeMMOSlave::TDescDownSlave descDown;
int sizeDesc = sizeof(descDown);
int countClient = pComponent->mNet.Slave->GetCountDown();
for( int iClient = 0 ; iClient < countClient ; iClient++)
{
//if(pComponent->mNet.Slave->GetDescDown(iClient, (void*)&descDown, sizeDesc))
//pBS->SendDown( descDown.id_session, bp);
if(pComponent->mNet.Slave->GetDescDown(iClient, (void*)&descDown, sizeDesc))
{
unsigned int id_client;
if(pComponent->mNet.Slave->FindClientKeyBySession(descDown.id_session,id_client))
listKey.push_back(id_client);
}
}
pBS->SendByClientKey( listKey, bp);
//###
//----------------------------
unlockQtSend();
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::Accept(unsigned int key, void* resForClient, int sizeResClient,
unsigned int id_session_slave,
unsigned int id_superserver)
{
// сохранить свой ключ
Context()->SetClientKey(key);
// сохранить сессию СуперСервера
SetID_SessionMasterSS(id_superserver);
// сохранить сессию Slave
SetID_SessionMasterSlave(id_session_slave);
// выставить состояние контекста
Context()->Accept();
// если SuperServer существует, то отослать запрос ему
// если нет, то отослать ответ клиенту сразу
if(GetID_SessionMasterSS()==INVALID_HANDLE_SESSION)
{
// сразу ответ клиенту и Slave
SendResultAccept2ClientAndSlave(key,
resForClient, sizeResClient);
return;
}
Context()->SaveAcceptData(resForClient, sizeResClient);
// SuperServer
TBreakPacket bp;
THeaderRequestM2SS h;
h.id_client = key;
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionMasterSS(), bp);
// ждем ответ от SuperServer
SetWaitSS();
}
//-----------------------------------------------------------------------------
void TScLoginClient_MasterImpl::Work(unsigned int now_ms)
{
// если клиент в очереди, обновить номер
if(Context()->GetNumInQueue())
{
if(now_ms > Context()->GetTimeLastNeedNumInQueue() + eDeltaTimeNumInQueue_ms)
{
NeedNumInQueueByClientKey(Context()->GetID_SessionClientMaster());
Context()->SetTimeLastNeedNumInQueue(now_ms);
TBreakPacket bp;
THeaderResultLoginM2C h;
h.result = THeaderResultLoginM2C::eQueue;
h.numInQueue = Context()->GetNumInQueue();
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientMaster(), bp);
}
return;
}
//
if(Context()->GetTimeWait() + Context()->GetDeltaTimeWaitMS() < now_ms)
{
// ошибка на той стороне
TEventError event;
event.code = LoginClient_MasterClientNotActive;
Context()->GetSE()->AddEventCopy(&event, sizeof(event));
Context()->Reject();
End();
}
}
//---------------------------------------------------------------------
void TSession::SendKeyRSA(TContainer& c_keyRSA)
{
TBreakPacket bp;
bp.PushFront((char*)c_keyRSA.GetPtr(), c_keyRSA.GetSize());
SendData(eKeyRSA, bp, true);
RefreshLastTime();
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::Disconnect()
{
THeaderDisconnectClientM2S h;
h.id_client = Context()->GetClientKey();
TBreakPacket bp;
bp.PushFront((char*)&h,sizeof(h));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bp);
End();
}
//-----------------------------------------------------------------------------
void TScLoginClient_ClientImpl::TryLogin(unsigned int ip, unsigned short port, unsigned char subNet,
void* pLogin, int sizeLogin, void* pPassword, int sizePassword)
{
if(Begin()==false)
{
// генерация ошибки
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScenarioLoginClient::TryLogin() scenario is not active.\n");
BL_FIX_BUG();
return;
}
Context()->SetNeedLeaveQueue(false);
Context()->SetSubNet(subNet);
TContainer cMITM;
TBreakPacket bpLP;// контейнер для всего пакета
if(Context()->GetMS()->GetUseCryptTCP())
{
// если данные шифруются, то формировать так:
// получить RSA public key от ManagerSession
TContainer cRSA;
bool resRSA = Context()->GetMS()->GetRSAPublicKeyForUp(cRSA);
BL_ASSERT(resRSA);
TCryptMITM cryptMITM;
bool res = cryptMITM.Calc(cRSA.GetPtr(), cRSA.GetSize(),
pLogin, sizeLogin, pPassword, sizePassword, cMITM);
BL_ASSERT(res);
bpLP.PushFront(cMITM.GetPtr(), cMITM.GetSize());
// сохранить на будущее
Context()->Set_L_AES_RSA(cMITM.GetPtr(), cMITM.GetSize());
}
else
{
// иначе просто отправить данные:
// формирование пакета
bpLP.PushFront((char*)pLogin, sizeLogin);
bpLP.PushFront((char*)pPassword, sizePassword);
}
THeaderTryLoginC2M h;
bpLP.PushFront((char*)&h, sizeof(h));
// отослать пакет для попытки авторизации
SetID_SessionClientMaster(Context()->GetMS()->Send(ip, port, bpLP, subNet));
if(GetID_SessionClientMaster()==INVALID_HANDLE_SESSION)
{
// Генерация ошибки
TEventError event;
event.code = LoginClient_ClientMasterNotReady;
Context()->GetSE()->AddEventCopy(&event, sizeof(event));
End();
return;
}
SetTimeWaitForNow();
}
//----------------------------------------------------------------------------------
void TNetControlTCP::Send( unsigned int ip, unsigned short port, TBreakPacket& bp )
{
THistoryPacketTCP::PackForSend( bp );
bp.Collect();
char* data = (char*) bp.GetCollectPtr();
int size = bp.GetSize();
RequestSend( data, size );
}
//--------------------------------------------------------------
void TScRecommutationClient_SlaveImpl::SaveContext(void* data, int size)
{
TBreakPacket bp;
if(data && size)
bp.PushFront((char*)data, size);
THeaderCheckBeginDonor h;
h.id_client = Context()->GetClientKey();
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bp);
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::Queue(int num, void* resForClient, int sizeResClient)
{
Context()->SetNumInQueue(num);
Context()->SaveQueueData(resForClient, sizeResClient);
TBreakPacket bp;
THeaderResultLoginM2C h;
h.result = THeaderResultLoginM2C::eQueue;
h.numInQueue = num;
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientMaster(), bp);
}
//----------------------------------------------------------------------------------
void TNetControlUDP::Send( unsigned int ip, unsigned short port, TBreakPacket& bp )
{
// формируем заголовок
TIP_Port ip_port( ip, port );
unsigned short count_out = IncreaseCntOut( ip_port );
bp.PushFront( (char*) &count_out, sizeof( count_out ) );
bp.Collect();
char* data = (char*) bp.GetCollectPtr();
int size = bp.GetSize();
RequestSendTo( data, size, ip_port );
}
//----------------------------------------------------------------------------------
void TNetControlTCP::Send(unsigned int ip, unsigned short port, TBreakPacket& bp)
{
// добавить заголовки в начало - 2 байт под заголовок + 4 байта - размер данных
THeaderTCP header;
header.size = bp.GetSize();
bp.PushFront((char*)&header, sizeof(header));
bp.Collect();
char* data = (char*)bp.GetCollectPtr();
int size = bp.GetSize();
RequestSend(data,size);
}
//-------------------------------------------------------------------
void TScenarioSendToClient::RecvFromMaster(TDescRecvSession* pDesc)
{
THeaderMaster* pH = (THeaderMaster*)pDesc->data;
NeedContextByClientKey(pH->id_client);
if(Context())
{
TBreakPacket bp;
bp.PushFront(pDesc->data + sizeof(THeaderMaster),
pDesc->sizeData - sizeof(THeaderMaster) );
Send<THeaderSlave>(pH->id_client, bp);
}
}
bool TCryptMITM::Calc(void* rsa, int size_rsa,
void* pLogin, int sizeLogin,
void* pPassword, int sizePassword,
TContainer& c_result)
{
TContainer cAES_RSA;
// зашифровать публичный ключ RSA с помощью AES, используя в качестве ключа пароль
TContainer cMD5_Password;
TMD5 md5Password;
md5Password.FastCalc(pPassword, sizePassword, cMD5_Password);
TCryptoAES_Impl crypt_aes;
crypt_aes.SetPublicKey(cMD5_Password.GetPtr(), cMD5_Password.GetSize());
if(crypt_aes.Encrypt(rsa, size_rsa, cAES_RSA)==false)
return false;
TBreakPacket bp;
// зашифрованный RSA
bp.PushFront(cAES_RSA.GetPtr(), cAES_RSA.GetSize());
// Login
bp.PushFront((char*)pLogin, sizeLogin);
// длина логина
char lenLogin = sizeLogin;
bp.PushFront(&lenLogin, sizeof(lenLogin));
// собрать
bp.Collect();
// отдать собранный пакет
c_result.Entrust((char*)bp.GetCollectPtr(), bp.GetSize());
// отцепиться
bp.UnlinkCollect();
return true;
}
//---------------------------------------------------------------------
void TSession::SendData(char type, TBreakPacket& bp, bool check, bool use_crypt)
{
THeader h(type);
h.use_crypt = use_crypt;
bp.PushFront((char*)&h, sizeof(THeader));
mTransport->Send(mIP_Port.ip, mIP_Port.port, bp, check);
}
//-----------------------------------------------------------------------------
void TScLoginClient_MasterImpl::Reject(void* resForClient, int sizeResClient)
{
Context()->Reject();
// сформировать отказ для клиента
THeaderResultLoginM2C h;
h.result = THeaderResultLoginM2C::eReject;
h.sizeResClient = sizeResClient;
TBreakPacket bp;
bp.PushFront((char*)resForClient, sizeResClient);
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientMaster(), bp);
End();
}
//--------------------------------------------------------------
void TScLoginClient_ClientImpl::LeaveQueue()
{
// спросить у контекста состоит ли клиент в очереди
if(Context()->GetNumInQueue()==0)
return;
TBreakPacket bp;
THeaderLeaveQueueC2M h;
bp.PushFront((char*)&h, sizeof(h));
unsigned int id_master = GetID_SessionClientMaster();
if(id_master==INVALID_HANDLE_SESSION)
return;
Context()->SetNeedLeaveQueue(true);
Context()->GetMS()->Send(id_master,bp);
}
//--------------------------------------------------------------
void TScLoginClient_ClientImpl::InfoSlaveM2C(TDescRecvSession* pDesc)
{
Context()->SetNeedLeaveQueue(false);
// смотрим что нам прислали
THeaderInfoSlaveM2C* pInfoSlave = (THeaderInfoSlaveM2C*)pDesc->data;
Context()->SetSlaveIP_Port(pInfoSlave->ip_port_slave);
// чисто для отладки, что бы удостовериться что назначили
// в будущем можно будет удалить
Context()->SetClientKey(pInfoSlave->id_client);
EventSetClientKey(pInfoSlave->id_client);
// формируем пакет для Master
TBreakPacket bp;
THeaderCheckInfoSlaveC2M h;
h.id_client = Context()->GetClientKey();// равнозначно - pInfoSlave->id_client;
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientMaster(),bp);
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::ClientConnectS2M(TDescRecvSession* pDesc)
{
THeaderClientConnectS2M* pHeader = (THeaderClientConnectS2M*)pDesc->data;
NeedContextByClientKey(pHeader->id_client);
if(Context()==NULL)
{
BL_FIX_BUG();
return;
}
//------------------------------------------------------------
// квитанция о запросе
THeaderCheckClientConnectM2S h;
h.id_client = pHeader->id_client;
TBreakPacket bp;
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bp);
// конец сценария
End();
}
//--------------------------------------------------------------
void TScRecommutationClient_SlaveImpl::RequestConnect(TDescRecvSession* pDesc)
{
THeaderRequestConnect* pHeader = (THeaderRequestConnect*)pDesc->data;
TDescRequestConnectForRecipient desc;
desc.id_session = pDesc ->id_session;
desc.key = pHeader->id_client;
desc.random_num = pHeader->random_num;
NeedContextByRequestForRecipient(&desc);
if(Context()==NULL)
{
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScRecommutationClient_SlaveImpl::RequestConnect not found session=0x%X, key=%u",
pDesc->id_session, pHeader->id_client);
return;
}
// запомнить сессию
SetID_SessionClientSlave(pDesc->id_session);
// Клиенту
TBreakPacket bpClient;
THeaderCheckRequestConnect hClient;
hClient.id_client = Context()->GetClientKey();
bpClient.PushFront((char*)&hClient, sizeof(hClient));
Context()->GetMS()->Send(GetID_SessionClientSlave(), bpClient);
// Мастеру
TBreakPacket bpMaster;
THeaderClientConnect hMaster;
hMaster.id_client = Context()->GetClientKey();
bpMaster.PushFront((char*)&hMaster, sizeof(hMaster));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bpMaster);
// разработчику
TEventRestoreContext* pEvent = new TEventRestoreContext;
pEvent->id_session = pDesc->id_session;
pEvent->c.SetDataByCount(Context()->GetContextDataPtr(), Context()->GetContextDataSize());
Context()->GetSE()->AddEventWithoutCopy<TEventRestoreContext>(pEvent);
// завершить сценарий
End();
}
//--------------------------------------------------------------
void TScLoginClient_SlaveImpl::InfoClientM2S(TDescRecvSession* pDesc)
{
THeaderInfoClientM2S* pHeader = (THeaderInfoClientM2S*)pDesc->data;
NeedContextByClientKey(pHeader->id_client);
if(Context()==NULL)
{
BL_FIX_BUG();
return;
}
//--------------------------------------------
// начало сценария
if(Context()->WasBegin()==false)
{
// стартовали впервые
Context()->SetWasBegin();
if(Begin()==false)
{
// генерация ошибки
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScLoginClient_SlaveImpl::InfoClientM2S() scenario is not active.\n");
BL_FIX_BUG();
return;
}
}
// Если WasBegin==true - старт уже был, Мастер не дождался Клиент, остановил у себя сценарий
// потом Клиент еще раз попытался авторизоваться, а Salve еще его ждет, т.е. это уже
// вторая попытка войти. Что ж продолжим авторизацию.
SetTimeWaitForNow();
// запомнить сессию
SetID_SessionMasterSlave(pDesc->id_session);
Context()->SetClientKey(pHeader->id_client);
// сформировать квитанцию
TBreakPacket bp;
THeaderCheckInfoClientS2M h;
h.id_client = Context()->GetClientKey();
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bp);
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::CheckRequestSS2M(TDescRecvSession* pDesc)
{
THeaderCheckRequestSS2M* pHeader = (THeaderCheckRequestSS2M*)pDesc->data;
NeedContextByClientKey(pHeader->id_client);
if(Context()==NULL)
{
// такая ситуация вполне возможна, пока SS слал ответ, клиент отвалился,
// но под Debug фиксировать это событие
BL_FIX_BUG();
return;
}
//-------------------------------------------------------------
// анализ ответа SuperServer-а
if(pHeader->isExistInSystem)
{
Context()->Reject();
// клиент уже есть в системе, повторная авторизация
string sReject = "Reject login. Client was been authorized.";
// сформировать отказ для клиента
THeaderResultLoginM2C h;
h.result = THeaderResultLoginM2C::eReject;
h.sizeResClient = sReject.length();
TBreakPacket bp;
bp.PushFront((char*)sReject.data(), sReject.length());
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientMaster(), bp);
End();
return;
}
//
void* resForClient = Context()->GetSaveAcceptDataPtr();
int sizeResClient = Context()->GetSaveAcceptDataSize();
Context()->Accept();
SendResultAccept2ClientAndSlave(pHeader->id_client,
resForClient,sizeResClient);
}
//--------------------------------------------------------------
void TScLoginClient_ClientImpl::Disconnect()
{
// ждет ли в очереди и хочет ли выйти из нее
if(Context()->NeedLeaveQueue())
{
TEventLeaveQueue event;
Context()->GetSE()->AddEventCopy(&event, sizeof(event));
End();
return;
}
// пере подключить транспорт с мастера на Slave
// формируем пакет для Slave
TBreakPacket bp;
THeaderConnectToSlaveC2S h;
// для Slave отдать свой ID, он по нему нас зарегистрирует
h.id_client = Context()->GetClientKey();
// для проверки на надежность нашего канала
if(Context()->GetMS()->GetUseCryptTCP())
bp.PushFront(Context()->GetPtr_L_AES_RSA(),Context()->GetSize_L_AES_RSA());
bp.PushFront((char*)&h, sizeof(h));
// открыть сессию по IP:port
TIP_Port ip_port_slave = Context()->GetSlaveIP_Port();
unsigned int id_slave =
Context()->GetMS()->Send(ip_port_slave.ip,
ip_port_slave.port,
bp, Context()->GetSubNet());
// проверка на наличие готовности Slave
if(id_slave==INVALID_HANDLE_SESSION)
{
// Генерация ошибки
TEventError event;
event.code = LoginClient_ClientNotExistSlave;
Context()->GetSE()->AddEventCopy(&event, sizeof(event));
End();
return;
}
SetID_SessionClientSlave(id_slave);
SetTimeWaitForNow();
}
//--------------------------------------------------------------
void TScRecommutationClient_SlaveImpl::BeginRecipient(TDescRecvSession* pDesc)
{
THeaderBeginRecipient* pHeader = (THeaderBeginRecipient*)pDesc->data;
NeedContextByClientKeyForSlave(pHeader->id_client, false);
if(Context()==NULL)
{
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScRecommutationClient_SlaveImpl::BeginRecipient() Context()==NULL.\n");
BL_FIX_BUG();
return;
}
//--------------------------------------------
Context()->SetRandomNum(pHeader->random_num);
Context()->SetClientKey(pHeader->id_client);
Context()->SetRoleAsRecipient();// роль Реципиента
Context()->SetID_SessionMasterSlave(pDesc->id_session);
// начало сценария
if(Begin()==false)
{
// генерация ошибки
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScRecommutationClient_SlaveImpl::BeginRecipient() scenario is not active.\n");
BL_FIX_BUG();
return;
}
// сохранить Контекст в контекст (извините за каламбур)
// Slave еще рано отдавать Контекст
Context()->SaveContextData(pDesc->data + sizeof(THeaderBeginRecipient),
pDesc->sizeData - sizeof(THeaderBeginRecipient));
// сформировать пакет далее для Мастера
TBreakPacket bp;
THeaderCheckBeginRecipient h;
h.id_client = Context()->GetClientKey();
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bp);
SetTimeWaitForNow();
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::CheckInfoClientS2M(TDescRecvSession* pDesc)
{
THeaderCheckInfoClientS2M* pHeader = (THeaderCheckInfoClientS2M*)pDesc->data;
NeedContextByClientKey(pHeader->id_client);
if(Context()==NULL)
{
BL_FIX_BUG();
return;
}
//------------------------------------------------------------
// ip и port Slave для клиента
TIP_Port ip_port_slave;
Context()->GetMS()->GetInfo(GetID_SessionMasterSlave(), ip_port_slave);
// отослать информацию о Slave
THeaderInfoSlaveM2C h;
h.id_client = Context()->GetClientKey();
h.ip_port_slave = ip_port_slave;
TBreakPacket bp;
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientMaster(), bp);
}
//----------------------------------------------------------------------------------
TContainer TBasePacket_PCS::Pack()
{
TBreakPacket bp;
bp.PushBack( (char*)&mType, sizeof(mType));
TContainer fromInherit = PackInherit();
bp.PushBack( fromInherit.GetPtr(), fromInherit.GetSize() );
bp.Collect();
TContainer result;
result.Entrust( (char*)bp.GetCollectPtr(), bp.GetSize() );
bp.UnlinkCollect();
return result;
}
//--------------------------------------------------------------
void TScLoginClient_SuperServerImpl::RequestM2SS(TDescRecvSession* pDesc)
{
unsigned int id_session_master = pDesc->id_session;
THeaderRequestM2SS* pRequest = (THeaderRequestM2SS*)pDesc->data;
NeedContextByMasterSessionByClientKey(id_session_master, pRequest->id_client);
bool isExist = false;
if(Context()->GetFakeClient())
isExist = true;
// проверка
if(Begin()==false)
{BL_FIX_BUG();}
End();
// формирование пакета
TBreakPacket bp;// контейнер для всего пакета
THeaderCheckRequestSS2M h;
h.id_client = pRequest->id_client;
h.isExistInSystem = isExist;
bp.PushFront((char*)&h, sizeof(h));
// отослать пакет для попытки авторизации
Context()->GetMS()->Send(id_session_master, bp);
}
//---------------------------------------------------------------------
void TSession::Send( TBreakPacket& bp, bool check )
{
if( check )
{
// Data + crc8(Data) => Encrypt
bp.CopyInBuffer( mBuffer );
unsigned char crc8;
mCalcCRC8.Calc( mBuffer.GetPtr(), mBuffer.GetSize(), crc8 );
bp.PushBack( (char*) &crc8, sizeof( crc8 ) );
bp.CopyInBuffer( mBuffer );
mSendAES.Encrypt( mBuffer.GetPtr(), mBuffer.GetSize(), mEncrypt );
bp.Reset();
bp.PushBack( (char*) mEncrypt.GetPtr(), mEncrypt.GetSize() );
}
SendData( eData, bp, check );
// гарантия того что пакет дойдет
// иначе сессия на той стороне не освежит время
if( check )
RefreshLastTime();
}
//--------------------------------------------------------------
void TScRecommutationClient_SlaveImpl::InfoRecipientToDonor(TDescRecvSession* pDesc)
{
THeaderInfoRecipientToDonor* pHeader = (THeaderInfoRecipientToDonor*)pDesc->data;
NeedContextByClientKeyForSlave(pHeader->id_client, true);
if(Context()==NULL)
{
GetLogger(STR_NAME_MMO_ENGINE)->
WriteF_time("TScRecommutationClient_SlaveImpl::InfoRecipientToDonor() Context()==NULL.\n");
BL_FIX_BUG();
return;
}
//--------------------------------------------
TBreakPacket bp;
THeaderInfoRecipientToClient h;
h.id_client = pHeader->id_client;
h.ip_port_recipient = pHeader->ip_port_recipient;
h.random_num = pHeader->random_num;
bp.PushFront((char*)&h, sizeof(h));
Context()->GetMS()->Send(GetID_SessionClientSlave(), bp);
SetTimeWaitForNow();
}
//--------------------------------------------------------------
void TScLoginClient_MasterImpl::SendResultAccept2ClientAndSlave(unsigned int key,
void* resForClient,
int sizeResClient)
{
// Client
TBreakPacket bp;
bp.PushFront((char*)resForClient, sizeResClient);
THeaderResultLoginM2C hForClient;
hForClient.id_client = key;
hForClient.result = THeaderResultLoginM2C::eAccept;
hForClient.sizeResClient = sizeResClient;
bp.PushFront((char*)&hForClient, sizeof(hForClient));
Context()->GetMS()->Send(GetID_SessionClientMaster(), bp);
bp.UnlinkPart();// очистить от частей
// Slave
THeaderInfoClientM2S hForSlave;
hForSlave.id_client = key;
bp.PushFront((char*)&hForSlave, sizeof(hForSlave));
Context()->GetMS()->Send(GetID_SessionMasterSlave(), bp);
// ждем ответ от Slave
SetWaitSlave();
}
