servertable.cpp

Agent in c++ for DragonRaja

			{
				szDummyMsg[0] = (BYTE)PTCL_NOTIFY_YOU_ARE_CERTIFIED;

				for( pDummyServerData = this->GetServerListHead(); pDummyServerData; pDummyServerData = pDummyServerData->pNextServerData )
				{
					if( pDummyServerData->dwConnectionIndex )
					{
						if( !this->Send( pDummyServerData->dwConnectionIndex, szDummyMsg, 1 ) )
						{
#ifdef __ON_DEBUG
//							_asm int 3;
#endif
						}
					}
				}
			}
		}
	// ------------------
	// 辑滚辆丰 舅覆 菩哦
	// ------------------
		break;
	case PTCL_REPORT_SERVER_DESTROY:
		{
			DWORD dwFinishType = *((DWORD *)pMsg);

			MyLog( LOG_NORMAL, "%s(%d) Reported DESTROY(by %s)", GetTypedServerText(pSender->dwServerType), pSender->wPort, GetFinishTypeText(dwFinishType) );
		}
		break;
	// ------------------
	// 辑滚惑怕 焊绊 菩哦
	// ------------------
	case PTCL_REPORT_SERVER_STATUS:
		// 辑滚 惑怕(STATUS, 荤侩磊 荐) 焊绊 菩哦.
		{
			LP_REPORT_SERVER_STATUS_PACKET pPacket = (LP_REPORT_SERVER_STATUS_PACKET)pMsg;

			// 矫埃 盎脚.
			pSender->dwLastCheckAliveTime = GetTickCount();

			// Status...
			this->SetServerStatus( pSender, pPacket->dwServerStatus );

			// 荤侩磊 荐..
			pSender->dwNumOfUsers = pPacket->dwNumOfUsers;
		}
		break;
	// ----------------------------
	// 辑滚埃 立加惑怕 舅覆 菩哦.
	// ----------------------------
	case PTCL_REPORT_SERVER_CONNECTION_STATUS_CHANGE:
		{
			LP_REPORT_SERVER_CONNECTION_STATUS_PACKET pPacket = (LP_REPORT_SERVER_CONNECTION_STATUS_PACKET)pMsg;
			LP_SERVER_DATA pServerData = this->GetServerData( pPacket->wPort );

			this->SetServerConnectionStatus( pSender, pServerData, pPacket->bConnectionType );
		}
		break;
// ----------------------------
// #endif for __IS_PROXY_SERVER
// ----------------------------
#endif

	default:
		{
#ifdef __ON_DEBUG
//			_asm int 3;
#endif
		return false;
		}
		break;
	}

	return true;
}

bool CServerTable::OnRecvDestroyServerMsg( LP_SERVER_DATA pSender, BYTE bID, char *pMsg, DWORD dwLength )
{
	if( (pSender == this->m_pOwnProxyServerData[0]) || (pSender == this->m_pOwnProxyServerData[0]) )
	{
		this->DestroyServer( (DWORD)FINISH_TYPE_BY_PROXY );
		return true;
	}
	return false;
}

bool CServerTable::ReportServerConnectionStatusChange( LP_SERVER_DATA pServerData, BYTE bConnectionStatus )
{
	char szDummyMsg[MM_MAX_PACKET_SIZE];

	LP_REPORT_SERVER_CONNECTION_STATUS_PACKET pPacket = (LP_REPORT_SERVER_CONNECTION_STATUS_PACKET)(szDummyMsg+1);
	szDummyMsg[0] = PTCL_REPORT_SERVER_CONNECTION_STATUS_CHANGE;

	pPacket->bConnectionType = bConnectionStatus;
	pPacket->wPort = pServerData->wPort;
	if( !this->SendToProxyServer( szDummyMsg, sizeof(BYTE)+sizeof(REPORT_SERVER_CONNECTION_STATUS_PACKET) ) )
	{
		MyLog( LOG_IGNORE, "ReportServerConnectionStatusChange() :: Failed To Notify it To PROXY" );
		return false;
	}

	return true;
}

bool CServerTable::RemoveConnectedServerDataFromHashTable( DWORD dwConnectionIndex )
{
	LP_SERVER_DATA pServerData;
	LP_HASHED_SERVER_DATA pHashedServerData;

	pServerData = GetConnectedServerData( dwConnectionIndex );
	if ( !pServerData || !pServerData->pHashedServerData )
	{
		return false;
	}
	pHashedServerData = pServerData->pHashedServerData;

	// ------------ For DEBUGGING by chan78 (SHOULD BE DELETED)
	LP_HASHED_SERVER_DATA pTest;
	DWORD dwCount = 0;
	for( WORD bb = 0; bb < this->m_wMaxBucketNum; bb++ )
	{
		pTest = this->m_ppServerTable[bb];
		while( pTest )
		{
			ASSERT(pTest);
			dwCount++;
//			if( this->m_ppServerTable[pTest->wPosInHashTable] == NULL )
//				_asm int 3;
			pTest = pTest->pNextHashedServerData;
		}
		
	}
//	if( g_pServerTable->GetNumOfConnectedServers() != dwCount )
//		_asm int 3;
	// ------------


#if defined(__IS_AGENT_SERVER) || defined(__IS_MAP_SERVER)
	// 郴霸 硅沥等 DB Demon捞搁.
	if( pServerData == this->m_pOwnDBDemonData )
	{
		SetServerStatus( STATUS_AWAITING_DB_DEMON_SETTING );
		MyLog( LOG_IMPORTANT, "SERVER Lost given DB DEMON Connection(%d/%d)", pServerData->dwConnectionIndex, pServerData->wPort );

		// Clear DB Demon Pointer.
		this->m_pOwnDBDemonData = NULL;

		this->RequestToSetDBDemon();
	}
#endif

#ifdef __IS_PROXY_SERVER
	if( pServerData->dwServerType == SERVER_TYPE_DB )
	{
		// DB狼 版快 捞 辑滚俊 硅沥等 葛电 辑滚甸狼 DB 硅沥 惑怕甫 官槽促.
		LP_SERVER_DATA pDummyToReset = NULL;
		for( WORD i = 0; i< MAX_SERVER_NUM; i++ )
		{
			pDummyToReset = pServerData->ppUsingServers[i];
			if( pDummyToReset )
			{
				pDummyToReset->pUsingDBDemon = NULL;

				// Modified by chan78 at 2001/02/21
				if( pDummyToReset->dwConnectionIndex && ((pDummyToReset->dwStatus > STATUS_AWAITING_DB_DEMON_SETTING) && (pDummyToReset->dwStatus <= STATUS_ACTIVATED)) )
				{
					this->SetServerStatus( pDummyToReset, STATUS_AWAITING_DB_DEMON_SETTING );
				}
				pDummyToReset = NULL;
			}
		}
	}
	else
	{
		// 扁鸥 辑滚狼 版快 硅沥等 DB Demon狼 府胶飘肺何磐 力芭茄促.
		if( pServerData->pUsingDBDemon )
		{
			LP_SERVER_DATA pDummyToReset = NULL;
			for( WORD i = 0; i< MAX_SERVER_NUM; i++ )
			{
				if( pServerData->pUsingDBDemon->ppUsingServers[i] == pServerData )
				{
					pServerData->pUsingDBDemon->ppUsingServers[i] = NULL;
					break;
				}
			}
		}
		// Modified by chan78 at 2001/02/21
		pServerData->pUsingDBDemon = NULL;
	}
#endif

	// Notify Connection Status Change to Proxy
#ifndef __IS_PROXY_SERVER
	this->ReportServerConnectionStatusChange( pServerData, (BYTE)CONNECTION_STATUS_NOT_CONNECTED );
#endif

#ifdef __IS_PROXY_SERVER
	LP_SERVER_DATA pDummyServer;
	for( pDummyServer = this->GetServerListHead(); pDummyServer; pDummyServer = pDummyServer->pNextServerData )
	{
		if( pDummyServer == pServerData ) continue;

		this->SetServerConnectionStatus( pServerData, pDummyServer, (BYTE)CONNECTION_STATUS_NOT_CONNECTED );
		this->SetServerConnectionStatus( pDummyServer, pServerData, (BYTE)CONNECTION_STATUS_NOT_CONNECTED );
	}
	
	// Added by chan78 at 2001/02/22 :: 荤侩磊荐 努府绢.
	pServerData->dwNumOfUsers = 0;

#endif

	// Processes for Typed Servers Disconnect
	this->OnDisconnectTypedServer( pServerData );

	this->m_dwNumOfConnectedServers--;
	this->m_dwNumOfTypedServers[pServerData->dwServerType]--;

	pServerData->dwConnectionIndex = 0;
	SetServerStatus( pServerData, STATUS_NOT_IN_NETWORK );

	MyLog( LOG_NORMAL, "%s(%d/%d) Has Lost Connection.", GetTypedServerText(pServerData->dwServerType), dwConnectionIndex, pServerData->wPort );

	// Unlink
	if( pHashedServerData->pPrevHashedServerData && pHashedServerData->pNextHashedServerData )
	{
		pHashedServerData->pPrevHashedServerData->pNextHashedServerData = pHashedServerData->pNextHashedServerData;
		pHashedServerData->pNextHashedServerData->pPrevHashedServerData = pHashedServerData->pPrevHashedServerData;
	}
	else if( pHashedServerData->pPrevHashedServerData && !pHashedServerData->pNextHashedServerData )
	{
		pHashedServerData->pPrevHashedServerData->pNextHashedServerData = NULL;
	}
	else if( !pHashedServerData->pPrevHashedServerData && pHashedServerData->pNextHashedServerData )
	{
		this->m_ppServerTable[pHashedServerData->wPosInHashTable] = pHashedServerData->pNextHashedServerData;
		pHashedServerData->pNextHashedServerData->pPrevHashedServerData = NULL;
	}
	else if( !pHashedServerData->pPrevHashedServerData && !pHashedServerData->pNextHashedServerData )
	{
		this->m_ppServerTable[pHashedServerData->wPosInHashTable] = NULL;
	}

	delete pHashedServerData;
	pHashedServerData = NULL;

	return true;
}

