C++ TBreakPacket类代码示例

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