예제 #1
0
bool ServerManager::ProcessCommands( )
{
	bool ret = false;

	if(m_MinFD == INVALID_SOCKET && m_MaxFD == INVALID_SOCKET)
	{
		return true;
	}

	for(int i=SCENE_PLAYER_ID; i<=BILLING_PLAYER_ID; i++)
	{
		ServerPlayer*	pPlayer = GetServerPlayer(i);
		if(!pPlayer) continue;

		if(pPlayer->IsValid())
		{
			if(pPlayer->GetSocket()->isSockError() )
			{
				RemoveServer(i);
			}
			else
			{
				ret = pPlayer->ProcessCommand(false);
				if(!ret)
				{
					RemoveServer( i );
				}
			}
		}
	}

	return true;
}
예제 #2
0
/**
 * \fn UPNPScanner::AddServer(const QString&, const QString&)
 *  Adds the server identified by usn and reachable via url to the list of
 *  known media servers and schedules an update to initiate a connection.
 */
void UPNPScanner::AddServer(const QString &usn, const QString &url)
{
    if (url.isEmpty())
    {
        RemoveServer(usn);
        return;
    }

    // sometimes initialisation is too early and m_masterHost is empty
    if (m_masterHost.isEmpty())
    {
        m_masterHost = gCoreContext->GetSetting("MasterServerIP");
        m_masterPort = gCoreContext->GetSettingOnHost("BackendStatusPort",
                       m_masterHost, "6544").toInt();
    }

    QUrl qurl(url);
    if (qurl.host() == m_masterHost && qurl.port() == m_masterPort)
    {
        LOG(VB_UPNP, LOG_INFO, LOC + "Ignoring master backend.");
        return;
    }

    m_lock.lock();
    if (!m_servers.contains(usn))
    {
        m_servers.insert(usn, new MediaServer(url));
        LOG(VB_GENERAL, LOG_INFO, LOC + QString("Adding: %1").arg(usn));
        ScheduleUpdate();
    }
    m_lock.unlock();
}
예제 #3
0
bool ServerManager::ProcessExceptions( )
{
	if(m_MinFD == INVALID_SOCKET && m_MaxFD == INVALID_SOCKET)
	{
		return true;
	}

	for(int i=SCENE_PLAYER_ID; i<=BILLING_PLAYER_ID; i++)
	{
		ServerPlayer*	pPlayer = GetServerPlayer(i);
		if(!pPlayer) continue;

		if(pPlayer->IsValid())
		{
			SOCKET s = pPlayer->GetSocket()->getSOCKET();
			if(FD_ISSET( s, &m_ExceptFDs[SELECT_USE]) )
			{
				g_pLog->log_debug("%u,%u,ProcessException......",pPlayer->PlayerID(),0);
				RemoveServer(i);
			}
		}
	}

	return true;
}
예제 #4
0
LRESULT CServerMonitorView::OnBnClickedStopAllMonitoring(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& bHandled)
{
  while (m_ServerList.GetSize() > 0)
  {
    RemoveServer(m_ServerList[0]);
  }
  return 0;
}
예제 #5
0
VOID
CloseAsc(ASSOC_IPC * asipc)
{
        int i = 0;

	/*
	** If we are a gcc let the client disconnect first. If ten seconds 
	** elapse then disconnect anyways.
	*/ 
	while( is_gcc && asipc->IpcInternal.AssocInfo->bPipesClosed == FALSE 
			&& i++ < 200 )
		PCsleep(50);

	if (asipc->SndStdChan)
        CloseHandle(asipc->SndStdChan);
	if (asipc->RcvStdChan)
	{
        WriteFile(asipc->RcvStdChan, "", 1, &i, NULL);
        Sleep(0);
        CloseHandle(asipc->RcvStdChan);
	}
	if (asipc->SndExpChan)
        CloseHandle(asipc->SndExpChan);
	if (asipc->RcvExpChan)
	{
        WriteFile(asipc->RcvExpChan, "", 1, &i, NULL);
        Sleep(0);
        CloseHandle(asipc->RcvExpChan);
	}
	if (asipc->ClientReadHandle)
	    CloseHandle(asipc->ClientReadHandle);
	
	/* Mark pipes as being closed. */
	if ( asipc->IpcInternal.AssocInfo )
	{
	    asipc->IpcInternal.AssocInfo->bPipesClosed = TRUE;
	    asipc->IpcInternal.AssocInfo->refs--; /* decrement reference ct */ 
	    asipc->IpcInternal.AssocInfo = NULL; 
	}
	
	asipc->SndStdChan = NULL;
	asipc->RcvStdChan = NULL;
	asipc->SndExpChan = NULL;
	asipc->RcvExpChan = NULL;
	asipc->ClientReadHandle = NULL;
	
	if ( asipc->IpcInternal.server )	
	{
		asipc->IpcInternal.server->nConnections--;
		if ( 0 == asipc->IpcInternal.server->nConnections )
			 RemoveServer( asipc->IpcInternal.server );
	}

	return;
}
예제 #6
0
void CServerList::RemoveDeadServers()
{
	if ( thePrefs::DeadServer() ) {
		for ( CInternalList::const_iterator it = m_servers.begin(); it != m_servers.end(); ) {
			CServer* server = *it++;
			if ( server->GetFailedCount() > thePrefs::GetDeadserverRetries() && !server->IsStaticMember()) {
				RemoveServer(server);
			}
		}
	}
}
예제 #7
0
void CServerListCtrl::RemoveAllDeadServers()
{
	ShowWindow(SW_HIDE);
	for(POSITION pos = server_list->list.GetHeadPosition(); pos != NULL;server_list->list.GetNext(pos)) {
		CServer* cur_server = server_list->list.GetAt(pos);
		if (cur_server->GetFailedCount() >= thePrefs.GetDeadserverRetries()){
			RemoveServer(cur_server);
			pos = server_list->list.GetHeadPosition();
		}
	}
	ShowWindow(SW_SHOW);
}
예제 #8
0
void CServerList::FilterServers()
{
	CInternalList::iterator it = m_servers.begin();
	while (it != m_servers.end()) {
		CServer* server = *it++;

		if (server->HasDynIP()) {
			continue;
		}
		
		if (theApp->ipfilter->IsFiltered(server->GetIP(), true)) {
			if (server == theApp->serverconnect->GetCurrentServer()) {
				AddLogLineC(_("Local server is filtered by the IPFilters, reconnecting to a different server!"));
				theApp->serverconnect->Disconnect();
				RemoveServer(server);
				theApp->serverconnect->ConnectToAnyServer();
			} else {
				RemoveServer(server);
			}			
		}
	}
}
예제 #9
0
bool ServerManager::ProcessOutputs( )
{
	bool ret = false;

	if(m_MinFD == INVALID_SOCKET && m_MaxFD == INVALID_SOCKET)
	{
		return true;
	}

	for(int i=SCENE_PLAYER_ID; i<=BILLING_PLAYER_ID; i++)
	{
		ServerPlayer*	pPlayer = GetServerPlayer(i);
		if(!pPlayer) continue;

		if(pPlayer->IsValid())
		{
			SOCKET s = pPlayer->GetSocket()->getSOCKET();
			if(FD_ISSET( s, &m_WriteFDs[SELECT_USE]) )
			{
				if(pPlayer->GetSocket()->isSockError() )
				{
					RemoveServer(i);
				}
				else
				{
					ret = pPlayer->ProcessOutput( );
					if(!ret)
					{
						RemoveServer( i );
					}
				}
			}
		}
	}

	return true;
}
예제 #10
0
void CServerListCtrl::RemoveAllFilteredServers()
{
	if (!thePrefs.GetFilterServerByIP())
		return;
	ShowWindow(SW_HIDE);
	for (POSITION pos = theApp.serverlist->list.GetHeadPosition(); pos != NULL; theApp.serverlist->list.GetNext(pos))
	{
		const CServer* cur_server = theApp.serverlist->list.GetAt(pos);
		if (theApp.ipfilter->IsFiltered(cur_server->GetIP()))
		{
			if (thePrefs.GetLogFilteredIPs())
				AddDebugLogLine(false, _T("Filtered server \"%s\" (IP=%s) - IP filter (%s)"), cur_server->GetListName(), ipstr(cur_server->GetIP()), theApp.ipfilter->GetLastHit());
			RemoveServer(cur_server);
			pos = theApp.serverlist->list.GetHeadPosition();
		}
	}
	ShowWindow(SW_SHOW);
}
예제 #11
0
void ChannelBalancer::RemoveAndDestroyChannel(SelectiveChannel::ChannelHandle handle) {
    if (!RemoveServer(ServerId(handle))) {
        return;
    }
    SocketUniquePtr ptr;
    const int rc = Socket::AddressFailedAsWell(handle, &ptr);
    if (rc >= 0) {
        SubChannel* sub = static_cast<SubChannel*>(ptr->user());
        {
            BAIDU_SCOPED_LOCK(_mutex);
            CHECK_EQ(1UL, _chan_map.erase(sub->chan));
        }
        {
            SocketUniquePtr ptr2(ptr.get()); // Dereference.
        }
        if (rc == 0) {
            ptr->ReleaseAdditionalReference();
        }
    }
}
예제 #12
0
파일: document.cpp 프로젝트: wfmdyh/wecan
// **************************************************************************
// DeleteContents ()
//
// Description:
//	Reset the document object for reuse.  This includes disconnect from all
//	OPC servers and deleting all server objects.
//
// Parameters:
//  none
//
// Returns:
//  void
// **************************************************************************
void CKDocument::DeleteContents () 
	{
	// Create a wait cursor object.  This will cause the wait cursor, 
	// usually an hourglass, to be displayed.  When this object goes
	// out of scope, its destructor will restore the previous cursor
	// type.
	CWaitCursor wc;
	
	// Update status bar text to indicate that we are unloading project:
	CKStatusBarText cText (IDS_UNLOADING_PROJECT);
	
	// Notify all views that the project is closing so that no request for
	// server/group/item is made (as in OnGetDispInfo) for a deleted object:
	UpdateAllViews (NULL, HINT_CLOSE_PROJECT, NULL);

	// Free all server connections maintained by the document.  Start with
	// head of linked list and work our way to end:
	while (m_pServerHead)
		{
		// Need to make a copy of current head of linked list:
		CKServer *pServer = m_pServerHead;

		// Reset linked list head to next server:
		m_pServerHead = pServer->GetNext ();

		// Delete server (previously the head of linked list):
		RemoveServer (pServer);
		}

	// Check that we deleted all servers in linked list (debug only):
	ASSERT (m_cdwServers == 0);

	// Invalidate currently selected server and group:
	m_pCurSelServer = NULL;
	m_pCurSelGroup = NULL;

	// Default processing:
	CDocument::DeleteContents ();
	}
