webserver.cpp

非常出名开源客户端下载的程序emule

		}
		else if(_ParseURL(Data.sURL, "op") == "resume" && IsSessionAdmin(Data,sSession))
		{
			if(found_file)
				found_file->ResumeFile();
		}
		else if(_ParseURL(Data.sURL, "op") == "cancel" && IsSessionAdmin(Data,sSession))
		{
			if(found_file)
				found_file->DeleteFile();
		}
	}
	if (_ParseURL(Data.sURL, "sort") != "") 
	{
		if(_ParseURL(Data.sURL, "sort") == "name")
			pThis->m_Params.DownloadSort = DOWN_SORT_NAME;
		else
		if(_ParseURL(Data.sURL, "sort") == "size")
			pThis->m_Params.DownloadSort = DOWN_SORT_SIZE;
		else
		if(_ParseURL(Data.sURL, "sort") == "transferred")
			pThis->m_Params.DownloadSort = DOWN_SORT_TRANSFERRED;
		else
		if(_ParseURL(Data.sURL, "sort") == "speed")
			pThis->m_Params.DownloadSort = DOWN_SORT_SPEED;
		else
		if(_ParseURL(Data.sURL, "sort") == "progress")
			pThis->m_Params.DownloadSort = DOWN_SORT_PROGRESS;

		if(_ParseURL(Data.sURL, "sortreverse") == "")
			pThis->m_Params.bDownloadSortReverse = false;
	}
	if (_ParseURL(Data.sURL, "sortreverse") != "") 
	{
		pThis->m_Params.bDownloadSortReverse = (_ParseURL(Data.sURL, "sortreverse") == "true");
	}
	if(_ParseURL(Data.sURL, "showuploadqueue") == "true")
	{
		pThis->m_Params.bShowUploadQueue = true;
	}
	if(_ParseURL(Data.sURL, "showuploadqueue") == "false")
	{
		pThis->m_Params.bShowUploadQueue = false;
	}
	CString sDownloadSortRev;
	if(pThis->m_Params.bDownloadSortReverse)
		sDownloadSortRev = "false";
	else
		sDownloadSortRev = "true";

	Out += pThis->m_Templates.sTransferImages;
	Out += pThis->m_Templates.sTransferList;
	Out.Replace("[DownloadHeader]", pThis->m_Templates.sTransferDownHeader);
	Out.Replace("[DownloadFooter]", pThis->m_Templates.sTransferDownFooter);
	Out.Replace("[UploadHeader]", pThis->m_Templates.sTransferUpHeader);
	Out.Replace("[UploadFooter]", pThis->m_Templates.sTransferUpFooter);
	Out.Replace("[Session]", sSession);
	if(pThis->m_Params.DownloadSort == DOWN_SORT_NAME)
		Out.Replace("[SortName]", "&sortreverse=" + sDownloadSortRev);
	else
		Out.Replace("[SortName]", "");
	if(pThis->m_Params.DownloadSort == DOWN_SORT_SIZE)
		Out.Replace("[SortSize]", "&sortreverse=" + sDownloadSortRev);
	else
		Out.Replace("[SortSize]", "");
	if(pThis->m_Params.DownloadSort == DOWN_SORT_TRANSFERRED)
		Out.Replace("[SortTransferred]", "&sortreverse=" + sDownloadSortRev);
	else
		Out.Replace("[SortTransferred]", "");
	if(pThis->m_Params.DownloadSort == DOWN_SORT_SPEED)
		Out.Replace("[SortSpeed]", "&sortreverse=" + sDownloadSortRev);
	else
		Out.Replace("[SortSpeed]", "");
	if(pThis->m_Params.DownloadSort == DOWN_SORT_PROGRESS)
		Out.Replace("[SortProgress]", "&sortreverse=" + sDownloadSortRev);
	else
		Out.Replace("[SortProgress]", "");

	Out.Replace("[DownloadList]", _GetPlainResString(IDS_TW_DOWNLOADS));
	Out.Replace("[Filename]", _GetPlainResString(IDS_DL_FILENAME));
	Out.Replace("[Size]", _GetPlainResString(IDS_DL_SIZE));
	Out.Replace("[Transferred]", _GetPlainResString(IDS_DL_TRANSF));
	Out.Replace("[Progress]", _GetPlainResString(IDS_DL_PROGRESS));
	Out.Replace("[Speed]", _GetPlainResString(IDS_DL_SPEED));
	Out.Replace("[Sources]", _GetPlainResString(IDS_DL_SOURCES));
	Out.Replace("[Actions]", _GetPlainResString(IDS_WEB_ACTIONS));
	Out.Replace("[UploadList]", _GetPlainResString(IDS_PW_CON_UPLBL));
	Out.Replace("[User]", _GetPlainResString(IDS_QL_USERNAME));
	Out.Replace("[TotalDown]", _GetPlainResString(IDS_INFLST_USER_TOTALDOWNLOAD));
	Out.Replace("[TotalUp]", _GetPlainResString(IDS_INFLST_USER_TOTALUPLOAD));

	CString OutE = pThis->m_Templates.sTransferDownLine;
	CString OutE2 = pThis->m_Templates.sTransferDownLineGood;

	float fTotalSize = 0, fTotalTransferred = 0, fTotalSpeed = 0;
	CArray<DownloadFiles, DownloadFiles> FilesArray;
	// Populating array

	for (int fx=0;fx<theApp.downloadqueue->GetFileCount();fx++)
	{
		CPartFile* cur_file =  theApp.downloadqueue->GetFileByIndex(fx);

		DownloadFiles dFile;
		dFile.sFileName = _SpecialChars(cur_file->GetFileName());
		dFile.lFileSize = cur_file->GetFileSize();
		dFile.lFileTransferred = cur_file->GetTransfered();
		dFile.lFileSpeed = cur_file->GetDatarate();
		dFile.nFileStatus = cur_file->GetStatus();
		dFile.sFileStatus = cur_file->getPartfileStatus();
		dFile.sFileHash = EncodeBase16(cur_file->GetFileHash(), 16);
		dFile.lSourceCount = cur_file->GetSourceCount();
		dFile.lNotCurrentSourceCount = cur_file->GetNotCurrentSourcesCount();
		dFile.lTransferringSourceCount = cur_file->GetTransferingSrcCount();
		if (theApp.serverconnect->IsConnected() && !theApp.serverconnect->IsLowID())
			dFile.sED2kLink = theApp.CreateED2kSourceLink(cur_file);
		else
            dFile.sED2kLink = theApp.CreateED2kLink(cur_file);
		dFile.sFileInfo = _SpecialChars(cur_file->GetDownloadFileInfo());

		FilesArray.Add(dFile);
	}

	// Sorting (simple bubble sort, we don't have tons of data here)
	bool bSorted = true;
	for(int nMax = 0;bSorted && nMax < FilesArray.GetCount()*2; nMax++)
	{
		bSorted = false;
		for(int i = 0; i < FilesArray.GetCount() - 1; i++)
		{
			bool bSwap = false;
			switch(pThis->m_Params.DownloadSort)
			{
			case DOWN_SORT_NAME:
				bSwap = FilesArray[i].sFileName.CompareNoCase(FilesArray[i+1].sFileName) > 0;
				break;
			case DOWN_SORT_SIZE:
				bSwap = FilesArray[i].lFileSize < FilesArray[i+1].lFileSize;
				break;
			case DOWN_SORT_TRANSFERRED:
				bSwap = FilesArray[i].lFileTransferred < FilesArray[i+1].lFileTransferred;
				break;
			case DOWN_SORT_SPEED:
				bSwap = FilesArray[i].lFileSpeed < FilesArray[i+1].lFileSpeed;
				break;
			case DOWN_SORT_PROGRESS:
				{
					int nPercent1 = 0, nPercent2 = 0;
					if(FilesArray[i].lFileSize > 0)
					{
						float fS = FilesArray[i].lFileSize, fT = FilesArray[i].lFileTransferred;
						nPercent1 = abs((fT * 100.0) / fS);
					}
					if(FilesArray[i+1].lFileSize > 0)
					{
						float fS = FilesArray[i+1].lFileSize, fT = FilesArray[i+1].lFileTransferred;
						nPercent2 = abs((fT * 100.0) / fS);
					}
					bSwap = nPercent1 < nPercent2;
				}
			}
			if(pThis->m_Params.bDownloadSortReverse)
			{
				bSwap = !bSwap;
			}
			if(bSwap)
			{
				bSorted = true;
				DownloadFiles TmpFile = FilesArray[i];
				FilesArray[i] = FilesArray[i+1];
				FilesArray[i+1] = TmpFile;
			}
		}
	}

	// Displaying
	CString sDownList = "";
	CString HTTPTemp;

	for(int i = 0; i < FilesArray.GetCount(); i++)
	{
		CString JSfileinfo=FilesArray[i].sFileInfo;
		JSfileinfo.Replace("\n","\\n");
		CString sActions = "<acronym title=\"" + FilesArray[i].sFileStatus + "\"><a href=\"javascript:alert(\'"+ JSfileinfo+"')\"><img src=\"javascript:img_info\" alt=\"" + FilesArray[i].sFileStatus + "\"></a></acronym> ";

		CString sED2kLink;
		sED2kLink.Format("<acronym title=\"[Ed2klink]\"><a href=\""+ FilesArray[i].sED2kLink +"\"><img src=\"javascript:img_link\" alt=\"[Ed2klink]\"></a></acronym> ");
		sED2kLink.Replace("[Ed2klink]", _GetPlainResString(IDS_SW_LINK));
		sActions += sED2kLink;

		bool bCanBeDeleted = true;
		switch(FilesArray[i].nFileStatus)
		{
		case PS_COMPLETING:
		case PS_COMPLETE:
			bCanBeDeleted = false;
			break;
		case PS_HASHING: 
		case PS_WAITINGFORHASH:
		case PS_ERROR:
			break;
		case PS_PAUSED:
		{
			CString sResume;
			sResume.Format("<acronym title=\"[Resume]\"><a href=\"[Link]\"><img src=\"javascript:img_resume\" alt=\"[Resume]\"></a></acronym> ");
			
			sResume.Replace("[Link]", IsSessionAdmin(Data,sSession)?CString("/?ses=" + sSession + "&w=transfer&op=resume&file=" + FilesArray[i].sFileHash):GetPermissionDenied()) ;
			
			sActions += sResume;
		}
			break; 
		default: // waiting or downloading
		{
			CString sPause;
			sPause.Format("<acronym title=\"[Pause]\"><a href=\"[Link]\"><img src=\"javascript:img_pause\" alt=\"[Pause]\"></a></acronym> ");
			sPause.Replace("[Link]", IsSessionAdmin(Data,sSession)?CString("/?ses=" + sSession + "&w=transfer&op=pause&file=" + FilesArray[i].sFileHash):GetPermissionDenied());
			sActions += sPause;
		}
			break;
		}
		if(bCanBeDeleted)
		{
			CString sCancel;
			sCancel.Format("<acronym title=\"[Cancel]\"><a href=\"[Link]\" onclick=\"return confirm(\'[ConfirmCancel]\')\"><img src=\"javascript:img_cancel\" alt=\"[Cancel]\"></a></acronym> ");
			sCancel.Replace("[Link]", IsSessionAdmin(Data,sSession)?CString("/?ses=" + sSession + "&w=transfer&op=cancel&file=" + FilesArray[i].sFileHash):GetPermissionDenied());
			sActions += sCancel;
		}
		sActions.Replace("[Resume]", _GetPlainResString(IDS_DL_RESUME));
		sActions.Replace("[Pause]", _GetPlainResString(IDS_DL_PAUSE));
		sActions.Replace("[Cancel]", _GetPlainResString(IDS_MAIN_BTN_CANCEL));
		sActions.Replace("[ConfirmCancel]", _GetPlainResString(IDS_Q_CANCELDL2, true));

		CString HTTPProcessData;
		// if downloading, draw in other color
		if(FilesArray[i].lFileSpeed > 0)
			HTTPProcessData = OutE2;
		else
			HTTPProcessData = OutE;

		if(FilesArray[i].sFileName.GetLength() > SHORT_FILENAME_LENGTH)
			HTTPProcessData.Replace("[ShortFileName]", FilesArray[i].sFileName.Left(SHORT_FILENAME_LENGTH) + "...");
		else
			HTTPProcessData.Replace("[ShortFileName]", FilesArray[i].sFileName);

		HTTPProcessData.Replace("[FileInfo]", FilesArray[i].sFileInfo);

		fTotalSize += FilesArray[i].lFileSize;

		HTTPProcessData.Replace("[2]", CastItoXBytes(FilesArray[i].lFileSize));

		if(FilesArray[i].lFileTransferred > 0)
		{
			fTotalTransferred += FilesArray[i].lFileTransferred;

			HTTPProcessData.Replace("[3]", CastItoXBytes(FilesArray[i].lFileTransferred));
		}
		else
			HTTPProcessData.Replace("[3]", "-");

		HTTPProcessData.Replace("[DownloadBar]", _GetDownloadGraph(Data,FilesArray[i].sFileHash));

		if(FilesArray[i].lFileSpeed > 0.0f)
		{
			fTotalSpeed += FilesArray[i].lFileSpeed;

			HTTPTemp.Format("%8.2f %s", FilesArray[i].lFileSpeed/1024.0 ,_GetPlainResString(IDS_KBYTESEC) );
			HTTPProcessData.Replace("[4]", HTTPTemp);
		}
		else
			HTTPProcessData.Replace("[4]", "-");
		if(FilesArray[i].lSourceCount > 0)
		{
			HTTPTemp.Format("%8i/%8i (%i)",
				FilesArray[i].lSourceCount-FilesArray[i].lNotCurrentSourceCount,
				FilesArray[i].lSourceCount,
				FilesArray[i].lTransferringSourceCount);

		HTTPProcessData.Replace("[5]", HTTPTemp);
		}
		else
			HTTPProcessData.Replace("[5]", "-");

		HTTPProcessData.Replace("[6]", sActions);

		sDownList += HTTPProcessData;
	}

	Out.Replace("[DownloadFilesList]", sDownList);
	
	Out.Replace("[TotalDownSize]", CastItoXBytes(fTotalSize));

	Out.Replace("[TotalDownTransferred]", CastItoXBytes(fTotalTransferred));
	
	HTTPTemp.Format("%8.2f %s", fTotalSpeed/1024.0,_GetPlainResString(IDS_KBYTESEC));
	Out.Replace("[TotalDownSpeed]", HTTPTemp);
	OutE = pThis->m_Templates.sTransferUpLine;
	
	HTTPTemp.Format("%i",pThis->m_Templates.iProgressbarWidth);
	Out.Replace("[PROGRESSBARWIDTHVAL]",HTTPTemp);

	fTotalSize = 0;
	fTotalTransferred = 0;
	fTotalSpeed = 0;

	CString sUpList = "";
	
	for (POSITION pos = theApp.uploadqueue->GetFirstFromUploadList();
		pos != 0;theApp.uploadqueue->GetNextFromUploadList(pos))
	{
		CUpDownClient* cur_client = theApp.uploadqueue->GetQueueClientAt(pos);
		CString HTTPProcessData = OutE;
		HTTPProcessData.Replace("[1]", _SpecialChars(cur_client->GetUserName()));
		HTTPProcessData.Replace("[FileInfo]", _SpecialChars(cur_client->GetUploadFileInfo()));

		CKnownFile* file = theApp.sharedfiles->GetFileByID(cur_client->GetUploadFileID());
		if (file)
			HTTPProcessData.Replace("[2]", _SpecialChars(CString(file->GetFileName())));
		else
			HTTPProcessData.Replace("[2]", _GetPlainResString(IDS_REQ_UNKNOWNFILE));

		fTotalSize += cur_client->GetTransferedDown();
		fTotalTransferred += cur_client->GetTransferedUp();
		CString HTTPTemp;
		HTTPTemp.Format("%s / %s", CastItoXBytes(cur_client->GetTransferedDown()),CastItoXBytes(cur_client->GetTransferedUp()));
		HTTPProcessData.Replace("[3]", HTTPTemp);

		fTotalSpeed += cur_client->GetDatarate();
		HTTPTemp.Format("%8.2f " + _GetPlainResString(IDS_KBYTESEC), cur_client->GetDatarate()/1024.0);
		HTTPProcessData.Replace("[4]", HTTPTemp);
		sUpList += HTTPProcessData;
	}
	Out.Replace("[UploadFilesList]", sUpList);
	HTTPTemp.Format("%s / %s", CastItoXBytes(fTotalSize), CastItoXBytes(fTotalTransferred));
	Out.Replace("[TotalUpTransferred]", HTTPTemp);
	HTTPTemp.Format("%8.2f " + _GetPlainResString(IDS_KBYTESEC), fTotalSpeed/1024.0);
	Out.Replace("[TotalUpSpeed]", HTTPTemp);

	if(pThis->m_Params.bShowUploadQueue) 
	{
		Out.Replace("[UploadQueue]", pThis->m_Templates.sTransferUpQueueShow);
		Out.Replace("[UploadQueueList]", _GetPlainResString(IDS_ONQUEUE));
		Out.Replace("[UserNameTitle]", _GetPlainResString(IDS_QL_USERNAME));
		Out.Replace("[FileNameTitle]", _GetPlainResString(IDS_DL_FILENAME));
		Out.Replace("[ScoreTitle]", _GetPlainResString(IDS_SCORE));
		Out.Replace("[BannedTitle]", _GetPlainResString(IDS_BANNED));

		OutE = pThis->m_Templates.sTransferUpQueueLine;
		// Replace [xx]
		CString sQueue = "";

		for (POSITION pos = theApp.uploadqueue->GetFirstFromWaitingList(); pos != 0;theApp.uploadqueue->GetNextFromWaitingList(pos)){
			CUpDownClient* cur_client = theApp.uploadqueue->GetWaitClientAt(pos);
			CString HTTPProcessData;
            char HTTPTempC[100] = "";
			HTTPProcessData = OutE;
			HTTPProcessData.Replace("[UserName]", _SpecialChars(cur_client->GetUserName()));
			if (cur_client->reqfile)
				HTTPProcessData.Replace("[FileName]", _SpecialChars(cur_client->reqfile->GetFileName()));
			else
				HTTPProcessData.Replace("[FileName]", "?");
			sprintf(HTTPTempC, "%i" , cur_client->GetScore(false));
			CString HTTPTemp = HTTPTempC;
			HTTPProcessData.Replace("[Score]", HTTPTemp);
			if (cur_client->IsBanned())
				HTTPProcessData.Replace("[Banned]", _GetPlainResString(IDS_YES));
			else
				HTTPProcessData.Replace("[Banned]", _GetPlainResString(IDS_NO));
			sQueue += HTTPProcessData;
		}
		Out.Replace("[QueueList]", sQueue);
	}
	else {
		Out.Replace("[UploadQueue]", pThis->m_Templates.sTransferUpQueueHide);
	}
	Out.Replace("[ShowQueue]", _GetPlainResString(IDS_WEB_SHOW_UPLOAD_QUEUE));
	Out.Replace("[HideQueue]", _GetPlainResString(IDS_WEB_HIDE_UPLOAD_QUEUE));
	Out.Replace("[Session]", sSession);

	return Out;
}

CString CWebServer::_GetDownloadLink(ThreadData Data)
{