D:/opendownloadmanager/ODM-1.x/fsDownloadsMgr.cpp Source File

00001 /*
00002   Free Download Manager Copyright (c) 2003-2007 FreeDownloadManager.ORG
00003   Open Download Manager Copyright (c) 2008-2010 OpenDownloadManager.ORG
00004 */        
00005 
00006 #include "stdafx.h"
00007 #include "fsDownloadsMgr.h"
00008 #include "inetutil.h"
00009 #include "mfchelp.h"
00010 #include "vmsRegisteredApp.h"
00011 
00012 #ifndef FDM_DLDR__RAWCODEONLY
00013 #include "DDRDlg.h"
00014 #include "WaitDlg.h"
00015 #include "ZipPreviewDlg.h"
00016 #include "WaitForConfirmationDlg.h"
00017 #include "WaitForConfirmationDlg.h"
00018 #include "DownloadsWnd.h"
00019 #include "UIThread.h"
00020 #endif
00021 
00022 #include "fsScheduleMgr.h"
00023 #include "fsSitesMgr.h"
00024 #include "misc.h"
00025 #include "system.h"
00026 #include "vmsFilesToDelete.h"
00027 #include "Hash\vmsHash.h"
00028 #include "Dlg_CheckFileIntegrity_Result.h"
00029 #include "vmsMetalinkFile.h"
00030 #include "Dlg_Download.h"
00031 #include "MyMessageBox.h"
00032 #include "vmsVideoSiteHtmlCodeParser.h"
00033 #include "FlashVideoDownloadsWnd.h"
00034 
00035 #ifndef FDM_DLDR__RAWCODEONLY
00036 extern CDownloadsWnd* _pwndDownloads;
00037 #endif
00038 
00039 #ifdef _DEBUG
00040 #undef THIS_FILE
00041 static char THIS_FILE[]=__FILE__;
00042 #define new DEBUG_NEW
00043 #endif
00044 
00045 using namespace fsArchive;
00046 
00047 const double DLD_HP_START_COEFF = 3.0;        
00048 
00049 fsDownloadsMgr::fsDownloadsMgr()
00050 {
00051         m_pfnEvents = NULL;
00052         m_cThreadsRunning = 0;
00053 
00054         m_bSkip1Cicle = FALSE;
00055         m_nID = 0;
00056 
00057         m_bAllowStart = TRUE;
00058         m_bDisablePD = FALSE;
00059 
00060         InitializeCriticalSection (&m_csQSection);
00061 
00062         InitializeCriticalSection (&m_csSave);
00063         
00064         m_bDeletingNow = m_bDeletingDeletedNow = m_bRestoringNow = FALSE;
00065 
00066 #ifndef FDM_DLDR__RAWCODEONLY
00067         m_histmgr.SetEventFunc (_HistoryMgrEvents, this);
00068 #endif
00069 
00070         fsInternetSession::InitializeWinInet ();
00071 }
00072 
00073 fsDownloadsMgr::~fsDownloadsMgr()
00074 {
00075 }
00076 
00077 UINT fsDownloadsMgr::Add(vmsDownloadSmartPtr dld, BOOL bKeepIDAsIs, bool bPlaceToTop)
00078 {
00079         
00080         if (dld->pMgr->GetDownloadMgr () != NULL)
00081         {
00082                 dld->pMgr->GetDownloadMgr ()->SetEventFunc (_DownloadMgrEvents, this);
00083                 dld->pMgr->GetDownloadMgr ()->SetEventDescFunc (_DownloadMgrEventDesc, this);
00084                 dld->pMgr->GetDownloadMgr ()->set_Download (dld);
00085         }
00086         else if (dld->pMgr->GetBtDownloadMgr () != NULL)
00087         {
00088                 dld->pMgr->GetBtDownloadMgr ()->SetEventsHandler (_BtDownloadManagerEventHandler, this);
00089         }
00090 
00091         dld->pMgr->UseDetailedLog (m_bDetLog);
00092         
00093         if (bKeepIDAsIs == FALSE)
00094                 dld->nID = m_nID++; 
00095         else
00096                 dld->nID = dld->nID;
00097 
00098         if (dld->pMgr->GetDownloadMgr () != NULL)
00099                 Apply_MirrParameters (dld);
00100 
00101         SYSTEMTIME time;
00102         GetLocalTime (&time);
00103         SystemTimeToFileTime (&time, &dld->dateAdded);
00104 
00105         
00106         if (dld->pMgr->GetDownloadMgr () != NULL)
00107         {
00108                 fsSiteInfo *site = _SitesMgr.FindSite2 (dld->pMgr->GetDownloadMgr ()->GetDNP ()->pszServerName, 
00109                         fsNPToSiteValidFor (dld->pMgr->GetDownloadMgr ()->GetDNP ()->enProtocol));
00110                 if (site)
00111                         dld->pMgr->GetDownloadMgr ()->GetDNP ()->dwFtpFlags = site->dwFtpFlags;
00112         }
00113 
00114         if (bPlaceToTop == false)
00115                 DownloadsList_Add (dld);
00116         else
00117                 DownloadsList_Insert (0, dld);
00118 
00119         m_bSkip1Cicle = TRUE;
00120 
00121         return dld->nID;
00122 }
00123 
00124 void fsDownloadsMgr::_DownloadMgrEventDesc(fsDownloadMgr *pMgr, fsDownloadMgr_EventDescType enType, LPCSTR pszEvent, LPVOID lp)
00125 {
00126         try {
00127 
00128         fsDownloadsMgr* pThis = (fsDownloadsMgr*) lp;
00129         vmsDownloadSmartPtr dld = pThis->GetDownloadByDownloadMgr (pMgr);
00130         if (dld == NULL)
00131                 return;
00132 
00133         pThis->OnDownloadDescEventRcvd (dld, enType, pszEvent);
00134 
00135         } 
00136         
00137         catch (...) {}                                          
00138 }
00139 
00140 vmsDownloadSmartPtr fsDownloadsMgr::GetDownloadByDownloadMgr(fsDownloadMgr *pMgr)
00141 {
00142         ASSERT (pMgr != NULL);
00143 
00144         try {
00145                 for (size_t i = 0; i < m_vDownloads.size (); i++)
00146                 {
00147                         if (m_vDownloads [i]->pMgr->GetDownloadMgr () == pMgr)
00148                                 return m_vDownloads [i];
00149                 }
00150         }catch (...){}
00151 
00152         return NULL;
00153 }
00154 
00155 DWORD fsDownloadsMgr::_DownloadMgrEvents(fsDownloadMgr *pMgr, fsDownloaderEvent enEvent, UINT uInfo, LPVOID lp)
00156 {
00157         fsDownloadsMgr* pThis = (fsDownloadsMgr*) lp;
00158 
00159         ASSERT (pMgr != NULL);
00160         vmsDownloadSmartPtr dld = pThis->GetDownloadByDownloadMgr (pMgr);
00161 
00162         if (dld == NULL)
00163                 return TRUE;
00164 
00165         try {
00166 
00167         switch (enEvent)
00168         {
00169                 case DE_SECTIONDONE:
00170                         pThis->Event (dld, DME_DOWNLOADEREVENTRECEIVED);
00171                         pThis->OnSectionStop (dld);
00172                 break;
00173 
00174                 case DE_SECTDOWNLOADING:
00175                         pThis->Event (dld, DME_SECTIONDOWNLOADING);
00176                 break;
00177 
00178                 case DE_SECTIONSTOPPED:
00179                         pThis->OnSectionStop (dld);
00180                 break;
00181 
00182                 case DE_EXTERROR:       
00183                         switch (uInfo)
00184                         {
00185                                 case DMEE_FILEWASDELETED:       
00186                                         dld->bAutoStart = FALSE; 
00187                                         break;
00188 
00189                                 case DMEE_STOPPEDORDONE: 
00190                                         if (FALSE == pThis->OnDownloadStoppedOrDone (dld))
00191                                                 return TRUE;
00192                                         dld = NULL;     
00193                                         break;
00194 
00195                                 case DMEE_FATALERROR:
00196                                 case DMEE_USERSTOP:
00197                                         dld->bAutoStart = FALSE;
00198                                         break;
00199 
00200                                 case DMEE_FILEUPDATED:
00201                                         pThis->Event (dld, DME_FILEUPDATED);
00202                                         dld = NULL;     
00203                                         break;
00204 
00205                                 case DMEE_STARTING:
00206                                         if (FALSE == pThis->Event (dld, DME_DLMGRTHREADSTARTING))
00207                                                 return FALSE;
00208                                         pThis->Event (dld, DME_CREATEDLDDIALOG);
00209                                         break;
00210                         }
00211                 break;
00212 
00213                 case DE_QUERYNEWSECTION:        
00214                         pThis->RebuildServerList ();    
00215                         return pThis->OnQueryNewSection (dld, uInfo);
00216 
00217                 case DE_SECTIONSTARTED:
00218                         pThis->ApplyTrafficLimit ();
00219                         pThis->RebuildServerList ();
00220                         pThis->Event (dld, DME_SECTIONSTARTED);
00221                 break;
00222 
00223                 case DE_ALLSTOPPEDORDONE:
00224                 break;
00225 
00226                 case DE_WRITEERROR:
00227                         dld->bAutoStart = FALSE;
00228                 break;
00229 
00230                 case DE_REDIRECTINGOKCONTINUEOPENING:
00231                         pThis->Event (dld, DME_REDIRECTED);
00232                         pThis->Event (dld, DME_UPDATEDLDDIALOG);
00233                         break;
00234 
00235                 case DE_NOMIRRFOUND:
00236                         dld->dwFlags |= DLD_DONTUSEMIRRORS; 
00237                         pMgr->GetDownloader ()->Set_SearchForMirrors (FALSE);
00238                         break;
00239 
00240                 case DE_FILESIZETOOBIG:
00241                         dld->bAutoStart = FALSE;
00242                         break;
00243 
00244                 case DE_NEEDFILE:
00245                         return pThis->OnBeforeDownload (dld);
00246 
00247                 case DE_CONFIRMARCHIVEDETECTION:
00248                 {
00249 #ifndef FDM_DLDR__RAWCODEONLY
00250                         UINT nRes;
00251                         UIThread *thr = (UIThread*) RUNTIME_CLASS (UIThread)->CreateObject ();
00252                         thr->set_Thread (_threadConfirmZIP, &nRes);
00253                         thr->CreateThread ();
00254                         WaitForSingleObject (thr->m_hThread, INFINITE);
00255                         return nRes;
00256 #else
00257                         return 0;
00258 #endif
00259                 }
00260 
00261                 case DE_ARCHIVEDETECTED:
00262                         return pThis->OnArchiveDetected (dld, (fsArchiveRebuilder*) uInfo);
00263         }
00264 
00265         }
00266         catch (...) {}
00267 
00268         if (dld) 
00269                 pThis->Event (dld, DME_DOWNLOADEREVENTRECEIVED);
00270 
00271         return TRUE;
00272 }
00273 
00274 void fsDownloadsMgr::ProcessDownloads()
00275 {
00276         
00277         DLDS_LIST vDldsToStop, vDldsToStart;
00278 
00279         if (m_bAllowStart == FALSE || m_bDisablePD)
00280                 return;
00281 
00282         LOG ("fsDsM::PD: start" << nl);
00283 
00284         
00285         m_mxBuildConns.Lock ();
00286 
00287         try {
00288 
00289         RebuildServerList (FALSE);
00290 
00291         UINT cConns = m_aTUM [m_enTUM].uMaxConns;
00292         UINT cDlds = m_aTUM [m_enTUM].uMaxDlds;
00293         UINT cMaxCPS = m_aTUM [m_enTUM].uMaxConnsPS;
00294         
00295         for (size_t i = 0; i < (size_t)_SitesMgr.GetSiteCount (); i++)
00296                 _SitesMgr.GetSite (i)->cConnsNow = min (_SitesMgr.GetSite (i)->cMaxConns, cMaxCPS);
00297 
00298         LOG ("fsDsM::PD: 1" << nl);
00299 
00300         for (i = 0; i < m_vDownloads.size (); i++)
00301         {
00302                 vmsDownloadSmartPtr dld = m_vDownloads [i];
00303 
00304                 if (dld->pMgr->IsDone ())
00305                         continue;
00306 
00307                 if (dld->pMgr->IsBittorrent () && 
00308                                 dld->pMgr->GetBtDownloadMgr ()->get_State () == BTDSE_QUEUED)
00309                         continue;
00310 
00311                 BOOL bAccept = FALSE;   
00312                 
00313                 fsDownloadMgr *pMgr = dld->pMgr->GetDownloadMgr (); 
00314                 LPCSTR pszSiteName = pMgr ? pMgr->GetDNP ()->pszServerName : NULL;
00315                 fsNetworkProtocol enNP = pMgr ? pMgr->GetDNP ()->enProtocol : (fsNetworkProtocol)-1;
00316 
00317                 if (cDlds && cConns)    
00318                 {       
00319                         fsSiteInfo* site = pMgr? _SitesMgr.FindSite2 (pszSiteName, fsNPToSiteValidFor (enNP)) : NULL;
00320                         if (site == NULL || site->cConnsNow)    
00321                         {
00322                                 UINT cDldConns = 0;     
00323 
00324                                 if (dld->pMgr->IsRunning ())
00325                                 {
00326                                         cDldConns = dld->pMgr->IsBittorrent () ? 0 : dld->pMgr->GetConnectionCount ();
00327 
00328                                         if (pMgr)
00329                                         {
00330                                                 cDldConns += pMgr->GetDownloader ()->GetCreatingNowSectionCount (UINT_MAX);
00331 
00332                                                 
00333                                                 for (int i = 0; i < pMgr->GetDownloader ()->GetMirrorURLCount (); i++)
00334                                                 {
00335                                                         UINT cMirrConns = pMgr->GetDownloader ()->GetCreatingNowSectionCount (i);
00336                                                         fsDownload_NetworkProperties* mirrDNP = pMgr->GetDownloader ()->MirrorDNP (i);
00337 
00338                                                         fsSiteInfo* mirrSite = _SitesMgr.FindSite2 (mirrDNP->pszServerName, fsNPToSiteValidFor (mirrDNP->enProtocol));
00339 
00340                                                         if (mirrSite->cConnsNow > cMirrConns)
00341                                                                 mirrSite->cConnsNow -= cMirrConns;
00342                                                         else
00343                                                                 mirrSite->cConnsNow = 0; 
00344                                                 }
00345                                         }
00346 
00347                                         bAccept = TRUE;
00348                                 }
00349                                 else
00350                                 {
00351                                         if (dld->bAutoStart)
00352                                         {
00353                                                 cDldConns = min (cConns, cMaxCPS);
00354                                                 if (pMgr)
00355                                                 {
00356                                                         cDldConns = min (cDldConns, site->cConnsNow);
00357                                                         cDldConns = min (cDldConns, pMgr->GetDP ()->uMaxSections);
00358                                                 }
00359                                                 else
00360                                                 {
00361                                                         cDldConns = min (cDldConns, 2);
00362                                                         
00363                                                 }
00364                                                 if (pMgr && cDldConns > 1)
00365                                                 {
00366                                                         UINT64 size = pMgr->GetDownloader ()->GetSSFileSize ();
00367                                                         if (size == _UI64_MAX)
00368                                                                 cDldConns = 1;
00369                                                         else if (size)
00370                                                                 cDldConns = min (cDldConns, 
00371                                                                         UINT (pMgr->GetDownloader ()->GetBytesLeft () / pMgr->GetDP ()->uSectionMinSize));
00372                                                 }
00373                                                 bAccept = TRUE;
00374                                         }
00375                                 }
00376 
00377                                 if (bAccept)
00378                                 {
00379                                         
00380                                         if (site)
00381                                         {
00382                                                 if(site->cConnsNow > cDldConns)
00383                                                         site->cConnsNow -= cDldConns;
00384                                                 else
00385                                                         site->cConnsNow = 0;
00386                                         }
00387 
00388                                         if (cConns > cDldConns)
00389                                                 cConns -= cDldConns;
00390                                         else
00391                                                 cConns = 0;
00392 
00393                                         cDlds--;
00394                                 }
00395                         }
00396                 }
00397 
00398                 if (bAccept && dld->pMgr->IsRunning () == FALSE)
00399                         vDldsToStart.push_back (dld);   
00400                 else if (bAccept == FALSE && dld->pMgr->IsRunning ())
00401                 {
00402                         
00403                         if (pMgr == NULL || dld->pMgr->GetNumberOfSections () == 0 || 
00404                                         (dld->pMgr->GetSSFileSize () != _UI64_MAX && dld->pMgr->IsResumeSupported () == RST_PRESENT))
00405                                 vDldsToStop.push_back (dld); 
00406                 }
00407         }
00408 
00409         RebuildServerList (TRUE);
00410 
00411         } catch (...) {}
00412 
00413         LOG ("fsDsM::PD: 2" << nl);
00414 
00415         m_mxBuildConns.Unlock (); 
00416 
00417         StopDownloads (vDldsToStop);
00418         StartDownloads (vDldsToStart);
00419 
00420         LOG ("fsDsM::PD: exit" << nl);
00421 }
00422 
00423 void fsDownloadsMgr::StartDownloads(DLDS_LIST &vpDlds, BOOL )
00424 {
00425         LOG ("fsDsM::SD: start" << nl);
00426 
00427         try {
00428 
00429         UINT cRunning = GetRunningDownloadCount ();
00430 
00431         LOG ("fsDsM::SD: number of running downloads = " << (DWORD)cRunning << nl);
00432 
00433         for (size_t i = 0; i < vpDlds.size (); i++)
00434         {
00435                 vmsDownloadSmartPtr dld = vpDlds [i];
00436 
00437                 if (cRunning < m_aTUM [m_enTUM].uMaxConns && cRunning < m_aTUM [m_enTUM].uMaxDlds && cRunning < 20)     
00438                 {
00439                         if (dld->pMgr->IsDone () == FALSE)
00440                         {
00441                                 LOG ("fsDsM::SD: start download (" << dld->pMgr->get_URL () << ")" << nl);
00442 
00443                                 dld->pMgr->StartDownloading ();
00444                                 cRunning ++;
00445                         }
00446                 }
00447                 else
00448                 {
00449                         dld->bAutoStart = TRUE;
00450                 }
00451         }
00452 
00453         }catch (...) {}
00454 
00455         ApplyTrafficLimit ();
00456 
00457         Event (NULL, DME_DLDSAUTOSTARTMDFD);
00458 
00459         LOG ("fsDsM::SD: exit" << nl);
00460 }
00461 
00462 void fsDownloadsMgr::StopDownloads(DLDS_LIST &vDlds, BOOL bByUser)
00463 {
00464         LOG ("fsDsM::SpD: start" << nl);
00465 
00466         try {
00467         
00468         if (bByUser)
00469         {
00470                 for (size_t i = 0; i < vDlds.size (); i++)
00471                         vDlds [i]->bAutoStart = FALSE;
00472         }
00473 
00474         for (size_t i = 0; i < vDlds.size (); i++)
00475                 vDlds [i]->pMgr->StopDownloading ();
00476 
00477         }
00478         catch (...) {}
00479 
00480         ApplyTrafficLimit ();
00481 
00482         if (bByUser)
00483                 Event (NULL, DME_DLDSAUTOSTARTMDFD);
00484 
00485         LOG ("fsDsM::SpD: exit" << nl);
00486 }
00487 
00488 void fsDownloadsMgr::SetEventsFunc(fntDownloadsMgrEventFunc pfn, LPVOID lpParam)
00489 {
00490         m_pfnEvents = pfn;
00491         m_lpEventsParam = lpParam;
00492 }
00493 
00494 DWORD fsDownloadsMgr::Event(vmsDownloadSmartPtr dld, fsDownloadsMgrEvent ev)
00495 {
00496         DWORD dwRet = TRUE; 
00497 
00498         if (dld && dld->pfnDownloadEventsFunc)
00499                 dwRet = dld->pfnDownloadEventsFunc (dld, ev, dld->lpEventsParam);
00500 
00501         if (m_pfnEvents)
00502                 dwRet = m_pfnEvents (dld, ev, m_lpEventsParam);
00503 
00504         return dwRet;
00505 }
00506 
00507 vmsDownloadSmartPtr fsDownloadsMgr::GetDownload(size_t iIndex)
00508 {
00509         try {
00510         if (iIndex >= m_vDownloads.size ())
00511                 return NULL;
00512 
00513         return m_vDownloads [iIndex];
00514         }
00515         catch (...) { return NULL; }
00516 }
00517 
00518 BOOL fsDownloadsMgr::LoadDownloads()
00519 {
00520         if (!m_saver.Load (&m_vDownloads, "downloads", FALSE))
00521                 return FALSE;
00522 
00523         BOOL bFailIfLarge = _App.CheckRecycleBinSize ();
00524         for (int j = 0; j < 2; j++)
00525         {
00526                 fsDLLoadResult res = m_saver.Load (&m_vDeletedDownloads, "downloads.del", j == 0 && bFailIfLarge);
00527                 if (res == DLLR_TOOLARGESIZE)
00528                 {
00529                         CWaitForConfirmationDlg dlg;
00530                         dlg.Init (LS (L_RBTOOLARGE), UINT_MAX, TRUE, FALSE, LS (L_DONTCHECKAGAIN));
00531                         dlg.m_pszIcon = IDI_WARNING;
00532                         UINT nRet = dlg.DoModal ();
00533                         if (dlg.m_bDontAsk)
00534                                 _App.CheckRecycleBinSize (FALSE);
00535                         if (nRet == IDOK)
00536                                 break;
00537                 }
00538                 else 
00539                         break;
00540         }
00541 
00542 #ifndef FDM_DLDR__RAWCODEONLY
00543         m_histmgr.LoadHistory ();
00544 #endif
00545 
00546         m_nID = 0;
00547 
00548         for (size_t i = 0; i < m_vDownloads.size (); i++)
00549         {
00550                 vmsDownloadSmartPtr dld = m_vDownloads [i];
00551 
00552                 dld->pdlg = NULL;
00553 
00554                 dld->pfnDownloadEventsFunc = NULL;
00555 
00556                 if (dld->pMgr->GetDownloadMgr ())
00557                 {
00558                         dld->pMgr->GetDownloadMgr ()->SetEventFunc (_DownloadMgrEvents, this);
00559                         dld->pMgr->GetDownloadMgr ()->SetEventDescFunc (_DownloadMgrEventDesc, this);                   
00560                         dld->pMgr->GetDownloadMgr ()->set_Download (dld);
00561                 }
00562                 else if (dld->pMgr->GetBtDownloadMgr ())
00563                 {
00564                         dld->pMgr->GetBtDownloadMgr ()->SetEventsHandler (_BtDownloadManagerEventHandler, this);
00565                 }
00566 
00567                 dld->pMgr->UseDetailedLog (m_bDetLog);
00568 
00569                 m_nID = max (m_nID, dld->nID);
00570 
00571                 dld->pGroup->cDownloads++;
00572         }
00573 
00574         for (i = 0; i < m_vDeletedDownloads.size (); i++)
00575         {
00576                 UINT id = m_vDeletedDownloads [i]->nID;
00577                 m_nID = max (m_nID, id);
00578         }
00579 
00580         m_nID++;
00581 
00582         LoadStateInformation ();
00583 
00584         Apply_MirrParameters ();
00585 
00586         if (_BT.is_Initialized ())
00587         {
00588                 InterlockedIncrement (&m_cThreadsRunning);
00589                 DWORD dw;
00590                 CloseHandle (
00591                         CreateThread (NULL, 0, _threadStartSeeding, this, 0, &dw));
00592         }
00593 
00594         return TRUE;
00595 }
00596 
00597 BOOL fsDownloadsMgr::Save()
00598 {
00599         EnterCriticalSection (&m_csSave);
00600 
00601         BOOL b = FALSE;
00602 
00603         try {
00604                 b = m_saver.Save (&m_vDownloads, "downloads");
00605                 if (FALSE == m_saver.Save (&m_vDeletedDownloads, "downloads.del"))
00606                         b = FALSE;
00607                 if (FALSE == m_histmgr.SaveHistory ())
00608                         b = FALSE;
00609                 if (FALSE == SaveStateInformation ())
00610                         b = FALSE;
00611                 if (FALSE == _BT.SaveState ())
00612                         b = FALSE;
00613         }catch (...){}
00614 
00615         LeaveCriticalSection (&m_csSave);
00616         return b;
00617 }
00618 
00619 int fsDownloadsMgr::GetDownloadIndex(vmsDownloadSmartPtr dld, int nFindStartPos)
00620 {
00621         ASSERT (nFindStartPos >= 0);
00622 
00623         for (size_t i = nFindStartPos; i < m_vDownloads.size (); i++)
00624         {
00625                 if (m_vDownloads [i] == dld)
00626                         return i;
00627         }
00628 
00629         return -1;
00630 }
00631 
00632 int fsDownloadsMgr::DeleteDownloads(DLDS_LIST &vDlds, BOOL bByUser, BOOL bDontConfirmFileDeleting)
00633 {
00634         size_t cMaxDlds = 40;
00635 
00636         try {
00637                 if (vDlds [0]->pfnDownloadEventsFunc)
00638                         cMaxDlds = 20;
00639         } catch (...) {}
00640         
00641         
00642         if (vDlds.size () < cMaxDlds)
00643                 return DeleteDownloads2 (&vDlds, bByUser, bDontConfirmFileDeleting);
00644 
00645         int iDeleted = 0;
00646         
00647         CWaitDlg dlg;
00648         dlg.StartWaiting (LS (L_DELETINGDLDS), _threadWaitDelDlds, TRUE, &vDlds, &bByUser, &bDontConfirmFileDeleting, &iDeleted, this);
00649 
00650         return iDeleted;
00651 }
00652 
00653 DWORD WINAPI fsDownloadsMgr::_threadDeleteDownload(LPVOID lp)
00654 {
00655         
00656         DLDS_LIST *pvDlds = (DLDS_LIST*) lp;
00657 
00658         try {
00659         
00660         for (size_t i = 0; i < pvDlds->size (); i++)
00661         {
00662                 vmsDownloadMgrSmartPtr mgr = pvDlds->at (i)->pMgr;
00663 
00664                 if (mgr->GetDownloadMgr ())
00665                 {
00666                         mgr->GetDownloadMgr ()->SetEventFunc (NULL, 0);
00667                         mgr->GetDownloadMgr ()->SetEventDescFunc (NULL, 0);
00668                 }
00669                 else if (mgr->GetBtDownloadMgr ())
00670                 {
00671                         mgr->GetBtDownloadMgr ()->SetEventsHandler (NULL, 0);
00672                 }
00673 
00674                 mgr->StopDownloading ();
00675         }
00676 
00677         MSG msg;
00678         
00679         for (i = 0; i < pvDlds->size (); i++)
00680         {
00681                 vmsDownloadSmartPtr dld = pvDlds->at (i);
00682                 while (dld->pMgr->IsRunning ())
00683                 {
00684                         while (PeekMessage (&msg, 0, 0, 0, PM_REMOVE))
00685                                 DispatchMessage (&msg);
00686 
00687                         Sleep (0);
00688                 }
00689         }
00690 
00691         while (PeekMessage (&msg, 0, 0, 0, PM_REMOVE))
00692                 DispatchMessage (&msg);
00693 
00694         }
00695         catch (...) {}
00696 
00697         try {
00698                 delete pvDlds;  
00699         }catch (...) {}
00700 
00701         return 0;
00702 }
00703 
00704 void fsDownloadsMgr::StopGroup(vmsDownloadsGroupSmartPtr pGroup)
00705 {
00706         DLDS_LIST vDlds;
00707 
00708         for (size_t i = 0; i < m_vDownloads.size (); i++)
00709         {
00710                 vmsDownloadSmartPtr dld = m_vDownloads [i];
00711 
00712                 if (dld->pGroup->nId == pGroup->nId)
00713                         vDlds.push_back (dld);
00714         }
00715 
00716         StopDownloads (vDlds, TRUE);
00717 }
00718 
00719 void fsDownloadsMgr::StartGroup(vmsDownloadsGroupSmartPtr pGroup)
00720 {
00721         DLDS_LIST vDlds;
00722 
00723         for (size_t i = 0; i < m_vDownloads.size (); i++)
00724         {
00725                 vmsDownloadSmartPtr dld = m_vDownloads [i];
00726 
00727                 if (dld->pGroup->nId == pGroup->nId && 
00728                           dld->pMgr->IsRunning () == FALSE)
00729                         vDlds.push_back (dld);
00730         }
00731 
00732         StartDownloads (vDlds, TRUE);
00733 }
00734 
00735 DWORD WINAPI fsDownloadsMgr::_threadDownloadsMgr(LPVOID lp)
00736 {
00737         fsDownloadsMgr *pThis = (fsDownloadsMgr*) lp;
00738         fsTicksMgr past, now;   
00739         fsTicksMgr lastSpeedMeasure;    
00740 
00741         pThis->m_bNeedExit = FALSE;
00742 
00743         now.Now ();
00744         past.Now ();
00745         lastSpeedMeasure.Now ();
00746 
00747         pThis->m_vSummSpeed.clear ();
00748 
00749         while (pThis->m_bNeedExit == FALSE)
00750         {
00751                 if (now - lastSpeedMeasure >= 5000)     
00752                 {
00753                         lastSpeedMeasure.Now ();
00754                         
00755                         if (pThis->m_vSummSpeed.size () == MAX_SUMMS)
00756                                 pThis->m_vSummSpeed.clear ();
00757 
00758                         UINT summ = 0;
00759                         
00760                         try {
00761                         for (int i = pThis->m_vDownloads.size () - 1; i >= 0; i--)
00762                                 summ += pThis->m_vDownloads [i]->pMgr->GetSpeed ();
00763                         }catch (...) {}
00764                         
00765                         if (summ == 0 && pThis->IsRunning () == FALSE)
00766                                 pThis->m_vSummSpeed.clear ();
00767                         else
00768                                 pThis->m_vSummSpeed.add (summ);
00769                 }
00770 
00771                 if (now - past > pThis->m_uAutosaveInterval)
00772                 {
00773                         
00774                         AfxGetApp ()->m_pMainWnd->PostMessage (WM_COMMAND, ID_SAVEALL);
00775                         past.Now ();
00776                 }
00777 
00778                 if (pThis->m_bSkip1Cicle == FALSE)
00779                 {
00780                         pThis->ManageTraffic ();
00781                 }
00782                 else
00783                         pThis->m_bSkip1Cicle = FALSE;
00784 
00785                 Sleep (1000);
00786                 now.Now ();
00787         }
00788 
00789         InterlockedDecrement (&pThis->m_cThreadsRunning);
00790 
00791         return 0;
00792 }
00793 
00794 void fsDownloadsMgr::SetAutosaveInterval(UINT uInterval)
00795 {
00796         m_uAutosaveInterval = uInterval;
00797 }
00798 
00799 fsTrafficUsageMode* fsDownloadsMgr::GetTUMs()
00800 {
00801         return m_aTUM;
00802 }
00803 
00804 void fsDownloadsMgr::RebuildServerList(BOOL bUpdateSiteList)
00805 {
00806         LOG ("fsDsM::RSL: start" << nl);
00807 
00808         m_mxBuildConns.Lock (); 
00809 
00810         try {
00811 
00812         for (int i = 0; i < _SitesMgr.GetSiteCount (); i++)
00813                 _SitesMgr.GetSite (i)->cConnsNow = 0;   
00814 
00815         
00816         for (i = m_vDownloads.size () - 1; i >= 0; i--)
00817         {
00818                 vmsDownloadSmartPtr dld = m_vDownloads [i];
00819 
00820                 if (dld->pMgr->GetDownloadMgr () == NULL)
00821                         continue;
00822 
00823                 fsDownloadMgr *pMgr = dld->pMgr->GetDownloadMgr ();
00824 
00825                 int cSects = pMgr->GetDownloader ()->GetNumberOfSections ();
00826                 fs::list <UINT> vMirrsCalculated;
00827                 
00828                 for (int j = -1; j < cSects || (cSects == 0 && j == 0); j++)
00829                 {
00830                         fsSection sect;
00831                         bool bSect = j != -1 && cSects != 0;
00832 
00833                         if (bSect)
00834                                 pMgr->GetDownloader ()->GetSectionInfo (j, &sect);
00835 
00836                         int cConns = bSect && (sect.state == SS_DOWNLOADING) ? 1 : 0;
00837 
00838                         UINT uSect = UINT_MAX;
00839                         if (bSect)
00840                                 uSect = j;
00841 
00842                         fsDownload_NetworkProperties *dnp = pMgr->GetDownloader ()->DNP (uSect);
00843 
00844                         LPCSTR pszServer = dnp->pszServerName;
00845                         fsNetworkProtocol np = dnp->enProtocol;
00846                         
00847                         fsSiteInfo *site = _SitesMgr.FindSite2 (pszServer, fsNPToSiteValidFor (np));
00848                         
00849                         for (int k = 0; k < vMirrsCalculated.size (); k++)
00850                         {
00851                                 if (vMirrsCalculated [k] == sect.nMirrorURL)
00852                                         break;
00853                         }
00854 
00855                         if (k != vMirrsCalculated.size ())
00856                         {
00857                                 cConns += pMgr->GetDownloader ()->GetCreatingNowSectionCount (sect.nMirrorURL);
00858                                 vMirrsCalculated.add (sect.nMirrorURL);
00859                         }
00860                         
00861                         if (site == NULL)
00862                         {
00863                                 
00864                                 fsSiteInfo site;
00865                                 site.strName = pszServer;
00866                                 site.cConnsNow = cConns;
00867                                 site.dwFtpFlags = dnp->dwFtpFlags;
00868                                 site.bTemp = TRUE;
00869                                 site.cMaxConns = UINT_MAX;
00870                                 site.pGroup = dld->pGroup;
00871                                 if (_App.SM_KeepPasswords ())
00872                                 {
00873                                         site.strUser = *dnp->pszUserName ? dnp->pszUserName : NULL;
00874                                         site.strPassword = *dnp->pszPassword ? dnp->pszPassword : NULL;
00875                                 }
00876                                 site.dwValidFor = fsNPToSiteValidFor (np) | SITE_VALIDFOR_SUBDOMAINS;
00877                                 _SitesMgr.AddSite (site);
00878                         }
00879                         else
00880                         {
00881                                 
00882                                 site->cConnsNow += cConns;
00883                         }
00884                 }
00885         }
00886 
00887         }
00888         catch (...) { }
00889 
00890         m_mxBuildConns.Unlock (); 
00891 
00892         try {
00893                 
00894                 if (bUpdateSiteList)
00895                 {
00896                         for (int i = 0; i < _SitesMgr.GetSiteCount (); i++)
00897                                 _SitesMgr.SiteUpdated (_SitesMgr.GetSite (i));
00898                 }
00899         }
00900         catch (...) {}
00901 
00902         LOG ("fsDsM::RSL: done" << nl);
00903 }
00904 BOOL fsDownloadsMgr::OnQueryNewSection(vmsDownloadSmartPtr dld, UINT nUsingMirror)
00905 {
00906         LOG ("Entering DLSM::OnQueryNewSection..." << nl);
00907 
00908         ASSERT (dld->pMgr->GetDownloadMgr () != NULL);
00909         
00910         
00911         if (dld->pMgr->GetDownloadMgr ()->GetDP ()->bIgnoreRestrictions)
00912         {
00913                 LOG ("Exit DLSM::OnQueryNewSection" << nl);
00914                 return TRUE;
00915         }
00916 
00917         EnterCriticalSection (&m_csQSection);
00918         BOOL b = TRUE; 
00919 
00920         fsDownload_NetworkProperties *dnp;
00921         if (nUsingMirror != UINT_MAX)
00922                 dnp = dld->pMgr->GetDownloadMgr ()->GetDownloader ()->MirrorDNP (nUsingMirror);
00923         else
00924                 dnp = dld->pMgr->GetDownloadMgr ()->GetDNP ();
00925 
00926         
00927         if (IsServerFilled (dnp->pszServerName, fsNPToSiteValidFor (dnp->enProtocol)))
00928         {
00929                 Event (dld, LS (L_LIMITREACHED), EDT_WARNING);
00930                 b = FALSE;
00931         }
00932         else if (IsMaxConnsReached ()) 
00933         {
00934                 Event (dld, LS (L_TOTALLIMITREACHED), EDT_WARNING);
00935                 b = FALSE;
00936         }
00937         
00938         if (b == FALSE && dld->bAutoStart == FALSE && dld->pMgr->IsDownloading () == FALSE)
00939                 dld->bAutoStart = TRUE;
00940 
00941         LeaveCriticalSection (&m_csQSection);
00942         LOG ("Exit DLSM::OnQueryNewSection" << nl);
00943         return b;
00944 }
00945 
00946 void fsDownloadsMgr::Event(vmsDownloadSmartPtr dld, LPCSTR pszEvent, fsDownloadMgr_EventDescType enType)
00947 {
00948         OnDownloadDescEventRcvd (dld, enType, pszEvent);
00949 }
00950 
00951 UINT fsDownloadsMgr::GetAmountConnections()
00952 {
00953         UINT nConns = 0;
00954 
00955         try {
00956 
00957         for (int i = _SitesMgr.GetSiteCount () - 1; i >= 0; i--)
00958                 nConns += _SitesMgr.GetSite (i)->cConnsNow;
00959 
00960         }catch (...) {}
00961 
00962         return nConns;
00963 }
00964 
00965 void fsDownloadsMgr::OnSectionStop(vmsDownloadSmartPtr dld)
00966 {
00967         ASSERT (dld->pMgr->GetDownloadMgr () != NULL);
00968 
00969         fsSiteInfo* site = _SitesMgr.FindSite2 (dld->pMgr->GetDownloadMgr ()->GetDNP ()->pszServerName, 
00970                 fsNPToSiteValidFor (dld->pMgr->GetDownloadMgr ()->GetDNP ()->enProtocol));
00971 
00972         if (site)
00973         {
00974                 site->cConnsNow --;     
00975                 _SitesMgr.SiteUpdated (site);
00976         }
00977 
00978         ApplyTrafficLimit ();
00979 }
00980 
00981 void fsDownloadsMgr::ManageTraffic()
00982 {
00983         
00984         
00985         
00986         
00987         
00988         
00989         
00990         
00991         
00992         ApplyTrafficLimit ();
00993 }
00994 
00995 void fsDownloadsMgr::SetTUM(fsTUM tum)
00996 {
00997         m_enUserTUM = m_enTUM = tum;
00998         ResetDldHpManageState ();
00999         ProcessDownloads ();
01000         ApplyTrafficLimit ();
01001 }
01002 
01003 fsTUM fsDownloadsMgr::GetTUM()
01004 {
01005         return m_enTUM;
01006 }
01007 
01008 void fsDownloadsMgr::ApplyTrafficLimit()
01009 {
01010         LOG ("fsDsM::ATL: start" << nl);
01011 
01012     try {
01013 
01014         if (m_vDownloads.size () == 0)
01015         {
01016                 LOG ("fsDsM::ATL: exit [0]" << nl);
01017                 return;
01018         }
01019 
01020         LOG ("fsDsM::ATL: apply bt properties" << nl);  
01021 
01022         if (_BT.is_Initialized ())
01023         {
01024                 _BT.get_Session ()->SetUploadLimit (
01025                         _App.Bittorrent_UploadTrafficLimit (m_enTUM));
01026                 _BT.get_Session ()->SetMaxUploads (
01027                         _App.Bittorrent_UploadConnectionLimit (m_enTUM));
01028         }
01029 
01030         if (m_gabInfo.dld == NULL)
01031         {
01032                 ApplyTrafficLimit_NoHpDld ();
01033         }
01034         else
01035         {
01036                 if (m_gabInfo.dld->pMgr->IsDownloading () == FALSE)
01037                 {
01038                         ResetDldHpManageState ();
01039                         ApplyTrafficLimit_NoHpDld ();
01040                 }
01041                 else
01042                 {
01043                         ApplyTrafficLimit_HasHpDld ();
01044                 }
01045         }
01046 
01047         }
01048         catch (...) {}
01049 
01050         LOG ("fsDsM::ATL: exit" << nl);
01051 }
01052 
01053 void fsDownloadsMgr::StartAllDownloads(BOOL bByUser)
01054 {
01055         DLDS_LIST vDlds;
01056 
01057         try {
01058 
01059         for (size_t i = 0; i < m_vDownloads.size (); i++)
01060         {
01061                 if (m_vDownloads [i]->pMgr->IsDone () == FALSE)
01062                         vDlds.push_back (m_vDownloads [i]);
01063         }
01064 
01065         }
01066         catch (...) {}
01067 
01068         StartDownloads (vDlds, bByUser);
01069 
01070 }
01071 
01072 void fsDownloadsMgr::StopAllDownloads(BOOL bByUser)
01073 {
01074         DLDS_LIST vDlds;
01075 
01076         try {
01077 
01078         for (size_t i = 0; i < m_vDownloads.size (); i++)
01079                 vDlds.push_back (m_vDownloads [i]);
01080 
01081         }
01082         catch (...) {}
01083 
01084         StopDownloads (vDlds, bByUser);
01085 }
01086 
01087 BOOL fsDownloadsMgr::IsSummarySpeedWasLessThan(UINT uSpeed, UINT uTimeInterval)
01088 {
01089         UINT uSize = m_vSummSpeed.size ();      
01090         UINT uNeed = uTimeInterval / 5; 
01091 
01092         if (uSize == 0)
01093                 return FALSE;
01094 
01095         if (uSize < uNeed)
01096                 return FALSE;
01097 
01098         for (UINT i = uSize - 1; i > uSize - uNeed; i--)
01099         {
01100                 
01101                 
01102                 if (m_vSummSpeed [i] >= uSpeed)
01103                                 return FALSE;
01104         }
01105 
01106         return TRUE;
01107 }
01108 
01109 BOOL fsDownloadsMgr::IsRunning()
01110 {
01111         try {
01112         for (int i = m_vDownloads.size () - 1; i >= 0; i--)
01113                 if (m_vDownloads [i]->pMgr->IsRunning ())
01114                         return TRUE;
01115         }
01116         catch (...) {}
01117 
01118         return FALSE;
01119 }
01120 
01121 void fsDownloadsMgr::CheckNoActiveDownloads()
01122 {
01123         if (IsRunning () == FALSE)
01124                 Event ((fsDownload*)NULL, DME_NOACTIVEDOWNLOADS);
01125 }
01126 
01127 vmsDownloadSmartPtr fsDownloadsMgr::GetDownloadByID(UINT nID)
01128 {
01129         try{
01130         for (int i = m_vDownloads.size () - 1; i >= 0; i--)
01131         {
01132                 vmsDownloadSmartPtr dld = m_vDownloads [i];
01133                 if (dld->nID == nID)
01134                         return dld;
01135         }
01136         }catch(...){}
01137 
01138         return NULL;
01139 }
01140 
01141 void fsDownloadsMgr::AllowStartNewDownloads(BOOL bAllow)
01142 {
01143         m_bAllowStart = bAllow;
01144 }
01145 
01146 void fsDownloadsMgr::LockList()
01147 {
01148         m_mxDlList.Lock ();
01149 }
01150 
01151 void fsDownloadsMgr::UnlockList()
01152 {
01153         m_mxDlList.Unlock ();
01154 }
01155 
01156 void fsDownloadsMgr::SaveSettings()
01157 {
01158         _App.Set_TUM (m_aTUM);
01159         _App.TUMManage (m_enTUMManage);
01160         _App.CurrentTUM (m_enUserTUM);
01161         _App.DDR (m_enDDR);
01162         _App.AutoDelCompleted (m_bAutoDelCompleted);
01163         _App.AutosaveInterval (m_uAutosaveInterval);
01164         _App.DetLog (m_bDetLog);
01165 
01166         _App.Avir_Perform (m_bVirCheck);
01167         _App.Avir_Name (m_strVirName);
01168         _App.Avir_Args (m_strVirArgs);
01169         _App.Avir_Exts (m_strVirExts);
01170 }
01171 
01172 void fsDownloadsMgr::ApplyConnectionType(fsConnectionType enCT)
01173 {
01174         switch (enCT)
01175         {
01176                 case CT_MODEM_14_4:
01177                         m_aTUM [TUM_LIGHT].uMaxConns = 1;
01178                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 1;
01179                         m_aTUM [TUM_LIGHT].uTrafficLimit = 200;
01180                         m_aTUM [TUM_LIGHT].uMaxDlds = 1;
01181 
01182                         m_aTUM [TUM_MEDIUM].uMaxConns = 1;
01183                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 1;
01184                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 800;
01185                         m_aTUM [TUM_MEDIUM].uMaxDlds = 1;
01186 
01187                         m_aTUM [TUM_HEAVY].uMaxConns = 3;
01188                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 3;
01189                         m_aTUM [TUM_HEAVY].uMaxDlds = 1;
01190 
01191                         _App.MaxSections (3);
01192                         _App.FileWriteCacheSize (0);
01193                         break;
01194 
01195                 case CT_MODEM_28_8:
01196                         m_aTUM [TUM_LIGHT].uMaxConns = 1;
01197                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 1;
01198                         m_aTUM [TUM_LIGHT].uTrafficLimit = 400;
01199                         m_aTUM [TUM_LIGHT].uMaxDlds = 1;
01200 
01201                         m_aTUM [TUM_MEDIUM].uMaxConns = 2;
01202                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 2;
01203                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 1600;
01204                         m_aTUM [TUM_MEDIUM].uMaxDlds = 1;
01205 
01206                         m_aTUM [TUM_HEAVY].uMaxConns = 4;
01207                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 3;
01208                         m_aTUM [TUM_HEAVY].uMaxDlds = 1;
01209 
01210                         _App.MaxSections (4);
01211                         _App.FileWriteCacheSize (0);
01212                         break;
01213 
01214                 case CT_MODEM_33_6:
01215                         m_aTUM [TUM_LIGHT].uMaxConns = 1;
01216                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 1;
01217                         m_aTUM [TUM_LIGHT].uTrafficLimit = 500;
01218                         m_aTUM [TUM_LIGHT].uMaxDlds = 1;
01219 
01220                         m_aTUM [TUM_MEDIUM].uMaxConns = 2;
01221                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 2;
01222                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 1900;
01223                         m_aTUM [TUM_MEDIUM].uMaxDlds = 1;
01224 
01225                         m_aTUM [TUM_HEAVY].uMaxConns = 8;
01226                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 4;
01227                         m_aTUM [TUM_HEAVY].uMaxDlds = 2;
01228 
01229                         _App.MaxSections (4);
01230                         _App.FileWriteCacheSize (0);
01231                         break;
01232 
01233                 case CT_MODEM_56_ISDN:
01234                         m_aTUM [TUM_LIGHT].uMaxConns = 1;
01235                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 1;
01236                         m_aTUM [TUM_LIGHT].uTrafficLimit = 800;
01237                         m_aTUM [TUM_LIGHT].uMaxDlds = 1;
01238 
01239                         m_aTUM [TUM_MEDIUM].uMaxConns = 4;
01240                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 2;
01241                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 3000;
01242                         m_aTUM [TUM_MEDIUM].uMaxDlds = 1;
01243 
01244                         m_aTUM [TUM_HEAVY].uMaxConns = 8;
01245                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 4;
01246                         m_aTUM [TUM_HEAVY].uMaxDlds = 2;
01247 
01248                         _App.MaxSections (4);
01249                         _App.FileWriteCacheSize (0);
01250                         break;
01251 
01252                 case CT_DUAL_ISDN:
01253                         m_aTUM [TUM_LIGHT].uMaxConns = 4;
01254                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 2;
01255                         m_aTUM [TUM_LIGHT].uTrafficLimit = 3000;
01256                         m_aTUM [TUM_LIGHT].uMaxDlds = 1;
01257 
01258                         m_aTUM [TUM_MEDIUM].uMaxConns = 8;
01259                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 3;
01260                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 7000;
01261                         m_aTUM [TUM_MEDIUM].uMaxDlds = 2;
01262 
01263                         m_aTUM [TUM_HEAVY].uMaxConns = 16;
01264                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 6;
01265                         m_aTUM [TUM_HEAVY].uMaxDlds = 3;
01266 
01267                         _App.MaxSections (4);
01268                         _App.FileWriteCacheSize (0);
01269                         break;
01270 
01271                 case CT_CABLE_DSL_256:
01272                         m_aTUM [TUM_LIGHT].uMaxConns = 6;
01273                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 3;
01274                         m_aTUM [TUM_LIGHT].uTrafficLimit = 6000;
01275                         m_aTUM [TUM_LIGHT].uMaxDlds = 2;
01276 
01277                         m_aTUM [TUM_MEDIUM].uMaxConns = 8;
01278                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 3;
01279                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 20000;
01280                         m_aTUM [TUM_MEDIUM].uMaxDlds = 3;
01281 
01282                         m_aTUM [TUM_HEAVY].uMaxConns = 10;
01283                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 4;
01284                         m_aTUM [TUM_HEAVY].uMaxDlds = 4;
01285 
01286                         _App.MaxSections (5);
01287                         _App.FileWriteCacheSize (0);
01288                         break;
01289 
01290                 case CT_CABLE_DSL_300:
01291                         m_aTUM [TUM_LIGHT].uMaxConns = 6;
01292                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 3;
01293                         m_aTUM [TUM_LIGHT].uTrafficLimit = 8000;
01294                         m_aTUM [TUM_LIGHT].uMaxDlds = 2;
01295 
01296                         m_aTUM [TUM_MEDIUM].uMaxConns = 8;
01297                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 3;
01298                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 25000;
01299                         m_aTUM [TUM_MEDIUM].uMaxDlds = 3;
01300 
01301                         m_aTUM [TUM_HEAVY].uMaxConns = 10;
01302                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 4;
01303                         m_aTUM [TUM_HEAVY].uMaxDlds = 4;
01304 
01305                         _App.MaxSections (5);
01306                         _App.FileWriteCacheSize (0);
01307                         break;
01308 
01309                 case CT_CABLE_DSL_512:
01310                         m_aTUM [TUM_LIGHT].uMaxConns = 6;
01311                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 3;
01312                         m_aTUM [TUM_LIGHT].uTrafficLimit = 20000;
01313                         m_aTUM [TUM_LIGHT].uMaxDlds = 2;
01314 
01315                         m_aTUM [TUM_MEDIUM].uMaxConns = 8;
01316                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 3;
01317                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 45000;
01318                         m_aTUM [TUM_MEDIUM].uMaxDlds = 3;
01319 
01320                         m_aTUM [TUM_HEAVY].uMaxConns = 12;
01321                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 4;
01322                         m_aTUM [TUM_HEAVY].uMaxDlds = 4;
01323 
01324                         _App.MaxSections (5);
01325                         _App.FileWriteCacheSize (1024*1024);
01326                         break;
01327 
01328                 case CT_T1:
01329                         m_aTUM [TUM_LIGHT].uMaxConns = 6;
01330                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 3;
01331                         m_aTUM [TUM_LIGHT].uTrafficLimit = 50000;
01332                         m_aTUM [TUM_LIGHT].uMaxDlds = 3;
01333 
01334                         m_aTUM [TUM_MEDIUM].uMaxConns = 8;
01335                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 3;
01336                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 150000;
01337                         m_aTUM [TUM_MEDIUM].uMaxDlds = 3;
01338 
01339                         m_aTUM [TUM_HEAVY].uMaxConns = 20;
01340                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 10;
01341                         m_aTUM [TUM_HEAVY].uMaxDlds = 4;
01342 
01343                         _App.MaxSections (10);
01344                         _App.FileWriteCacheSize (3*1024*1024);
01345                         break;
01346 
01347                 case CT_LAN_10:
01348                         m_aTUM [TUM_LIGHT].uMaxConns = 12;
01349                         m_aTUM [TUM_LIGHT].uMaxConnsPS = 4;
01350                         m_aTUM [TUM_LIGHT].uTrafficLimit = 100000;
01351                         m_aTUM [TUM_LIGHT].uMaxDlds = 3;
01352 
01353                         m_aTUM [TUM_MEDIUM].uMaxConns = 20;
01354                         m_aTUM [TUM_MEDIUM].uMaxConnsPS = 5;
01355                         m_aTUM [TUM_MEDIUM].uTrafficLimit = 400000;
01356                         m_aTUM [TUM_MEDIUM].uMaxDlds = 4;
01357 
01358                         m_aTUM [TUM_HEAVY].uMaxConns = 60;
01359                         m_aTUM [TUM_HEAVY].uMaxConnsPS = 12;
01360                         m_aTUM [TUM_HEAVY].uMaxDlds = 5;
01361 
01362                         _App.MaxSections (12);
01363                         _App.FileWriteCacheSize (3*1024*1024);
01364                         break;
01365         }
01366 
01367         m_aTUM [TUM_HEAVY].uTrafficLimit = UINT_MAX;
01368 
01369         _App.NOW (enCT);
01370 }
01371 
01372 void fsDownloadsMgr::InitTUM()
01373 {
01374         DWORD dwFlags;
01375 
01376         InternetGetConnectedState (&dwFlags, 0);
01377 
01378         if ( (dwFlags & INTERNET_CONNECTION_MODEM) || (dwFlags & INTERNET_RAS_INSTALLED) )
01379                 ApplyConnectionType (CT_MODEM_56_ISDN);
01380         else if (dwFlags & INTERNET_CONNECTION_LAN)
01381                 ApplyConnectionType (CT_LAN_10);
01382         else
01383                 ApplyConnectionType (CT_CABLE_DSL_256);
01384 }
01385 
01386 BOOL fsDownloadsMgr::IsServerFilled(LPCSTR pszServer, DWORD dwReqProtocols)
01387 {
01388         fsSiteInfo *site = _SitesMgr.FindSite2 (pszServer, dwReqProtocols);
01389 
01390         if (site == NULL)
01391                 return FALSE;
01392 
01393         if (site->cConnsNow >= m_aTUM [m_enTUM].uMaxConnsPS || site->cConnsNow >= site->cMaxConns)
01394                 return TRUE;
01395 
01396         return FALSE;
01397 }
01398 
01399 BOOL fsDownloadsMgr::IsMaxConnsReached()
01400 {
01401         if (GetAmountConnections () >= m_aTUM [m_enTUM].uMaxConns)
01402                 return TRUE;
01403 
01404         return FALSE;
01405 }
01406 
01407 void fsDownloadsMgr::ReadSettings()
01408 {
01409         if (FALSE == _App.Get_TUM (m_aTUM))
01410                 InitTUM ();
01411 
01412         m_aTUM [TUM_HEAVY].uTrafficLimit = UINT_MAX;
01413 
01414         m_enUserTUM = m_enTUM = _App.CurrentTUM ();
01415         m_enTUMManage = _App.TUMManage ();
01416         m_enDDR = _App.DDR ();
01417         m_bAutoDelCompleted = _App.AutoDelCompleted ();
01418         m_uAutosaveInterval = _App.AutosaveInterval ();
01419         m_bDetLog = _App.DetLog ();
01420 
01421         m_bVirCheck = _App.Avir_Perform ();
01422         m_strVirName = _App.Avir_Name ();
01423         m_strVirArgs = _App.Avir_Args ();
01424         m_strVirExts = _App.Avir_Exts ();
01425 
01426         ReadMirrParameters ();
01427         ReadDeletedSettings ();
01428 
01429         m_histmgr.ReadSettings ();
01430 }
01431 
01432 int fsDownloadsMgr::GetRunningDownloadCount()
01433 {
01434         int cRunning = 0;
01435 
01436         try {
01437 
01438                 for (size_t i = 0; i < m_vDownloads.size (); i++)
01439                         if (m_vDownloads [i]->pMgr->IsRunning ())
01440                                 cRunning ++;
01441         }
01442         catch (...) {}
01443 
01444         return cRunning;
01445 }
01446 
01447 void fsDownloadsMgr::_IECatchMgrEvents(fsIECatchMgrEvent ev, LPVOID lp)
01448 {
01449         fsDownloadsMgr *pThis = (fsDownloadsMgr*) lp;
01450 
01451         switch (ev)
01452         {
01453                 case ICME_DLSTARTED:
01454                         switch (pThis->m_enTUMManage)
01455                         {
01456                                 case TM_OFF:
01457                                 return;
01458 
01459                                 case TM_DECREASEBYONELEVEL:
01460                                         switch (pThis->m_enTUM)
01461                                         {
01462                                                 case TUM_HEAVY:
01463                                                         pThis->m_enTUM = TUM_MEDIUM;
01464                                                         break;
01465 
01466                                                 case TUM_MEDIUM:
01467                                                         pThis->m_enTUM = TUM_LIGHT;
01468                                                         break;
01469                                         }
01470                                 break;
01471 
01472                                 case TM_SETTOLIGHT:
01473                                         pThis->m_enTUM = TUM_LIGHT;
01474                                 break;
01475                         }
01476                 break;
01477 
01478                 case ICME_DLCOMPLETED:
01479                         if (pThis->m_enTUM != pThis->m_enUserTUM)
01480                                 pThis->m_enTUM = pThis->m_enUserTUM;
01481                 break;
01482         }
01483 }
01484 
01485 void fsDownloadsMgr::AttachToIECatchMgr(fsIECatchMgr *mgr)
01486 {
01487         mgr->SetEventsFunc (_IECatchMgrEvents, this);
01488 }
01489 
01490 void fsDownloadsMgr::SetTUMManage(fsTUMManage enManage)
01491 {
01492         m_enTUMManage = enManage;
01493         if (enManage == TM_OFF) 
01494         {
01495                 if (m_enTUM != m_enUserTUM)
01496                         m_enTUM = m_enUserTUM; 
01497         }
01498 }
01499 
01500 fsTUMManage fsDownloadsMgr::GetTUMManage()
01501 {
01502         return m_enTUMManage;
01503 }
01504 
01505 BOOL fsDownloadsMgr::IsDeletingNow()
01506 {
01507         return m_bDeletingNow;
01508 }
01509 
01510 void fsDownloadsMgr::UseDetailedLog(BOOL b)
01511 {
01512         m_bDetLog = b;
01513         for (int i = m_vDownloads.size () - 1; i >= 0; i--)
01514                 m_vDownloads [i]->pMgr->UseDetailedLog (b);
01515 }
01516 
01517 int fsDownloadsMgr::DeleteDownloads2(DLDS_LIST *vDlds, BOOL bByUser, BOOL bDontConfirmFileDeleting, BOOL* pbNeedStop, int* piProgress)
01518 {
01519         DLDS_LIST *pvDlds;
01520         fsnew1 (pvDlds, DLDS_LIST);
01521         UINT i = 0;
01522         fsDeleteDownloadReaction enDDR = m_enDDR;
01523 
01524         
01525         if (bDontConfirmFileDeleting && enDDR == DDR_ASK)
01526                 enDDR = DDR_WITHFILE;   
01527 
01528         #ifdef _USELOGGING
01529         if (IsDeletingNow ())
01530                 LOG ("Someone is deleting downloads already..." << nl);
01531         #endif
01532 
01533         
01534         while (IsDeletingNow ())
01535         {
01536                 if (pbNeedStop && *pbNeedStop)
01537                         break;
01538 
01539                 
01540                 MSG msg;
01541                 while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
01542                         DispatchMessage (&msg);
01543 
01544                 Sleep (50);
01545         }
01546 
01547         if (pbNeedStop && *pbNeedStop)
01548                 return 0;
01549 
01550         LOG ("Start deleting..." << nl);
01551 
01552         m_bDeletingNow = TRUE;
01553         m_bDisablePD = TRUE;
01554         LockList ();
01555 
01556         LOG ("list locked, going into loop..." << nl);
01557 
01558         vmsDownloadSmartPtr dldFake;
01559         Download_CreateInstance (dldFake);
01560         dldFake->pMgr->GetDownloadMgr ()->CreateByUrl ("http://localhost/", TRUE);
01561 
01562         DeletedDownloads_UseTmpList (TRUE);
01563 
01564         try {
01565 
01566         _pwndDownloads->set_DontUpdateTIPO (TRUE);
01567 
01568         
01569         std::vector <size_t> vIndexes;
01570         size_t cDlds = vDlds->size ();
01571         size_t nStart = 0;      
01572 
01573         
01574         for (i = 0; i < cDlds; i++)
01575                 vIndexes.push_back ((size_t)-1);
01576 
01577         
01578         for (i = 0; i < m_vDownloads.size (); i++)
01579         {
01580                 vmsDownloadSmartPtr dld = m_vDownloads [i];
01581 
01582                 
01583                 for (size_t j = nStart; j < cDlds; j++)
01584                 {
01585                         if (dld == vDlds->at (j))
01586                         {                               
01587                                 vIndexes [j] = i;
01588 
01589                                 
01590                                 for (size_t k = j; k > nStart && vIndexes [k - 1] != -1; k--)
01591                                         ; 
01592                                 if (k == nStart)
01593                                         nStart = j + 1; 
01594                                 break;
01595                         }
01596                 }
01597         }
01598         
01599 
01600         
01601         BOOL bBypassDeleted = m_bBypassDeleted || bByUser == FALSE || bDontConfirmFileDeleting;
01602 
01603         for (i = 0; i < (UINT)vDlds->size (); i++)
01604         {
01605                 
01606                 
01607                 if (pbNeedStop && *pbNeedStop)
01608                         break;
01609 
01610                 vmsDownloadSmartPtr dld = vDlds->at (i);
01611 
01612                 int iIndex = vIndexes [i];
01613                 if (iIndex == -1) 
01614                         continue;
01615 
01616                 BOOL bDone = dld->pMgr->IsDone ();
01617 
01618                 if (bBypassDeleted && dld->pMgr->IsFileInitializedOnDisk ())
01619                 {
01620                         
01621                         
01622                         if (bDontConfirmFileDeleting || bDone == FALSE)
01623                                 if (FALSE == DeleteDownloadFile (dld, FALSE, enDDR, TRUE))
01624                                         break;
01625                 }
01626 
01627                 if (dld->pdlg)
01628                         Event (dld, DME_CLOSEDLDDIALOG);
01629 
01630                 if (piProgress)
01631                         *piProgress = (int) ((double)i / vDlds->size () * 100);
01632 
01633                 if (dld->pMgr->GetDownloadMgr ())
01634                 {
01635                         dld->pMgr->GetDownloadMgr ()->SetEventDescFunc (NULL, 0);
01636                         dld->pMgr->GetDownloadMgr ()->SetEventFunc (NULL, 0);
01637                 }
01638                 else if (dld->pMgr->GetBtDownloadMgr ())
01639                 {
01640                         dld->pMgr->GetBtDownloadMgr ()->SetEventsHandler (NULL, 0);
01641                 }
01642 
01643                 Event (dld, DME_DOWNLOADWILLBEDELETED);
01644                 
01645                 m_vDownloads [iIndex] = dldFake;
01646                 dld->pGroup->cDownloads--;
01647 
01648                 Event (dld, DME_DOWNLOADWASDELETEDFROMLIST);
01649                 dld->pfnDownloadEventsFunc = NULL;
01650 
01651                 if (FALSE == bBypassDeleted && 
01652                         (m_bBypassCopleted == FALSE || bDone == FALSE))
01653                 {
01654                         dld = PutDownloadToDeleted (dld);
01655                         if (dld && dld->pMgr->IsFileInitializedOnDisk ())
01656                                 DeleteDownloadFile (dld, FALSE, enDDR, TRUE);
01657                 }
01658                 else
01659                 {
01660                         Event (dld, DME_DLDWILLBEFULLYDELETED);
01661                         if ((dld->dwFlags & DLD_DONTPUTTOHISTORY) == 0 && bDone == FALSE)
01662                                 m_histmgr.AddToHistory (dld);
01663                 }
01664                 
01665                 if (dld)
01666                         pvDlds->push_back (dld);
01667         }
01668 
01669         }
01670         catch (...) {}
01671 
01672         int cDeleted = i;
01673 
01674         DeletedDownloads_UseTmpList (FALSE);
01675 
01676         
01677 
01678         DLDS_LIST v;
01679         for (i = 0; i < m_vDownloads.size (); i++)
01680         {
01681                 if (m_vDownloads [i] != dldFake)
01682                         v.push_back (m_vDownloads [i]);
01683         }
01684         m_vDownloads = v;       
01685 
01686         _pwndDownloads->set_DontUpdateTIPO (FALSE);
01687 
01688         LOG ("downloads deleted from list" << nl);
01689 
01690         m_bDeletingNow = FALSE;
01691         m_bDisablePD = FALSE;
01692 
01693         _pwndDownloads->UpdateTrayIconPlusOthers ();
01694         _pwndDownloads->UpdateNumbersOfDownloadsInGroups ();
01695 
01696         if (pvDlds->size ())
01697         {
01698                 DWORD dw;
01699                 CloseHandle (CreateThread (NULL, 0, _threadDeleteDownload, pvDlds, 0, &dw));
01700         }
01701         else
01702         {
01703                 delete pvDlds;
01704         }
01705 
01706         ProcessDownloads ();
01707 
01708         UnlockList ();
01709 
01710         return cDeleted;        
01711 }
01712 
01713 DWORD WINAPI fsDownloadsMgr::_threadWaitDelDlds(LPVOID lp)
01714 {
01715         ProcWaitInfo *info = (ProcWaitInfo*) lp;
01716         DLDS_LIST *vDlds =  (DLDS_LIST*) info->lpParam1;
01717         BOOL bByUser = *((BOOL*) info->lpParam2);
01718         BOOL bDontConfirmFileDeleting = *((BOOL*) info->lpParam3);
01719         int *pcDlds = (int*) info->lpParam4;
01720         fsDownloadsMgr* pThis = (fsDownloadsMgr*) info->lpParam5;
01721 
01722         pThis->Event (NULL, DME_BEGINDELETEMANYDOWNLOADS);
01723         *pcDlds = pThis->DeleteDownloads2 (vDlds, bByUser, bDontConfirmFileDeleting, &info->bNeedStop, &info->iProgress);
01724         pThis->Event (NULL, DME_ENDDELETEMANYDOWNLOADS);
01725 
01726         info->bWaitDone = TRUE;
01727 
01728         return 0;
01729 }
01730 
01731 void fsDownloadsMgr::Download_CloneSettings(vmsDownloadSmartPtr dst, vmsDownloadSmartPtr src)
01732 {
01733         dst->bAutoStart = src->bAutoStart;
01734         dst->dwFlags = src->dwFlags;
01735         dst->dwReserved = src->dwReserved;
01736         dst->strComment = src->strComment;
01737         dst->pGroup = src->pGroup;
01738         if (dst->pMgr && src->pMgr)
01739         {
01740                 ASSERT (dst->pMgr->GetDownloadMgr () != NULL && src->pMgr->GetDownloadMgr () != NULL);
01741                 dst->pMgr->GetDownloadMgr ()->CloneSettings (src->pMgr->GetDownloadMgr ());
01742         }
01743 }
01744 
01745 BOOL fsDownloadsMgr::PerformVirusCheck(vmsDownloadSmartPtr dld, BOOL bCheckExtReqs, BOOL bWaitDone)
01746 {
01747         if (m_strVirName == "")
01748                 return TRUE;
01749 
01750         bool bMultiTorrent = dld->pMgr->GetBtDownloadMgr () != NULL && 
01751                 dld->pMgr->GetBtDownloadMgr ()->get_FileCount () != 1;
01752 
01753         bool bMultiTorrentCheck = bMultiTorrent && bCheckExtReqs;
01754 
01755         int nFiles = bMultiTorrentCheck ? dld->pMgr->GetBtDownloadMgr ()->get_FileCount () : 1;
01756 
01757         fsString strFile;
01758 
01759         for (int i = 0; i < nFiles; i++)
01760         {
01761                 char szFile [MY_MAX_PATH];
01762                 
01763                 if (bMultiTorrentCheck)
01764                         strFile = dld->pMgr->GetBtDownloadMgr ()->get_OutputFilePathName (i);
01765                 else
01766                         strFile = dld->pMgr->get_OutputFilePathName ();
01767 
01768                 fsGetFileName (strFile, szFile);
01769 
01770                 if (bCheckExtReqs)
01771                 {
01772                         char *pszExt = strrchr (strFile, '.');
01773 
01774                         
01775                         if (pszExt && IsExtInExtsStr (m_strVirExts, pszExt+1))
01776                                 break;  
01777                 }
01778                 else
01779                         break;
01780         }
01781         if (i == nFiles)
01782                 return TRUE; 
01783 
01784         
01785         
01786 
01787         Event (dld, LS (L_LAUNCHAVIR), EDT_INQUIRY);
01788         
01789         CString strArgs = m_strVirArgs;
01790         CString str = '"'; str += strFile; str += '"';
01791         strArgs.Replace ("%file%", str);
01792 
01793         if (bWaitDone == FALSE)
01794         {
01795                 DWORD dwErr = (DWORD) ShellExecute (HWND_DESKTOP, "open", m_strVirName, strArgs, NULL, SW_SHOW);
01796                 if (dwErr <= 32)
01797                 {
01798                         SetLastError (dwErr);
01799                         goto _lErr;
01800                 }       
01801         }
01802         else
01803         {
01804                 STARTUPINFO si;
01805                 PROCESS_INFORMATION pi;
01806 
01807                 ZeroMemory (&si, sizeof (si));
01808                 si.cb = sizeof (si);
01809                 ZeroMemory (&pi, sizeof (pi));
01810 
01811                 fsString str = m_strVirName;
01812                 if (strchr (str, '\\') == NULL && strchr (str, '/') == NULL)
01813                         str = vmsRegisteredApp::GetFullPath (str);
01814 
01815                 if (FALSE == CreateProcess (str, (LPSTR)(LPCSTR)strArgs, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
01816                         goto _lErr;
01817 
01818                 WaitForSingleObject (pi.hProcess, 30*1000);
01819         }
01820 
01821         Event (dld, LS (L_SUCCESS), EDT_RESPONSE_S);
01822         return TRUE;
01823 
01824 _lErr:
01825         CHAR szErr [1000]; DWORD dwErr = GetLastError ();
01826         fsErrorToStr (szErr, sizeof (szErr), &dwErr);
01827         Event (dld, szErr, EDT_RESPONSE_E);
01828         return FALSE;
01829 }
01830 
01831 void fsDownloadsMgr::Apply_MirrParameters()
01832 {
01833         for (size_t i = 0; i < m_vDownloads.size (); i++)
01834         {
01835                 vmsDownloadSmartPtr dld = m_vDownloads [i];
01836                 if (dld->pMgr->GetDownloadMgr () != NULL)
01837                         Apply_MirrParameters (dld);
01838         }
01839 }
01840 
01841 void fsDownloadsMgr::ReadMirrParameters()
01842 {
01843         m_bMirrAutoSearch = _App.Mirr_AutoSearch ();
01844         m_uMirrFileMinSize = _App.Mirr_FileMinSize ();
01845         m_bMirrCalcSpeed = _App.Mirr_CalcSpeed ();
01846         m_cMaxMirrs = _App.Mirr_MaxCount ();
01847         m_uMirrRecalcSpeedTime = _App.Mirr_RecalcSpeedTime ();
01848         m_bMirrDontSearchIfSizeUnk = _App.Mirr_DontSearchIfSizeUnk ();
01849 }
01850 
01851 void fsDownloadsMgr::Apply_MirrParameters(vmsDownloadSmartPtr dld)
01852 {
01853         ASSERT (dld->pMgr->GetDownloadMgr () != NULL);
01854 
01855         fsInternetDownloader *dldr = dld->pMgr->GetDownloadMgr ()->GetDownloader ();
01856 
01857         if ((dld->dwFlags & DLD_DONTUSEMIRRORS) == 0)
01858         {
01859                 dldr->Set_SearchForMirrors (m_bMirrAutoSearch);
01860                 dldr->Set_MirrDontSearchIfSizeUnk (m_bMirrDontSearchIfSizeUnk);
01861                 dldr->Set_MirrFileMinSize (m_uMirrFileMinSize);
01862         }
01863         else
01864                 dldr->Set_SearchForMirrors (FALSE);
01865 
01866         dldr->Set_MirrCalcSpeed (m_bMirrCalcSpeed);
01867         dldr->Set_MirrMaxCount (m_cMaxMirrs);
01868         dld->pMgr->GetDownloadMgr ()->Set_MirrRecalcSpeedTime (m_uMirrRecalcSpeedTime);
01869 }
01870 
01871 DWORD fsDownloadsMgr::OnBeforeDownload(vmsDownloadSmartPtr dld)
01872 {
01873         BOOL bOK = TRUE;
01874 
01875         ASSERT (dld->pMgr->GetDownloadMgr ());
01876 
01877         if (dld->dwFlags & DLD_CTREQ_HTML)
01878         {
01879                 LPCSTR pszType = dld->pMgr->GetDownloadMgr ()->GetDownloader ()->GetContentType ();
01880 
01881                 if(strstr (pszType, "html") == NULL)
01882                         bOK = FALSE;
01883         }
01884 
01885         if (bOK && dld->pfnDownloadEventsFunc && (dld->dwFlags & DLD_NOTIFYBEFOREDOWNLOAD))
01886                 bOK = dld->pfnDownloadEventsFunc (dld, DME_BEFOREDOWNLOADING, dld->lpEventsParam);
01887 
01888         if (bOK == FALSE)
01889         {
01890                 DLDS_LIST vpDlds;
01891                 vpDlds.push_back (dld);
01892                 DeleteDownloads (vpDlds, FALSE, TRUE);
01893         }
01894 
01895         return bOK;
01896 }
01897 
01898 int fsDownloadsMgr::Get_DeletedDownloadCount()
01899 {
01900         return m_vDeletedDownloads.size () ? 
01901                 m_vDeletedDownloads.size () : m_vDeletedDownloads_tmp.size ();
01902 }
01903 
01904 vmsDownloadSmartPtr fsDownloadsMgr::Get_DeletedDownload(int iIndex)
01905 {
01906         if (m_vDeletedDownloads.size ()) 
01907         {
01908                 return m_vDeletedDownloads [iIndex];
01909         }
01910         else
01911         {
01912                 std::list <vmsDownloadSmartPtr>::iterator iter = m_vDeletedDownloads_tmp.begin ();
01913                 while (iIndex--)
01914                         iter++;
01915                 return *iter;
01916         }
01917 }
01918 
01919 void fsDownloadsMgr::ReadDeletedSettings()
01920 {
01921         ASSERT (m_vDeletedDownloads_tmp.size () == 0);
01922 
01923         m_bBypassDeleted = _App.Deleted_Bypass ();
01924         m_cMaxDeleted = _App.Deleted_MaxCount ();
01925         m_bBypassCopleted = _App.Deleted_BypassCompleted ();
01926 
01927         DLDS_LIST v;
01928 
01929         if (m_bBypassDeleted)
01930         {
01931                 v = m_vDeletedDownloads;
01932         }
01933         else if (UINT (m_vDeletedDownloads.size ()) > m_cMaxDeleted)
01934         {
01935                 for (size_t i = m_cMaxDeleted; i < m_vDeletedDownloads.size (); i++)
01936                         v.push_back (m_vDeletedDownloads [i]);
01937         }
01938 
01939         if (v.size ())
01940                 DeleteDeletedDownloads (v, TRUE);
01941 }
01942 
01943 vmsDownloadSmartPtr fsDownloadsMgr::PutDownloadToDeleted(vmsDownloadSmartPtr dld)
01944 {
01945         ASSERT (m_vDeletedDownloads.size () == 0);
01946 
01947         dld->pMgr->StopDownloading ();
01948         m_vDeletedDownloads_tmp.insert (m_vDeletedDownloads_tmp.begin (), dld);
01949         Event (dld, DME_DLDADDEDTODELETED);
01950 
01951         vmsDownloadSmartPtr ret;
01952 
01953         UINT sz = m_vDeletedDownloads_tmp.size ();
01954         if (sz > m_cMaxDeleted)
01955         {
01956                 std::list <vmsDownloadSmartPtr>::iterator it = m_vDeletedDownloads_tmp.end ();
01957                 it--;
01958                 ret = *it;
01959                 m_vDeletedDownloads_tmp.erase (it);
01960                 Event (ret, DME_DLDREMOVEDFROMDELETED);
01961                 Event (ret, DME_DLDWILLBEFULLYDELETED);
01962                 if ((ret->dwFlags & DLD_DONTPUTTOHISTORY) == 0 &&
01963                                 ret->pMgr->IsDone () == FALSE)
01964                         m_histmgr.AddToHistory (ret);
01965         }
01966 
01967         return ret;
01968 }
01969 
01970 BOOL fsDownloadsMgr::DeleteDownloadFile(vmsDownloadSmartPtr dld, BOOL bNoCancel, fsDeleteDownloadReaction &enDoDDR, BOOL bDownloadWillBeDeletedAlso)
01971 {
01972         fsDeleteDownloadReaction enDDR = enDoDDR;
01973         
01974         if (dld->dwFlags & DLD_DELETEFILEALWAYS)
01975                 enDDR = DDR_WITHFILE;
01976 
01977         if (enDDR == DDR_ASK)
01978         {
01979                 LOG ("asking user permission for deleting this download..." << nl);
01980 
01981                 CDDRDlg dlg;
01982                 dlg.m_bNoCancel = bNoCancel;
01983                 if (dld->pMgr->GetDownloadMgr ())
01984                         dlg.m_strUrl = dld->pMgr->get_URL ();
01985                 else if (dld->pMgr->GetBtDownloadMgr ())
01986                         dlg.m_strUrl = dld->pMgr->GetBtDownloadMgr ()->get_TorrentName ();
01987                 if (IDCANCEL == dlg.DoModal ())
01988                 {
01989                         LOG ("user has declined that" << nl);
01990                         return FALSE;
01991                 }
01992 
01993                 LOG ("user has approved" << nl);
01994                 
01995                 if (dlg.m_bDontAskAgain) m_enDDR = enDoDDR = dlg.m_enDDR;
01996                 if (dlg.m_bForAll) enDoDDR = dlg.m_enDDR;
01997                 enDDR = dlg.m_enDDR;
01998         }
01999                 
02000         if (enDDR == DDR_WITHFILE)
02001         {
02002                 LOG ("deleting file..." << nl);
02003 
02004                 if (dld->pMgr->GetDownloadMgr ())
02005                 {
02006                         dld->pMgr->GetDownloadMgr ()->SetEventDescFunc (NULL, 0);
02007                         dld->pMgr->GetDownloadMgr ()->SetEventFunc (NULL, 0);
02008                         dld->pMgr->GetDownloadMgr ()->CloseFile ();
02009                 }
02010                 else if (dld->pMgr->GetBtDownloadMgr ())
02011                 {
02012                         dld->pMgr->GetBtDownloadMgr ()->SetEventsHandler (NULL, 0);
02013                 }
02014                 
02015                 Event (dld, DME_DOWNLOADFILEWILLBEDELETED);
02016                 if (FALSE == dld->pMgr->DeleteFile ())
02017                 {
02018                         LOG ("can't delete" << nl);
02019                         MessageBox (NULL, LS (L_CANTDELETE), LS (L_ERR), MB_ICONERROR);
02020                 }
02021 
02022                 LOG ("file deleted" << nl);
02023         }
02024         
02025         return TRUE;
02026 }
02027 
02028 void fsDownloadsMgr::ClearDeleted()
02029 {
02030         ASSERT (m_vDeletedDownloads_tmp.size () == 0);
02031 
02032         if (m_vDeletedDownloads.size () == 0)
02033                 return;
02034 
02035         DLDS_LIST v;
02036 
02037         v = m_vDeletedDownloads;
02038 
02039         DeleteDeletedDownloads (v, FALSE);
02040 }
02041 
02042 int fsDownloadsMgr::DeleteDeletedDownloads(DLDS_LIST &vDlds, BOOL bNoCancel)
02043 {
02044         size_t cMaxDlds = 40;
02045 
02046         
02047         
02048         if (vDlds.size () < cMaxDlds)
02049                 return DeleteDeletedDownloads2 (&vDlds, bNoCancel, NULL, NULL);
02050 
02051         
02052 
02053         int iDeleted = 0;
02054         
02055         CWaitDlg dlg;
02056         dlg.StartWaiting (LS (L_DELETINGDLDS), _threadWaitDelDeletingsDlds, TRUE, &vDlds, &bNoCancel, &iDeleted, this);
02057 
02058         return iDeleted;
02059 }
02060 
02061 int fsDownloadsMgr::DeleteDeletedDownloads2(DLDS_LIST *vDlds, BOOL bNoCancel, BOOL* pbNeedStop, int* piProgress)
02062 {
02063         DLDS_LIST *pvDlds;
02064         fsnew1 (pvDlds, DLDS_LIST);
02065         UINT i = 0;
02066         fsDeleteDownloadReaction enDDR = m_enDDR;
02067 
02068         #ifdef _USELOGGING
02069         if (IsDeletingDeletedNow ())
02070                 LOG ("Someone is deleting downloads already..." << nl);
02071         #endif
02072 
02073         
02074         while (IsDeletingDeletedNow ())
02075         {
02076                 if (pbNeedStop && *pbNeedStop)
02077                         break;
02078 
02079                 
02080                 MSG msg;
02081                 while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
02082                         DispatchMessage (&msg);
02083 
02084                 Sleep (50);
02085         }
02086 
02087         if (pbNeedStop && *pbNeedStop)
02088                 return 0;
02089 
02090         m_bDeletingDeletedNow = TRUE;
02091 
02092         vmsDownloadSmartPtr dldFake;
02093         Download_CreateInstance (dldFake);
02094         dldFake->pMgr->GetDownloadMgr ()->CreateByUrl ("http://localhost/", TRUE);
02095 
02096         try {
02097 
02098         ASSERT (m_vDeletedDownloads.size () != 0);
02099 
02100         
02101         std::vector <size_t> vIndexes;
02102         size_t cDlds = vDlds->size ();
02103         size_t nStart = 0;      
02104         
02105 
02106         for (i = 0; i < cDlds; i++)
02107                 vIndexes.push_back ((size_t)-1);
02108 
02109         for (i = 0; i < m_vDeletedDownloads.size (); i++)
02110         {
02111                 vmsDownloadSmartPtr dld = m_vDeletedDownloads [i];
02112 
02113                 for (size_t j = nStart; j < cDlds; j++)
02114                 {
02115                         if (dld == vDlds->at (j))
02116                         {                               
02117                                 vIndexes [j] = i;
02118 
02119                                 for (size_t k = j; k > nStart && vIndexes [k - 1] != -1; k--)
02120                                         ;
02121                                 if (k == nStart)
02122                                         nStart = j + 1;
02123                                 break;
02124                         }
02125                 }
02126 
02127         }
02128         
02129 
02130         for (i = 0; i < (UINT)vDlds->size (); i++)
02131         {
02132                 
02133                 
02134                 if (pbNeedStop && *pbNeedStop)
02135                         break;
02136 
02137                 vmsDownloadSmartPtr dld = vDlds->at (i);
02138 
02139                 int iIndex = vIndexes [i];
02140                 if (iIndex == -1)
02141                         continue;
02142 
02143                 if (dld->pMgr->IsDone () == FALSE && dld->pMgr->IsFileInitializedOnDisk ())
02144                 {
02145                         if (FALSE == DeleteDownloadFile (dld, bNoCancel, enDDR, TRUE))
02146                                 break;
02147                 }
02148 
02149                 if (piProgress)
02150                         *piProgress = (int) ((double)i / vDlds->size () * 100);
02151 
02152                 Event (dld, DME_DLDWILLBEFULLYDELETED);
02153                 if ((dld->dwFlags & DLD_DONTPUTTOHISTORY) == 0 &&
02154                                 dld->pMgr->IsDone () == FALSE)
02155                         m_histmgr.AddToHistory (dld);
02156 
02157                 m_vDeletedDownloads [iIndex] = dldFake;
02158 
02159                 Event (dld, DME_DLDREMOVEDFROMDELETED);
02160                         
02161                 pvDlds->push_back (dld);
02162         }
02163 
02164         }
02165         catch (...) {}
02166 
02167         int cDeleted = i;
02168 
02169         DLDS_LIST v;
02170         for (i = 0; i < m_vDeletedDownloads.size (); i++)
02171         {
02172                 if (m_vDeletedDownloads [i] != dldFake)
02173                         v.push_back (m_vDeletedDownloads [i]);
02174         }
02175         m_vDeletedDownloads = v;        
02176 
02177         Event (NULL, DME_RECYCLEBINCONTENTCHANGED);
02178 
02179         m_bDeletingDeletedNow = FALSE;
02180 
02181         if (pvDlds->size ())
02182         {
02183                 DWORD dw;
02184                 CloseHandle (CreateThread (NULL, 0, _threadDeleteDownload, pvDlds, 0, &dw));
02185         }
02186         else
02187         {
02188                 delete pvDlds;
02189         }
02190 
02191         return cDeleted;        
02192 }
02193 
02194 BOOL fsDownloadsMgr::IsDeletingDeletedNow()
02195 {
02196         return m_bDeletingDeletedNow;
02197 }
02198 
02199 int fsDownloadsMgr::GetDeletedDownloadIndex(vmsDownloadSmartPtr dld)
02200 {
02201         for (size_t i = 0; i < m_vDeletedDownloads.size (); i++)
02202         {
02203                 if (m_vDeletedDownloads [i] == dld)
02204                         return i;
02205         }
02206 
02207         return -1;
02208 }
02209 
02210 DWORD WINAPI fsDownloadsMgr::_threadWaitDelDeletingsDlds(LPVOID lp)
02211 {
02212         ProcWaitInfo *info = (ProcWaitInfo*) lp;
02213         DLDS_LIST *vDlds =  (DLDS_LIST*) info->lpParam1;
02214         BOOL bNoCancel = *(BOOL*) info->lpParam2;
02215         int *pcDlds = (int*) info->lpParam3;
02216         fsDownloadsMgr* pThis = (fsDownloadsMgr*) info->lpParam4;
02217 
02218         *pcDlds = pThis->DeleteDeletedDownloads2 (vDlds, bNoCancel, &info->bNeedStop, &info->iProgress);
02219 
02220         info->bWaitDone = TRUE;
02221 
02222         return 0;
02223 }
02224 
02225 int fsDownloadsMgr::RestoreDownloads(DLDS_LIST &vDlds)
02226 {
02227         size_t cMaxDlds = 40;
02228 
02229         if (vDlds.size () < cMaxDlds)
02230                 return RestoreDownloads2 (&vDlds, NULL, NULL);
02231 
02232         
02233 
02234         int iRestored = 0;
02235         
02236         CWaitDlg dlg;
02237         dlg.StartWaiting (LS (L_RESTORINGDLDS), _threadWaitRestoringDlds, TRUE, &vDlds, &iRestored, this);
02238 
02239         return iRestored;
02240 }
02241 
02242 int fsDownloadsMgr::RestoreDownloads2(DLDS_LIST* vDlds, BOOL *pbNeedStop, int *piProgress)
02243 {
02244         UINT i = 0;
02245 
02246         
02247         while (IsRestoringNow ())
02248         {
02249                 if (pbNeedStop && *pbNeedStop)
02250                         break;
02251 
02252                 
02253                 MSG msg;
02254                 while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
02255                         DispatchMessage (&msg);
02256 
02257                 Sleep (50);
02258         }
02259 
02260         if (pbNeedStop && *pbNeedStop)
02261                 return 0;
02262 
02263         m_bRestoringNow = TRUE;
02264 
02265         vmsDownloadSmartPtr dldFake;
02266         Download_CreateInstance (dldFake);
02267         dldFake->pMgr->GetDownloadMgr ()->CreateByUrl ("http://localhost/", TRUE);
02268 
02269         try {
02270 
02271         ASSERT (m_vDeletedDownloads.size () != 0);
02272 
02273         
02274         std::vector <size_t> vIndexes;
02275         size_t cDlds = vDlds->size ();
02276         size_t nStart = 0;      
02277         
02278 
02279         for (i = 0; i < cDlds; i++)
02280                 vIndexes.push_back ((size_t)-1);
02281 
02282         for (i = 0; i < m_vDeletedDownloads.size (); i++)
02283         {
02284                 vmsDownloadSmartPtr dld = m_vDeletedDownloads [i];
02285 
02286                 for (size_t j = nStart; j < cDlds; j++)
02287                 {
02288                         if (dld == vDlds->at (j))
02289                         {                               
02290                                 vIndexes [j] = i;
02291 
02292                                 for (size_t k = j; k > nStart && vIndexes [k - 1] != -1; k--)
02293                                         ;
02294                                 if (k == nStart)
02295                                         nStart = j + 1;
02296                                 break;
02297                         }
02298                 }
02299 
02300         }
02301         
02302 
02303         for (i = 0; i < (UINT)vDlds->size (); i++)
02304         {
02305                 
02306                 
02307                 if (pbNeedStop && *pbNeedStop)
02308                         break;
02309 
02310                 vmsDownloadSmartPtr dld = vDlds->at (i);
02311 
02312                 int iIndex = vIndexes [i];
02313                 if (iIndex == -1)
02314                         continue;
02315 
02316                 if (dld->pGroup->bAboutToBeDeleted)
02317                         dld->pGroup = _DldsGrps.FindGroup (GRP_OTHER_ID);
02318 
02319                 m_vDeletedDownloads [iIndex] = dldFake;
02320                 Event (dld, DME_DLDREMOVEDFROMDELETED);
02321 
02322                 Add (dld, TRUE);
02323                 if (dld->dwFlags & DLD_FLASH_VIDEO)
02324                         _pwndFVDownloads->AddDownload (dld);
02325 
02326                 Event (dld, DME_DLDRESTORED);
02327 
02328                 if (piProgress)
02329                         *piProgress = (int) ((double)i / vDlds->size () * 100);
02330         }
02331 
02332         }
02333         catch (...) {}
02334 
02335         int cRestored = i;
02336 
02337         DLDS_LIST v;
02338         for (i = 0; i < m_vDeletedDownloads.size (); i++)
02339         {
02340                 if (m_vDeletedDownloads [i] != dldFake)
02341                         v.push_back (m_vDeletedDownloads [i]);
02342         }
02343         m_vDeletedDownloads = v;        
02344 
02345         Event (NULL, DME_RECYCLEBINCONTENTCHANGED);
02346 
02347         m_bRestoringNow = FALSE;
02348 
02349         if (cRestored)
02350                 ProcessDownloads ();
02351 
02352         return cRestored;       
02353 }
02354 
02355 BOOL fsDownloadsMgr::IsRestoringNow()
02356 {
02357         return m_bRestoringNow;
02358 }
02359 
02360 DWORD WINAPI fsDownloadsMgr::_threadWaitRestoringDlds(LPVOID lp)
02361 {
02362         ProcWaitInfo *info = (ProcWaitInfo*) lp;
02363         DLDS_LIST *vDlds =  (DLDS_LIST*) info->lpParam1;
02364         int *pcDlds = (int*) info->lpParam2;
02365         fsDownloadsMgr* pThis = (fsDownloadsMgr*) info->lpParam3;
02366 
02367         *pcDlds = pThis->RestoreDownloads2 (vDlds, &info->bNeedStop, &info->iProgress);
02368 
02369         info->bWaitDone = TRUE;
02370 
02371         return 0;
02372 }
02373 
02374 void fsDownloadsMgr::_HistoryMgrEvents(fsDownloadsHistoryMgrEvent ev, int info, LPVOID lp)
02375 {
02376         fsDownloadsMgr* pThis = (fsDownloadsMgr*) lp;
02377         fsDLHistoryRecord* rec = (fsDLHistoryRecord*) info;
02378 
02379         switch (ev)
02380         {
02381                 case DHME_RECORDADDED:
02382                         pThis->Event (rec, DME_RECADDEDTOHISTORY);
02383                         break;
02384 
02385                 case DHME_RECORDDELETED:
02386                         pThis->Event (rec, DME_RECDELETEDFROMHISTORY);
02387                         break;
02388 
02389                 case DHME_HISTORYCLEARED:
02390                         pThis->Event (rec, DME_HISTORYCLEARED);
02391                         break;
02392         }
02393 }
02394 
02395 void fsDownloadsMgr::Event(fsDLHistoryRecord *rec, fsDownloadsMgrEvent ev)
02396 {
02397         if (m_pfnEvents)
02398                 m_pfnEvents ((fsDownload*)rec, ev, m_lpEventsParam);
02399 }
02400 
02401 struct _threadArchiveDetectedInfo
02402 {
02403         fsArchiveRebuilder *ar;
02404         BOOL* pbRes;
02405 };
02406 
02407 DWORD fsDownloadsMgr::OnArchiveDetected(vmsDownloadSmartPtr dld, fsArchiveRebuilder *ar)
02408 {
02409         BOOL b;
02410         UIThread *thr = (UIThread*) RUNTIME_CLASS (UIThread)->CreateObject ();
02411         _threadArchiveDetectedInfo inf;
02412         inf.ar = ar; inf.pbRes = &b;
02413         thr->set_Thread (_threadArchiveDetected, &inf);
02414         thr->CreateThread ();
02415         WaitForSingleObject (thr->m_hThread, INFINITE);
02416 
02417         if (b == FALSE)
02418                 dld->bAutoStart = FALSE;
02419 
02420         return b;
02421 }
02422 
02423 void fsDownloadsMgr::MoveDownloadToEndOfList(vmsDownloadSmartPtr dld)
02424 {
02425         int iIndex = GetDownloadIndex (dld);
02426         if (iIndex != -1)
02427         {
02428                 LockList ();
02429                 DownloadsList_Del (iIndex);
02430                 DownloadsList_Add (dld);
02431                 UnlockList ();
02432         }
02433 }
02434 
02435 DWORD WINAPI fsDownloadsMgr::_threadConfirmZIP(LPVOID lp)
02436 {
02437         CWaitForConfirmationDlg dlg;
02438         UINT* pnRes = (UINT*) lp;
02439 
02440         dlg.Init (LS (L_ZIPDETECTED), 30, TRUE, TRUE, LS (L_DONTPREVIEWINFUTURE), LS (L_YOUTURNEDOFFPREVIEW));
02441 
02442         *pnRes = _DlgMgr.DoModal (&dlg) == IDOK;
02443 
02444         if (dlg.m_bDontAsk)
02445                 _App.NewDL_UseZIPPreview (FALSE);
02446 
02447         return 0;
02448 }
02449 
02450 DWORD WINAPI fsDownloadsMgr::_threadArchiveDetected(LPVOID lp)
02451 {
02452         CZipPreviewDlg dlg;
02453         _threadArchiveDetectedInfo* inf = (_threadArchiveDetectedInfo*) lp;
02454 
02455         dlg.m_ar = inf->ar;
02456         *inf->pbRes = _DlgMgr.DoModal (&dlg) == IDOK;
02457 
02458         return 0;
02459 }
02460 
02461 void fsDownloadsMgr::Initialize()
02462 {
02463         ReadSettings ();
02464 
02465         InterlockedIncrement (&m_cThreadsRunning);
02466         
02467         DWORD dw;
02468         CloseHandle (
02469                 CreateThread (NULL, 0, _threadDownloadsMgr, this, 0, &dw));
02470 }
02471 
02472 void fsDownloadsMgr::LaunchDownload(vmsDownloadSmartPtr dld, UINT nWaitForConfirmation)
02473 {
02474         if (nWaitForConfirmation != 0)
02475         {
02476                 CWaitForConfirmationDlg dlg;
02477                 char szFile [MY_MAX_PATH];
02478                 if (dld->pMgr->GetDownloadMgr ())
02479                         fsGetFileName (dld->pMgr->get_OutputFilePathName (), szFile);
02480                 else if (dld->pMgr->GetBtDownloadMgr ())
02481                         lstrcpy (szFile, dld->pMgr->GetBtDownloadMgr ()->get_TorrentName ());
02482                 CString strMsg = "\""; strMsg += szFile; strMsg += "\" ";
02483                 if (dld->strComment != "") {
02484                         strMsg += '('; strMsg += dld->strComment; strMsg += ") ";
02485                 }
02486                 strMsg += LS (L_WASSCHEDULEDTOLAUNCH); strMsg += "\n";
02487                 strMsg += LS (L_DOYOUWANTTOLAUNCHIT);
02488                 dlg.Init (strMsg, nWaitForConfirmation);
02489                 if (IDCANCEL == dlg.DoModal ())
02490                         return;
02491         }
02492 
02493         CString strFileName = dld->pMgr->get_OutputFilePathName ();
02494         if (dld->pMgr->IsBittorrent ())
02495                 strFileName += dld->pMgr->GetBtDownloadMgr ()->get_RootFolderName ();
02496 
02497         ShellExecute (::GetDesktopWindow (), "open", strFileName, NULL, NULL, SW_SHOW);
02498 }
02499 
02500 void fsDownloadsMgr::Shutdown()
02501 {
02502         m_bNeedExit = TRUE;
02503         while (m_cThreadsRunning)
02504                 Sleep (10);
02505 
02506         if (_BT.is_Initialized ())
02507                 _BT.get_Session ()->set_EventsHandler (NULL, NULL);
02508         
02509         m_vDownloads.clear ();
02510 
02511         if (_BT.is_Initialized ())
02512                 _BT.Shutdown ();
02513 
02514         DeleteCriticalSection (&m_csQSection);
02515         
02516         DeleteCriticalSection (&m_csSave);
02517 }
02518 
02519 void fsDownloadsMgr::ApplyAER(fsAlreadyExistReaction enAER)
02520 {
02521         LockList ();
02522         for (int i = m_vDownloads.size () - 1; i >= 0; i--)
02523         {
02524                 if (m_vDownloads [i]->pMgr->GetDownloadMgr () != NULL)
02525                         m_vDownloads [i]->pMgr->GetDownloadMgr ()->GetDP ()->enAER = enAER;
02526         }
02527         UnlockList ();
02528 }
02529 
02530 BOOL fsDownloadsMgr::GenerateDescriptionFile(vmsDownloadSmartPtr dld)
02531 {
02532         if (dld->strComment.GetLength () == 0)
02533                 return FALSE;
02534 
02535         CString str = dld->strComment;
02536         str.Replace ("\r", "");
02537 
02538         str += "\n\n"; str += LS (L_THISFILEWASDLDEDFROM); str += ":\n";
02539         if (dld->pMgr->GetDownloadMgr ())
02540         {
02541                 str += dld->pMgr->get_URL ();
02542         }
02543         else if (dld->pMgr->GetBtDownloadMgr ())
02544         {
02545                 str += dld->pMgr->GetBtDownloadMgr ()->get_TorrentName ();
02546                 str += " (";
02547                 str += dld->pMgr->get_URL ();
02548                 str += ")";
02549         }
02550 
02551         str += "\n\n"; str += LS (L_DATE); str += ": ";
02552         
02553         FILETIME time;
02554         SYSTEMTIME systime;
02555         GetLocalTime (&systime);
02556         SystemTimeToFileTime (&systime, &time);
02557 
02558         char szDate [1000], szTime [1000];
02559         FileTimeToStr (&time, szDate, szTime, FALSE);
02560         str += szDate; str += ", "; str += szTime;
02561 
02562         CStdioFile file;
02563         CString strName = dld->pMgr->get_OutputFilePathName ();
02564         if (dld->pMgr->GetBtDownloadMgr () != NULL && 
02565                         dld->pMgr->GetBtDownloadMgr ()->get_FileCount () != 1)
02566         {
02567                 strName += "\\"; 
02568                 strName += dld->pMgr->GetBtDownloadMgr ()->get_TorrentName ();
02569         }
02570         strName += ".dsc.txt";
02571 
02572         file.Open (strName, CFile::typeText | CFile::modeCreate | CFile::modeWrite);
02573         file.WriteString (str);
02574         file.Close ();
02575 
02576         return TRUE;
02577 }
02578 
02579 BOOL fsDownloadsMgr::LoadStateInformation()
02580 {
02581         CString strFileName = fsGetDataFilePath ("dlmgrsi.sav");
02582 
02583         if (GetFileAttributes (strFileName) == DWORD (-1))
02584                 return TRUE;
02585 
02586         HANDLE hFile  = CreateFile (strFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
02587                 0, NULL);
02588 
02589         if (hFile == INVALID_HANDLE_VALUE)
02590                 return FALSE;
02591 
02592         DWORD dw;
02593 
02594         fsStateInfoFileHdr hdr;
02595         if (FALSE == ReadFile (hFile, &hdr, sizeof (hdr), &dw, NULL))
02596         {
02597                 CloseHandle (hFile);
02598                 return FALSE;
02599         }
02600 
02601         BOOL bOldFormat = FALSE;
02602 
02603         if (strncmp (hdr.szSig, DLMGRFILE_SIG, sizeof (DLMGRFILE_SIG)))
02604         {
02605                 
02606                 
02607                 bOldFormat = TRUE;
02608                 SetFilePointer (hFile, 0, NULL, FILE_BEGIN);
02609         }
02610 
02611         UINT u;
02612         if (FALSE == ReadFile (hFile, &u, sizeof (u), &dw, NULL))
02613         {
02614                 CloseHandle (hFile);
02615                 return FALSE;
02616         }
02617 
02618         m_nID = u;
02619 
02620         if (bOldFormat)
02621         {
02622                 vmsStringRecentList vFilePathes;
02623                 if (FALSE == vFilePathes.Load (hFile))
02624                 {
02625                         CloseHandle (hFile);
02626                         return FALSE;
02627                 }
02628 
02629                 for (int i = 0; i < vFilePathes.get_Count (); i++)
02630                 {
02631                         char sz [MY_MAX_PATH] = "";
02632                         fsGetFileName (vFilePathes.get_String (i), sz);
02633                         m_LastFilesDownloaded.Add (sz, vFilePathes.get_String (i));
02634                 }
02635         }
02636         else
02637         {
02638                 if (FALSE == m_LastFilesDownloaded.Load (hFile))
02639                 {
02640                         CloseHandle (hFile);
02641                         return FALSE;
02642                 }
02643         }
02644 
02645         CloseHandle (hFile);
02646 
02647         return TRUE;
02648 }
02649 
02650 BOOL fsDownloadsMgr::SaveStateInformation()
02651 {
02652         CString strFileName = fsGetDataFilePath ("dlmgrsi.sav");
02653 
02654         HANDLE hFile = CreateFile (strFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
02655                 FILE_ATTRIBUTE_HIDDEN, NULL);
02656 
02657         if (hFile == INVALID_HANDLE_VALUE)
02658                 return FALSE;
02659 
02660         DWORD dw;
02661 
02662         fsStateInfoFileHdr hdr;
02663         if (FALSE == WriteFile (hFile, &hdr, sizeof (hdr), &dw, NULL))
02664         {
02665                 CloseHandle (hFile);
02666                 return FALSE;
02667         }
02668 
02669         if (FALSE == WriteFile (hFile, &m_nID, sizeof (m_nID), &dw, NULL))
02670         {
02671                 CloseHandle (hFile);
02672                 return FALSE;
02673         }
02674 
02675         if (FALSE == m_LastFilesDownloaded.Save (hFile))
02676         {
02677                 CloseHandle (hFile);
02678                 return FALSE;
02679         }
02680 
02681         CloseHandle (hFile);
02682 
02683         return TRUE;
02684 }
02685 
02686 UINT fsDownloadsMgr::GetNextDownloadID()
02687 {
02688         return m_nID;
02689 }
02690 
02691 const vmsFileRecentList* fsDownloadsMgr::get_LastFilesDownloaded() const
02692 {
02693         return &m_LastFilesDownloaded;
02694 }
02695 
02696 void fsDownloadsMgr::LastFilesDownloaded_Clear()
02697 {
02698         m_LastFilesDownloaded.Clear ();
02699 }
02700 
02701 void fsDownloadsMgr::MoveDownloads(DLDS_LIST_REF vDlds, vmsDownloadSmartPtr pDldPosition, bool bUp)
02702 {
02703         LockList ();
02704 
02705         size_t nIndexPos = GetDownloadIndex (pDldPosition);
02706 
02707         for (size_t i = 0; i < vDlds.size (); i++)
02708         {
02709                 size_t nIndex = GetDownloadIndex (vDlds [i]);
02710                 if (nIndex == -1) 
02711                 {
02712                         vDlds.erase (vDlds.begin () + i--);
02713                         continue;
02714                 }
02715                 DownloadsList_Del (nIndex);
02716         }
02717 
02718         size_t n = GetDownloadIndex (pDldPosition);
02719         if (n != -1)
02720                 nIndexPos = n;
02721         if (bUp == false)
02722                 nIndexPos++;
02723         if (nIndexPos > m_vDownloads.size ())
02724                 nIndexPos = m_vDownloads.size ();
02725 
02726         for (i = 0; i < vDlds.size (); i++)
02727                 DownloadsList_Insert (nIndexPos++, vDlds [i]);
02728 
02729         UnlockList ();
02730 }
02731 
02732 void fsDownloadsMgr::ReorderDownloads(DLDS_LIST_REF vDlds, DLDS_LIST_REF vReqOrder, bool bDldsSorted)
02733 {
02734         if (vDlds.size () != vReqOrder.size ())
02735                 return; 
02736 
02737         LockList ();
02738 
02739         
02740         fs::list <int> vIndxs;
02741         
02742         
02743         size_t nPrevIndx = (size_t)-1; 
02744         for (size_t i = 0; i < vDlds.size (); i++) 
02745         {
02746                 if (m_vDownloads [nPrevIndx + 1] == vDlds [i]) {
02747                         vIndxs.add (++nPrevIndx);       
02748                 }
02749                 else {
02750                         
02751                         
02752                         
02753                         vIndxs.add (nPrevIndx = GetDownloadIndex (vDlds [i], bDldsSorted ? nPrevIndx + 1 : 0));
02754                         if (nPrevIndx == m_vDownloads.size () - 1)
02755                                 nPrevIndx = (size_t)-1;
02756                 }
02757         }
02758 
02759         
02760 
02761         for (i = 0; i < vReqOrder.size (); i++)
02762         {
02763                 size_t nNewIndx = vIndxs [i];   
02764                 if (nNewIndx == (size_t)-1)
02765                         continue;
02766 
02767                 size_t nOldIndx;        
02768 
02769                 
02770 
02771                 vmsDownloadSmartPtr dld = vReqOrder [i];
02772                 for (size_t j = 0; j < vDlds.size (); j++){
02773                         if (dld == vDlds [j])
02774                                 break;
02775                 }
02776                 if (j == vDlds.size ())
02777                         continue;       
02778                 nOldIndx = vIndxs [j];
02779                 if (nOldIndx == (size_t)-1)
02780                         continue;
02781 
02782                 
02783 
02784                 vIndxs [i] = (size_t)-1;        
02785                 vIndxs [j] = (size_t)-1;        
02786 
02787                 if (nNewIndx != nOldIndx)
02788                 {
02789                         
02790 
02791                         vmsDownloadSmartPtr dldTmp = m_vDownloads [nNewIndx];
02792                         m_vDownloads [nNewIndx] = dld;
02793                         m_vDownloads [nOldIndx] = dldTmp;
02794                 }
02795         }
02796 
02797         UnlockList ();
02798 }
02799 
02800 DWORD WINAPI fsDownloadsMgr::_threadIntegrityCheckAndVirCheckAndLaunch(LPVOID lp)
02801 {
02802         vmsDownloadSmartPtr dld = (fsDownload*) lp;
02803         dld->Release (); 
02804 
02805         bool bNeedLaunchDld = (dld->dwFlags & DLD_NOAUTOLAUNCH) == 0 && 
02806                 dld->pMgr->IsLaunchWhenDone ();
02807         bool bNeedIntegrityCheck = dld->pMgr->GetDownloadMgr () != NULL && 
02808                 dld->pMgr->GetDownloadMgr ()->GetDP ()->bCheckIntegrityWhenDone && 
02809                 *dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum;
02810 
02811         if (bNeedIntegrityCheck)
02812         {
02813                 _DldsMgr.Event (dld, LS (L_PERFORMINGINTEGRITYCHECK), EDT_INQUIRY);
02814 
02815                 fsDownload_Properties *dp = dld->pMgr->GetDownloadMgr ()->GetDP ();
02816 
02817                 vmsHash hash;
02818                 hash.set_SHA2Strength ((vmsHash_SHA2Strength) HIWORD (dp->dwIntegrityCheckAlgorithm));
02819                 fsString strHashResult = hash.Hash (dp->pszFileName, (vmsHashAlgorithm) LOWORD (dp->dwIntegrityCheckAlgorithm)).c_str ();
02820                 if (strHashResult == dp->pszCheckSum)
02821                 {
02822                         
02823                         _DldsMgr.Event (dld, LS (L_INTEGRITYCHECKSUCCEEDED), EDT_RESPONSE_S);
02824                 }
02825                 else
02826                 {
02827                         
02828                         _DldsMgr.Event (dld, LS (L_INTEGRITYCHECKFAILED), EDT_RESPONSE_E);
02829 
02830                         switch (dp->enICFR)
02831                         {
02832                         case ICFR_ASKUSER:
02833                         {
02834                                 CDlg_CheckFileIntegrity_Result dlg;
02835                                 dlg.m_bResultOK = FALSE;
02836                                 char sz [MY_MAX_PATH];
02837                                 fsGetFileName (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName, sz);
02838                                 dlg.m_strFileName = sz;
02839                                 dlg.m_strUrl = dld->pMgr->get_URL ();
02840                                 dlg.m_strValidHash = dp->pszCheckSum;
02841                                 dlg.m_strResultHash = strHashResult;
02842                                 if (IDC_RESTARTDOWNLOAD == _DlgMgr.DoModal (&dlg))
02843                                 {
02844                                         _pwndDownloads->RestartDownload (dld, TRUE);
02845                                         return 0;
02846                                 }
02847                         }
02848                         break;
02849 
02850                         case ICFR_RESTART:
02851                                 _pwndDownloads->RestartDownload (dld, TRUE);
02852                         return 0;
02853 
02854                         case ICFR_IGNORE:
02855                         break;
02856 
02857                         default:
02858                                 ASSERT (FALSE);
02859                         }
02860                 }
02861         }
02862 
02863         if (_DldsMgr.m_bVirCheck)
02864         {
02865                 BOOL bOk = _DldsMgr.PerformVirusCheck (dld, TRUE, bNeedLaunchDld);
02866 
02867                 if (bOk == FALSE && bNeedLaunchDld)
02868                 {
02869                         CWaitForConfirmationDlg dlg;
02870                         dlg.Init (LS (L_VIRCHECKFAILEDLAUNCHDLDANYWAY), 60, FALSE, TRUE);
02871                         dlg.m_pszIcon = IDI_WARNING;
02872 
02873                         if (IDOK != _DlgMgr.DoModal (&dlg))
02874                                 bNeedLaunchDld = false;
02875                 }
02876         }
02877 
02878         if (dld->dwFlags & DLD_FLASH_VIDEO)
02879                 _pwndFVDownloads->OnDownloadDone (dld);
02880 
02881         if (bNeedLaunchDld)
02882                 _DldsMgr.LaunchDownload (dld, dld->pMgr->IsDontConfirmLaunchWhenDone () ? 0 : _App.ConfTimeout_LaunchDld ());
02883 
02884         _DldsMgr.OnDldDoneCheckIfNeedDel (dld);
02885 
02886         InterlockedDecrement (&_DldsMgr.m_cThreadsRunning);
02887 
02888         return 0;
02889 }
02890 
02891 void fsDownloadsMgr::OnDldDoneCheckIfNeedDel(vmsDownloadSmartPtr dld)
02892 {
02893         if (m_bAutoDelCompleted || (dld->dwFlags & DLD_DELETEWHENDONE) != 0)
02894         {
02895                 DLDS_LIST vDlds;
02896                 vDlds.push_back (dld);
02897                 DeleteDownloads (vDlds, FALSE, (dld->dwFlags & DLD_DELETEFILEALWAYS) != FALSE);
02898                 Event ((fsDownload*)NULL, DME_DLDAUTODELETED);
02899         }
02900 }
02901 
02902 BOOL fsDownloadsMgr::OnDldDone_CheckDownloadIsMetaLink(vmsDownloadSmartPtr dld)
02903 {
02904         if (dld->pMgr->GetDownloadMgr () == NULL)
02905                 return FALSE;
02906 
02907         fsString strFile = dld->pMgr->get_OutputFilePathName ();
02908         if (lstrlen (strFile) > 10 && lstrcmpi (strFile + lstrlen (strFile) - 9, ".metalink") != 0)
02909                 return FALSE; 
02910 
02911         vmsMetalinkFile mf;
02912         if (FALSE == mf.Parse (strFile))
02913                 return FALSE;
02914 
02915         if (mf.get_FileCount () == 0)
02916                 return FALSE;
02917 
02918         
02919         BOOL bRecreated = FALSE;
02920         
02921         int iWinOSFile = -1;
02922 
02923         for (int iFile = 0; iFile < mf.get_FileCount () && iWinOSFile != -1; iFile++)
02924         {
02925                 vmsMetalinkFile_File *file = mf.get_File (iFile);
02926 
02927                 
02928                 if (file->strOS.GetLength () && strstr (file->strOS, "Windows") == NULL)
02929                         continue;
02930 
02931                 iWinOSFile = iFile;
02932         }
02933 
02934         if (iWinOSFile == -1)
02935                 iWinOSFile = 0;
02936 
02937         vmsMetalinkFile_File *file = mf.get_File (iWinOSFile);
02938         
02939         if (file->vMirrors.size () == 0)
02940                 return FALSE;
02941 
02942         
02943         fsString strBtUrl;
02944 
02945         for (int i = 0; i < file->vMirrors.size (); i++)
02946         {
02947                 vmsMetalinkFile_File_Url *url = &file->vMirrors [i];
02948 
02949                 if (strcmpi (url->strProtocol, "http") && strcmpi (url->strProtocol, "https") &&
02950                                 strcmpi (url->strProtocol, "ftp"))
02951                 {
02952                         if (strcmpi (url->strProtocol, "bittorrent") == 0)
02953                                 strBtUrl = url->strUrl;
02954                         continue;
02955                 }
02956 
02957                 if (bRecreated == FALSE)
02958                 {
02959                         if (IR_SUCCESS != dld->pMgr->GetDownloadMgr ()->CreateByUrl (url->strUrl))
02960                                 continue;
02961                         dld->pMgr->GetDownloadMgr ()->Reset ();
02962                         bRecreated = TRUE;
02963                 }
02964                 else
02965                 {
02966                         dld->pMgr->GetDownloadMgr ()->GetDownloader ()->AddMirrorURL (url->strUrl);
02967                 }
02968         }
02969 
02970         if (bRecreated == FALSE)
02971         {
02972                 if (strBtUrl.IsEmpty ())
02973                         return FALSE;
02974                 
02975                 
02976                 if (IR_SUCCESS != dld->pMgr->GetDownloadMgr ()->CreateByUrl (strBtUrl))
02977                         return FALSE;
02978                 dld->pMgr->GetDownloadMgr ()->Reset ();
02979                 bRecreated = TRUE;
02980         }
02981 
02982         Event (dld, LS (L_METALINK_DETECTED), EDT_INQUIRY);
02983 
02984         for (i = 0; i < file->vHashes.size (); i++)
02985         {
02986                 vmsMetalinkFile_File_Hash *hash = &file->vHashes [i];
02987                 DWORD dwAlg;
02988                 if (hash->strChecksum.GetLength () == 0)
02989                         continue;
02990                 
02991                 if (lstrcmpi (hash->strAlgorithm, "md5") == 0)
02992                         dwAlg = HA_MD5;
02993 
02994                 else if (lstrcmpi (hash->strAlgorithm, "sha1") == 0 || 
02995                                 lstrcmpi (hash->strAlgorithm, "sha-1") == 0)
02996                         dwAlg = HA_SHA1;
02997 
02998                 else
02999                         continue;
03000 
03001                 
03002                 dld->pMgr->GetDownloadMgr ()->GetDP ()->dwIntegrityCheckAlgorithm = dwAlg;
03003                 SAFE_DELETE_ARRAY (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum);
03004                 dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum = new char [hash->strChecksum.GetLength () + 1];
03005                 lstrcpy (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum, hash->strChecksum);
03006         }
03007 
03008         DeleteFile (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName);
03009         LPSTR psz = strrchr (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName, '\\');
03010         if (psz == NULL)
03011                 psz = strrchr (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName, '/');
03012         if (psz)
03013                 *psz = 0;
03014 
03015         char szNewFile [MY_MAX_PATH];
03016         lstrcpy (szNewFile, dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName);
03017         lstrcat (szNewFile, "\\");
03018         if (file->strName.pszString != NULL)
03019                 lstrcat (szNewFile, file->strName);
03020         SAFE_DELETE_ARRAY (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName);
03021         dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName = new char [lstrlen (szNewFile) + 1];
03022         lstrcpy (dld->pMgr->GetDownloadMgr ()->GetDP ()->pszFileName, szNewFile);
03023 
03024         if (dld->strComment.GetLength () != 0)
03025                 dld->strComment += "\r\n";
03026         dld->strComment += mf.get_Description ();
03027 
03028         dld->pMgr->StartDownloading ();
03029 
03030         return TRUE;
03031 }
03032 
03033 void fsDownloadsMgr::DownloadsList_Add(vmsDownloadSmartPtr dld)
03034 {
03035         m_vDownloads.push_back (dld);
03036         dld->pGroup->cDownloads++;
03037 }
03038 
03039 void fsDownloadsMgr::DownloadsList_Del(size_t nIndex)
03040 {
03041         m_vDownloads [nIndex]->pGroup->cDownloads--;
03042         m_vDownloads.erase (m_vDownloads.begin () + nIndex);
03043 }
03044 
03045 void fsDownloadsMgr::DownloadsList_Insert(size_t nIndexBefore, vmsDownloadSmartPtr dld)
03046 {
03047         m_vDownloads.insert (m_vDownloads.begin () + nIndexBefore, dld);
03048         dld->pGroup->cDownloads++;
03049 }
03050 
03051 void fsDownloadsMgr::DeletedDownloads_UseTmpList(BOOL bUse)
03052 {
03053         if (bUse)
03054         {
03055                 ASSERT (m_vDeletedDownloads_tmp.size () == 0);
03056                 std::list <vmsDownloadSmartPtr> v;
03057                 for (size_t i = 0; i < m_vDeletedDownloads.size (); i++)
03058                         v.push_back (m_vDeletedDownloads [i]);
03059                 m_vDeletedDownloads_tmp = v;
03060                 m_vDeletedDownloads.clear ();
03061         }
03062         else
03063         {
03064                 ASSERT (m_vDeletedDownloads.size () == 0);
03065                 DLDS_LIST v;
03066                 std::list <vmsDownloadSmartPtr>::iterator iter;
03067                 for (iter = m_vDeletedDownloads_tmp.begin (); iter != m_vDeletedDownloads_tmp.end (); iter++)
03068                         v.push_back (*iter);
03069                 m_vDeletedDownloads = v;
03070                 m_vDeletedDownloads_tmp.clear ();               
03071         }
03072 }
03073 
03074 BOOL fsDownloadsMgr::DeleteGroupsDownloads(vmsDownloadsGroupSmartPtr pGroup, BOOL bInclSubgroups)
03075 {
03076         std::vector <vmsDownloadsGroupSmartPtr> v;
03077         if (bInclSubgroups)
03078                 _DldsGrps.GetGroupWithSubgroups (pGroup, v);
03079         else
03080                 v.push_back (pGroup);
03081 
03082         DLDS_LIST vDlds;
03083 
03084         for (int i = m_vDownloads.size () - 1; i >= 0; i--)
03085         {
03086                 vmsDownloadSmartPtr dld = m_vDownloads [i];
03087                 
03088                 for (size_t j = 0; j < v.size (); j++)
03089                 {
03090                         if (v [j] == dld->pGroup)
03091                         {
03092                                 
03093                                 vDlds.push_back (dld);
03094                                 break;
03095                         }
03096                 }
03097         }
03098 
03099         if (vDlds.size () == 0)
03100                 return TRUE;
03101 
03102         size_t cToDelete = vDlds.size ();
03103         size_t cDeleted = DeleteDownloads (vDlds, TRUE, FALSE);
03104         if (cDeleted != cToDelete)
03105                 return FALSE;
03106 
03107         return TRUE;
03108 }
03109 
03110 void fsDownloadsMgr::GetEventColors(fsDownloadMgr_EventDescType enType, COLORREF &clrText, COLORREF &clrBg, int &iImage)
03111 {
03112         clrText = RGB (0, 0, 0);
03113 
03114         
03115         
03116         switch (enType)
03117         {
03118                 case EDT_INQUIRY:
03119                         clrBg = CLR_INQUIRY;
03120                         iImage = 0;
03121                         break;
03122 
03123                 case EDT_INQUIRY2:
03124                         clrBg = CLR_INQUIRY2;
03125                         iImage = 0;
03126                         break;
03127 
03128                 case EDT_DONE:
03129                         clrBg = CLR_DONE;
03130                         iImage = 1;
03131                         break;
03132 
03133                 case EDT_RESPONSE_S:
03134                         clrBg = CLR_RESPONSE_S;
03135                         iImage = 2;
03136                         break;
03137 
03138                 case EDT_RESPONSE_S2:
03139                         clrBg = CLR_RESPONSE_S2;
03140                         iImage = 2;
03141                         break;
03142 
03143                 case EDT_RESPONSE_E:
03144                         clrBg = CLR_RESPONSE_E;
03145                         iImage = 3;
03146                         break;
03147 
03148                 case EDT_WARNING:
03149                         clrBg = CLR_WARNING;
03150                         iImage = 5;
03151                         break;
03152 
03153                 default:
03154                         ASSERT (4!=4);
03155                         return;
03156         }
03157 }
03158 
03159 BOOL fsDownloadsMgr::OnDldDone_CheckDownloadIsBittorrent(vmsDownloadSmartPtr dld)
03160 {
03161         if (Is9xME)
03162                 return FALSE;
03163 
03164         if (dld->pMgr->GetDownloadMgr () == NULL)
03165                 return FALSE;
03166 
03167         fsString strFile = dld->pMgr->get_OutputFilePathName ();
03168         if (lstrlen (strFile) > 10 && lstrcmpi (strFile + lstrlen (strFile) - 8, ".torrent") != 0)
03169                 return FALSE; 
03170 
03171         if (_App.Bittorrent_Enable () == FALSE)
03172         {
03173                 if (_App.View_DontAskEnableBittorrent () == FALSE)
03174                 {
03175                         CMyMessageBox dlg (_pwndDownloads);
03176                         dlg.m_hIcon = LoadIcon (NULL, IDI_QUESTION);
03177                         dlg.m_strBtn1Text = LS (L_YES);
03178                         dlg.m_strBtn2Text = LS (L_NO);
03179                         dlg.m_strCheckBoxText = LS (L_DONTASKAGAIN);
03180                         dlg.m_strText = LS (L_ENABLEBTISREQ);
03181                         dlg.m_strTitle = LS (L_CONFIRMATION);
03182                         dlg.m_bChecked = FALSE;
03183                         if (IDC_BTN1 != _DlgMgr.DoModal (&dlg))
03184                         {
03185                                 if (dlg.m_bChecked)
03186                                         _App.View_DontAskEnableBittorrent (TRUE);
03187                                 return FALSE;
03188                         }
03189                         _App.Bittorrent_Enable (TRUE);
03190                 }
03191                 else 
03192                 {
03193                         return FALSE;
03194                 }
03195         }
03196 
03197         if (_AppMgr.IsBtInstalled () == FALSE)
03198         {
03199                 _AppMgr.ShowInstallBtMessage ();
03200                 _App.Bittorrent_Enable (FALSE);
03201                 return FALSE;
03202         }
03203 
03204         char szPath [MY_MAX_PATH];
03205         fsGetPath (strFile, szPath);
03206 
03207         dld->pMgr->GetDownloadMgr ()->CloseFile ();
03208 
03209         vmsBtDownloadManager *pBtMgr = new vmsBtDownloadManager;
03210 
03211         if (dld->pMgr->GetDownloadMgr ()->GetDP ()->bReserveDiskSpace)
03212                 pBtMgr->enable_Flags (BTDF_RESERVE_DISK_SPACE);
03213         else
03214                 pBtMgr->disable_Flags (BTDF_RESERVE_DISK_SPACE);
03215 
03216         if (dld->pMgr->IsLaunchWhenDone ())
03217                 pBtMgr->enable_Flags (BTDF_LAUNCH_WHEN_DONE);
03218         else
03219                 pBtMgr->disable_Flags (BTDF_LAUNCH_WHEN_DONE);
03220 
03221         if (dld->pMgr->IsDescriptionFileShouldBeGenerated ())
03222                 pBtMgr->enable_Flags (BTDF_GENERATE_DESC_FILE);
03223         else
03224                 pBtMgr->disable_Flags (BTDF_GENERATE_DESC_FILE);
03225 
03226         if (dld->pMgr->GetDownloadMgr ()->GetDP ()->bIgnoreRestrictions)
03227                 pBtMgr->enable_Flags (BTDF_IGNORE_ALL_RESTRICTIONS);
03228         else
03229                 pBtMgr->disable_Flags (BTDF_IGNORE_ALL_RESTRICTIONS);  
03230 
03231         if (FALSE == pBtMgr->CreateByTorrentFile (strFile, szPath, dld->pMgr->get_URL ()))
03232                 return FALSE;
03233 
03234         fsString strComment = pBtMgr->get_TorrentComment ();
03235         if (strComment.IsEmpty () == FALSE)
03236         {
03237                 if (dld->strComment.IsEmpty () == FALSE)
03238                         dld->strComment += "\r\n";
03239                 dld->strComment += strComment;
03240         }
03241 
03242         vmsDownloadMgrEx *pNewMgr = new vmsDownloadMgrEx;
03243         pNewMgr->Attach (pBtMgr);
03244 
03245         vmsDownloadMgrEx *pMgr = dld->pMgr;
03246         pMgr->AddRef ();
03247         pMgr->DeleteFile ();
03248 
03249         dld->pMgr = pNewMgr;
03250         dld->pMgr->GetBtDownloadMgr ()->SetEventsHandler (_BtDownloadManagerEventHandler, this);
03251 
03252         Event (dld, LS (L_BITTORRENT_DETECTED), EDT_INQUIRY);
03253         Event (dld, DME_BTDLD_STAT_CHANGED);
03254 
03255         dld->pMgr->StartDownloading ();
03256 
03257         DWORD dw;       
03258         CloseHandle (
03259                 CreateThread (NULL, 0, _threadDeleteDownloadMgrEx, pMgr, 0, &dw));
03260 
03261         return TRUE;
03262 }
03263 
03264 DWORD WINAPI fsDownloadsMgr::_threadDeleteDownloadMgrEx(LPVOID lp)
03265 {
03266         vmsDownloadMgrEx *pMgr = (vmsDownloadMgrEx*) lp;
03267         pMgr->Release ();
03268         return 0;
03269 }
03270 
03271 void fsDownloadsMgr::_BtSessionEventsHandler(vmsBtSession *, vmsBtSessionEvent *ev, LPVOID lp)
03272 {
03273         fsDownloadsMgr *pthis = (fsDownloadsMgr*)lp;
03274 
03275         vmsDownloadSmartPtr dld;
03276         if (ev->pDownload)
03277                 dld = pthis->FindDownloadByBtDownload (ev->pDownload);
03278         if (dld == NULL)
03279                 return;
03280 
03281         switch (ev->enType)
03282         {
03283         case BTSET_FILE_ERROR:
03284     case BTSET_BTDLD_WAS_RESET:
03285                 dld->bAutoStart = FALSE;
03286                 dld->pMgr->GetBtDownloadMgr ()->DeleteBtDownload ();
03287                 if (ev->enType == BTSET_FILE_ERROR)
03288                         pthis->Event (dld, LS (L_BT_FILE_ERROR), EDT_RESPONSE_E);
03289                 break;
03290 
03291         case BTSET_TRACKER_ANNOUNCE:
03292                 if (dld->pMgr->IsRunning () == FALSE)
03293                         return;
03294                 pthis->Event (dld, LS (L_BT_TRACKER_ANNOUNCE), EDT_INQUIRY);
03295                 dld->pMgr->GetBtDownloadMgr ()->m_strTrackerStatus = LS (L_CONNECTING);
03296                 break;
03297 
03298         case BTSET_TRACKER:
03299                 if (dld->pMgr->IsRunning () == FALSE)
03300                         return;
03301                 pthis->Event (dld, LS (L_BT_TRACKER_ERROR), EDT_RESPONSE_E);
03302                 if (pthis->m_bDetLog && ev->pszMsg)
03303                 {
03304                         LPCSTR pszMsg = strchr (ev->pszMsg, '"');
03305                         if (pszMsg)
03306                                 pszMsg = strchr (pszMsg+1, '"');
03307                         if (pszMsg)
03308                                 pszMsg += 2;
03309                         if (pszMsg == NULL)
03310                                 pszMsg = ev->pszMsg;
03311                         pthis->EventEx (dld, pszMsg, EDT_RESPONSE_E, 70);
03312                         dld->pMgr->GetBtDownloadMgr ()->m_strTrackerStatus = LS (L_FAILED); 
03313                         dld->pMgr->GetBtDownloadMgr ()->m_strTrackerStatus += ": ";
03314                         dld->pMgr->GetBtDownloadMgr ()->m_strTrackerStatus += pszMsg;
03315                 }
03316                 char sz [1000];
03317                 int nNext; nNext = dld->pMgr->GetBtDownloadMgr ()->get_NextAnnounceInterval ();
03318                 if (nNext)
03319                 {
03320                         sprintf (sz, LS (L_NEXT_CONNECT_WITH_TRACKER_IN), nNext);
03321                         pthis->Event (dld, sz, EDT_INQUIRY);
03322                 }
03323                 break;
03324 
03325         case BTSET_TRACKER_REPLY:
03326                 if (dld->pMgr->IsRunning () == FALSE)
03327                         return;
03328                 dld->pMgr->GetBtDownloadMgr ()->m_strTrackerStatus = "OK"; 
03329                 pthis->Event (dld, LS (L_BT_TRACKER_OK_RESPONSE), EDT_RESPONSE_S);
03330                 break;
03331 
03332         case BTSET_HASH_FAILED:
03333                 if (dld->pMgr->IsRunning () == FALSE)
03334                         return;
03335                 pthis->Event (dld, LS (L_BT_HASH_FAILED), EDT_WARNING);
03336                 break;
03337         }
03338 
03339         pthis->Event (dld, DME_DOWNLOAD_STATE_CHANGED);
03340         pthis->Event (dld, DME_BTDLD_STAT_CHANGED);
03341 }
03342 
03343 void fsDownloadsMgr::AttachToBtSession()
03344 {
03345         _BT.get_Session ()->set_EventsHandler (_BtSessionEventsHandler, this);
03346 }
03347 
03348 vmsDownloadSmartPtr fsDownloadsMgr::GetDownloadByBtDownloadMgr(vmsBtDownloadManager *pMgr)
03349 {
03350         ASSERT (pMgr != NULL);
03351 
03352         try {
03353                 for (size_t i = 0; i < m_vDownloads.size (); i++)
03354                 {
03355                         if (m_vDownloads [i]->pMgr->GetBtDownloadMgr () == pMgr)
03356                                 return m_vDownloads [i];
03357                 }
03358         }catch (...){}
03359 
03360         return NULL;
03361 }
03362 
03363 vmsDownloadSmartPtr fsDownloadsMgr::FindDownloadByBtDownload(vmsBtDownload *pDld)
03364 {
03365         ASSERT (pDld != NULL);
03366 
03367         try {
03368                 for (size_t i = 0; i < m_vDownloads.size (); i++)
03369                 {
03370                         if (m_vDownloads [i]->pMgr->GetBtDownloadMgr () != NULL &&
03371                                         m_vDownloads [i]->pMgr->GetBtDownloadMgr ()->get_BtDownload () == pDld)
03372                                 return m_vDownloads [i];
03373                 }
03374         }catch (...){}
03375 
03376         return NULL;
03377 }
03378 
03379 DWORD fsDownloadsMgr::_BtDownloadManagerEventHandler(vmsBtDownloadManager *pMgr, vmsBtDownloadManagerEvent ev, DWORD dwInfo, LPVOID lp)
03380 {
03381         fsDownloadsMgr* pthis = (fsDownloadsMgr*) lp;
03382 
03383         vmsDownloadSmartPtr dld;
03384         dld = pthis->GetDownloadByBtDownloadMgr  (pMgr);
03385 
03386         if (dld != NULL)
03387         {
03388                 switch (ev)
03389                 {
03390                 case BTDME_CHECKING_FILES:
03391                 case BTDME_ALLOCATING:
03392                         pthis->Event (dld, LS (L_PREP_FILES_ONDISK), EDT_INQUIRY);
03393                         break;
03394 
03395                 case BTDME_ALLOCATION_FAILED:
03396                         CHAR szErr [1000];
03397                         fsErrorToStr (szErr, sizeof (szErr), &dwInfo);
03398                         dld->bAutoStart = FALSE;
03399                         pthis->Event (dld, szErr, EDT_RESPONSE_E);
03400                         break;
03401 
03402                 case BTDME_DOWNLOAD_STARTED:
03403                         pthis->Event (dld, DME_DLMGRTHREADSTARTING);
03404                         pthis->Event (dld, DME_CREATEDLDDIALOG);
03405                         pthis->Event (dld, LS (L_STARTING), EDT_RESPONSE_S);
03406                         break;
03407 
03408                 case BTDME_DOWNLOAD_STOPPED_OR_DONE:
03409                         pthis->Event (dld, dld->pMgr->IsDone () ? LS (L_DONE) : LS (L_STOPPED), EDT_RESPONSE_S);
03410                         pthis->OnDownloadStoppedOrDone (dld);
03411                         return 0;
03412 
03413                 case BTDME_DOWNLOADING:
03414                         pthis->Event (dld, LS (L_DOWNLOADING), EDT_RESPONSE_S);
03415                         break;
03416 
03417                 case BTDME_SEEDING:
03418                         pthis->ProcessDownloads ();
03419                         break;
03420                 }
03421 
03422                 pthis->Event (dld, DME_DOWNLOAD_STATE_CHANGED);
03423         }
03424 
03425         return 0;
03426 }
03427 
03428 BOOL fsDownloadsMgr::OnDownloadStoppedOrDone(vmsDownloadSmartPtr dld)
03429 {
03430         #ifdef _USELOGGING
03431         LPVOID lp = dld->pMgr->GetDownloadMgr () ? (LPVOID)dld->pMgr->GetDownloadMgr () : (LPVOID)dld->pMgr->GetBtDownloadMgr ();
03432         #endif
03433         #define LOG_local(x) LOG("fsDsM::ODSOD(" << (DWORD)lp << "): " << x << nl)
03434 
03435         LOG_local ("1");
03436         Event (dld, DME_DOWNLOADEREVENTRECEIVED);
03437         LOG_local ("2");
03438         Event (dld, DME_DOWNLOADSTOPPEDORDONE);
03439         LOG_local ("3");
03440         Event (dld, DME_UPDATEDLDDIALOG);
03441         LOG_local ("4");
03442 
03443         if (m_gabInfo.dld == dld)
03444                 m_gabInfo.dld = NULL;
03445 
03446         if (dld->pMgr->IsDone ())       
03447         {
03448                 if (OnDldDone_CheckDownloadIsMetaLink (dld))
03449                         return FALSE;
03450 
03451                 if (OnDldDone_CheckDownloadIsBittorrent (dld))
03452                         return FALSE;
03453 
03454                 if (OnDldDone_CheckDownloadIsHtmlPageWithVideo (dld))
03455                         return FALSE;
03456 
03457                 #ifndef FDM_DLDR__RAWCODEONLY
03458                 if ((dld->dwFlags & DLD_DONTPUTTOHISTORY) == 0)
03459                         m_histmgr.AddToHistory (dld);
03460                 #endif
03461 
03462                 if (dld->pMgr->IsDescriptionFileShouldBeGenerated ())
03463                         GenerateDescriptionFile (dld);
03464 
03465                 if (FALSE == dld->pMgr->IsHtmlSpiderDownload ())
03466                 {
03467                         if (dld->pMgr->GetBtDownloadMgr () && dld->pMgr->GetBtDownloadMgr ()->get_FileCount () > 1)
03468                         {
03469                                 m_LastFilesDownloaded.Add (dld->pMgr->GetBtDownloadMgr ()->get_TorrentName (), 
03470                                         dld->pMgr->get_OutputFilePathName ());
03471                         }
03472                         else
03473                         {
03474                                 fsString strPath = dld->pMgr->get_OutputFilePathName ();
03475                                 char sz [MY_MAX_PATH] = "";
03476                                 fsGetFileName (strPath, sz);
03477                                 m_LastFilesDownloaded.Add (sz, strPath);
03478                         }
03479                 }
03480 
03481                 if (dld->dwFlags & DLD_DELETEFILEATRESTART)
03482                 {
03483                         if (dld->pMgr->GetBtDownloadMgr () && dld->pMgr->GetBtDownloadMgr ()->get_FileCount () > 1)
03484                         {
03485                                 for (int i = 0; i < dld->pMgr->GetBtDownloadMgr ()->get_FileCount (); i++)
03486                                         vmsDeleteFileAtWinBoot  (dld->pMgr->GetBtDownloadMgr ()->get_OutputFilePathName (i));
03487                         }
03488                         else
03489                         {                       
03490                                 vmsDeleteFileAtWinBoot  (dld->pMgr->get_OutputFilePathName ());
03491                         }
03492                 }
03493 
03494                 dld->bAutoStart = FALSE;
03495 
03496                 bool bNeedLaunchDld = (dld->dwFlags & DLD_NOAUTOLAUNCH) == 0 && 
03497                         dld->pMgr->IsLaunchWhenDone ();
03498                 bool bNeedIntegrityCheck = dld->pMgr->GetDownloadMgr () != NULL &&
03499                         dld->pMgr->GetDownloadMgr ()->GetDP ()->bCheckIntegrityWhenDone && 
03500                         *dld->pMgr->GetDownloadMgr ()->GetDP ()->pszCheckSum;
03501                 bool bNeedThread = m_bVirCheck || bNeedLaunchDld || bNeedIntegrityCheck ||
03502                         (dld->dwFlags & DLD_FLASH_VIDEO);
03503 
03504                 if (bNeedThread)
03505                 {
03506                         dld->AddRef (); 
03507                         InterlockedIncrement (&m_cThreadsRunning);
03508                         DWORD dw;
03509                         CloseHandle (
03510                                 CreateThread (NULL, 0, _threadIntegrityCheckAndVirCheckAndLaunch, dld, 0, &dw));
03511                 }
03512                 else
03513                 {
03514                         OnDldDoneCheckIfNeedDel (dld);
03515                 }
03516 
03517                 if (dld->dwFlags & DLD_MF_AUTO_CONVERT)
03518                 {
03519                         dld->AddRef ();
03520                         _pwndDownloads->PostMessage (WM_DLD_CONVERT_MEDIA, MCM_OS_SEARCH_IN_MGR, 
03521                                 (LPARAM)(fsDownload*)dld);
03522                 }
03523         }
03524 
03525         ProcessDownloads ();    
03526         LOG_local ("5");
03527         CheckNoActiveDownloads (); 
03528         LOG_local ("6");
03529 
03530         return TRUE;
03531 }
03532 
03533 void fsDownloadsMgr::OnDownloadDescEventRcvd(vmsDownloadSmartPtr dld, fsDownloadMgr_EventDescType enType, LPCSTR pszEvent)
03534 {
03535         try {
03536 
03537         COLORREF clrBg, clrText;
03538         int iImage;
03539 
03540         GetEventColors (enType, clrText, clrBg, iImage);
03541 
03542         fsDownloadEvents event;
03543         SYSTEMTIME time;
03544         GetLocalTime (&time);
03545 
03546         event.clrBg = clrBg;
03547         event.clrText = clrText;
03548         event.strEvent = pszEvent;
03549         event.iImage = iImage;
03550         SystemTimeToFileTime (&time, &event.timeEvent);
03551 
03552         dld->vEvents.add (event);       
03553 
03554         
03555         Event (dld, DME_EVENTDESCRIPRIONRECEIVED);
03556 
03557         }catch (...) {}
03558 }
03559 
03560 void fsDownloadsMgr::ResetDldHpManageState()
03561 {
03562         m_gabInfo.enCurState = _inc_GrantAllBandwidthInfo::CS_Start;
03563         m_gabInfo.uBandwidth = 0;
03564         m_gabInfo.uDldMaxSpeed = 0;
03565 }
03566 
03567 void fsDownloadsMgr::GetRunningDownloads(DLDS_LIST &v)
03568 {
03569         for (size_t i = 0; i < m_vDownloads.size (); i++)
03570         {
03571                 if (m_vDownloads [i]->pMgr->IsRunning ())
03572                         v.push_back (m_vDownloads [i]);
03573         }
03574 }
03575 
03576 void fsDownloadsMgr::ApplyTrafficLimit_NoHpDld()
03577 {
03578         LOG ("fsDsM::ATL_NHD: start" << nl);
03579 
03580         DLDS_LIST vRunningDlds;
03581         GetRunningDownloads (vRunningDlds);
03582         if (vRunningDlds.size () == 0)
03583         {
03584                 LOG ("fsDsM::ATL_NHD: exit [0]" << nl);
03585                 return;
03586         }
03587 
03588         UINT tlpd = m_aTUM [m_enTUM].uTrafficLimit / vRunningDlds.size ();  
03589 
03590         m_bSkip1Cicle = TRUE;
03591 
03592         ApplyTrafficLimitForListOfDownloads (vRunningDlds, tlpd);
03593 
03594         LOG ("fsDsM::ATL_NHD: exit" << nl);
03595 }
03596 
03597 void fsDownloadsMgr::ApplyTrafficLimit_HasHpDld()
03598 {
03599         LOG ("fsDsM::ATL_HHD: start" << nl);
03600 
03601         ASSERT (m_gabInfo.dld != NULL);
03602         ASSERT (m_gabInfo.dld->pMgr->IsRunning ());
03603 
03604         DLDS_LIST vRunningDlds;
03605         GetRunningDownloads (vRunningDlds);
03606         if (vRunningDlds.size () == 0)
03607         {
03608                 LOG ("fsDsM::ATL_HHD: exit [0]" << nl);
03609                 return;
03610         }
03611 
03612         
03613 
03614         if (vRunningDlds.size () == 1)
03615         {
03616                 UINT uTraffLimit = m_aTUM [m_enTUM].uTrafficLimit;
03617                 if (m_gabInfo.dld->pMgr->GetDownloadMgr ())
03618                         uTraffLimit = min (uTraffLimit, m_gabInfo.dld->pMgr->GetDownloadMgr ()->GetDP ()->uTrafficRestriction);
03619                 m_gabInfo.dld->pMgr->LimitTraffic (uTraffLimit);
03620                 LOG ("fsDsM::ATL_HHD: exit [1]" << nl);
03621                 return;
03622         }
03623 
03624         
03625 
03626         for (size_t i = 0; i < vRunningDlds.size (); i++)
03627         {
03628                 if (vRunningDlds [i] == m_gabInfo.dld)
03629                 {
03630                         vRunningDlds.erase (vRunningDlds.begin () + i);
03631                         break;
03632                 }
03633         }
03634 
03635         BOOL bWaiting = FALSE;
03636 
03637         if (m_gabInfo.enCurState == _inc_GrantAllBandwidthInfo::CS_Measuring_Bandwidth ||
03638                         m_gabInfo.enCurState == _inc_GrantAllBandwidthInfo::CS_Measuring_DldMaxSpeed)
03639         {
03640                 fsTicksMgr time;
03641                 UINT nTimeout = m_gabInfo.enCurState == _inc_GrantAllBandwidthInfo::CS_Measuring_Bandwidth ? 15 : 60;
03642                 if (time - m_gabInfo.timeStateChange < nTimeout * 1000)
03643                         bWaiting = TRUE;
03644         }
03645 
03646         if (bWaiting == FALSE)
03647         switch (m_gabInfo.enCurState)
03648         {
03649         case _inc_GrantAllBandwidthInfo::CS_Start:
03650                 m_gabInfo.uBandwidth = m_aTUM [m_enTUM].uTrafficLimit;
03651                 m_gabInfo.uDldMaxSpeed = 0;
03652                 ApplyTrafficLimit_NoHpDld ();
03653                 if (m_gabInfo.uBandwidth == UINT_MAX)
03654                 {
03655                         m_gabInfo.enCurState = _inc_GrantAllBandwidthInfo::CS_Measuring_Bandwidth;
03656                         m_gabInfo.timeStateChange.Now ();
03657                         break;
03658                 }
03659                 
03660         case _inc_GrantAllBandwidthInfo::CS_Measuring_Bandwidth:
03661         {
03662                 if (m_gabInfo.uBandwidth == UINT_MAX)
03663                 {
03664                         m_gabInfo.uBandwidth = m_gabInfo.dld->pMgr->GetSpeed ();
03665                         for (size_t i = 0; i < vRunningDlds.size (); i++)
03666                                 m_gabInfo.uBandwidth += vRunningDlds [i]->pMgr->GetSpeed ();
03667                 }
03668                 m_gabInfo.uDldMaxSpeed = m_gabInfo.uBandwidth - vRunningDlds.size ();
03669                 m_gabInfo.enCurState = _inc_GrantAllBandwidthInfo::CS_Measuring_DldMaxSpeed;
03670                 m_gabInfo.dld->pMgr->LimitTraffic (m_aTUM [m_enTUM].uTrafficLimit);
03671                 m_gabInfo.timeStateChange.Now ();
03672         }
03673                 break;
03674 
03675         case _inc_GrantAllBandwidthInfo::CS_Measuring_DldMaxSpeed:
03676                 m_gabInfo.uDldMaxSpeed = m_gabInfo.dld->pMgr->GetSpeed ();
03677                 m_gabInfo.uBandwidth = max (m_gabInfo.uBandwidth, m_gabInfo.uDldMaxSpeed + vRunningDlds.size ());
03678                 m_gabInfo.enCurState = _inc_GrantAllBandwidthInfo::CS_Done;
03679                 m_gabInfo.timeStateChange.Now ();
03680                 break;
03681 
03682         case _inc_GrantAllBandwidthInfo::CS_Done:
03683         {
03684                 m_gabInfo.uDldMaxSpeed = max (m_gabInfo.uDldMaxSpeed, m_gabInfo.dld->pMgr->GetSpeed ());
03685 
03686                 if (m_aTUM [m_enTUM].uTrafficLimit == UINT_MAX)
03687                 {
03688                         UINT uBandwidth = m_gabInfo.dld->pMgr->GetSpeed ();;
03689                         for (size_t i = 0; i < vRunningDlds.size (); i++)
03690                                 uBandwidth += vRunningDlds [i]->pMgr->GetSpeed ();
03691                         m_gabInfo.uBandwidth = max (m_gabInfo.uBandwidth, uBandwidth);
03692                         m_gabInfo.uBandwidth = max (m_gabInfo.uBandwidth, m_gabInfo.uDldMaxSpeed + vRunningDlds.size ());
03693                 }
03694                 
03695                 m_gabInfo.uDldMaxSpeed = min (m_gabInfo.uDldMaxSpeed, m_gabInfo.uBandwidth - vRunningDlds.size ());
03696         }
03697                 break;
03698         }
03699 
03700         m_bSkip1Cicle = TRUE;
03701 
03702         if (m_gabInfo.enCurState != _inc_GrantAllBandwidthInfo::CS_Measuring_Bandwidth)
03703         {
03704                 ApplyTrafficLimitForListOfDownloads (vRunningDlds, 
03705                         (m_gabInfo.uBandwidth - m_gabInfo.uDldMaxSpeed) / vRunningDlds.size ());
03706         }
03707 
03708         LOG ("fsDsM::ATL_HHD: exit" << nl);
03709 }
03710 
03711 void fsDownloadsMgr::ApplyTrafficLimitForListOfDownloads(DLDS_LIST vDlds, UINT nLimit)
03712 {
03713         LOG ("fsDsM::ATLFLOD: start" << nl);
03714 
03715         UINT uShortage = 0;
03716         UINT cLimitedWithReqLimit = 0;
03717 
03718         if (nLimit == 0)
03719                 nLimit = 1;
03720 
03721         LOG ("fsDsM::ATLFLOD: number of downloads = " << DWORD (vDlds.size ()) << nl);
03722 
03723         
03724         for (size_t i = 0; i < vDlds.size (); i++)
03725         {
03726                 vmsDownloadMgrSmartPtr pMgr = vDlds [i]->pMgr;
03727                 UINT dldLimit = UINT_MAX;
03728                 if (pMgr->GetDownloadMgr () != NULL)
03729                 {
03730                         if (pMgr->GetDownloadMgr ()->GetDP ()->bIgnoreRestrictions)
03731                                 continue;
03732                         dldLimit = pMgr->GetDownloadMgr ()->GetDP ()->uTrafficRestriction;
03733                 }
03734 
03735                 if (dldLimit >= nLimit)
03736                 {
03737                         pMgr->LimitTraffic (nLimit);
03738                         cLimitedWithReqLimit++;
03739                 }
03740                 else 
03741                 {
03742                         
03743                         
03744                         pMgr->LimitTraffic (dldLimit);
03745                         uShortage += nLimit - dldLimit; 
03746                 }
03747         }
03748 
03749         LOG ("fsDsM::ATLFLOD: 1" << nl);
03750 
03751         if (cLimitedWithReqLimit)
03752                 uShortage /= cLimitedWithReqLimit;
03753 
03754         for (i = 0; i < vDlds.size (); i++)
03755         {
03756                 vmsDownloadMgrSmartPtr pMgr = vDlds [i]->pMgr;
03757                 if (pMgr->GetTrafficLimit () == nLimit)
03758                 {
03759                         
03760                         pMgr->LimitTraffic (nLimit + uShortage);
03761                 }
03762         }
03763 
03764         LOG ("fsDsM::ATLFLOD: exit" << nl);
03765 }
03766 
03767 void fsDownloadsMgr::set_HighestPriorityDownload(vmsDownloadSmartPtr dld)
03768 {
03769         m_gabInfo.dld = dld;
03770         ResetDldHpManageState ();
03771         ApplyTrafficLimit ();
03772 }
03773 
03774 int fsDownloadsMgr::IsSuchUrlExistsAlready(vmsDownloadSmartPtr dld)
03775 {
03776         fsURL url1, url2;
03777 
03778         if (dld->pMgr->GetDownloadMgr () == NULL)
03779                 return 0;
03780 
03781         fsDownload_NetworkProperties* dnp0 = dld->pMgr->GetDownloadMgr ()->GetDNP ();
03782 
03783         for (size_t i = 0; i < GetCount (); i++)
03784         {
03785                 vmsDownloadSmartPtr d = GetDownload (i);
03786                 if (d->pMgr->GetDownloadMgr () == NULL)
03787                         continue;
03788                 fsDownload_NetworkProperties* dnp = d->pMgr->GetDownloadMgr ()->GetDNP ();
03789 
03790                 if (dnp0->enProtocol == dnp->enProtocol && 
03791                         dnp0->uServerPort == dnp->uServerPort &&
03792                         fsIsServersEqual (dnp0->pszServerName, dnp->pszServerName, FALSE) && 
03793                         lstrcmp (dnp0->pszPathName, dnp->pszPathName) == 0 &&
03794                         lstrcmp (dnp0->pszUserName, dnp->pszUserName) == 0)
03795                 {
03796                         return i;
03797                 }
03798         }
03799 
03800         return -1;
03801 }
03802 
03803 BOOL fsDownloadsMgr::OnDldDone_CheckDownloadIsHtmlPageWithVideo(vmsDownloadSmartPtr dld)
03804 {
03805         if (dld->dwFlags & DLD_USEDBYHTMLSPIDER)
03806                 return FALSE;   
03807 
03808         if (dld->pMgr->GetDownloadMgr () == NULL)
03809                 return FALSE;
03810 
03811         fsDownloadMgr *pMgr = dld->pMgr->GetDownloadMgr ();
03812 
03813         if ((dld->dwFlags & DLD_NEED_ONDONE_FOR_FLASH_VIDEO) == 0 &&
03814                         strstr (pMgr->GetDownloader ()->GetContentType (), "html")  == NULL)
03815                 return FALSE;
03816         
03817         if (pMgr->GetDownloader ()->GetLDFileSize () > 500000)
03818                 return FALSE;
03819 
03820         HANDLE hFile = CreateFile (pMgr->GetDP ()->pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, 
03821                 OPEN_EXISTING, 0, NULL);
03822         if (hFile == INVALID_HANDLE_VALUE)
03823                 return FALSE;
03824 
03825         DWORD dw = GetFileSize (hFile, NULL);
03826 
03827         LPSTR pszHtml = new char [dw + 1];
03828         ReadFile (hFile, pszHtml, dw, &dw, NULL);
03829         pszHtml [dw] = 0;
03830 
03831         CloseHandle (hFile);
03832 
03833         vmsVideoSiteHtmlCodeParser vshcp;
03834         BOOL b;
03835 
03836         if (dld->dwFlags & DLD_NEED_ONDONE_FOR_FLASH_VIDEO)
03837         {
03838                 dld->dwFlags &= ~DLD_NEED_ONDONE_FOR_FLASH_VIDEO;
03839                 b = vshcp.Parse_Further (pMgr->GetDNP ()->pszServerName, pszHtml);
03840         }
03841         else
03842         {
03843                 b = vshcp.Parse (pMgr->GetDNP ()->pszServerName, pszHtml);
03844         }       
03845 
03846         delete [] pszHtml;
03847 
03848         if (b == FALSE)
03849                 return FALSE;
03850 
03851         if (IR_SUCCESS != dld->pMgr->GetDownloadMgr ()->CreateByUrl (vshcp.get_VideoUrl ()))
03852                 return FALSE;
03853         dld->pMgr->GetDownloadMgr ()->Reset ();
03854 
03855         if (vshcp.get_IsVideoUrlDirectLink ())
03856         {
03857                 if ((dld->dwFlags & DLD_FLASH_VIDEO) == 0)
03858                 {
03859                         dld->dwFlags |= DLD_FLASH_VIDEO;
03860                         _pwndFVDownloads->AddDownload (dld);
03861                         Event (dld, LS (L_FVDLD_DETECTED), EDT_INQUIRY);
03862                 }
03863         }
03864         else
03865         {
03866                 dld->dwFlags |= DLD_NEED_ONDONE_FOR_FLASH_VIDEO;
03867         }
03868 
03869         DeleteFile (pMgr->GetDP ()->pszFileName);
03870         LPSTR psz = strrchr (pMgr->GetDP ()->pszFileName, '\\');
03871         if (psz == NULL)
03872                 psz = strrchr (pMgr->GetDP ()->pszFileName, '/');
03873         if (psz)
03874                 psz [1] = 0;
03875 
03876         char szNewFile [MY_MAX_PATH];
03877         lstrcpy (szNewFile, pMgr->GetDP ()->pszFileName);
03878         fsString strFile;
03879         if (vshcp.get_VideoTitle () != NULL && *vshcp.get_VideoTitle ())
03880         {
03881                 strFile = vshcp.get_VideoTitle ();
03882                 LPCSTR pszInvChars = "\\/:*?\"<>|";
03883                 LPSTR psz = strFile;
03884                 while (*psz)
03885                 {
03886                         if (strchr (pszInvChars, *psz) != NULL)
03887                                 *psz = ' ';
03888                         psz++;
03889                 }
03890 
03891                 if (dld->strComment.GetLength () != 0)
03892                         dld->strComment += "\r\n";
03893                 dld->strComment += vshcp.get_VideoTitle ();
03894         }
03895         else
03896         {
03897                 strFile = LS (L_UNKNOWN);
03898         }
03899         lstrcat (szNewFile, strFile);
03900         lstrcat (szNewFile, ".");
03901         lstrcat (szNewFile, vshcp.get_VideoType ());
03902 
03903         SAFE_DELETE_ARRAY (pMgr->GetDP ()->pszFileName);
03904         pMgr->GetDP ()->pszFileName = new char [lstrlen (szNewFile) + 1];
03905         lstrcpy (pMgr->GetDP ()->pszFileName, szNewFile);
03906 
03907         dld->pMgr->StartDownloading (); 
03908 
03909         return TRUE;
03910 }
03911 
03912 void fsDownloadsMgr::DownloadStateChanged(vmsDownloadSmartPtr dld)
03913 {
03914         Event (dld, DME_DOWNLOAD_STATE_CHANGED);
03915 }
03916 
03917 void fsDownloadsMgr::AddEvent(vmsDownloadSmartPtr dld, LPCSTR pszEvent, fsDownloadMgr_EventDescType enType)
03918 {
03919         Event (dld, pszEvent, enType);
03920 }
03921 
03922 void fsDownloadsMgr::EventEx(vmsDownloadSmartPtr dld, LPCSTR pszEvent, fsDownloadMgr_EventDescType enType, int nMaxCharsPerLine)
03923 {
03924         fsString strEvent;
03925         int n = 0;
03926 
03927         while (*pszEvent)
03928         {
03929                 if (*pszEvent == ' ' && n >= nMaxCharsPerLine)
03930                 {
03931                         Event (dld, strEvent, enType);
03932                         strEvent = "";
03933                         n = 0;
03934                         pszEvent++;
03935                 }
03936                 else
03937                 {
03938                         strEvent += *pszEvent++;
03939                         if (*pszEvent == '\n' || *pszEvent == '\r')
03940                         {
03941                                 n = nMaxCharsPerLine;
03942                                 while (*pszEvent == '\n' || *pszEvent == '\r')
03943                                         pszEvent++;
03944                                 continue;
03945                         }
03946                         else
03947                         {
03948                                 n++;
03949 
03950                         }
03951                 }
03952         }
03953 
03954         if (strEvent.IsEmpty () == FALSE)
03955                 Event (dld, strEvent, enType);
03956 }
03957 
03958 vmsDownloadSmartPtr fsDownloadsMgr::get_HighestPriorityDownload()
03959 {
03960         return m_gabInfo.dld;
03961 }
03962 
03963 DWORD WINAPI fsDownloadsMgr::_threadStartSeeding(LPVOID lp)
03964 {
03965         fsDownloadsMgr *pthis = (fsDownloadsMgr*) lp;
03966 
03967         for (int k = 0; k < 2; k++)
03968         {
03969                 
03970                 for (int i = 0; i < k == 0 ? 15 : 300; i++)
03971                 {
03972                         Sleep (1000);
03973                         if (pthis->m_bNeedExit)
03974                                 break;
03975                 }
03976 
03977                 if (pthis->m_bNeedExit)
03978                         break;
03979 
03980                 vmsBtSession *pS = (vmsBtSession*) _BT.get_Session ();
03981                 for (i = 0; i < pS->get_DownloadCount (); i++)
03982                 {
03983                         vmsBtDownload *dld = pS->get_Download (i);
03984                         if (dld->GetState () == BTDS_SEEDING && dld->IsPaused ())
03985                                 dld->Resume ();
03986                 }
03987         }
03988 
03989         InterlockedDecrement (&pthis->m_cThreadsRunning);
03990         return 0;
03991 }
03992 
03993 BOOL fsDownloadsMgr::AllowStartNewDownloads()
03994 {
03995         return m_bAllowStart;
03996 }