예제 #13
0
int RGClient :: Send (int serverId, unsigned char* sendBuffer, unsigned char*& replyBuffer, int sendLength, int& replyMax) {

	int len;
	LastError = RGOK;
	
	if (serverId <= 0) {

		LastError = RGILLEGALSERVERID;
		return -1;
	}
	
	RGServerPort* port = ServerPortList.GetElementAt (serverId);

	if (port == NULL) {

		LastError = RGSERVERNULL;
		return -1;
	}

	*ServerPid = port->GetServerPid ();
	int status = port->Send (sendLength, sendBuffer);

	if (status < 0) {

		LastError = port->GetLastError ();
		RemoveServer (serverId);
		return -1;
	}

	HANDLE HandleArray [2];
	HandleArray [0] = port->GetServerHandle ();
	HandleArray [1] = OKToReadHandle;

	status = WaitForReadAccess (HandleArray);

	if (status < 0) {

		RemoveServer (serverId);
		return -1;
	}

	len = *Length;

	//
	// Test for buffer overflow...we don't like to encourage this!
	//

	if (len > replyMax) {

		delete[] replyBuffer;
		replyBuffer = new unsigned char [len];
		replyMax = len;
	}

	//
	// Test for continuation
	//

	if (*Type == RGBLOCKINGSEND) {
		
		//
		// No continuation needed
		//	

		memcpy (replyBuffer, DataBegin, len);
		return 0;
	}

	//
	// Need continuation
	//

	Boolean Loop = TRUE;
	unsigned char* CurrentOutputPointer = replyBuffer;
	int WriteSize = BufferSize;
	int LeftToWrite = len;
	Boolean Wait = FALSE;

	while (Loop) {
		
		if (Wait) {
		
			status = WaitForReadAccess (HandleArray);  // wait for continuation clearance

			if (status < 0)
				return status;
		}

		Wait = TRUE;
		memcpy (CurrentOutputPointer, DataBegin, WriteSize);
		CurrentOutputPointer += BufferSize;
		LeftToWrite -= BufferSize;
		HandleArray [1] = ContinuationHandle;

		if ((LeftToWrite <= 0) || (*Type == RGBLOCKINGSEND))
			Loop = FALSE;

		else {

			SetEvent (OKToWriteHandle);
		
			if (LeftToWrite <= BufferSize)
				WriteSize = LeftToWrite;
		}
	}  // end of while loop

	return 0;
}
예제 #14
0
void
NetPrefsServerView::MessageReceived (BMessage * msg)
{
  switch (msg->what)
  {
    case M_SERVER_ITEM_SELECTED:
      {
        BRow *row (fServerList->CurrentSelection ());
        if (row)
        {
          fEditButton->SetEnabled (true);
          fRemoveButton->SetEnabled (true);
        }
        else
        {
          fEditButton->SetEnabled (false);
          fRemoveButton->SetEnabled (false);
        }
      }
      break;

    case M_SERVER_ADD_ITEM:
      {
        BMessenger msgr (fEntryWin);
        if (msgr.IsValid ())
          fEntryWin->Activate ();
        else
        {
          fEntryWin = new ServerEntryWindow (this, new BMessage (M_SERVER_RECV_DATA), NULL, 0);
          fEntryWin->Show ();
        }
      }
      break;

    case M_SERVER_EDIT_ITEM:
      {
        BMessenger msgr (fEntryWin);
        if (msgr.IsValid ())
          fEntryWin->Activate ();
        else
        {
          BRow *row (fServerList->CurrentSelection ());
          if (!row)
            break;
          int32 count (0);
          ssize_t size (0);
          type_code type;
          fActiveNetwork->GetInfo ("server", &type, &count);
          const ServerData *compData;
          for (int32 i = 0; i < count; i++)
          {
            fActiveNetwork->FindData ("server", B_RAW_TYPE, i, reinterpret_cast < const void **>(&compData), &size);
            if (!strcmp (compData->serverName, ((BStringField *) row->GetField (1))->String ()))
              break;
	      }
          BMessage *invoke (new BMessage (M_SERVER_RECV_DATA));
          invoke->AddBool ("edit", true);
          fEntryWin = new ServerEntryWindow (this, invoke, compData, size);
          fEntryWin->Show ();
          }
      }
      break;


    case M_SERVER_REMOVE_ITEM:
      {
        RemoveServer ();
        fNetWin.SendMessage (M_SERVER_DATA_CHANGED);
      }
      break;

    case M_SERVER_RECV_DATA:
      {
        const ServerData *data;
        ssize_t size;
        Window ()->DisableUpdates ();
        msg->FindData ("server", B_RAW_TYPE, reinterpret_cast < const void **>(&data), &size);
        if (msg->HasBool ("edit"))
          RemoveServer ();
        UpdateNetworkData (data);
        AddServer (data);
        Window ()->EnableUpdates ();
        fNetWin.SendMessage (M_SERVER_DATA_CHANGED);
      }
      break;

    default:
      BView::MessageReceived (msg);
      break;
  }
}
예제 #15
0
void CServerList::ServerStats()
{
	uint32 tNow = ::GetTickCount();

	if (theApp->IsConnectedED2K() && m_servers.size() > 0) {
		CServer* ping_server = GetNextStatServer();
		CServer* test = ping_server;
		if (!ping_server) {
			return;
		}

		while (ping_server->GetLastPingedTime() && (tNow - ping_server->GetLastPingedTime()) < UDPSERVSTATREASKTIME) {
			ping_server = GetNextStatServer();
			if (ping_server == test) {
				return;
			}
		}
		
		if (ping_server->GetFailedCount() >= thePrefs::GetDeadserverRetries() && thePrefs::DeadServer() && !ping_server->IsStaticMember()) {
			RemoveServer(ping_server);
			return;
		}
				
		srand((unsigned)time(NULL));
		ping_server->SetRealLastPingedTime(tNow); // this is not used to calcualte the next ping, but only to ensure a minimum delay for premature pings		
		if (!ping_server->GetCryptPingReplyPending() && (!ping_server->GetLastPingedTime() || (tNow - ping_server->GetLastPingedTime()) >= UDPSERVSTATREASKTIME) && theApp->GetPublicIP() && thePrefs::IsServerCryptLayerUDPEnabled()) {
			// We try a obfsucation ping first and wait 20 seconds for an answer
			// if it doesn't get responsed, we don't count it as error but continue with a normal ping
			ping_server->SetCryptPingReplyPending(true);
			uint32 nPacketLen = 4 + (uint8)(rand() % 16); // max padding 16 bytes
			CScopedArray<byte> pRawPacket(nPacketLen);
			uint32 dwChallenge = (rand() << 17) | (rand() << 2) | (rand() & 0x03);
			if (dwChallenge == 0) {
				dwChallenge++;
			}
			
			memcpy(pRawPacket.get(), &dwChallenge, sizeof(uint32));
			for (uint32 i = 4; i < nPacketLen; i++) { // fillng up the remaining bytes with random data
				pRawPacket[i] = (uint8)rand();
			}

			ping_server->SetChallenge(dwChallenge);
			ping_server->SetLastPinged(tNow);
			ping_server->SetLastPingedTime((tNow - (uint32)UDPSERVSTATREASKTIME) + 20); // give it 20 seconds to respond
			
			AddDebugLogLineN(logServerUDP, CFormat(wxT(">> Sending OP__GlobServStatReq (obfuscated) to server %s:%u")) % ping_server->GetAddress() % ping_server->GetPort());

			CPacket* packet = new CPacket(pRawPacket[1], nPacketLen - 2, pRawPacket[0]);
			packet->CopyToDataBuffer(0, pRawPacket.get() + 2, nPacketLen - 2);
			
			theStats::AddUpOverheadServer(packet->GetPacketSize());
			theApp->serverconnect->SendUDPPacket(packet, ping_server, true, true /*raw packet*/, 12 /* Port offset is 12 for obfuscated encryption*/);
		} else if (ping_server->GetCryptPingReplyPending() || theApp->GetPublicIP() == 0 || !thePrefs::IsServerCryptLayerUDPEnabled()){
			// our obfsucation ping request was not answered, so probably the server doesn'T supports obfuscation
			// continue with a normal request
			if (ping_server->GetCryptPingReplyPending() && thePrefs::IsServerCryptLayerUDPEnabled()) {
				AddDebugLogLineN(logServerUDP, wxT("CryptPing failed for server ") + ping_server->GetListName());
			} else if (thePrefs::IsServerCryptLayerUDPEnabled()) {
				AddDebugLogLineN(logServerUDP, wxT("CryptPing skipped because our public IP is unknown for server ") + ping_server->GetListName());
			}
			
			ping_server->SetCryptPingReplyPending(false);			
			
			CPacket* packet = new CPacket(OP_GLOBSERVSTATREQ, 4, OP_EDONKEYPROT);
			uint32 challenge = 0x55AA0000 + (uint16)rand();
			ping_server->SetChallenge(challenge);
			packet->CopyUInt32ToDataBuffer(challenge);
			ping_server->SetLastPinged(tNow);
			ping_server->SetLastPingedTime(tNow - (rand() % HR2S(1)));
			ping_server->AddFailedCount();
			Notify_ServerRefresh(ping_server);
			theStats::AddUpOverheadServer(packet->GetPacketSize());
			theApp->serverconnect->SendUDPPacket(packet, ping_server, true);
		} else {
			wxFAIL;
		}
	}
}
예제 #16
0
void CChatControl::Timer()
{
	int ChatConnects = 0;

	
	if(m_TryUltraCache > 0)
		m_TryUltraCache--;

	if(m_ServerList.size() == 0)
		m_UltraCacheMode = false;


	// Manage connected chat servers
	std::vector<CChatServer*>::iterator itServer;
	for(itServer = m_ServerList.begin(); itServer != m_ServerList.end(); itServer++)
	{
		if((*itServer)->m_Status == SOCK_CONNECTED)
		{
			ChatConnects++;
		}
		else
		{
			if((*itServer)->m_SecsDead > 5)
			{
				RemoveServer(*itServer);
				itServer--;
			}
			else
				(*itServer)->m_SecsDead++;
		}
	}



	// Send a connect request if we're connected and in the cache channel
	if(ChatConnects)
		if(m_UltraCacheMode)
		{
			if(m_SecsRequest > 50)
				m_SecsRequest = SendRequest() ? 0 : 50;
			else
				m_SecsRequest++;
		}


	// Chat window open
	if(m_pDoc->m_pViewChat)
	{
		if(m_AutoConnect)
		{
			bool ChatConnect = false;

			for(int i = 0; i < m_ServerList.size(); i++)
				if(m_ServerList[i]->m_Host == "irc.freenode.net")
					ChatConnect = true;

			if(!ChatConnect)
				GetConnect();
		}
	}

	// Chat window not open
	else if(m_AutoConnect)
	{
		if(ChatConnects)
		{
			if(!m_UltraCacheMode && m_TryUltraCache == 0)
				if(m_autNetwork->ClientMode() == CLIENT_LEAF || m_autPrefs->GetMinConnects() != -1 && m_autNetwork->GetNormalConnectedCount() >= m_autPrefs->GetMinConnects())
					RemoveServer( m_ServerList[0] );
		}
		else
		{
			if(m_autNetwork->GetNormalConnectedCount() == 0)
				GetConnect();

			m_UltraCacheMode = false;
			m_TryUltraCache  = 0;
		}
	}

	// Clean Chat Sockets
	std::vector<CChatServer*>::iterator itChat;
	for(itChat = m_ServerList.begin(); itChat != m_ServerList.end(); itChat++)
		if((*itChat)->m_Status == SOCK_CLOSED)
		{
			delete *itChat;
			m_ServerList.erase(itChat);

			itChat--;
		}

	// Remove old ident connects
	std::vector<CChatIdentd*>::iterator itIdent;
	for(itIdent = m_IdentdList.begin(); itIdent != m_IdentdList.end(); itIdent++)
	{
		(*itIdent)->m_SecsAlive++;

		if((*itIdent)->m_SecsAlive >= 10)
		{
			delete *itIdent;
			m_IdentdList.erase(itIdent);

			itIdent--;
		}
	}

}