void CUploadsWnd::OnUploadsDisconnect()
{
CSingleLock pLock( &Transfers.m_pSection, TRUE );
CList<CUploadFile*> pList;
for ( POSITION pos = UploadFiles.GetIterator() ; pos ; )
{
CUploadFile* pFile = UploadFiles.GetNext( pos );
if ( IsSelected( pFile ) ) pList.AddTail( pFile );
}
while ( ! pList.IsEmpty() )
{
CUploadFile* pFile = pList.RemoveHead();
if ( UploadFiles.Check( pFile ) && pFile->GetActive() != NULL )
{
CUploadTransfer* pUpload = pFile->GetActive();
if ( pUpload->m_nProtocol == PROTOCOL_ED2K && pUpload->m_nState != upsNull )
{
CString strFormat, strMessage;
LoadString( strFormat, IDS_UPLOAD_CANCEL_ED2K );
strMessage.Format( strFormat, (LPCTSTR)pUpload->m_sFileName );
pLock.Unlock();
UINT nResp = AfxMessageBox( strMessage, MB_ICONQUESTION|MB_YESNOCANCEL|MB_DEFBUTTON2 );
pLock.Lock();
if ( nResp == IDCANCEL ) break;
if ( nResp != IDYES || ! Uploads.Check( pUpload ) ) continue;
}
pUpload->Close( TRUE );
}
}
}
void CUploadsWnd::OnSecurityBan()
{
CSingleLock pLock( &Transfers.m_pSection, TRUE );
CList<CUploadFile*> pList;
for ( POSITION pos = UploadFiles.GetIterator() ; pos ; )
{
CUploadFile* pFile = UploadFiles.GetNext( pos );
if ( IsSelected( pFile ) ) pList.AddTail( pFile );
}
while ( ! pList.IsEmpty() )
{
CUploadFile* pFile = pList.RemoveHead();
if ( UploadFiles.Check( pFile ) && pFile->GetActive() != NULL )
{
CUploadTransfer* pUpload = pFile->GetActive();
IN_ADDR pAddress = pUpload->m_pHost.sin_addr;
pUpload->Remove( FALSE );
pLock.Unlock();
Security.Ban( &pAddress, banSession );
pLock.Lock();
}
}
}
void CPrivateChatWnd::OnChatPriority()
{
if ( ! m_pSession )
return;
CSingleLock pLock( &Transfers.m_pSection );
if ( ! pLock.Lock( 500 ) )
return;
DWORD nAddress = m_pSession->m_pHost.sin_addr.s_addr;
for ( POSITION pos = Uploads.GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = Uploads.GetNext( pos );
if ( pUpload->m_pHost.sin_addr.s_addr == nAddress &&
pUpload->m_nState == upsQueued )
{
pUpload->Promote();
}
}
CString strMessage;
strMessage.Format( LoadString( IDS_CHAT_PRIORITY_GRANTED ), (LPCTSTR)HostToString( &m_pSession->m_pHost ) );
CChatWnd::OnStatusMessage( 2, strMessage );
}
void CUploadFile::Remove()
{
for ( POSITION pos = m_pTransfers.GetHeadPosition() ; pos ; )
{
CUploadTransfer* pUpload = (CUploadTransfer*)m_pTransfers.GetNext( pos );
pUpload->Remove();
}
}
void CUploadsWnd::OnUploadsClearCompleted()
{
CSingleLock pLock( &Transfers.m_pSection, TRUE );
for ( POSITION pos = Uploads.GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = Uploads.GetNext( pos );
if ( pUpload->m_nState == upsNull ) pUpload->Remove( FALSE );
}
m_wndUploads.Update();
}
void CUploadsWnd::OnTimer(UINT_PTR nIDEvent)
{
// Reset Selection Timer event (posted by ctrluploads)
if ( nIDEvent == 5 )
{
m_tSel = 0;
return;
}
const DWORD tNow = GetTickCount();
// Clear event (5 second timer)
if ( nIDEvent == 4 )
{
CSingleLock pLock( &Transfers.m_pSection );
if ( ! pLock.Lock( 10 ) ) return;
//BOOL bCull = Uploads.GetCount( NULL ) > 50; // Obsolete
DWORD nCount = 0;
for ( POSITION pos = Uploads.GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = Uploads.GetNext( pos );
if ( pUpload->m_nState == upsNull )
{
if ( ( tNow > pUpload->m_tConnected + Settings.Uploads.ClearDelay ) &&
( Settings.Uploads.AutoClear || pUpload->m_nUploaded == 0 || nCount > 30 ) )
pUpload->Remove( FALSE );
else
nCount++;
}
}
return;
}
// Update event (2 second timer)
if ( nIDEvent == 2 )
{
// If the window is visible or hasn't been updated in 10 seconds
if ( ( IsWindowVisible() && IsActive( FALSE ) ) || tNow > m_tLastUpdate + 10*1000 )
{
m_wndUploads.Update();
m_tLastUpdate = tNow;
}
return;
}
}
void CUploadsWnd::OnTimer(UINT nIDEvent)
{
// Reset Selection Timer event (posted by ctrluploads)
if ( nIDEvent == 5 ) m_tSel = 0;
// Clear event (5 second timer)
if ( nIDEvent == 4 )
{
CSingleLock pLock( &Transfers.m_pSection );
if ( ! pLock.Lock( 10 ) ) return;
DWORD tNow = GetTickCount();
BOOL bCull = Uploads.GetCount( NULL ) > 75;
for ( POSITION pos = Uploads.GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = Uploads.GetNext( pos );
if ( pUpload->m_nState == upsNull &&
tNow - pUpload->m_tConnected > Settings.Uploads.ClearDelay )
{
if ( Settings.Uploads.AutoClear || pUpload->m_nUploaded == 0 || bCull )
{
pUpload->Remove( FALSE );
}
}
}
}
// Update event (2 second timer)
if ( nIDEvent == 2 )
{
DWORD tNow = GetTickCount();
// If the window is visible or hasn't been updated in 10 seconds
if ( ( IsWindowVisible() && IsActive( FALSE ) ) || ( ( tNow - m_tLastUpdate ) > 10*1000 ) )
{
m_wndUploads.Update();
m_tLastUpdate = tNow;
}
}
}
void CPrivateChatFrame::OnChatPriority()
{
CSingleLock pLock( &Transfers.m_pSection );
if ( ! pLock.Lock( 500 ) ) return;
const DWORD nAddress = m_pSession->m_pHost.sin_addr.S_un.S_addr;
int nCount = 0;
for ( POSITION pos = Uploads.GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = Uploads.GetNext( pos );
if ( pUpload->m_pHost.sin_addr.S_un.S_addr == nAddress && pUpload->m_nState == upsQueued )
pUpload->Promote( nCount < 2 ); // First couple get unlimited, others dequeued
nCount++;
}
m_pSession->StatusMessage( 2, IDS_CHAT_PRIORITY_GRANTED, (LPCTSTR)m_pSession->m_sAddress, nCount );
}
BOOL CUploads::OnAccept(CConnection* pConnection, LPCTSTR pszHandshake)
{
CSingleLock pLock( &Transfers.m_pSection );
if ( ! pLock.Lock( 250 ) ) return FALSE;
if ( Settings.Remote.Enable && ( _tcsncmp( pszHandshake, _T("GET /remote/"), 12 ) == 0 ) )
{
new CRemote( pConnection );
return TRUE;
}
else if ( Settings.Remote.Enable && ( _tcsncmp( pszHandshake, _T("GET /remote HTTP"), 16 ) == 0 ) )
{
// The user entered the remote page into a browser, but forgot the trailing '/'
new CRemote( pConnection );
return TRUE;
}
else if ( Settings.Uploads.MaxPerHost > 0 )
{
CUploadTransfer* pUpload = new CUploadTransferHTTP();
for ( POSITION pos = GetIterator() ; pos ; )
{
CUploadTransfer* pTest = GetNext( pos );
if ( pTest->m_pHost.sin_addr.S_un.S_addr ==
pConnection->m_pHost.sin_addr.S_un.S_addr )
{
pTest->m_bLive = FALSE;
}
}
pUpload->AttachTo( pConnection );
return TRUE;
}
return FALSE;
}
void CUploadsCtrl::PaintFile(CDC& dc, const CRect& rcRow, CUploadQueue* /*pQueue*/, CUploadFile* pFile, int nPosition, BOOL bFocus)
{
ASSUME_LOCK( Transfers.m_pSection );
CUploadTransfer* pTransfer = pFile->GetActive();
int nFlagImage = Flags.GetFlagIndex( pTransfer->m_sCountry );
COLORREF crNatural = CoolInterface.m_crWindow;
COLORREF crBack = pFile->m_bSelected ? CoolInterface.m_crHighlight : crNatural;
COLORREF crLeftAligned = crBack;
COLORREF crBorder = pFile->m_bSelected ? CoolInterface.m_crFragmentBorderSelected : CoolInterface.m_crFragmentBorder;
dc.SetBkColor( crBack );
dc.SetBkMode( OPAQUE );
if ( pFile->m_bSelected )
dc.SetTextColor( CoolInterface.m_crHiText );
else if ( pTransfer == NULL || pTransfer->m_nState == upsNull )
dc.SetTextColor( CoolInterface.m_crDisabled );
else
dc.SetTextColor( CoolInterface.m_crText );
int nTextLeft = rcRow.right, nTextRight = rcRow.left;
HDITEM pColumn = {};
pColumn.mask = HDI_FORMAT | HDI_LPARAM;
for ( int nColumn = 0 ; m_wndHeader.GetItem( nColumn, &pColumn ) ; nColumn++ )
{
CString strText;
CRect rcCell;
m_wndHeader.GetItemRect( nColumn, &rcCell );
rcCell.left += rcRow.left;
rcCell.right += rcRow.left;
rcCell.top = rcRow.top;
rcCell.bottom = rcRow.bottom;
crLeftAligned = ( rcRow.left == rcCell.left ? crNatural : crBack ) ;
switch ( pColumn.lParam )
{
case UPLOAD_COLUMN_TITLE:
dc.FillSolidRect( rcCell.left, rcCell.top, 24, rcCell.Height(), crLeftAligned );
rcCell.left += 24;
dc.FillSolidRect( rcCell.left, rcCell.bottom - 1, 16, 1, crLeftAligned );
ShellIcons.Draw( &dc, ShellIcons.Get( ( lstrcmpi(
PathFindExtension( pFile->m_sPath ), _T(".partial") ) ?
pFile->m_sPath : pFile->m_sName ), 16 ), 16,
rcCell.left, rcCell.top, crBack, pFile->m_bSelected );
rcCell.left += 16;
dc.FillSolidRect( rcCell.left, rcCell.top, 1, rcCell.Height(), crLeftAligned );
rcCell.left += 1;
strText = pFile->m_sName;
break;
case UPLOAD_COLUMN_USER:
if ( pTransfer == NULL )
strText.Empty();
else if ( pTransfer->m_sRemoteNick.IsEmpty() )
strText = pTransfer->m_sAddress;
else
strText = pTransfer->m_sRemoteNick + _T(" (") + pTransfer->m_sAddress + _T(")");
break;
case UPLOAD_COLUMN_SIZE:
strText = Settings.SmartVolume( pFile->m_nSize );
break;
case UPLOAD_COLUMN_PROGRESS:
dc.Draw3dRect( &rcCell, crBack, crBack );
rcCell.DeflateRect( 1, 1 );
dc.Draw3dRect( &rcCell, crBack, crBack );
rcCell.DeflateRect( 0, 1 );
dc.Draw3dRect( &rcCell, crBorder, crBorder );
rcCell.DeflateRect( 1, 1 );
CFragmentBar::DrawUpload( &dc, &rcCell, pFile, crNatural );
break;
case UPLOAD_COLUMN_SPEED:
if ( pTransfer == NULL || pTransfer->m_nState == upsNull )
LoadString( strText, IDS_STATUS_COMPLETED );
else if ( pTransfer->m_nProtocol == PROTOCOL_BT )
{
CUploadTransferBT* pBT = (CUploadTransferBT*)pTransfer;
if ( ! pBT->m_bInterested )
LoadString( strText, IDS_STATUS_UNINTERESTED );
else if ( pBT->m_bChoked )
LoadString( strText, IDS_STATUS_CHOKED );
else
{
DWORD nSpeed = pTransfer->GetMeasuredSpeed();
if ( nSpeed )
strText = Settings.SmartSpeed( nSpeed );
}
}
else if ( nPosition > 0 )
{
CString strQ;
LoadString( strQ, IDS_STATUS_Q );
strText.Format( _T("%s %i"), (LPCTSTR)strQ, nPosition );
}
else
{
DWORD nSpeed = pTransfer->GetMeasuredSpeed();
if ( nSpeed )
strText = Settings.SmartSpeed( nSpeed );
else
LoadString( strText, IDS_STATUS_NEXT );
}
break;
case UPLOAD_COLUMN_CLIENT:
if ( pTransfer != NULL ) strText = pTransfer->m_sUserAgent;
break;
case UPLOAD_COLUMN_RATING:
strText.Format(_T("%u"), pTransfer->m_nUserRating );
break;
case UPLOAD_COLUMN_COUNTRY:
dc.FillSolidRect( rcCell.left, rcCell.top, 20, rcCell.Height(), crBack );
rcCell.left += 2;
if ( nFlagImage >= 0 )
Flags.Draw( nFlagImage, dc.GetSafeHdc(), rcCell.left, rcCell.top + 2, CLR_NONE, CLR_DEFAULT, pFile->m_bSelected ? ILD_SELECTED : ILD_NORMAL );
rcCell.left += 16;
dc.FillSolidRect( rcCell.left, rcCell.top, 1, rcCell.Height(), crNatural );
strText = pTransfer->m_sCountry;
break;
}
nTextLeft = min( (LONG)nTextLeft, rcCell.left );
nTextRight = max( (LONG)nTextRight, rcCell.right );
if ( pColumn.lParam == UPLOAD_COLUMN_PROGRESS ) continue;
if ( rcCell.Width() < 8 ) strText.Empty();
if ( dc.GetTextExtent( strText ).cx > rcCell.Width() - 8 )
{
while ( dc.GetTextExtent( strText + _T('\x2026') ).cx > ( rcCell.Width() - 8 ) && strText.GetLength() > 0 )
{
strText.Truncate( strText.GetLength() - 1 );
}
if ( strText.GetLength() > 0 ) strText += _T('\x2026');
}
int nWidth = dc.GetTextExtent( strText ).cx;
int nPos = 0;
switch ( pColumn.fmt & LVCFMT_JUSTIFYMASK )
{
default:
nPos = ( rcCell.left + 4 );
break;
case LVCFMT_CENTER:
nPos = ( ( rcCell.left + rcCell.right ) / 2 ) - ( nWidth / 2 );
break;
case LVCFMT_RIGHT:
nPos = ( rcCell.right - 4 - nWidth );
break;
}
dc.SetBkColor( crBack );
dc.ExtTextOut( nPos, rcCell.top + 2, ETO_CLIPPED|ETO_OPAQUE,
&rcCell, strText, NULL );
}
if ( nTextRight < rcRow.right )
{
CRect rcBlank( nTextRight, rcRow.top, rcRow.right, rcRow.bottom );
dc.FillSolidRect( &rcBlank, crBack );
}
if ( bFocus )
{
CRect rcFocus( nTextLeft, rcRow.top, max( (int)rcRow.right, nTextRight ), rcRow.bottom );
dc.Draw3dRect( &rcFocus, CoolInterface.m_crHiBorder, CoolInterface.m_crHiBorder );
}
}
void CRemote::PageUploads()
{
if ( CheckCookie() ) return;
m_nTab = tabUploads;
CSingleLock pLock( &UploadQueues.m_pSection, FALSE );
if ( ! SafeLock( pLock ) )
return;
Prepare(); // Header
CString strRandom;
strRandom.Format( L"%i", GetRandomNum( 0i32, _I32_MAX ) );
Add( L"random", strRandom );
Output( L"uploadsHeader" );
for ( POSITION posQueue = CUploadsCtrl::GetQueueIterator(); posQueue != NULL; )
{
CUploadQueue* pQueue = CUploadsCtrl::GetNextQueue( posQueue );
CString strQueueID;
strQueueID.Format( L"%p", pQueue );
if ( GetKey( L"queue_expand" ) == strQueueID )
pQueue->m_bExpanded = TRUE;
else if ( GetKey( L"queue_collapse" ) == strQueueID )
pQueue->m_bExpanded = FALSE;
POSITION posFile = CUploadsCtrl::GetFileIterator( pQueue );
if ( posFile == NULL ) continue;
Prepare();
Add( L"queue_id", strQueueID );
Add( L"queue_caption", pQueue->m_sName );
if ( pQueue->m_bExpanded )
Add( L"queue_expanded", L"true" );
if ( pQueue != UploadQueues.m_pTorrentQueue && pQueue != UploadQueues.m_pHistoryQueue )
{
CString str;
str.Format( L"%u", pQueue->GetTransferCount() );
Add( L"queue_transfers", str );
str.Format( L"%u", pQueue->GetQueuedCount() );
Add( L"queue_queued", str );
Add( L"queue_bandwidth", Settings.SmartSpeed( pQueue->GetMeasuredSpeed() ) );
}
Output( L"uploadsQueueStart" );
if ( pQueue->m_bExpanded )
{
while ( posFile != NULL )
{
int nPosition;
CUploadFile* pFile = CUploadsCtrl::GetNextFile( pQueue, posFile, &nPosition );
if ( pFile == NULL ) continue;
CUploadTransfer* pTransfer = pFile->GetActive();
CString strFileID;
strFileID.Format( L"%p", pFile );
if ( GetKey( L"drop" ) == strFileID )
{
pFile->Remove();
continue;
}
Add( L"file_id", strFileID );
Add( L"file_filename", pFile->m_sName );
Add( L"file_size", Settings.SmartVolume( pFile->m_nSize ) );
if ( pTransfer != NULL )
{
Add( L"file_address", pTransfer->m_sAddress );
Add( L"file_nick", pTransfer->m_sRemoteNick );
Add( L"file_user", pTransfer->m_sAddress + L" - " + pTransfer->m_sRemoteNick );
Add( L"file_agent", pTransfer->m_sUserAgent );
}
CString str;
if ( pTransfer == NULL || pTransfer->m_nState == upsNull )
{
LoadString( str, IDS_STATUS_COMPLETED );
}
else if ( pTransfer->m_nProtocol == PROTOCOL_BT )
{
CUploadTransferBT* pBT = (CUploadTransferBT*)pTransfer;
if ( ! pBT->m_bInterested )
LoadString( str, IDS_STATUS_UNINTERESTED );
else if ( pBT->m_bChoked )
LoadString( str, IDS_STATUS_CHOKED );
else if ( DWORD nSpeed = pTransfer->GetMeasuredSpeed() )
str = Settings.SmartSpeed( nSpeed );
}
else if ( nPosition > 0 )
{
LoadString( str, IDS_STATUS_Q );
str.Format( L"%s %i", (LPCTSTR)str, nPosition );
}
else
{
if ( DWORD nSpeed = pTransfer->GetMeasuredSpeed() )
str = Settings.SmartSpeed( nSpeed );
else
LoadString( str, IDS_STATUS_NEXT );
}
Add( L"file_speed", str );
Add( L"file_status", str );
Output( L"uploadsFile" );
Prepare( L"file_" );
}
}
Output( L"uploadsQueueEnd" );
Prepare( L"queue_" );
}
Prepare();
Output( L"uploadsFooter" );
}
void CUploads::OnRun()
{
CSingleLock pLock( &UploadQueues.m_pSection, TRUE );
int nCountTorrent = 0;
POSITION pos;
m_nCount = 0;
m_nBandwidth = 0;
//Set measured queue speeds to 0
for ( pos = UploadQueues.GetIterator() ; pos ; )
{
UploadQueues.GetNext( pos )->m_nMeasured = 0;
}
UploadQueues.m_pTorrentQueue->m_nMeasured = 0;
UploadQueues.m_pTorrentQueue->m_nMinTransfers = 0;
UploadQueues.m_pTorrentQueue->m_nMaxTransfers = 0;
for ( pos = GetIterator() ; pos ; )
{
CUploadTransfer* pTransfer = GetNext( pos );
DWORD nMeasured = pTransfer->GetMeasuredSpeed();
if ( ( pTransfer->m_nProtocol == PROTOCOL_BT ) && ( pTransfer->m_nState != upsNull ) )
{
// This is a torrent transfer
CUploadTransferBT* pBT = (CUploadTransferBT*)pTransfer;
if ( ( ! pBT->m_bInterested ) || ( pBT->m_bChoked ) )
{
// Choked- Increment appropriate torrent counter
UploadQueues.m_pTorrentQueue->m_nMaxTransfers ++;
}
else
{
// Active torrent. (Uploading or requesting)
// Increment normal counters
m_nCount ++;
m_nBandwidth += nMeasured;
// Increment torrent counters
nCountTorrent ++;
UploadQueues.m_pTorrentQueue->m_nMinTransfers ++;
UploadQueues.m_pTorrentQueue->m_nMeasured += nMeasured;
//theApp.Message( MSG_SYSTEM, pTransfer->m_sAddress );
//theApp.Message( MSG_SYSTEM, _T("Port: %i "), pTransfer->m_pHost.sin_port );
}
}
else if ( pTransfer->m_nState == upsUploading )
{
// Regular transfer that's uploading
m_nCount ++;
m_nBandwidth += nMeasured;
if ( pTransfer->m_pQueue != NULL && UploadQueues.Check( pTransfer->m_pQueue ) )
pTransfer->m_pQueue->m_nMeasured += nMeasured;
}
}
if ( nCountTorrent > 0 ) //If there are any active torrents
{ //Assign bandwidth to BT (4/5ths by default)
m_nTorrentSpeed = Settings.Bandwidth.Uploads;
if ( m_nTorrentSpeed == 0 ) m_nTorrentSpeed = 0xFFFFFFFF;
m_nTorrentSpeed = min( m_nTorrentSpeed, Settings.Connection.OutSpeed * 128 );
m_nTorrentSpeed = m_nTorrentSpeed * Settings.BitTorrent.BandwidthPercentage / 100;
m_nTorrentSpeed = m_nTorrentSpeed / nCountTorrent;
m_nTorrentSpeed = max( m_nTorrentSpeed, Settings.Bandwidth.Request );
}
else
{ //If there are no torrents, set to zero
m_nTorrentSpeed = 0;
}
}
BOOL CUploads::EnforcePerHostLimit(CUploadTransfer* pHit, BOOL bRequest)
{
int nCount = 0;
for ( POSITION pos = GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = GetNext( pos );
if ( pUpload->m_nState == upsUploading ||
pUpload->m_nState == upsQueued ||
pUpload->m_nState == upsPreQueue )
{
if ( pUpload->m_pHost.sin_addr.S_un.S_addr == pHit->m_pHost.sin_addr.S_un.S_addr )
nCount++;
}
}
if ( nCount <= Settings.Uploads.MaxPerHost ) return FALSE;
while ( nCount > Settings.Uploads.MaxPerHost )
{
CUploadTransfer* pNewest = NULL;
for ( POSITION pos = GetIterator() ; pos ; )
{
CUploadTransfer* pUpload = GetNext( pos );
if ( pUpload->m_nState == upsUploading ||
pUpload->m_nState == upsQueued ||
pUpload->m_nState == upsPreQueue )
{
if ( pUpload != pHit && pUpload->m_pHost.sin_addr.S_un.S_addr == pHit->m_pHost.sin_addr.S_un.S_addr )
{
if ( bRequest && pUpload->m_pBaseFile == pHit->m_pBaseFile )
{
pNewest = pUpload;
break;
}
if ( pNewest == NULL || pUpload->m_tConnected > pNewest->m_tConnected )
pNewest = pUpload;
}
}
}
if ( pNewest == NULL ) break;
if ( bRequest )
{
if ( pNewest->m_pBaseFile == pHit->m_pBaseFile && ! pNewest->m_bLive )
{
UploadQueues.StealPosition( pHit, pNewest );
theApp.Message( MSG_ERROR, IDS_UPLOAD_DROPPED_OLDER,
(LPCTSTR)pNewest->m_sAddress );
pNewest->Close( FALSE );
}
else
{
return FALSE;
}
}
else
{
theApp.Message( MSG_ERROR, IDS_UPLOAD_DROPPED_NEWER, (LPCTSTR)pNewest->m_sAddress );
pNewest->Close( FALSE );
}
nCount--;
}
return FALSE;
}
