queuectrl.cpp

一个支持FTP,SFTP的客户端程序

// FileZilla - a Windows ftp client

// Copyright (C) 2002-2004 - Tim Kosse <[e-mail]>

// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

// QueueCtrl.cpp: Implementierungsdatei
//

#include "stdafx.h"
#include "filezilla.h"
#include "QueueCtrl.h"
#include "queueview.h"
#include "mainfrm.h"
#include "ftplistctrl.h"
#include "commandqueue.h"
#include "FileExistsDlg.h"
#include "StatusView.h"
#include "FtpTreeView.h"
#include "LocalView2.h"
#include "misc\MarkupSTL.h"
#include "AsyncRequestQueue.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

CQueueData::CQueueData()
{
	bActive = FALSE;
	nOpen = 0;
	nState = 0;
	priority = 0;
	pTransferStatus = NULL;
	retrycount = 0;
	pTransferApi = NULL;
	bStop = FALSE;
	nAutoUsePrimary = 0;
	bTransferStarted = FALSE;
	bTriedAutoResume = false;
	bPaused = FALSE;
	bAbort = FALSE;
	nProgressOffset = 260;
	nListItemState = 0;
	pProgressControl = NULL;
}

CQueueData::~CQueueData()
{
}

/////////////////////////////////////////////////////////////////////////////
// CQueueCtrl

CQueueCtrl::CQueueCtrl()
{
	m_nProcessQueue = 0;
	m_bMayUsePrimaryConnection = FALSE;
	m_nActiveCount = 0;
	m_nMaxApiCount = COptions::GetOptionVal(OPTION_TRANSFERAPICOUNT);
	m_bPrimaryConnectionTransferInProgress = FALSE;
	m_bUseMultiple = COptions::GetOptionVal(OPTION_TRANSFERUSEMULTIPLE);
	m_bQuit = FALSE;
	m_nQuitCount = 0;
}

CQueueCtrl::~CQueueCtrl()
{
	if (!m_bQuit)
	{
		for (UINT i=0; i<m_TransferApiArray.size(); i++)
		{
			m_TransferApiArray[i].pTransferApi->Destroy();
			delete m_TransferApiArray[i].pTransferApi;
			delete m_TransferApiArray[i].pLastActiveTime;
		}
	}
	m_TransferApiArray.clear();

	for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
	{
		delete iter->pTransferStatus;
		delete iter->pProgressControl;
	}
	m_QueueItems.clear();
}

BEGIN_MESSAGE_MAP(CQueueCtrl, CListCtrl)
	//{{AFX_MSG_MAP(CQueueCtrl)
	ON_WM_CREATE()
	ON_NOTIFY_REFLECT(LVN_GETDISPINFO, OnGetdispinfo)
	ON_WM_DESTROY()
	ON_WM_CONTEXTMENU()
	ON_COMMAND(ID_QUEUECONTEXT_MOVEDOWN, OnQueuecontextMovedown)
	ON_COMMAND(ID_QUEUECONTEXT_MOVETOBOTTOM, OnQueuecontextMovetobottom)
	ON_COMMAND(ID_QUEUECONTEXT_MOVETOTOP, OnQueuecontextMovetotop)
	ON_COMMAND(ID_QUEUECONTEXT_MOVEUP, OnQueuecontextMoveup)
	ON_COMMAND(ID_QUEUECONTEXT_PROCESSQUEUE, OnQueuecontextProcessqueue)
	ON_COMMAND(ID_QUEUECONTEXT_REMOVEFROMQUEUE, OnQueuecontextRemovefromqueue)
	ON_COMMAND(ID_QUEUECONTEXT_RESETSTATUS, OnQueuecontextResetstatus)
	ON_WM_KEYDOWN()
	ON_WM_DROPFILES()
	ON_WM_TIMER()
	ON_WM_PAINT()
	ON_WM_ERASEBKGND()
	ON_COMMAND(ID_QUEUECONTEXT_ABORT, OnQueuecontextAbort)
	ON_COMMAND(ID_QUEUECONTEXT_PAUSE, OnQueuecontextPause)
	ON_COMMAND(ID_QUEUECONTEXT_RESUME, OnQueuecontextResume)
	ON_NOTIFY_REFLECT(LVN_ITEMCHANGED, OnItemchanged)
	ON_WM_CHAR()
	ON_NOTIFY_REFLECT(LVN_ODSTATECHANGED, OnOdstatechanged)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// Behandlungsroutinen f黵 Nachrichten CQueueCtrl 

int CQueueCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CListCtrl::OnCreate(lpCreateStruct) == -1)
		return -1;

	SetCallbackMask(LVIS_SELECTED);
	
	CString str;
	str.LoadString(IDS_HEADER_LOCALNAME);
	InsertColumn(0, str, LVCFMT_LEFT, 200);
	str.LoadString(IDS_HEADER_SIZE);
	InsertColumn(1, str, LVCFMT_RIGHT, 70);
	str.LoadString(IDS_HEADER_DIRECTION);
	InsertColumn(2, str, LVCFMT_CENTER, 65);
	str.LoadString(IDS_HEADER_REMOTENAME);
	InsertColumn(3, str, LVCFMT_LEFT, 200);
	str.LoadString(IDS_HEADER_HOST);
	InsertColumn(4, str, LVCFMT_LEFT, 100);
	str.LoadString(IDS_HEADER_STATUS);
	InsertColumn(5, str, LVCFMT_LEFT, 200);

	DragAcceptFiles(TRUE);

	SetExtendedStyle(LVS_EX_INFOTIP);

	t_TransferApi api={0};
	m_TransferApiArray.resize(m_nMaxApiCount);
	for (UINT i = 0;i < m_nMaxApiCount; i++)
	{
		api.pTransferApi = new CFileZillaApi();
		if (!api.pTransferApi)
			return -1;
		if (api.pTransferApi->Init(GetSafeHwnd(), WM_APP + 10 + i)!=FZ_REPLY_OK)
			return -1;
		api.pTransferApi->SetDebugLevel(COptions::GetOptionVal(OPTION_DEBUGTRACE)?4:0);
		m_TransferApiArray[i] = api;
	}

	m_nTimerID = SetTimer(1234, 1000, 0);
	
	return 0;
}

int CQueueCtrl::AddItem(t_transferfile transferfile, BOOL stdtransfer /*=FALSE*/, int nOpen /*=0*/)
{
	CQueueData queueData;

	queueData.priority = stdtransfer?2:1;
	queueData.nOpen = nOpen;
	
	m_bMayUsePrimaryConnection = IsQueueEmpty();

	queueData.transferFile = transferfile;
	queueData.transferFile.nUserData = nOpen;

	m_QueueItems.insert(FindValidIndex(queueData.priority), queueData);
	SetItemCount(m_QueueItems.size() + m_nActiveCount);
	UpdateStatusbar();
	return 1;
}

int CQueueCtrl::AddItem(CQueueData queueData)
{
	queueData.transferFile.nUserData = queueData.nOpen;

	if (!queueData.priority)
		queueData.priority = 1;
	
	m_bMayUsePrimaryConnection = IsQueueEmpty();

	m_QueueItems.insert(FindValidIndex(queueData.priority), queueData);
	SetItemCount(m_QueueItems.size() + m_nActiveCount);
	UpdateStatusbar();
	
	return 1;
}

