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 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 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::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 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 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 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::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 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 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 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 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 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 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); } }
//---------------------------------------------------------------------------------- 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 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 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(); }
//-------------------------------------------------------------- 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 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 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); }
//-------------------------------------------------------------- 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 TScLoginClient_SlaveImpl::CheckClientConnectM2S(TDescRecvSession* pDesc) { THeaderCheckClientConnectM2S* pHeader = (THeaderCheckClientConnectM2S*)pDesc->data; NeedContextByClientKey_SecondCallSlave(pHeader->id_client); if(Context()==NULL) return; //-------------------------------------------- // отсылка уведомления Developer Slave события Connect TEventConnectDown* pEvent = new TEventConnectDown; pEvent->id_session = GetID_SessionClientSlave(); pEvent->c.SetData(Context()->GetPtr_L_AES_RSA(), Context()->GetSize_L_AES_RSA()); Context()->GetSE()->AddEventWithoutCopy<TEventConnectDown>(pEvent); // отослать клиенту уведомление THeaderCheckConnectToSlaveS2C h; TBreakPacket bp; bp.PushFront((char*)&h, sizeof(h)); Context()->GetMS()->Send(GetID_SessionClientSlave(),bp); Context()->Accept(); End(); }
//-------------------------------------------------------------- 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_SlaveImpl::ConnectToSlaveC2S(TDescRecvSession* pDesc) { // защита от хака if(pDesc->sizeData<sizeof(THeaderConnectToSlaveC2S)) return; THeaderConnectToSlaveC2S* pHeader = (THeaderConnectToSlaveC2S*)pDesc->data; // существует ли вообще клиент с данным ключом, // то есть был ли добавлен на ожидание от Мастера данный Клиент // загрузить контекст для работы NeedContextByClientSessionByClientKey(pDesc->id_session, pHeader->id_client); if(Context()==NULL) { // генерация ошибки GetLogger(STR_NAME_MMO_ENGINE)-> WriteF_time("TScLoginClient_SlaveImpl::SetIsExistClientID() id client is not exist.\n"); BL_FIX_BUG(); return; } // запомнить сессию Клиента SetID_SessionClientSlave(pDesc->id_session); // уведомить Мастера о запросе от клиента THeaderClientConnectS2M h; h.id_client = Context()->GetClientKey();// указать какой клиент захотел соединиться TBreakPacket bp; bp.PushFront((char*)&h, sizeof(h)); Context()->GetMS()->Send(GetID_SessionMasterSlave(),bp); // сохранить информацию о логине и пароле клиента char* data = pDesc->data + sizeof(THeaderConnectToSlaveC2S); int sizeData = pDesc->sizeData - sizeof(THeaderConnectToSlaveC2S); Context()->Set_L_AES_RSA(data, sizeData); }
//------------------------------------------------------------------------- void TManagerSession::Send(TSession* pSession, TBreakPacket bp, bool check) { if(check==true)// TCP if(GetUseCryptTCP()) { // достать ip и порт TIP_Port ip_port; pSession->GetInfo(ip_port); pSession->IncrementCounterOut(); unsigned int counter_out = pSession->GetCounterOut(); bp.PushFront((char*)&counter_out, sizeof(counter_out)); // зашифровать TContainer c_encrypt; mMngCtxCrypto.Send(ip_port, bp, c_encrypt); // создать новый пакет TBreakPacket encrypt_bp; encrypt_bp.PushFront((char*)c_encrypt.GetPtr(), c_encrypt.GetSize()); // отослать с параметром "шифруется" pSession->Send(encrypt_bp, true, true); return; } // либо UDP, либо не шифрованный TCP pSession->Send(bp, check); }