CCollectionFile::File* CCollectionFile::FindByURN(LPCTSTR pszURN)
{
Hashes::Sha1Hash oSHA1;
Hashes::TigerHash oTiger;
Hashes::Md5Hash oMD5;
Hashes::Ed2kHash oED2K;
Hashes::BtHash oBTH;
oSHA1.fromUrn( pszURN );
oMD5.fromUrn( pszURN );
oTiger.fromUrn( pszURN );
oED2K.fromUrn( pszURN );
oBTH.fromUrn( pszURN ) || oBTH.fromUrn< Hashes::base16Encoding >( pszURN );
for ( POSITION pos = GetFileIterator(); pos; )
{
File* pFile = GetNextFile( pos );
if ( validAndEqual( oSHA1, pFile->m_oSHA1 ) ) return pFile;
if ( validAndEqual( oMD5, pFile->m_oMD5 ) ) return pFile;
if ( validAndEqual( oTiger, pFile->m_oTiger ) ) return pFile;
if ( validAndEqual( oED2K, pFile->m_oED2K ) ) return pFile;
if ( validAndEqual( oBTH, pFile->m_oBTH ) ) return pFile;
}
return NULL;
}
BOOL CLibraryCollectionView::ShowCollection(CLibraryFile* pFile)
{
if ( pFile != NULL )
{
if ( m_pCollection->IsOpen() && validAndEqual( m_oSHA1, pFile->m_oSHA1 ) )
return TRUE; // Already opened
m_bTrusted = TRI_UNKNOWN;
if ( m_pCollection->Open( pFile->GetPath() ) )
{
if ( SUCCEEDED( m_pWebCtrl->Navigate( CString( _T("p2p-col://") ) +
pFile->m_oSHA1.toString() + _T("/") ) ) )
{
m_oSHA1 = pFile->m_oSHA1;
return TRUE;
}
}
}
m_bTrusted = TRI_UNKNOWN;
if ( m_pCollection->IsOpen() )
{
m_pCollection->Close();
if ( m_pWebCtrl != NULL )
m_pWebCtrl->Navigate( _T("about:blank") );
}
return FALSE;
}
CRouteCacheItem* CRouteCache::Lookup(const Hashes::Guid& oGUID, CNeighbour** ppNeighbour, SOCKADDR_IN* pEndpoint)
{
CRouteCacheItem* pItem = m_pRecent->Find( oGUID );
if ( pItem == NULL )
{
pItem = m_pHistory->Find( oGUID );
if ( pItem == NULL )
{
if ( ppNeighbour ) *ppNeighbour = NULL;
if ( pEndpoint ) ZeroMemory( pEndpoint, sizeof(SOCKADDR_IN) );
return NULL;
}
ASSERT( oGUID.isValid() );
ASSERT( pItem->m_oGUID.isValid() );
ASSERT( validAndEqual( oGUID, pItem->m_oGUID ) );
// This needs to be done, because CRouteCache::Add() can cause m_pHistory cache table deleted.
// Thus need to copy data member of CRouteCacheItem if it is in m_pHistory, before it gets deleted.
Hashes::Guid oTempGUID( pItem->m_oGUID );
CNeighbour* pTempNeighbour = const_cast<CNeighbour*>(pItem->m_pNeighbour);
SOCKADDR_IN pTempEndPoint = pItem->m_pEndpoint;
DWORD tTempAddTime = pItem->m_tAdded;
pItem = Add( oTempGUID, pTempNeighbour, &pTempEndPoint, tTempAddTime );
}
if ( ppNeighbour ) *ppNeighbour = (CNeighbour*)pItem->m_pNeighbour;
if ( pEndpoint ) *pEndpoint = pItem->m_pEndpoint;
return pItem;
}
BOOL CPrivateChatWnd::Find(const Hashes::Guid& oGUID, bool bLive) const
{
if ( m_pSession && validAndEqual( m_pSession->m_oGUID, oGUID ) )
{
return ( bLive == m_pSession->IsOnline() );
}
return FALSE;
}
CEDClient* CEDClients::GetByGUID(const Hashes::Guid& oGUID) const
{
for ( CEDClient* pClient = m_pFirst ; pClient ; pClient = pClient->m_pEdNext )
{
if ( validAndEqual( pClient->m_oGUID, oGUID ) ) return pClient;
}
return NULL;
}
CCollectionFile::File* CCollectionFile::FindFile(CLibraryFile* pShared, BOOL bApply)
{
File* pFile = NULL;
for ( POSITION pos = GetFileIterator(); pos; )
{
pFile = GetNextFile( pos );
if ( validAndEqual( pShared->m_oSHA1, pFile->m_oSHA1 ) ) break;
if ( validAndEqual( pShared->m_oMD5, pFile->m_oMD5 ) ) break;
if ( validAndEqual( pShared->m_oTiger, pFile->m_oTiger ) ) break;
if ( validAndEqual( pShared->m_oED2K, pFile->m_oED2K ) ) break;
if ( validAndEqual( pShared->m_oBTH, pFile->m_oBTH ) ) break;
pFile = NULL;
}
if ( bApply && pFile != NULL )
pFile->ApplyMetadata( pShared );
return pFile;
}
CRouteCacheItem* CRouteCacheTable::Find(const Hashes::Guid& oGUID)
{
WORD nGUID = 0, *ppGUID = (WORD*)&oGUID[ 0 ];
for ( int nIt = 8; nIt; nIt-- )
nGUID = WORD( ( nGUID + *ppGUID++ ) & 0xffff );
CRouteCacheItem* pItem = *( m_pHash + ( nGUID & ROUTE_HASH_MASK ) );
for ( ; pItem; pItem = pItem->m_pNext )
{
if ( validAndEqual( oGUID, pItem->m_oGUID ) ) return pItem;
}
return NULL;
}
CEDClient* CEDClients::GetByID(DWORD nClientID, IN_ADDR* pServer, const Hashes::Guid& oGUID) const
{
for ( CEDClient* pClient = m_pFirst ; pClient ; pClient = pClient->m_pEdNext )
{
if ( pServer && pClient->m_pServer.sin_addr.S_un.S_addr != pServer->S_un.S_addr )
continue;
if ( pClient->m_nClientID == nClientID )
{
if ( ! oGUID || validAndEqual( pClient->m_oGUID, oGUID ) )
return pClient;
}
}
return NULL;
}
BOOL CHostBrowser::OnPush(const Hashes::Guid& oClientID, CConnection* pConnection)
{
//CQuickLock oTransfersLock( Transfers.m_pSection );
// ED2K connections aren't handled here- they are in ED2KClient
if ( m_nProtocol == PROTOCOL_ED2K || m_nProtocol == PROTOCOL_DC || m_tPushed == 0 ) return FALSE;
if ( IsValid() || ! pConnection->IsValid() || ! validAndEqual( m_oClientID, oClientID ) ) return FALSE;
AttachTo( pConnection );
m_pAddress = m_pHost.sin_addr;
m_nPort = htons( m_pHost.sin_port );
SendRequest();
return TRUE;
}
CLibraryFile* CLibraryMaps::LookupFileByMD5(const Hashes::Md5Hash& oMD5, BOOL bSharedOnly, BOOL bAvailableOnly) const
{
if ( ! oMD5 ) return NULL;
CQuickLock oLock( Library.m_pSection );
CLibraryFile* pFile = m_pMD5Map[ oMD5[ 0 ] & HASH_MASK ];
for ( ; pFile ; pFile = pFile->m_pNextMD5 )
{
if ( validAndEqual( oMD5, pFile->m_oMD5 ) )
{
if ( pFile->CheckFileAttributes( SIZE_UNKNOWN, bSharedOnly, bAvailableOnly ) )
return pFile;
//return NULL;
}
}
return NULL;
}
CLibraryFile* CLibraryMaps::LookupFileByBTH(const Hashes::BtHash& oBTH, BOOL bSharedOnly, BOOL bAvailableOnly) const
{
if ( ! oBTH ) return NULL;
CQuickLock oLock( Library.m_pSection );
CLibraryFile* pFile = m_pBTHMap[ oBTH[ 0 ] & HASH_MASK ];
for ( ; pFile ; pFile = pFile->m_pNextBTH )
{
if ( validAndEqual( oBTH, pFile->m_oBTH ) )
{
if ( pFile->CheckFileAttributes( SIZE_UNKNOWN, bSharedOnly, bAvailableOnly ) )
return pFile;
//return NULL;
}
}
return NULL;
}
CLibraryFile* CLibraryMaps::LookupFileByED2K(const Hashes::Ed2kHash& oED2K, BOOL bSharedOnly, BOOL bAvailableOnly) const
{
if ( ! oED2K ) return NULL;
CQuickLock oLock( Library.m_pSection );
CLibraryFile* pFile = m_pED2KMap[ oED2K[ 0 ] & HASH_MASK ];
for ( ; pFile ; pFile = pFile->m_pNextED2K )
{
if ( validAndEqual( oED2K, pFile->m_oED2K ) )
{
if ( pFile->CheckFileAttributes( SIZE_UNKNOWN, bSharedOnly, bAvailableOnly ) )
return pFile;
//return NULL;
}
}
return NULL;
}
CLibraryFile* CLibraryMaps::LookupFileByTiger(const Hashes::TigerHash& oTiger, BOOL bSharedOnly, BOOL bAvailableOnly) const
{
if ( ! oTiger ) return NULL;
CQuickLock oLock( Library.m_pSection );
CLibraryFile* pFile = m_pTigerMap[ oTiger[ 0 ] & HASH_MASK ];
for ( ; pFile ; pFile = pFile->m_pNextTiger )
{
if ( validAndEqual( oTiger, pFile->m_oTiger ) )
{
if ( pFile->CheckFileAttributes( SIZE_UNKNOWN, bSharedOnly, bAvailableOnly ) )
return pFile;
//return NULL;
}
}
return NULL;
}
CLibraryFile* CLibraryMaps::LookupFileBySHA1(const Hashes::Sha1Hash& oSHA1, BOOL bSharedOnly, BOOL bAvailableOnly) const
{
if ( ! oSHA1 ) return NULL;
CQuickLock oLock( Library.m_pSection );
CLibraryFile* pFile = m_pSHA1Map[ oSHA1[ 0 ] & HASH_MASK ];
for ( ; pFile ; pFile = pFile->m_pNextSHA1 )
{
if ( validAndEqual( oSHA1, pFile->m_oSHA1 ) )
{
if ( pFile->CheckFileAttributes( SIZE_UNKNOWN, bSharedOnly, bAvailableOnly ) )
return pFile;
//return NULL; // Note Ghost file would block matching physical file
}
}
return NULL;
}
CFileList* CLibraryMaps::LookupFilesByHash(const CPeerProjectFile* pFilter, BOOL bSharedOnly, BOOL bAvailableOnly, int nMaximum) const
{
CQuickLock oLock( Library.m_pSection );
CFileList* pFiles = NULL;
if ( pFilter->m_oSHA1 )
{
for ( CLibraryFile* pFile = m_pSHA1Map[ pFilter->m_oSHA1[ 0 ] & HASH_MASK ] ;
pFile ; pFile = pFile->m_pNextSHA1 )
{
if ( validAndEqual( pFile->m_oSHA1, pFilter->m_oSHA1 ) &&
*pFile == *pFilter &&
pFile->CheckFileAttributes( pFilter->m_nSize, bSharedOnly, bAvailableOnly ) )
{
if ( ! pFiles )
pFiles = new CFileList;
if ( pFiles->Find( pFile ) == NULL )
{
if ( bSharedOnly )
{
pFile->m_nHitsToday++;
pFile->m_nHitsTotal++;
}
pFiles->AddTail( pFile );
if ( nMaximum && pFiles->GetCount() >= nMaximum )
break;
}
}
}
return pFiles;
}
if ( pFilter->m_oED2K )
{
for ( CLibraryFile* pFile = m_pED2KMap[ pFilter->m_oED2K[ 0 ] & HASH_MASK ] ;
pFile ; pFile = pFile->m_pNextED2K )
{
if ( validAndEqual( pFile->m_oED2K, pFilter->m_oED2K ) &&
*pFile == *pFilter &&
pFile->CheckFileAttributes( pFilter->m_nSize, bSharedOnly, bAvailableOnly ) )
{
if ( ! pFiles )
pFiles = new CFileList;
if ( pFiles->Find( pFile ) == NULL )
{
if ( bSharedOnly )
{
pFile->m_nHitsToday++;
pFile->m_nHitsTotal++;
}
pFiles->AddTail( pFile );
if ( nMaximum && pFiles->GetCount() >= nMaximum )
return pFiles;
}
}
}
return pFiles;
}
if ( pFilter->m_oTiger )
{
for ( CLibraryFile* pFile = m_pTigerMap[ pFilter->m_oTiger[ 0 ] & HASH_MASK ] ;
pFile ; pFile = pFile->m_pNextTiger )
{
if ( validAndEqual( pFile->m_oTiger, pFilter->m_oTiger ) &&
*pFile == *pFilter &&
pFile->CheckFileAttributes( pFilter->m_nSize, bSharedOnly, bAvailableOnly ) )
{
if ( ! pFiles )
pFiles = new CFileList;
if ( pFiles->Find( pFile ) == NULL )
{
if ( bSharedOnly )
{
pFile->m_nHitsToday++;
pFile->m_nHitsTotal++;
}
pFiles->AddTail( pFile );
if ( nMaximum && pFiles->GetCount() >= nMaximum )
break;
}
}
}
return pFiles;
}
if ( pFilter->m_oBTH )
{
for ( CLibraryFile* pFile = m_pBTHMap[ pFilter->m_oBTH[ 0 ] & HASH_MASK ] ;
pFile ; pFile = pFile->m_pNextBTH )
{
if ( validAndEqual( pFile->m_oBTH, pFilter->m_oBTH ) &&
*pFile == *pFilter &&
pFile->CheckFileAttributes( pFilter->m_nSize, bSharedOnly, bAvailableOnly ) )
{
if ( ! pFiles )
pFiles = new CFileList;
if ( pFiles->Find( pFile ) == NULL )
{
if ( bSharedOnly )
{
pFile->m_nHitsToday++;
pFile->m_nHitsTotal++;
}
pFiles->AddTail( pFile );
if ( nMaximum && pFiles->GetCount() >= nMaximum )
return pFiles;
}
}
}
return pFiles;
}
if ( pFilter->m_oMD5 )
{
// Since MD5 is not commonly used for searches we use it for the duplicate file search
// which requires getting a list of files not to return only 1 file. See CLibrary::CheckDuplicates
for ( CLibraryFile* pFile = m_pMD5Map[ pFilter->m_oMD5[ 0 ] & HASH_MASK ] ;
pFile ; pFile = pFile->m_pNextMD5 )
{
if ( validAndEqual( pFile->m_oMD5, pFilter->m_oMD5 ) &&
*pFile == *pFilter &&
pFile->CheckFileAttributes( pFilter->m_nSize, bSharedOnly, bAvailableOnly ) )
{
if ( ! pFiles )
pFiles = new CFileList;
if ( pFiles->Find( pFile ) == NULL )
{
if ( bSharedOnly )
{
pFile->m_nHitsToday++;
pFile->m_nHitsTotal++;
}
pFiles->AddTail( pFile );
if ( nMaximum && pFiles->GetCount() >= nMaximum )
break;
}
}
}
return pFiles;
}
if ( ! pFilter->m_sName.IsEmpty() &&
pFilter->m_nSize != SIZE_UNKNOWN && pFilter->m_nSize != 0 )
{
if ( CLibraryFile* pFile = LibraryMaps.LookupFileByName( pFilter->m_sName, pFilter->m_nSize, bSharedOnly, bAvailableOnly ) )
{
if ( ! pFiles )
pFiles = new CFileList;
if ( pFiles->Find( pFile ) == NULL )
{
if ( bSharedOnly )
{
pFile->m_nHitsToday++;
pFile->m_nHitsTotal++;
}
pFiles->AddTail( pFile );
}
}
return pFiles;
}
return pFiles; // Null
}