bool CServerTable::AddServerDataToList( LP_SERVER_DATA pServerData )
{
	if ( !this->m_pServerListHead )
	{
		this->m_pServerListHead = pServerData;
		this->m_pServerListHead->pNextServerData = NULL;
		this->m_pServerListTail = this->m_pServerListHead;
	} 
	else 
	{
		pServerData->pNextServerData = NULL;
		this->m_pServerListTail->pNextServerData = pServerData;
		this->m_pServerListTail = pServerData;
	}
	return true;
}

bool CServerTable::AddConnectedServerDataToHashTable( LP_SERVER_DATA pServerData, DWORD dwConnectionIndex )
{
	LP_HASHED_SERVER_DATA pHashedServerData;
	LP_HASHED_SERVER_DATA pHashedServerPrv;
	WORD wIndex;

	pServerData->dwConnectionIndex = dwConnectionIndex;

	// Get Position in Hashtable and get it's own pointer
	wIndex = (WORD)(pServerData->wPort % this->m_wMaxBucketNum);

	// Get a new HASHED_SERVER_DATA
	pHashedServerData = new HASHED_SERVER_DATA;
	memset( pHashedServerData, 0, sizeof( HASHED_SERVER_DATA ) );

	// Fill Datas
	pHashedServerData->wPosInHashTable = wIndex;
	pHashedServerData->pServerData = pServerData;

	// Add It to Linked List;
	pHashedServerPrv = this->m_ppServerTable[wIndex];
	if( pHashedServerPrv )
	{
		pHashedServerPrv->pPrevHashedServerData = pHashedServerData;
		pHashedServerData->pNextHashedServerData = pHashedServerPrv;
	}
	this->m_ppServerTable[wIndex] = pHashedServerData;
	pServerData->pHashedServerData = pHashedServerData;

	// Processes for Typed Servers OnConnect
	this->OnConnectTypedServer( pServerData );

	this->m_dwNumOfConnectedServers++;
	this->m_dwNumOfTypedServers[pServerData->dwServerType]++;

	return true;
}

