C++ TBreakPacket::PushFront方法代码示例

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);
}