📄 transfersocket.cpp
字号:
{
m_bSentClose = TRUE;
m_pOwner->m_pOwner->PostThreadMessage(m_nInternalMessageID, FZAPI_THREADMSG_TRANSFEREND, m_nMode);
}
}
return;
}
}
else
numread = 0;
if (!currentBufferSize && !m_bufferpos)
{
// Not allowed to send yet, try later
TriggerEvent(FD_WRITE);
return;
}
ASSERT(numread>=0);
ASSERT(m_bufferpos>=0);
numsent = Send(m_pBuffer, numread+m_bufferpos);
}
}
}
void CTransferSocket::UpdateStatusBar(bool forceUpdate)
{
if (m_nTransferState != STATE_STARTED)
return;
if (!forceUpdate)
{
//Don't flood the main window with messages
//Else performance would be really low
LARGE_INTEGER curtime;
LARGE_INTEGER freq;
QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&curtime);
if (((curtime.QuadPart-m_LastUpdateTime.QuadPart) < (freq.QuadPart/15) ) )
return;
m_LastUpdateTime = curtime;
}
//Update the statusbar
CTimeSpan timespan=CTime::GetCurrentTime()-m_StartTime;
int elapsed=(int)timespan.GetTotalSeconds();
t_ffam_transferstatus *status=new t_ffam_transferstatus;
status->bFileTransfer=TRUE;
status->timeelapsed=elapsed;
status->bytes=m_transferdata.transfersize-m_transferdata.transferleft;
if (m_transferdata.transfersize>0 && !(m_nMode&CSMODE_LIST))
{
double leftmodifier=static_cast<double>(m_transferdata.transfersize-m_transferdata.nTransferStart-m_transferdata.transferleft);
leftmodifier*=100;
if (m_transferdata.transfersize-m_transferdata.nTransferStart)
leftmodifier /= (m_transferdata.transfersize-m_transferdata.nTransferStart);
else
leftmodifier = 1;
if (leftmodifier == 0)
leftmodifier = 1;
double leftmodifier2 = 100 - leftmodifier;
int left=static_cast<int>((elapsed/leftmodifier)*leftmodifier2);
double percent=100*static_cast<double>(m_transferdata.transfersize-m_transferdata.transferleft);
percent/=m_transferdata.transfersize;
status->percent=static_cast<int>(percent);
if (status->percent>100)
status->percent=100;
if (left < 0)
left = -1;
status->timeleft=left;
}
else
{
status->percent=-1;
status->timeleft=-1;
}
int count = 0;
status->transferrate = 0;
for ( int i = 0; i < SPEED_SECONDS; i++)
{
if ( m_UsedForTransfer[ i])
{
status->transferrate += m_Transfered[ i];
count++;
}
}
if ( count > 0)
status->transferrate = status->transferrate / count;
else if (m_Transfered[0])
status->transferrate = m_Transfered[0];
else
status->timeleft=-1;
PostMessage(m_pOwner->m_pOwner->m_hOwnerWnd, m_pOwner->m_pOwner->m_nReplyMessageID, FZ_MSG_MAKEMSG(FZ_MSG_TRANSFERSTATUS, 0), (LPARAM)status);
}
void CTransferSocket::UpdateSendLed()
{
//Don't flood the main window with messages
//Else performance would be really low
LARGE_INTEGER curtime;
LARGE_INTEGER freq;
QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&curtime);
static LARGE_INTEGER oldtime={0};
if ( ( (curtime.QuadPart-oldtime.QuadPart) < (freq.QuadPart/15) ) )
return;
oldtime=curtime;
PostMessage(m_pOwner->m_pOwner->m_hOwnerWnd, m_pOwner->m_pOwner->m_nReplyMessageID, FZ_MSG_MAKEMSG(FZ_MSG_SOCKETSTATUS, FZ_SOCKETSTATUS_SEND), 0);
}
void CTransferSocket::UpdateRecvLed()
{
//Don't flood the main window with messages
//Else performance would be really low
LARGE_INTEGER curtime;
LARGE_INTEGER freq;
QueryPerformanceFrequency(&freq);
QueryPerformanceCounter(&curtime);
static LARGE_INTEGER oldtime={0};
if ( ( (curtime.QuadPart-oldtime.QuadPart) < (freq.QuadPart/15) ) )
return;
oldtime=curtime;
PostMessage(m_pOwner->m_pOwner->m_hOwnerWnd, m_pOwner->m_pOwner->m_nReplyMessageID, FZ_MSG_MAKEMSG(FZ_MSG_SOCKETSTATUS, FZ_SOCKETSTATUS_RECV), 0);
}
BOOL CTransferSocket::Create(BOOL bUseSsl)
{
if (bUseSsl)
m_pSslLayer = new CAsyncSslSocketLayer;
if (!m_pOwner->m_CurrentServer.fwbypass)
{
int nProxyType = COptions::GetOptionVal(OPTION_PROXYTYPE);
if (nProxyType != PROXYTYPE_NOPROXY)
{
USES_CONVERSION;
m_pProxyLayer = new CAsyncProxySocketLayer;
if (nProxyType == PROXYTYPE_SOCKS4)
m_pProxyLayer->SetProxy(PROXYTYPE_SOCKS4, T2CA(COptions::GetOption(OPTION_PROXYHOST)), COptions::GetOptionVal(OPTION_PROXYPORT));
else if (nProxyType == PROXYTYPE_SOCKS4A)
m_pProxyLayer->SetProxy(PROXYTYPE_SOCKS4A, T2CA(COptions::GetOption(OPTION_PROXYHOST)), COptions::GetOptionVal(OPTION_PROXYPORT));
else if (nProxyType == PROXYTYPE_SOCKS5)
if (COptions::GetOptionVal(OPTION_PROXYUSELOGON))
m_pProxyLayer->SetProxy(PROXYTYPE_SOCKS5, T2CA(COptions::GetOption(OPTION_PROXYHOST)),
COptions::GetOptionVal(OPTION_PROXYPORT),
T2CA(COptions::GetOption(OPTION_PROXYUSER)),
T2CA(CCrypt::decrypt(COptions::GetOption(OPTION_PROXYPASS))));
else
m_pProxyLayer->SetProxy(PROXYTYPE_SOCKS5, T2CA(COptions::GetOption(OPTION_PROXYHOST)),
COptions::GetOptionVal(OPTION_PROXYPORT));
else if (nProxyType == PROXYTYPE_HTTP11)
if (COptions::GetOptionVal(OPTION_PROXYUSELOGON))
m_pProxyLayer->SetProxy(PROXYTYPE_HTTP11, T2CA(COptions::GetOption(OPTION_PROXYHOST)), COptions::GetOptionVal(OPTION_PROXYPORT),
T2CA(COptions::GetOption(OPTION_PROXYUSER)),
T2CA(CCrypt::decrypt(COptions::GetOption(OPTION_PROXYPASS))));
else
m_pProxyLayer->SetProxy(PROXYTYPE_HTTP11, T2CA(COptions::GetOption(OPTION_PROXYHOST)), COptions::GetOptionVal(OPTION_PROXYPORT));
else
ASSERT(FALSE);
AddLayer(m_pProxyLayer);
}
}
if (!COptions::GetOptionVal(OPTION_LIMITPORTRANGE))
{
if (!CAsyncSocketEx::Create(0, SOCK_STREAM, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE, 0, GetFamily()))
return FALSE;
return TRUE;
}
else
{
int min=COptions::GetOptionVal(OPTION_PORTRANGELOW);
int max=COptions::GetOptionVal(OPTION_PORTRANGEHIGH);
if (min>=max)
{
m_pOwner->ShowStatus(IDS_ERRORMSG_CANTCREATEDUETOPORTRANGE,1);
return FALSE;
}
int startport=static_cast<int>(min+((double)rand()*(max-min))/(RAND_MAX+1));
int port=startport;
while (!CAsyncSocketEx::Create(port, SOCK_STREAM, FD_READ | FD_WRITE | FD_OOB | FD_ACCEPT | FD_CONNECT | FD_CLOSE, 0, GetFamily()))
{
port++;
if (port>max)
port=min;
if (port==startport)
{
m_pOwner->ShowStatus(IDS_ERRORMSG_CANTCREATEDUETOPORTRANGE,1);
return FALSE;
}
}
}
return TRUE;
}
void CTransferSocket::Close()
{
LogMessage(__FILE__, __LINE__, this,FZ_LOG_DEBUG, _T("Close()"));
m_bCheckTimeout = FALSE;
CAsyncSocketEx::Close();
}
int CTransferSocket::OnLayerCallback(std::list<t_callbackMsg>& callbacks)
{
for (std::list<t_callbackMsg>::iterator iter = callbacks.begin(); iter != callbacks.end(); iter++)
{
if (iter->nType == LAYERCALLBACK_STATECHANGE)
{
if (iter->pLayer == m_pProxyLayer)
LogMessage(__FILE__, __LINE__, this, FZ_LOG_INFO, _T("m_pProxyLayer changed state from %d to %d"), iter->nParam2, iter->nParam1);
else if (iter->pLayer == m_pSslLayer)
LogMessage(__FILE__, __LINE__, this, FZ_LOG_INFO, _T("m_pSslLayer changed state from %d to %d"), iter->nParam2, iter->nParam1);
else if (iter->pLayer == m_pGssLayer)
LogMessage(__FILE__, __LINE__, this, FZ_LOG_INFO, _T("m_pGssLayer changed state from %d to %d"), iter->nParam2, iter->nParam1);
else
LogMessage(__FILE__, __LINE__, this, FZ_LOG_INFO, _T("Layer @ %d changed state from %d to %d"), iter->pLayer, iter->nParam2, iter->nParam1);
}
else if (iter->nType == LAYERCALLBACK_LAYERSPECIFIC)
{
if (iter->pLayer == m_pProxyLayer)
{
switch (iter->nParam1)
{
case PROXYERROR_NOCONN:
m_pOwner->ShowStatus(IDS_ERRORMSG_PROXY_NOCONN, 1);
break;
case PROXYERROR_REQUESTFAILED:
m_pOwner->ShowStatus(IDS_ERRORMSG_PROXY_REQUESTFAILED, 1);
break;
case PROXYERROR_AUTHTYPEUNKNOWN:
m_pOwner->ShowStatus(IDS_ERRORMSG_PROXY_AUTHTYPEUNKNOWN, 1);
break;
case PROXYERROR_AUTHFAILED:
m_pOwner->ShowStatus(IDS_ERRORMSG_PROXY_AUTHFAILED, 1);
break;
case PROXYERROR_AUTHNOLOGON:
m_pOwner->ShowStatus(IDS_ERRORMSG_PROXY_AUTHNOLOGON, 1);
break;
case PROXYERROR_CANTRESOLVEHOST:
m_pOwner->ShowStatus(IDS_ERRORMSG_PROXY_CANTRESOLVEHOST, 1);
break;
default:
LogMessage(__FILE__, __LINE__, this, FZ_LOG_WARNING, _T("Unknown proxy error"));
}
}
else if (iter->pLayer == m_pSslLayer)
{
switch (iter->nParam1)
{
case SSL_INFO:
switch(iter->nParam2)
{
case SSL_INFO_SHUTDOWNCOMPLETE:
Close();
if (!m_bSentClose)
{
m_bSentClose=TRUE;
m_pOwner->m_pOwner->PostThreadMessage(m_nInternalMessageID, FZAPI_THREADMSG_TRANSFEREND, m_nMode);
}
break;
case SSL_INFO_ESTABLISHED:
m_pOwner->ShowStatus(IDS_STATUSMSG_SSLESTABLISHEDTRANSFER, 0);
TriggerEvent(FD_FORCEREAD);
break;
}
break;
case SSL_FAILURE:
switch (iter->nParam2)
{
case SSL_FAILURE_ESTABLISH:
m_pOwner->ShowStatus(IDS_ERRORMSG_CANTESTABLISHSSLCONNECTION, 1);
break;
case SSL_FAILURE_LOADDLLS:
m_pOwner->ShowStatus(IDS_ERRORMSG_CANTLOADSSLDLLS, 1);
break;
case SSL_FAILURE_INITSSL:
m_pOwner->ShowStatus(IDS_ERRORMSG_CANTINITSSL, 1);
break;
}
if (!m_bSentClose)
{
m_nMode |= CSMODE_TRANSFERERROR;
m_bSentClose = TRUE;
m_pOwner->m_pOwner->PostThreadMessage(m_nInternalMessageID, FZAPI_THREADMSG_TRANSFEREND, m_nMode);
}
break;
case SSL_VERIFY_CERT:
t_SslCertData data;
if (m_pSslLayer->GetPeerCertificateData(data))
m_pSslLayer->SetNotifyReply(data.priv_data, SSL_VERIFY_CERT, 1);
else
{
Close();
if (!m_bSentClose)
{
m_nMode |= CSMODE_TRANSFERERROR;
m_bSentClose = TRUE;
m_pOwner->m_pOwner->PostThreadMessage(m_nInternalMessageID, FZAPI_THREADMSG_TRANSFEREND, m_nMode);
}
}
break;
}
}
else if (iter->pLayer == m_pGssLayer)
{
USES_CONVERSION;
switch (iter->nParam1)
{
case GSS_INFO:
LogMessage(FZ_LOG_INFO, A2CT(iter->str));
break;
case GSS_ERROR:
LogMessage(FZ_LOG_APIERROR, A2CT(iter->str));
break;
case GSS_SHUTDOWN_COMPLETE:
Close();
if (!m_bSentClose)
{
m_bSentClose = TRUE;
m_pOwner->m_pOwner->PostThreadMessage(m_nInternalMessageID, FZAPI_THREADMSG_TRANSFEREND, m_nMode);
}
break;
}
}
}
delete [] iter->str;
}
return 0;
}
void CTransferSocket::Transfered(int count, CTime time)
{
CTimeSpan ts = time - m_TransferedFirst;
int diff = (int)ts.GetTotalSeconds();
if (diff < 0)
diff = 0;
if ( diff >= SPEED_SECONDS)
{
int move = diff - SPEED_SECONDS + 1;
int start = SPEED_SECONDS - move;
if ( start <= 0)
start = 0;
else
{
for ( int i = 0; i < SPEED_SECONDS - move; i++)
{
m_Transfered[ i] = m_Transfered[ i + move];
m_UsedForTransfer[ i] = m_UsedForTransfer[ i + move];
}
}
for ( int i = start; i < SPEED_SECONDS; i++)
{
m_Transfered[ i] = 0;
m_UsedForTransfer[ i] = false;
}
if (move >= SPEED_SECONDS)
{
m_TransferedFirst = time;
diff = 0;
}
else
{
m_TransferedFirst += CTimeSpan( move);
ts = time - m_TransferedFirst;
diff = (int)(ts.GetTotalSeconds() % 60);
}
}
m_Transfered[ diff] += count;
for ( int i = 0; i < diff - 1; i++)
m_UsedForTransfer[ i] = true;
}
void CTransferSocket::UseGSS(CAsyncGssSocketLayer *pGssLayer)
{
m_pGssLayer = new CAsyncGssSocketLayer;
m_pGssLayer->InitTransferChannel(pGssLayer);
}
bool CTransferSocket::InitZlib(int level)
{
int res;
if (m_nMode & CSMODE_UPLOAD)
res = deflateInit2(&m_zlibStream, level, Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY);
else
res = inflateInit2(&m_zlibStream, 15);
if (res == Z_OK)
m_useZlib = true;
return res == Z_OK;
m_zlibStream.next_in = (Bytef *)&m_zlibStream.next_in; // Make sure next_in is never 0
return false;
}
int CTransferSocket::ReadDataFromFile(char *buffer, int len)
{
TRY
{
if (!m_transferdata.bType)
return m_pFile->Read(buffer, len);
else
{ //Read the file as ASCII file with CRLF line end
if (!m_ReadBuffer)
m_ReadBuffer = new char[BUFSIZE];
if (!m_ReadSize)
m_ReadSize = m_pFile->Read(m_ReadBuffer, len);
int numread = 0;
while (numread < len)
{
if (m_ReadPos >= m_ReadSize)
{
m_ReadSize = m_pFile->Read(m_ReadBuffer, len);
m_ReadPos = 0;
if (!m_ReadSize)
break;
}
if (m_ReadBuffer[m_ReadPos] == '\n' && m_cLastChar != '\r')
{
buffer[numread++] = '\r';
m_cLastChar = '\r';
if (numread == len)
break;
}
buffer[numread] = m_ReadBuffer[m_ReadPos];
m_cLastChar = buffer[numread];
numread++;
m_ReadPos++;
}
ASSERT(numread <= len);
return numread;
}
}
CATCH_ALL(e)
{
TCHAR error[BUFSIZE];
if (e->GetErrorMessage(error, BUFSIZE))
m_pOwner->ShowStatus(error, 1);
if (ShutDown() || GetLastError() != WSAEWOULDBLOCK)
{
Close();
if (!m_bSentClose)
{
m_nMode |= CSMODE_TRANSFERERROR;
m_bSentClose = TRUE;
m_pOwner->m_pOwner->PostThreadMessage(m_nInternalMessageID, FZAPI_THREADMSG_TRANSFEREND, m_nMode);
}
}
return -1;
}
END_CATCH_ALL;
}⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -