void CClientList::IncomingBuddy(Kademlia::CContact* contact, Kademlia::CUInt128* buddyID )
{
uint32 nContactIP = ntohl(contact->GetIPAddress());
//If eMule already knows this client, abort this.. It could cause conflicts.
//Although the odds of this happening is very small, it could still happen.
if (FindClientByIP(nContactIP, contact->GetTCPPort()))
{
return;
}
// don't connect ourself
if (theApp.serverconnect->GetLocalIP() == nContactIP && thePrefs.GetPort() == contact->GetTCPPort())
return;
//Add client to the lists to be processed.
CUpDownClient* pNewClient = new CUpDownClient(0, contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, false );
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_INCOMING_BUDDY);
byte ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(ID);
buddyID->ToByteArray(ID);
pNewClient->SetBuddyID(ID);
AddToKadList(pNewClient);
AddClient(pNewClient);
}
BOOL CDownloadClientsCtrl::OnCommand(WPARAM wParam,LPARAM lParam ){
int iSel = GetNextItem(-1, LVIS_SELECTED | LVIS_FOCUSED);
if (iSel != -1){
CUpDownClient* client = (CUpDownClient*)GetItemData(iSel);
switch (wParam){
case MP_SHOWLIST:
client->RequestSharedFileList();
break;
case MP_MESSAGE:
theApp.emuledlg->chatwnd->StartSession(client);
break;
case MP_ADDFRIEND:
if (theApp.friendlist->AddFriend(client))
Update(iSel);
break;
case MPG_ALTENTER:
case MP_DETAIL:{
CClientDetailDialog dialog(client, this);
dialog.DoModal();
break;
}
case MP_BOOT:
if (client->GetKadPort())
Kademlia::CKademlia::bootstrap(ntohl(client->GetIP()), client->GetKadPort());
break;
}
}
return true;
}
/*
* This function adds a file indicated by filehash to suspended_uploads_list
*/
uint16 CUploadQueue::SuspendUpload( const CMD4Hash& filehash )
{
AddLogLineM( false, CFormat( _("Suspending upload of file: %s" ) )
% filehash.Encode() );
uint16 removed = 0;
//Append the filehash to the list.
suspended_uploads_list.push_back(filehash);
wxString base16hash = filehash.Encode();
CClientPtrList::iterator it = m_uploadinglist.begin();
while (it != m_uploadinglist.end()) {
CUpDownClient *potential = *it++;
//check if the client is uploading the file we need to suspend
if(potential->GetUploadFileID() == filehash) {
//remove the unlucky client from the upload queue and add to the waiting queue
RemoveFromUploadQueue(potential);
m_waitinglist.push_back(potential);
theStats::AddWaitingClient();
potential->SetUploadState(US_ONUPLOADQUEUE);
potential->SendRankingInfo();
Notify_QlistRefreshClient(potential);
Notify_ShowQueueCount(m_waitinglist.size());
removed++;
}
}
return removed;
}
void CQueueListCtrl::OnGetDispInfo(NMHDR *pNMHDR, LRESULT *pResult)
{
NMLVDISPINFO *pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
if (g_App.m_pMDlg->IsRunning())
{
// Although we have an owner drawn listview control we store the text for the primary item in the listview, to be
// capable of quick searching those items via the keyboard. Because our listview items may change their contents,
// we do this via a text callback function. The listview control will send us the LVN_DISPINFO notification if
// it needs to know the contents of the primary item.
//
// But, the listview control sends this notification all the time, even if we do not search for an item. At least
// this notification is only sent for the visible items and not for all items in the list. Though, because this
// function is invoked *very* often, no *NOT* put any time consuming code here in.
if ((pDispInfo->item.mask & LVIF_TEXT) != 0)
{
// Check for own search request, the rest of the flood comes from list control
// and isn't used as list is drawn by us
if (pDispInfo->item.cchTextMax == ML_SEARCH_SZ)
{
CUpDownClient *pClient = reinterpret_cast<CUpDownClient*>(pDispInfo->item.lParam);
if (pClient != NULL)
{
switch (pDispInfo->item.iSubItem)
{
case QLCOL_USERNAME:
_tcsncpy(pDispInfo->item.pszText, pClient->GetUserName(), pDispInfo->item.cchTextMax);
pDispInfo->item.pszText[pDispInfo->item.cchTextMax - 1] = _T('\0');
break;
case QLCOL_COUNTRY:
_tcsncpy(pDispInfo->item.pszText, pClient->GetCountryName(), pDispInfo->item.cchTextMax);
pDispInfo->item.pszText[pDispInfo->item.cchTextMax - 1] = _T('\0');
break;
case QLCOL_FILENAME:
{
CKnownFile *pKnownFile = g_App.m_pSharedFilesList->GetFileByID(pClient->m_reqFileHash);
if (pKnownFile != NULL)
{
_tcsncpy(pDispInfo->item.pszText, pKnownFile->GetFileName(), pDispInfo->item.cchTextMax);
pDispInfo->item.pszText[pDispInfo->item.cchTextMax - 1] = _T('\0');
break;
}
}
default:
pDispInfo->item.pszText[0] = _T('\0');
break;
}
}
}
else if (pDispInfo->item.cchTextMax != 0)
pDispInfo->item.pszText[0] = _T('\0');
}
}
*pResult = 0;
}
void CUploadQueue::RemoveFromWaitingQueue(POSITION pos, bool updatewindow){
CUpDownClient* todelete = waitinglist.GetAt(pos);
waitinglist.RemoveAt(pos);
if (updatewindow)
theApp.emuledlg->transferwnd->queuelistctrl.RemoveClient(todelete);
todelete->SetUploadState(US_NONE);
}
bool CClientList::IncomingBuddy(Kademlia::CContact* contact, Kademlia::CUInt128* buddyID)
{
uint32_t nContactIP = wxUINT32_SWAP_ALWAYS(contact->GetIPAddress());
//If aMule already knows this client, abort this.. It could cause conflicts.
//Although the odds of this happening is very small, it could still happen.
if (FindClientByIP(nContactIP, contact->GetTCPPort())) {
return false;
} else if (IsKadFirewallCheckIP(nContactIP)) { // doing a kad firewall check with this IP, abort
AddDebugLogLineN(logKadMain, wxT("Kad TCP firewallcheck / Buddy request collision for IP ") + Uint32toStringIP(nContactIP));
return false;
}
if (theApp->GetPublicIP() == nContactIP && thePrefs::GetPort() == contact->GetTCPPort()) {
return false; // don't connect ourself
}
//Add client to the lists to be processed.
CUpDownClient* pNewClient = new CUpDownClient(contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, NULL, false, true );
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_INCOMING_BUDDY);
byte ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(CMD4Hash(ID));
buddyID->ToByteArray(ID);
pNewClient->SetBuddyID(ID);
AddToKadList(pNewClient);
AddClient(pNewClient);
return true;
}
bool CClientList::IncomingBuddy(Kademlia::CContact* contact, Kademlia::CUInt128* buddyID )
{
uint32 nContactIP = ntohl(contact->GetIPAddress());
//If eMule already knows this client, abort this.. It could cause conflicts.
//Although the odds of this happening is very small, it could still happen.
if (FindClientByIP(nContactIP, contact->GetTCPPort()))
return false;
else if (IsKadFirewallCheckIP(nContactIP)){ // doing a kad firewall check with this IP, abort
DEBUG_ONLY( DebugLogWarning(_T("KAD tcp Firewallcheck / Buddy request collosion for IP %s"), ipstr(nContactIP)) );
return false;
}
else if (theApp.serverconnect->GetLocalIP() == nContactIP && thePrefs.GetPort() == contact->GetTCPPort())
return false; // don't connect ourself
//Add client to the lists to be processed.
CUpDownClient* pNewClient = new CUpDownClient(0, contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, false );
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_INCOMING_BUDDY);
byte ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(ID); //??
buddyID->ToByteArray(ID);
pNewClient->SetBuddyID(ID);
//MORPH START - Changed by SiRoB, Optimization
/*
AddToKadList(pNewClient);
AddClient(pNewClient);
*/
m_KadList.AddTail(pNewClient);
AddClient(pNewClient, true);
//MORPH END - Changed by SiRoB, Optimization
return true;
}
BOOL CUploadListCtrl::OnCommand(WPARAM wParam, LPARAM /*lParam*/)
{
wParam = LOWORD(wParam);
switch (wParam)
{
case MP_FIND:
OnFindStart();
return TRUE;
}
int iSel = GetNextItem(-1, LVIS_SELECTED | LVIS_FOCUSED);
if (iSel != -1) {
CUpDownClient* client = (CUpDownClient*)GetItemData(iSel);
switch (wParam) {
case MP_SHOWLIST:
client->RequestSharedFileList();
break;
#if _ENABLE_NOUSE
case MP_MESSAGE:
theApp.emuledlg->chatwnd->StartSession(client);
break;
case MP_ADDFRIEND:
if (theApp.friendlist->AddFriend(client))
Update(iSel);
break;
#endif
case MP_DETAIL:
case MPG_ALTENTER:
case IDA_ENTER:
{
CClientDetailDialog dialog(client, this);
dialog.DoModal();
break;
}
#ifdef _ENABLE_NOUSE
case MP_BOOT:
if (client->GetKadPort())
Kademlia::CKademlia::Bootstrap(ntohl(client->GetIP()), client->GetKadPort(), (client->GetKadVersion() > 1));
break;
#endif
case MP_REMOVECLIENT:
CGlobalVariable::uploadqueue->RemoveFromUploadQueue(client, _T("remove client active for debug test"));
break;
}
}
if( wParam==MP_SHOWUPQUEUE )
{
theApp.emuledlg->transferwnd->uploadlistctrl.Hide();
theApp.emuledlg->transferwnd->queuelistctrl.Visable();
theApp.emuledlg->m_mainTabWnd.m_dlgDownload.ShowUpingOrQueue(IDC_QUEUELIST);
theApp.emuledlg->m_mainTabWnd.m_dlgDownload.DoResize(1);
}
return true;
}
void CUploadQueue::RemoveFromWaitingQueue(POSITION pos, bool updatewindow){
CUpDownClient* todelete = waitinglist.GetAt(pos);
waitinglist.RemoveAt(pos);
if (updatewindow) {
theApp.emuledlg->transferwnd->queuelistctrl.RemoveClient(todelete);
theApp.emuledlg->transferwnd->ShowQueueCount(waitinglist.GetCount());
}
todelete->m_bAddNextConnect = false;
todelete->SetUploadState(US_NONE);
}
void CUploadQueue::RemoveFromWaitingQueue(CClientPtrList::iterator pos)
{
CUpDownClient* todelete = *pos;
m_waitinglist.erase(pos);
theStats::RemoveWaitingClient();
if( todelete->IsBanned() ) {
todelete->UnBan();
}
Notify_QlistRemoveClient(todelete);
todelete->SetUploadState(US_NONE);
}
void CClientList::FilterQueues()
{
// Filter client list
for ( IDMap::iterator it = m_ipList.begin(); it != m_ipList.end(); ) {
IDMap::iterator tmp = it++; // Don't change this to a ++it!
CUpDownClient* client = tmp->second.GetClient();
if ( theApp->ipfilter->IsFiltered(client->GetConnectIP())) {
client->Disconnected(wxT("Filtered by IPFilter"));
client->Safe_Delete();
}
}
}
void CFriendList::RequestSharedFileList(CFriend* cur_friend)
{
if (cur_friend) {
CUpDownClient* client = cur_friend->GetLinkedClient().GetClient();
if (!client) {
client = new CUpDownClient(cur_friend->GetPort(), cur_friend->GetIP(), 0, 0, 0, true, true);
client->SetUserName(cur_friend->GetName());
theApp->clientlist->AddClient(client);
cur_friend->LinkClient(CCLIENTREF(client, wxT("CFriendList::RequestSharedFileList")));
}
client->RequestSharedFileList();
}
}
CUpDownClient* CFriend::GetClientForChatSession()
{
CUpDownClient* pResult;
if (GetLinkedClient(true) != NULL)
pResult = GetLinkedClient(false);
else{
pResult = new CUpDownClient(0, m_nLastUsedPort, m_dwLastUsedIP, 0, 0, true);
pResult->SetUserName(m_strName);
pResult->SetUserHash(m_abyUserhash);
theApp.clientlist->AddClient(pResult);
SetLinkedClient(pResult);
}
pResult->SetChatState(MS_CHATTING);
return pResult;
};
bool CUploadQueue::RemoveFromUploadQueue(CUpDownClient* client, LPCTSTR pszReason, bool updatewindow, bool earlyabort){
bool result = false;
uint32 slotCounter = 1;
for (POSITION pos = uploadinglist.GetHeadPosition();pos != 0;){
POSITION curPos = pos;
CUpDownClient* curClient = uploadinglist.GetNext(pos);
if (client == curClient){
if (updatewindow)
theApp.emuledlg->transferwnd->uploadlistctrl.RemoveClient(client);
if (thePrefs.GetLogUlDlEvents())
AddDebugLogLine(DLP_DEFAULT, true,_T("Removing client from upload list: %s Client: %s Transferred: %s SessionUp: %s QueueSessionPayload: %s In buffer: %s Req blocks: %i File: %s"), pszReason==NULL ? _T("") : pszReason, client->DbgGetClientInfo(), CastSecondsToHM( client->GetUpStartTimeDelay()/1000), CastItoXBytes(client->GetSessionUp(), false, false), CastItoXBytes(client->GetQueueSessionPayloadUp(), false, false), CastItoXBytes(client->GetPayloadInBuffer()), client->GetNumberOfRequestedBlocksInQueue(), (theApp.sharedfiles->GetFileByID(client->GetUploadFileID())?theApp.sharedfiles->GetFileByID(client->GetUploadFileID())->GetFileName():_T("")));
client->m_bAddNextConnect = false;
uploadinglist.RemoveAt(curPos);
bool removed = theApp.uploadBandwidthThrottler->RemoveFromStandardList(client->socket);
bool pcRemoved = theApp.uploadBandwidthThrottler->RemoveFromStandardList((CClientReqSocket*)client->m_pPCUpSocket);
(void)removed;
(void)pcRemoved;
//if(thePrefs.GetLogUlDlEvents() && !(removed || pcRemoved)) {
// AddDebugLogLine(false, _T("UploadQueue: Didn't find socket to delete. Adress: 0x%x"), client->socket);
//}
if(client->GetSessionUp() > 0) {
++successfullupcount;
totaluploadtime += client->GetUpStartTimeDelay()/1000;
} else if(earlyabort == false)
++failedupcount;
CKnownFile* requestedFile = theApp.sharedfiles->GetFileByID(client->GetUploadFileID());
if(requestedFile != NULL) {
requestedFile->UpdatePartsInfo();
}
theApp.clientlist->AddTrackClient(client); // Keep track of this client
client->SetUploadState(US_NONE);
client->ClearUploadBlockRequests();
client->SetCollectionUploadSlot(false);
m_iHighestNumberOfFullyActivatedSlotsSinceLastCall = 0;
result = true;
} else {
curClient->SetSlotNumber(slotCounter);
slotCounter++;
}
}
return result;
}
int CALLBACK AcceptConnectionCond(LPWSABUF lpCallerId, LPWSABUF /*lpCallerData*/, LPQOS /*lpSQOS*/, LPQOS /*lpGQOS*/,
LPWSABUF /*lpCalleeId*/, LPWSABUF /*lpCalleeData*/, GROUP FAR* /*g*/, DWORD /*dwCallbackData*/)
{
if (lpCallerId && lpCallerId->buf && lpCallerId->len >= sizeof SOCKADDR_IN)
{
LPSOCKADDR_IN pSockAddr = (LPSOCKADDR_IN)lpCallerId->buf;
ASSERT( pSockAddr->sin_addr.S_un.S_addr != 0 && pSockAddr->sin_addr.S_un.S_addr != INADDR_NONE );
if (CGlobalVariable::ipfilter->IsFiltered(pSockAddr->sin_addr.S_un.S_addr)){
if (thePrefs.GetLogFilteredIPs())
AddDebugLogLine(false, _T("Rejecting connection attempt (IP=%s) - IP filter (%s)"), ipstr(pSockAddr->sin_addr.S_un.S_addr), CGlobalVariable::ipfilter->GetLastHit());
_iAcceptConnectionCondRejected = 1;
return CF_REJECT;
}
if (CGlobalVariable::clientlist->IsBannedClient(pSockAddr->sin_addr.S_un.S_addr)){
if (thePrefs.GetLogBannedClients()){
CUpDownClient* pClient = CGlobalVariable::clientlist->FindClientByIP(pSockAddr->sin_addr.S_un.S_addr);
AddDebugLogLine(false, _T("Rejecting connection attempt of banned client %s %s"), ipstr(pSockAddr->sin_addr.S_un.S_addr), pClient->DbgGetClientInfo());
}
_iAcceptConnectionCondRejected = 2;
return CF_REJECT;
}
}
else {
if (thePrefs.GetVerbose())
DebugLogError(_T("Client TCP socket: AcceptConnectionCond unexpected lpCallerId"));
}
return CF_ACCEPT;
}
bool CClientList::DoRequestFirewallCheckUDP(const Kademlia::CContact& contact){
// first make sure we don't know this IP already from somewhere
if (FindClientByIP(ntohl(contact.GetIPAddress())) != NULL)
return false;
// fine, justcreate the client object, set the state and wait
// TODO: We don't know the clients usershash, this means we cannot build an obfuscated connection, which
// again mean that the whole check won't work on "Require Obfuscation" setting, which is not a huge problem,
// but certainly not nice. Only somewhat acceptable way to solve this is to use the KadID instead.
CUpDownClient* pNewClient = new CUpDownClient(0, contact.GetTCPPort(), contact.GetIPAddress(), 0, 0, false );
pNewClient->SetKadState(KS_QUEUED_FWCHECK_UDP);
DebugLog(_T("Selected client for UDP Firewallcheck: %s"), ipstr(ntohl(contact.GetIPAddress())));
AddToKadList(pNewClient);
AddClient(pNewClient);
ASSERT( !pNewClient->SupportsDirectUDPCallback() );
return true;
}
void CFriendList::StartChatSession(CFriend* Friend)
{
if (Friend) {
CUpDownClient* client = Friend->GetLinkedClient().GetClient();
if (!client) {
client = new CUpDownClient(Friend->GetPort(), Friend->GetIP(), 0, 0, 0, true, true);
client->SetIP(Friend->GetIP());
client->SetUserName(Friend->GetName());
theApp->clientlist->AddClient(client);
Friend->LinkClient(CCLIENTREF(client, wxT("CFriendList::StartChatSession")));
}
} else {
AddLogLineC(_("CRITICAL - no client on StartChatSession"));
}
}
bool CClientList::SendChatMessage(uint64 client_id, const wxString& message)
{
CUpDownClient* client = FindClientByIP(IP_FROM_GUI_ID(client_id), PORT_FROM_GUI_ID(client_id));
AddDebugLogLineN( logClient, wxT("Trying to Send Message.") );
if (client) {
AddDebugLogLineN( logClient, wxT("Sending.") );
} else {
AddDebugLogLineC( logClient,
CFormat( wxT("No client (GUI_ID %lli [%s:%llu]) found in CClientList::SendChatMessage(). Creating") )
% client_id
% Uint32toStringIP(IP_FROM_GUI_ID(client_id))
% PORT_FROM_GUI_ID(client_id) );
client = new CUpDownClient(PORT_FROM_GUI_ID(client_id),IP_FROM_GUI_ID(client_id),0,0,NULL, true, true);
AddClient(client);
}
return client->SendChatMessage(message);
}
// Check all clients that uploaded corrupted data,
// and ban them if they didn't upload enough good data too.
void CCorruptionBlackBox::EvaluateData()
{
CCBBClientMap::iterator it = m_badClients.begin();
for (; it != m_badClients.end(); ++it) {
uint32 ip = it->first;
uint64 bad = it->second.m_downloaded;
if (!bad) {
wxFAIL; // this should not happen
continue;
}
uint64 good = 0;
CCBBClientMap::iterator it2 = m_goodClients.find(ip);
if (it2 != m_goodClients.end()) {
good = it2->second.m_downloaded;
}
int nCorruptPercentage = bad * 100 / (bad + good);
if (nCorruptPercentage > CBB_BANTHRESHOLD) {
CUpDownClient* pEvilClient = theApp->clientlist->FindClientByIP(ip);
wxString clientName;
if (pEvilClient != NULL) {
clientName = pEvilClient->GetClientShortInfo();
AddDebugLogLineN(logPartFile, CFormat(wxT("CorruptionBlackBox(%s): Banning: Found client which sent %d of %d corrupted data, %s"))
% m_partNumber % bad % (good + bad) % pEvilClient->GetClientFullInfo());
theApp->clientlist->AddTrackClient(pEvilClient);
pEvilClient->Ban(); // Identified as sender of corrupt data
// Stop download right away
pEvilClient->SetDownloadState(DS_BANNED);
if (pEvilClient->Disconnected(wxT("Upload of corrupted data"))) {
pEvilClient->Safe_Delete();
}
} else {
clientName = Uint32toStringIP(ip);
theApp->clientlist->AddBannedClient(ip);
}
AddLogLineN(CFormat(_("Banned client %s for sending %s corrupt data of %s total for the file '%s'"))
% clientName % CastItoXBytes(bad) % CastItoXBytes(good + bad) % m_fileName);
} else {
CUpDownClient* pSuspectClient = theApp->clientlist->FindClientByIP(ip);
if (pSuspectClient != NULL) {
AddDebugLogLineN(logPartFile, CFormat(wxT("CorruptionBlackBox(%s): Reporting: Found client which probably sent %d of %d corrupted data, but it is within the acceptable limit, %s"))
% m_partNumber % bad % (good + bad) % pSuspectClient->GetClientFullInfo());
theApp->clientlist->AddTrackClient(pSuspectClient);
} else {
AddDebugLogLineN(logPartFile, CFormat(wxT("CorruptionBlackBox(%s): Reporting: Found client which probably sent %d of %d corrupted data, but it is within the acceptable limit, %s"))
% m_partNumber % bad % (good + bad) % Uint32toStringIP(ip));
}
}
}
}
bool CClientList::AttachToAlreadyKnown(CUpDownClient** client, CClientReqSocket* sender){
POSITION pos1, pos2;
CUpDownClient* tocheck = (*client);
CUpDownClient* found_client = NULL;
CUpDownClient* found_client2 = NULL;
for (pos1 = list.GetHeadPosition(); (pos2 = pos1) != NULL; ){
list.GetNext(pos1);
CUpDownClient* cur_client = list.GetAt(pos2);
if (tocheck->Compare(cur_client,false)){ //matching userhash
found_client2 = cur_client;
}
if (tocheck->Compare(cur_client,true)){ //matching IP
found_client = cur_client;
break;
}
}
if (found_client == NULL)
found_client = found_client2;
if (found_client != NULL){
if (tocheck == found_client){
//we found the same client instance (client may have sent more than one OP_HELLO). do not delete that client!
return true;
}
if (sender){
if (found_client->socket){
if (found_client->socket->IsConnected()
&& (found_client->GetIP() != tocheck->GetIP() || found_client->GetUserPort() != tocheck->GetUserPort() ) )
{
// if found_client is connected and has the IS_IDENTIFIED, it's safe to say that the other one is a bad guy
if (found_client->Credits() && found_client->Credits()->GetCurrentIdentState(found_client->GetIP()) == IS_IDENTIFIED){
if (thePrefs.GetLogBannedClients())
AddDebugLogLine(false, _T("Clients: %s (%s), Banreason: Userhash invalid"), tocheck->GetUserName(), ipstr(tocheck->GetConnectIP()));
tocheck->Ban();
return false;
}
//IDS_CLIENTCOL Warning: Found matching client, to a currently connected client: %s (%s) and %s (%s)
if (thePrefs.GetLogBannedClients())
AddDebugLogLine(true,GetResString(IDS_CLIENTCOL), tocheck->GetUserName(), ipstr(tocheck->GetConnectIP()), found_client->GetUserName(), ipstr(found_client->GetConnectIP()));
return false;
}
found_client->socket->client = 0;
found_client->socket->Safe_Delete();
}
found_client->socket = sender;
tocheck->socket = 0;
}
*client = 0;
delete tocheck;
*client = found_client;
return true;
}
return false;
}
bool CClientList::DoRequestFirewallCheckUDP(const Kademlia::CContact& contact)
{
// first make sure we don't know this IP already from somewhere
if (IsIPAlreadyKnown(wxUINT32_SWAP_ALWAYS(contact.GetIPAddress()))) {
return false;
}
// fine, just create the client object, set the state and wait
// TODO: We don't know the client's userhash, this means we cannot build an obfuscated connection, which
// again mean that the whole check won't work on "Require Obfuscation" setting, which is not a huge problem,
// but certainly not nice. Only somewhat acceptable way to solve this is to use the KadID instead.
CUpDownClient* pNewClient = new CUpDownClient(contact.GetTCPPort(), contact.GetIPAddress(), 0, 0, NULL, false, true);
pNewClient->SetKadState(KS_QUEUED_FWCHECK_UDP);
AddDebugLogLineN(logClient, wxT("Selected client for UDP Firewallcheck: ") + KadIPToString(contact.GetIPAddress()));
AddToKadList(pNewClient);
AddClient(pNewClient);
wxASSERT(!pNewClient->SupportsDirectUDPCallback());
return true;
}
void CPeerCacheDownSocket::OnClose(int nErrorCode)
{
DEBUG_ONLY( Debug(_T("%08x %hs\n"), this, __FUNCTION__) );
DisableDownloadLimit(); // receive pending data
CUpDownClient* pCurClient = GetClient();
if (pCurClient && pCurClient->m_pPCDownSocket != this)
pCurClient = NULL;
CPeerCacheSocket::OnClose(nErrorCode);
if (pCurClient)
{
ASSERT( pCurClient->m_pPCDownSocket == NULL );
// this callback is only invoked if that closed socket was(!) currently attached to the client
pCurClient->OnPeerCacheDownSocketClosed(nErrorCode);
}
}
void CClientList::RequestTCP(Kademlia::CContact* contact)
{
uint32 nContactIP = ntohl(contact->GetIPAddress());
// don't connect ourself
if (theApp.serverconnect->GetLocalIP() == nContactIP && thePrefs.GetPort() == contact->GetTCPPort())
return;
CUpDownClient* pNewClient = FindClientByIP(nContactIP, contact->GetTCPPort());
if (!pNewClient)
pNewClient = new CUpDownClient(0, contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, false );
//Add client to the lists to be processed.
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_QUEUED_FWCHECK);
m_KadList.AddTail(pNewClient);
//This method checks if this is a dup already.
AddClient(pNewClient);
}
bool LastCommonRouteFinder::AddHostsToCheck(CUpDownClientPtrList &list) {
bool gotEnoughHosts = true;
if(needMoreHosts) {
addHostLocker.Lock();
if(needMoreHosts) {
POSITION pos = list.GetHeadPosition();
if(pos) {
uint32 startPos = rand()/(RAND_MAX/(min(list.GetCount(), 100)));
for(uint32 skipCounter = 0; skipCounter < startPos && pos != NULL; skipCounter++) {
list.GetNext(pos);
}
if(!pos) {
pos = list.GetHeadPosition();
}
uint32 tryCount = 0;
while(needMoreHosts && tryCount < (uint32)list.GetCount()) {
tryCount++;
CUpDownClient* client = list.GetNext(pos);
if(!pos) {
pos = list.GetHeadPosition();
}
uint32 ip = client->GetIP();
AddHostToCheckNoLock(ip);
}
}
}
gotEnoughHosts = !needMoreHosts;
addHostLocker.Unlock();
}
return gotEnoughHosts;
}
void CClientList::RequestBuddy(Kademlia::CContact* contact)
{
uint32 nContactIP = ntohl(contact->GetIPAddress());
// don't connect ourself
if (theApp.serverconnect->GetLocalIP() == nContactIP && thePrefs.GetPort() == contact->GetTCPPort())
return;
CUpDownClient* pNewClient = FindClientByIP(nContactIP, contact->GetTCPPort());
if (!pNewClient)
pNewClient = new CUpDownClient(0, contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, false );
//Add client to the lists to be processed.
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_QUEUED_BUDDY);
byte ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(ID);
AddToKadList(pNewClient);
//This method checks if this is a dup already.
AddClient(pNewClient);
}
void CClientList::RequestBuddy(Kademlia::CContact* contact, uint8_t connectOptions)
{
uint32_t nContactIP = wxUINT32_SWAP_ALWAYS(contact->GetIPAddress());
// Don't connect to ourself
if (theApp->GetPublicIP() == nContactIP && thePrefs::GetPort() == contact->GetTCPPort()) {
return;
}
CUpDownClient* pNewClient = FindClientByIP(nContactIP, contact->GetTCPPort());
if (!pNewClient) {
pNewClient = new CUpDownClient(contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, NULL, false, true );
} else if (pNewClient->GetKadState() != KS_NONE) {
return; // already busy with this client in some way (probably fw stuff), don't mess with it
} else if (IsKadFirewallCheckIP(nContactIP)) { // doing a kad firewall check with this IP, abort
AddDebugLogLineN(logKadMain, wxT("Kad TCP firewallcheck / Buddy request collision for IP ") + Uint32toStringIP(nContactIP));
return;
}
//Add client to the lists to be processed.
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_QUEUED_BUDDY);
uint8_t ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(CMD4Hash(ID));
pNewClient->SetConnectOptions(connectOptions, true, false);
AddToKadList(pNewClient);
//This method checks if this is a dup already.
AddClient(pNewClient);
}
void CClientList::CleanUpClientList(){
// we remove clients which are not needed any more by time
// this check is also done on CUpDownClient::Disconnected, however it will not catch all
// cases (if a client changes the state without beeing connected
//
// Adding this check directly to every point where any state changes would be more effective,
// is however not compatible with the current code, because there are points where a client has
// no state for some code lines and the code is also not prepared that a client object gets
// invalid while working with it (aka setting a new state)
// so this way is just the easy and safe one to go (as long as emule is basically single threaded)
const uint32 cur_tick = ::GetTickCount();
if (m_dwLastClientCleanUp + CLIENTLIST_CLEANUP_TIME < cur_tick ){
m_dwLastClientCleanUp = cur_tick;
POSITION pos1, pos2;
uint32 cDeleted = 0;
for (pos1 = list.GetHeadPosition();( pos2 = pos1 ) != NULL;){
list.GetNext(pos1);
CUpDownClient* pCurClient = list.GetAt(pos2);
if ((pCurClient->GetUploadState() == US_NONE || pCurClient->GetUploadState() == US_BANNED && !pCurClient->IsBanned())
&& pCurClient->GetDownloadState() == DS_NONE
&& pCurClient->GetChatState() == MS_NONE
&& pCurClient->GetKadState() == KS_NONE
&& pCurClient->socket == NULL)
{
cDeleted++;
delete pCurClient;
}
}
DEBUG_ONLY(AddDebugLogLine(false,_T("Cleaned ClientList, removed %i not used known clients"), cDeleted));
}
}
void CClientList::RequestBuddy(Kademlia::CContact* contact, uint8 byConnectOptions)
{
uint32 nContactIP = ntohl(contact->GetIPAddress());
// don't connect ourself
if (theApp.serverconnect->GetLocalIP() == nContactIP && thePrefs.GetPort() == contact->GetTCPPort())
return;
CUpDownClient* pNewClient = FindClientByIP(nContactIP, contact->GetTCPPort());
if (!pNewClient)
pNewClient = new CUpDownClient(0, contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, false );
else if (pNewClient->GetKadState() != KS_NONE)
return; // already busy with this client in some way (probably fw stuff), don't mess with it
else if (IsKadFirewallCheckIP(nContactIP)){ // doing a kad firewall check with this IP, abort
DEBUG_ONLY( DebugLogWarning(_T("KAD tcp Firewallcheck / Buddy request collosion for IP %s"), ipstr(nContactIP)) );
return;
}
//Add client to the lists to be processed.
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_QUEUED_BUDDY);
byte ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(ID);
pNewClient->SetConnectOptions(byConnectOptions, true, false);
AddToKadList(pNewClient);
//This method checks if this is a dup already.
AddClient(pNewClient);
}
bool CClientList::RequestTCP(Kademlia::CContact* contact, uint8 byConnectOptions)
{
uint32 nContactIP = ntohl(contact->GetIPAddress());
// don't connect ourself
if (theApp.serverconnect->GetLocalIP() == nContactIP && thePrefs.GetPort() == contact->GetTCPPort())
return false;
CUpDownClient* pNewClient = FindClientByIP(nContactIP, contact->GetTCPPort());
if (!pNewClient)
pNewClient = new CUpDownClient(0, contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, false );
else if (pNewClient->GetKadState() != KS_NONE)
return false; // already busy with this client in some way (probably buddy stuff), don't mess with it
//Add client to the lists to be processed.
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_QUEUED_FWCHECK);
if (contact->GetClientID() != 0){
byte ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(ID);
pNewClient->SetConnectOptions(byConnectOptions, true, false);
}
m_KadList.AddTail(pNewClient);
//This method checks if this is a dup already.
AddClient(pNewClient);
return true;
}
bool CClientList::RequestTCP(Kademlia::CContact* contact, uint8_t connectOptions)
{
uint32_t nContactIP = wxUINT32_SWAP_ALWAYS(contact->GetIPAddress());
// don't connect ourself
if (theApp->GetPublicIP() == nContactIP && thePrefs::GetPort() == contact->GetTCPPort()) {
return false;
}
CUpDownClient* pNewClient = FindClientByIP(nContactIP, contact->GetTCPPort());
if (!pNewClient) {
//#warning Do we actually have to check friendstate here?
pNewClient = new CUpDownClient(contact->GetTCPPort(), contact->GetIPAddress(), 0, 0, NULL, false, true);
} else if (pNewClient->GetKadState() != KS_NONE) {
return false; // already busy with this client in some way (probably buddy stuff), don't mess with it
}
//Add client to the lists to be processed.
pNewClient->SetKadPort(contact->GetUDPPort());
pNewClient->SetKadState(KS_QUEUED_FWCHECK);
if (contact->GetClientID() != 0) {
uint8_t ID[16];
contact->GetClientID().ToByteArray(ID);
pNewClient->SetUserHash(CMD4Hash(ID));
pNewClient->SetConnectOptions(connectOptions, true, false);
}
AddToKadList(pNewClient); // This was a direct adding, but I like to check duplicates
//This method checks if this is a dup already.
AddClient(pNewClient);
return true;
}