bool CServerTable::ConnectToServer( LP_SERVER_DATA pServerData, DWORD dwConnectType )
{
	if( !this->m_pINet->ConnectToServerWithServerSide( pServerData->szIP, pServerData->wPort, OnConnectServerSuccess, OnFailedToConnectServer, (void *)pServerData ) )
	{
		// 角菩茄 版快!?
		return false;
	}

	// 己傍
	this->SetServerStatus( pServerData, STATUS_TRYING_TO_CONNECT );
	pServerData->dwConnectType = dwConnectType;

	return true;
}

bool CServerTable::ConnectToServer( WORD wServerID, DWORD dwConnectType )
{
	LP_SERVER_DATA pServerData = this->GetServerData( wServerID );
	return this->ConnectToServer( pServerData, dwConnectType );
}

bool CServerTable::StartServer( DWORD dwType )
{
	switch( dwType )
	{
	case TYPE_SERVER_SIDE:
		{
			if ( !(this->m_pINet->StartServerWithServerSide( m_pOwnServerData->szIP, m_pOwnServerData->wPort)) ) // 辑滚 啊悼
				return false;
		}
		break;
	case TYPE_USER_SIDE:
		{
			switch( m_pOwnServerData->dwServerType )
			{
			case SERVER_TYPE_AGENT:
			case SERVER_TYPE_PROXY:
				{
					if ( !(this->m_pINet->StartServerWithUserSide( m_pOwnServerData->szIPForUser, m_pOwnServerData->wPortForUser)) )
						return false;
				}
				break;
			case SERVER_TYPE_MAP:
			case SERVER_TYPE_DB:
				{
					return false;
				}
				break;
			default:
				{
					return false;
				}
			}
		}
		break;
	default:
		{
			return false;
		}
		break;
	}
	return true;
}

bool CServerTable::ConnectToProxyServer()
{
	LP_AWAITING_CONNECTION_RESULT_DATA pResult = this->GetConnectionResultData();
	LP_SERVER_PORT_LIST_PACKET pConnectedList = (LP_SERVER_PORT_LIST_PACKET)(pResult->szAnswer+1);

	DWORD dwCount = 0;
	char szSendMsg[32];
	LP_SERVER_DATA pServerData;

	// Clear pResult & pConnectedList
	pResult->dwConnectionType = CONNECT_TYPE_WITH_PROXY;
	pResult->dwResultCheckedServers = 0;
	pResult->dwToConnectServers = 0;
	pResult->pSender = NULL;
	pConnectedList->wNum = 0;

	for( DWORD dwDummy = PRIMARY_SERVER; dwDummy <= SECONDARY_SERVER; dwDummy++ )
	{
		pServerData = this->m_pOwnProxyServerData[dwDummy];

		if( !pServerData )
			continue;

		if( !pServerData->wPort )
			continue;

		// Already Connected
		if( pServerData->dwConnectionIndex )
		{
			dwCount++;
			continue;
		}

		// Connect...
		if( this->m_pINet->ConnectToServerWithServerSide( pServerData->szIP, pServerData->wPort, OnConnectServerSuccess, OnFailedToConnectServer, (void *)pServerData ) )
		{
			this->SetServerStatus( pServerData, STATUS_TRYING_TO_CONNECT );
			pServerData->dwConnectType = CONNECT_TYPE_WITH_PROXY;
			pResult->dwToConnectServers++;
			dwCount++;
		}

	}

	// 己傍? 角菩?
	if( dwCount )
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool CServerTable::BeginNegotiationWithProxyServer( LP_SERVER_DATA pServerData )
{
	char szSendMsg[32];

	// Proxy Server 绰 立加父 登搁 疵 捞侩且 荐 乐绰 惑怕肺 啊沥茄促.
	this->SetServerStatus( pServerData, STATUS_ACTIVATED );