void CQueueCtrl::OnDestroy() 
{
	if (m_bQuit)
	{
		CListCtrl::OnDestroy();
		return;
	}

	for (UINT i=0; i<m_TransferApiArray.size(); i++)
	{
		m_TransferApiArray[i].pTransferApi->Destroy();
		delete m_TransferApiArray[i].pTransferApi;
		delete m_TransferApiArray[i].pLastActiveTime;
	}
	m_TransferApiArray.clear();

	KillTimer(m_nTimerID);

	CMutex mutex(FALSE, _T("FileZilla Queue Mutex"), 0);
	CSingleLock mLock(&mutex, TRUE);
	
	CMarkupSTL *pMarkup;

	if (COptions::LockXML(&pMarkup))
	{
		pMarkup->ResetPos();
		if (!pMarkup->FindChildElem( _T("TransferQueue") ))
			pMarkup->AddChildElem( _T("TransferQueue") );

		pMarkup->IntoElem();
		
		for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
		{
			const CQueueData &queueData = *iter;
			if (!queueData.priority && !queueData.bPaused)
				continue;

			pMarkup->AddChildElem( _T("QueueItem") );
			pMarkup->IntoElem();
			pMarkup->AddChildElem( _T("File") );
			pMarkup->AddChildAttrib( _T("Localfile"), queueData.transferFile.localfile);
			pMarkup->AddChildAttrib( _T("Size"), queueData.transferFile.size);
			pMarkup->AddChildAttrib( _T("Remotefile"), queueData.transferFile.remotefile);
			pMarkup->AddChildAttrib( _T("Remotepath"), queueData.transferFile.remotepath.GetSafePath());
			
			pMarkup->AddChildElem( _T("Data") );
			pMarkup->AddChildAttrib( _T("Transfermode"), queueData.transferFile.nType);
			pMarkup->AddChildAttrib( _T("Get"), queueData.transferFile.get);
			pMarkup->AddChildAttrib( _T("RetryCount"), queueData.retrycount);
			pMarkup->AddChildAttrib( _T("Open"), queueData.nOpen);

			COptions::SaveServer(pMarkup, queueData.transferFile.server);

			pMarkup->OutOfElem();
		}
		COptions::UnlockXML();
	}
	else
	{
		
		int j=0;
		TCHAR buffer[1000];
		HKEY key;
		if (RegOpenKey(HKEY_CURRENT_USER, _T("Software\\FileZilla\\Queue\\") ,&key)==ERROR_SUCCESS)
		{
			while (RegEnumKey(key,j,buffer,1000)==ERROR_SUCCESS)
			{
				j++;
			}
			RegCloseKey(key);
		}
		
		for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
		{
			const CQueueData &queueData = *iter;
			if (!queueData.priority && !queueData.bPaused)
				continue;
			
			CString str;
			str.Format(_T("%d"), j);
			HKEY key2;
			if (RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\FileZilla\\Queue\\"+str, 0, 0, REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &key2, NULL)==ERROR_SUCCESS)
			{
				COptions::SetKey(key2, "Localfile", queueData.transferFile.localfile);
				COptions::SetKey(key2, "Size", queueData.transferFile.size);
				COptions::SetKey(key2, "Remotefile", queueData.transferFile.remotefile);
				COptions::SetKey(key2, "Remotepath", queueData.transferFile.remotepath.GetSafePath());
				COptions::SetKey(key2, "Transfer mode", queueData.transferFile.nType);
				COptions::SetKey(key2, "Get", queueData.transferFile.get);
				COptions::SetKey(key2, "Retry Count", queueData.retrycount);
				COptions::SetKey(key2, "Open", queueData.nOpen);
				
				COptions::SaveServer(key2, queueData.transferFile.server);

				RegCloseKey(key2);
			}
			j++;
		}
	}

	m_nActiveCount = 0;
	m_QueueItems.clear();
	DeleteAllItems();
	
	CListCtrl::OnDestroy();	
}

void CQueueCtrl::ProcessReply(int nReplyCode, int nApiIndex /*=-1*/)
{
	ASSERT(nApiIndex >= -1 && nApiIndex < static_cast<int>(m_TransferApiArray.size()));
	if (nApiIndex < -1 || nApiIndex >= static_cast<int>(m_TransferApiArray.size()))
		return;

	CMainFrame *pMainFrame = DYNAMIC_DOWNCAST(CMainFrame, GetParentFrame());
	m_bMayUsePrimaryConnection = FALSE;

	while (TRUE)
	{
		ASSERT(Validate());
		
		//Make sure pFileZillaApi is either NULL or in the active list. If not, stop processing
		t_TransferApi api={0};
		if (nApiIndex > -1)
			api = m_TransferApiArray[nApiIndex];
		
		//Find the item
		unsigned int nIndex;
		CQueueData queueData;
		for (nIndex = 0; nIndex < m_QueueItems.size(); nIndex++)
		{
			queueData = m_QueueItems[nIndex];
			if (!queueData.bActive)
				return;
			if (queueData.pTransferApi == api.pTransferApi)
				break;
		}
		if (nIndex == m_QueueItems.size())
			return;

		//Initialize all required data variables
		t_transferfile &transferFile = queueData.transferFile;
		
		t_ServerDataMapIter ServerDataMapIter = m_ServerDataMap.find(transferFile.server);
		ASSERT(ServerDataMapIter != m_ServerDataMap.end());
		if (ServerDataMapIter == m_ServerDataMap.end())
			return;
			
		BOOL bConnectError = FALSE;
		
		int nState = queueData.nState;
		
		if (nReplyCode&FZ_REPLY_DISCONNECTED && nState==QUEUESTATE_DISCONNECT)
		{
			ASSERT(api.pTransferApi);
			if (!api.pTransferApi)
				return;
			queueData.nState = QUEUESTATE_CONNECT;
			if (api.pTransferApi->Connect(transferFile.server)==FZ_REPLY_WOULDBLOCK)
			{
				queueData.status.Format(IDS_STATUSMSG_CONNECTING, (transferFile.server.name!="")?transferFile.server.name:transferFile.server.host);
				m_QueueItems[nIndex] = queueData;
				return;
			}
			else
				nReplyCode |= FZ_REPLY_ERROR | FZ_REPLY_CRITICALERROR;
		}
		else if (nState==QUEUESTATE_CONNECT)
		{
			ASSERT(api.pTransferApi);
			if (!api.pTransferApi)
				return;
			if (nReplyCode == FZ_REPLY_OK)
			{
				ServerDataMapIter->second.nCurrentActive++;
				if (ServerDataMapIter->second.nCurrentActive > ServerDataMapIter->second.nActiveMax)
					ServerDataMapIter->second.nActiveMax++;
				queueData.nState = QUEUESTATE_TRANSFER;
				int res = api.pTransferApi->FileTransfer(transferFile);
				if (res==FZ_REPLY_WOULDBLOCK)
				{
					queueData.status.Format(IDS_QUEUESTATUS_TRANSFERRING);
					m_QueueItems[nIndex] = queueData;
					return;
				}
				else
					nReplyCode|=FZ_REPLY_ERROR;
			}
			else
			{
				if (ServerDataMapIter->second.nFailedConnections < 5)
					ServerDataMapIter->second.nFailedConnections++;
				if (ServerDataMapIter->second.nFailedConnections==5 && ServerDataMapIter->second.nActiveMax)
				{
					if (ServerDataMapIter->second.nCurrentActive<ServerDataMapIter->second.nActiveMax)
						ServerDataMapIter->second.nActiveMax--;
					ServerDataMapIter->second.nFailedConnections = 3;
				}
				if (ServerDataMapIter->second.nCurrentActive)
					bConnectError = TRUE;
				
				nReplyCode |= FZ_REPLY_ERROR;
				
				//Check if primary connection is connected to the same server
				//and increase nAutoUsePrimary if necessary

				CMainFrame *pMainFrame=DYNAMIC_DOWNCAST(CMainFrame,GetParentFrame());
				if (pMainFrame->IsConnected())
				{
					t_server server;
					CServerPath path;
					if (pMainFrame->m_pCommandQueue->GetLastServer(server, path) && 
						server==transferFile.server)
					{
						if (!ServerDataMapIter->second.nActiveMax)
						{
							queueData.nAutoUsePrimary = 3;
							//Increase nAutoUsePrimary on all other items which use the same server
							for (t_QueueVector::iterator iter = m_QueueItems.begin(); iter != m_QueueItems.end(); iter++)
							{
								if (!iter->bActive &&
									iter->transferFile.server == transferFile.server && iter->nAutoUsePrimary<3)
									iter->nAutoUsePrimary ++;
							}
						}
					}
				}

				m_RetryServerList.AddServer(transferFile.server);
			}
		}

		if (nApiIndex == -1)
			m_bPrimaryConnectionTransferInProgress = FALSE;
	
		if (transferFile.get)