void CLocalSearch::CreatePacketG2()
{
CG2Packet* pPacket = CG2Packet::New( G2_PACKET_HIT, TRUE );
m_pPacket = pPacket;
pPacket->WritePacket( "GU", 16 );
GGUID tmp( MyProfile.GUID );
pPacket->Write( &tmp, sizeof(GGUID) );
if ( TRUE /* Network.IsListening() */ )
{
pPacket->WritePacket( "NA", 6 );
pPacket->WriteLongLE( Network.m_pHost.sin_addr.S_un.S_addr );
pPacket->WriteShortBE( htons( Network.m_pHost.sin_port ) );
}
pPacket->WritePacket( "V", 4 );
pPacket->WriteString( SHAREAZA_VENDOR_A, FALSE );
if ( ! Network.IsStable() || ! Datagrams.IsStable() )
{
pPacket->WritePacket( "FW", 0 );
}
{
CSingleLock pNetLock( &Network.m_pSection );
if ( pNetLock.Lock( 50 ) )
{
for ( POSITION pos = Neighbours.GetIterator() ; pos ; )
{
CNeighbour* pNeighbour = Neighbours.GetNext( pos );
if ( pNeighbour->m_nNodeType != ntLeaf &&
pNeighbour->m_nProtocol == PROTOCOL_G2 )
{
pPacket->WritePacket( "NH", 6 );
pPacket->WriteLongLE( pNeighbour->m_pHost.sin_addr.S_un.S_addr );
pPacket->WriteShortBE( htons( pNeighbour->m_pHost.sin_port ) );
}
}
}
}
if ( ! Uploads.m_bStable ) pPacket->WritePacket( "UNSTA", 0 );
CSingleLock pQueueLock( &UploadQueues.m_pSection );
int nQueue = 1;
if ( pQueueLock.Lock() )
{
for ( POSITION pos = UploadQueues.GetIterator() ; pos ; nQueue++ )
{
CUploadQueue* pQueue = UploadQueues.GetNext( pos );
pPacket->WritePacket( "HG", ( 4 + 7 ) + 2, TRUE );
pPacket->WritePacket( "SS", 7 );
pPacket->WriteShortBE( pQueue->GetQueuedCount() + pQueue->GetTransferCount() );
pPacket->WriteByte( pQueue->GetTransferCount( TRUE ) );
pPacket->WriteLongBE( pQueue->GetPredictedBandwidth() * 8 / 1024 );
pPacket->WriteByte( 0 );
pPacket->WriteByte( nQueue );
}
pQueueLock.Unlock();
}
CString strNick = MyProfile.GetNick();
if ( strNick.GetLength() > 32 ) strNick = strNick.Left( 32 );
if ( strNick.GetLength() )
{
int nNick = pPacket->GetStringLen( strNick );
pPacket->WritePacket( "UPRO", nNick + 6, TRUE );
pPacket->WritePacket( "NICK", nNick );
pPacket->WriteString( strNick, FALSE );
}
if ( Settings.Community.ServeProfile ) pPacket->WritePacket( "BUP", 0 );
if ( Settings.Community.ServeFiles ) pPacket->WritePacket( "BH", 0 );
if ( Settings.Community.ChatEnable ) pPacket->WritePacket( "PCH", 0 );
}
CG2Packet* CLocalSearch::CreatePacketG2()
{
CG2Packet* pPacket = CG2Packet::New( G2_PACKET_HIT, TRUE );
pPacket->WritePacket( G2_PACKET_NODE_GUID, Hashes::Guid::byteCount );
pPacket->Write( Hashes::Guid( MyProfile.oGUID ) );
pPacket->WritePacket( G2_PACKET_NODE_ADDRESS, 6 );
pPacket->WriteLongLE( Network.m_pHost.sin_addr.s_addr );
pPacket->WriteShortBE( htons( Network.m_pHost.sin_port ) );
pPacket->WritePacket( G2_PACKET_VENDOR, 4 );
pPacket->WriteString( VENDOR_CODE, FALSE );
if ( Network.IsFirewalled() )
{
pPacket->WritePacket( G2_PACKET_PEER_FIREWALLED, 0 );
}
{
CSingleLock pNetLock( &Network.m_pSection );
if ( pNetLock.Lock( 50 ) )
{
for ( POSITION pos = Neighbours.GetIterator() ; pos ; )
{
CNeighbour* pNeighbour = Neighbours.GetNext( pos );
if ( pNeighbour->m_nNodeType != ntLeaf &&
pNeighbour->m_nProtocol == PROTOCOL_G2 )
{
pPacket->WritePacket( G2_PACKET_NEIGHBOUR_HUB, 6 );
pPacket->WriteLongLE( pNeighbour->m_pHost.sin_addr.s_addr );
pPacket->WriteShortBE( htons( pNeighbour->m_pHost.sin_port ) );
}
}
}
}
if ( ! Uploads.m_bStable ) pPacket->WritePacket( G2_PACKET_PEER_UNSTABLE, 0 );
CSingleLock pQueueLock( &UploadQueues.m_pSection );
int nQueue = 1;
if ( pQueueLock.Lock() )
{
for ( POSITION pos = UploadQueues.GetIterator() ; pos ; nQueue++ )
{
CUploadQueue* pQueue = UploadQueues.GetNext( pos );
pPacket->WritePacket( G2_PACKET_HIT_GROUP, ( 4 + 7 ) + 2, TRUE );
pPacket->WritePacket( G2_PACKET_PEER_STATUS, 7 );
pPacket->WriteShortBE( WORD( pQueue->GetQueuedCount() + pQueue->GetTransferCount() ) );
pPacket->WriteByte( BYTE( pQueue->GetTransferCount( TRUE ) ) );
pPacket->WriteLongBE( pQueue->GetPredictedBandwidth() * 8 / 1024 );
pPacket->WriteByte( 0 );
pPacket->WriteByte( BYTE( nQueue ) );
}
pQueueLock.Unlock();
}
CString strNick = MyProfile.GetNick();
if ( strNick.GetLength() > 32 ) strNick = strNick.Left( 32 );
if ( strNick.GetLength() )
{
int nNick = pPacket->GetStringLen( strNick );
pPacket->WritePacket( G2_PACKET_PROFILE, nNick + 6, TRUE );
pPacket->WritePacket( G2_PACKET_NICK, nNick );
pPacket->WriteString( strNick, FALSE );
}
if ( Settings.Community.ServeProfile ) pPacket->WritePacket( G2_PACKET_BROWSE_PROFILE, 0 );
if ( Settings.Community.ServeFiles ) pPacket->WritePacket( G2_PACKET_BROWSE_HOST, 0 );
if ( Settings.Community.ChatEnable ) pPacket->WritePacket( G2_PACKET_PEER_CHAT, 0 );
return pPacket;
}
BOOL CLocalSearch::AddHitG2(CLibraryFile* pFile, int nIndex)
{
CG2Packet* pPacket = (CG2Packet*)m_pPacket;
CString strMetadata, strComment;
BOOL bCollection = FALSE;
BOOL bPreview = FALSE;
DWORD nGroup = 0;
// Pass 1: Calculate child group size
if ( pFile->m_bTiger && pFile->m_bSHA1 )
{
nGroup += 5 + 3 + sizeof(SHA1) + sizeof(TIGEROOT);
}
else if ( pFile->m_bTiger )
{
nGroup += 5 + 4 + sizeof(TIGEROOT);
}
else if ( pFile->m_bSHA1 )
{
nGroup += 5 + 5 + sizeof(SHA1);
}
if ( pFile->m_bED2K )
{
nGroup += 5 + 5 + sizeof(MD4);
}
if ( m_pSearch == NULL || m_pSearch->m_bWantDN )
{
if ( pFile->GetSize() <= 0xFFFFFFFF )
{
nGroup += 8 + pPacket->GetStringLen( pFile->m_sName );
}
else
{
nGroup += 4 + 8;
nGroup += 4 + pPacket->GetStringLen( pFile->m_sName );
}
if ( LPCTSTR pszType = _tcsrchr( pFile->m_sName, '.' ) )
{
if ( _tcsicmp( pszType, _T(".co") ) == 0 ||
_tcsicmp( pszType, _T(".collection") ) == 0 )
{
if ( ! pFile->m_bBogus )
{
nGroup += 2 + 7;
bCollection = TRUE;
}
}
}
}
if ( pFile->IsAvailable() && ( m_pSearch == NULL || m_pSearch->m_bWantURL ) )
{
nGroup += 5;
if ( pFile->m_pSources.GetCount() ) nGroup += 7;
if ( Settings.Uploads.SharePreviews )
{
if ( pFile->m_bCachedPreview ||
_tcsistr( pFile->m_sName, _T(".jpg") ) ||
_tcsistr( pFile->m_sName, _T(".png") ) )
{
bPreview = TRUE;
}
}
if ( bPreview ) nGroup += 5;
}
if ( pFile->m_pMetadata != NULL && ( m_pSearch == NULL || m_pSearch->m_bWantXML ) )
{
strMetadata = pFile->m_pMetadata->ToString();
int nMetadata = pPacket->GetStringLen( strMetadata );
nGroup += 4 + nMetadata;
if ( nMetadata > 0xFF )
{
nGroup ++;
if ( nMetadata > 0xFFFF ) nGroup ++;
}
}
if ( m_pSearch == NULL || m_pSearch->m_bWantCOM )
{
if ( pFile->m_nRating > 0 || pFile->m_sComments.GetLength() > 0 )
{
if ( pFile->m_nRating > 0 )
{
strComment.Format( _T("<comment rating=\"%i\">"), pFile->m_nRating - 1 );
CXMLNode::ValueToString( pFile->m_sComments, strComment );
if ( strComment.GetLength() > 2048 ) strComment = strComment.Left( 2048 );
strComment += _T("</comment>");
}
else
{
strComment = _T("<comment>");
CXMLNode::ValueToString( pFile->m_sComments, strComment );
if ( strComment.GetLength() > 2048 ) strComment = strComment.Left( 2048 );
strComment += _T("</comment>");
}
Replace( strComment, _T("\r\n"), _T("{n}") );
int nComment = pPacket->GetStringLen( strComment );
nGroup += 5 + nComment;
if ( nComment > 0xFF )
{
nGroup ++;
if ( nComment > 0xFFFF ) nGroup ++;
}
}
if ( pFile->m_bBogus ) nGroup += 7;
}
else
{
if ( ! pFile->IsAvailable() ) return FALSE;
}
if ( m_pSearch == NULL ) nGroup += 8;
nGroup += 4;
// Pass 2: Write the child packet
pPacket->WritePacket( "H", nGroup, TRUE );
if ( pFile->m_bTiger && pFile->m_bSHA1 )
{
pPacket->WritePacket( "URN", 3 + sizeof(SHA1) + sizeof(TIGEROOT) );
pPacket->WriteString( "bp" );
pPacket->Write( &pFile->m_pSHA1, sizeof(SHA1) );
pPacket->Write( &pFile->m_pTiger, sizeof(TIGEROOT) );
}
else if ( pFile->m_bTiger )
{
pPacket->WritePacket( "URN", 4 + sizeof(TIGEROOT) );
pPacket->WriteString( "ttr" );
pPacket->Write( &pFile->m_pTiger, sizeof(TIGEROOT) );
}
else if ( pFile->m_bSHA1 )
{
pPacket->WritePacket( "URN", 5 + sizeof(SHA1) );
pPacket->WriteString( "sha1" );
pPacket->Write( &pFile->m_pSHA1, sizeof(SHA1) );
}
if ( pFile->m_bED2K )
{
pPacket->WritePacket( "URN", 5 + sizeof(MD4) );
pPacket->WriteString( "ed2k" );
pPacket->Write( &pFile->m_pED2K, sizeof(MD4) );
}
if ( m_pSearch == NULL || m_pSearch->m_bWantDN )
{
if ( pFile->GetSize() <= 0xFFFFFFFF )
{
pPacket->WritePacket( "DN", pPacket->GetStringLen( pFile->m_sName ) + 4 );
pPacket->WriteLongBE( (DWORD)pFile->GetSize() );
pPacket->WriteString( pFile->m_sName, FALSE );
}
else
{
pPacket->WritePacket( "SZ", 8 );
pPacket->WriteInt64( pFile->GetSize() );
pPacket->WritePacket( "DN", pPacket->GetStringLen( pFile->m_sName ) );
pPacket->WriteString( pFile->m_sName, FALSE );
}
if ( bCollection ) pPacket->WritePacket( "COLLECT", 0 );
}
{
CSingleLock pQueueLock( &UploadQueues.m_pSection, TRUE );
CUploadQueue* pQueue = UploadQueues.SelectQueue( PROTOCOL_HTTP, pFile );
pPacket->WritePacket( "G", 1 );
pPacket->WriteByte( pQueue ? pQueue->m_nIndex + 1 : 0 );
}
if ( pFile->IsAvailable() && ( m_pSearch == NULL || m_pSearch->m_bWantURL ) )
{
pPacket->WritePacket( "URL", 0 );
if ( int nCount = pFile->m_pSources.GetCount() )
{
pPacket->WritePacket( "CSC", 2 );
pPacket->WriteShortBE( (WORD)nCount );
}
if ( bPreview )
{
pPacket->WritePacket( "PVU", 0 );
}
}
if ( strMetadata.GetLength() )
{
pPacket->WritePacket( "MD", pPacket->GetStringLen( strMetadata ) );
pPacket->WriteString( strMetadata, FALSE );
}
if ( m_pSearch == NULL || m_pSearch->m_bWantCOM )
{
if ( strComment.GetLength() )
{
pPacket->WritePacket( "COM", pPacket->GetStringLen( strComment ) );
pPacket->WriteString( strComment, FALSE );
}
if ( pFile->m_bBogus ) pPacket->WritePacket( "BOGUS", 0 );
}
if ( m_pSearch == NULL )
{
pPacket->WritePacket( "ID", 4 );
pPacket->WriteLongBE( pFile->m_nIndex );
}
return TRUE;
}
void CLocalSearch::AddHitG2(CG2Packet* pPacket, CSchemaMap& /*pSchemas*/, CLibraryFile* pFile, int /*nIndex*/)
{
// Pass 1: Calculate child group size
// Pass 2: Write the child packet
DWORD nGroup = 0;
bool bCalculate = false;
do
{
bCalculate = ! bCalculate;
if ( ! bCalculate )
{
pPacket->WritePacket( G2_PACKET_HIT_DESCRIPTOR, nGroup, TRUE );
}
if ( pFile->m_oTiger && pFile->m_oSHA1 )
{
const char prefix[] = "bp";
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URN, sizeof( prefix ) + Hashes::Sha1Hash::byteCount + Hashes::TigerHash::byteCount );
else
{
pPacket->WritePacket( G2_PACKET_URN, sizeof( prefix ) + Hashes::Sha1Hash::byteCount + Hashes::TigerHash::byteCount );
pPacket->WriteString( prefix );
pPacket->Write( pFile->m_oSHA1 );
pPacket->Write( pFile->m_oTiger );
}
}
else if ( pFile->m_oTiger )
{
const char prefix[] = "ttr";
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URN, sizeof( prefix ) + Hashes::TigerHash::byteCount );
else
{
pPacket->WritePacket( G2_PACKET_URN, sizeof( prefix ) + Hashes::TigerHash::byteCount );
pPacket->WriteString( prefix );
pPacket->Write( pFile->m_oTiger );
}
}
else if ( pFile->m_oSHA1 )
{
const char prefix[] = "sha1";
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URN, sizeof( prefix ) + Hashes::Sha1Hash::byteCount );
else
{
pPacket->WritePacket( G2_PACKET_URN, sizeof( prefix ) + Hashes::Sha1Hash::byteCount );
pPacket->WriteString( prefix );
pPacket->Write( pFile->m_oSHA1 );
}
}
if ( pFile->m_oED2K )
{
const char prefix[] = "ed2k";
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URN, sizeof( prefix ) + Hashes::Ed2kHash::byteCount );
else
{
pPacket->WritePacket( G2_PACKET_URN, sizeof( prefix ) + Hashes::Ed2kHash::byteCount );
pPacket->WriteString( prefix );
pPacket->Write( pFile->m_oED2K );
}
}
if ( pFile->m_oBTH )
{
const char prefix[] = "btih";
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URN, sizeof( prefix ) + Hashes::BtHash::byteCount );
else
{
pPacket->WritePacket( G2_PACKET_URN, sizeof( prefix ) + Hashes::BtHash::byteCount );
pPacket->WriteString( prefix );
pPacket->Write( pFile->m_oBTH );
}
}
if ( pFile->m_oMD5 )
{
const char prefix[] = "md5";
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URN, sizeof( prefix ) + Hashes::Md5Hash::byteCount );
else
{
pPacket->WritePacket( G2_PACKET_URN, sizeof( prefix ) + Hashes::Md5Hash::byteCount );
pPacket->WriteString( prefix );
pPacket->Write( pFile->m_oMD5 );
}
}
if ( ! m_pSearch || m_pSearch->m_bWantDN )
{
if ( pFile->GetSize() <= 0xFFFFFFFF )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_DESCRIPTIVE_NAME, sizeof( DWORD ) + pPacket->GetStringLen( pFile->m_sName ) );
else
{
pPacket->WritePacket( G2_PACKET_DESCRIPTIVE_NAME, sizeof( DWORD ) + pPacket->GetStringLen( pFile->m_sName ) );
pPacket->WriteLongBE( (DWORD)pFile->GetSize() );
pPacket->WriteString( pFile->m_sName, FALSE );
}
}
else
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_SIZE, sizeof( QWORD ) ) +
G2_PACKET_LEN( G2_PACKET_DESCRIPTIVE_NAME, pPacket->GetStringLen( pFile->m_sName ) );
else
{
pPacket->WritePacket( G2_PACKET_SIZE, sizeof( QWORD ) );
pPacket->WriteInt64( pFile->GetSize() );
pPacket->WritePacket( G2_PACKET_DESCRIPTIVE_NAME, pPacket->GetStringLen( pFile->m_sName ) );
pPacket->WriteString( pFile->m_sName, FALSE );
}
}
if ( LPCTSTR pszType = _tcsrchr( pFile->m_sName, '.' ) )
{
if ( _tcsicmp( pszType, _T(".co") ) == 0 ||
_tcsicmp( pszType, _T(".collection") ) == 0 ||
_tcsicmp( pszType, _T(".emulecollection") ) == 0 )
{
if ( ! pFile->m_bBogus )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_COLLECTION, 0 );
else
pPacket->WritePacket( G2_PACKET_COLLECTION, 0 );
}
}
}
}
if ( ! m_pSearch || m_pSearch->m_bWantURL )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_URL, 0 );
else
pPacket->WritePacket( G2_PACKET_URL, 0 );
if ( INT_PTR nCount = pFile->m_pSources.GetCount() )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_CACHED_SOURCES, sizeof( WORD ) );
else
{
pPacket->WritePacket( G2_PACKET_CACHED_SOURCES, sizeof( WORD ) );
pPacket->WriteShortBE( (WORD)nCount );
}
}
if ( Settings.Uploads.SharePreviews &&
( pFile->m_bCachedPreview || ( Settings.Uploads.DynamicPreviews &&
CImageServices::IsFileViewable( (LPCTSTR)pFile->m_sName ) ) ) )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_PREVIEW_URL, 0 );
else
pPacket->WritePacket( G2_PACKET_PREVIEW_URL, 0 );
}
}
if ( pFile->m_pMetadata != NULL && ( ! m_pSearch || m_pSearch->m_bWantXML ) )
{
CString strMetadata = pFile->m_pMetadata->ToString();
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_METADATA, pPacket->GetStringLen( strMetadata ) );
else
{
pPacket->WritePacket( G2_PACKET_METADATA, pPacket->GetStringLen( strMetadata ) );
pPacket->WriteString( strMetadata, FALSE );
}
}
{
CQuickLock pQueueLock( UploadQueues.m_pSection );
CUploadQueue* pQueue = UploadQueues.SelectQueue( PROTOCOL_HTTP, pFile );
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_GROUP_ID, sizeof( BYTE ) );
else
{
pPacket->WritePacket( G2_PACKET_GROUP_ID, sizeof( BYTE ) );
pPacket->WriteByte( BYTE( pQueue ? pQueue->m_nIndex + 1 : 0 ) );
}
}
if ( ! m_pSearch || m_pSearch->m_bWantCOM )
{
if ( pFile->IsRated() )
{
CString strComment;
if ( pFile->m_nRating > 0 )
strComment.Format( _T("<comment rating=\"%i\">"), pFile->m_nRating - 1 );
else
strComment = _T("<comment>");
strComment += Escape( pFile->m_sComments );
if ( strComment.GetLength() > 2048 ) strComment = strComment.Left( 2048 );
strComment += _T("</comment>");
strComment.Replace( _T("\r\n"), _T("{n}") );
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_COMMENT, pPacket->GetStringLen( strComment ) );
else
{
pPacket->WritePacket( G2_PACKET_COMMENT, pPacket->GetStringLen( strComment ) );
pPacket->WriteString( strComment, FALSE );
}
}
if ( pFile->m_bBogus )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_BOGUS, 0 );
else
pPacket->WritePacket( G2_PACKET_BOGUS, 0 );
}
}
if ( ! m_pSearch )
{
if ( bCalculate )
nGroup += G2_PACKET_LEN( G2_PACKET_OBJECT_ID, sizeof( DWORD ) );
else
{
pPacket->WritePacket( G2_PACKET_OBJECT_ID, sizeof( DWORD ) );
pPacket->WriteLongBE( pFile->m_nIndex );
}
}
}
while( bCalculate );
}