void CDownloadGroupDlg::OnCbnCloseupSchemas()
{
// Get filters
CList< CString > oList;
for ( int nItem = 0 ; nItem < m_wndFilterList.GetCount() ; nItem++ )
{
CString strFilter;
m_wndFilterList.GetLBText( nItem, strFilter );
if ( oList.Find( strFilter ) == NULL )
oList.AddTail( strFilter );
}
// Remove old schema filters (preserve custom ones)
if ( CSchemaPtr pOldSchema = SchemaCache.Get( m_sOldSchemaURI ) )
{
for ( POSITION pos = pOldSchema->GetFilterIterator(); pos ; )
{
CString strFilter;
BOOL bResult;
pOldSchema->GetNextFilter( pos, strFilter, bResult );
if ( bResult )
{
strFilter.Insert( 0, _T('.') );
while ( POSITION pos = oList.Find( strFilter ) )
oList.RemoveAt( pos );
}
}
}
// Add new schema filters
if ( CSchemaPtr pNewSchema = SchemaCache.Get( m_wndSchemas.GetSelectedURI() ) )
{
for ( POSITION pos = pNewSchema->GetFilterIterator(); pos ; )
{
CString strFilter;
BOOL bResult;
pNewSchema->GetNextFilter( pos, strFilter, bResult );
if ( bResult )
{
strFilter.Insert( 0, _T('.') );
oList.AddTail( strFilter );
}
}
}
// Refill interface filters list
m_wndFilterList.ResetContent();
for ( POSITION pos = oList.GetHeadPosition() ; pos ; )
m_wndFilterList.AddString( oList.GetNext( pos ) );
m_sOldSchemaURI = m_wndSchemas.GetSelectedURI();
}
void CLibraryFolderCtrl::Update(DWORD nUpdateCookie)
{
CList< CLibraryFolder* > pAlready;
for ( HTREEITEM hItem = GetChildItem( m_hRoot ) ; hItem ; )
{
HTREEITEM hNext = GetNextSiblingItem( hItem );
CLibraryFolder* pFolder = (CLibraryFolder*)GetItemData( hItem );
if ( LibraryFolders.CheckFolder( pFolder ) )
{
Update( pFolder, hItem, NULL, nUpdateCookie, FALSE );
pAlready.AddTail( pFolder );
}
else
{
DeleteItem( hItem );
}
hItem = hNext;
}
for ( POSITION pos = LibraryFolders.GetFolderIterator() ; pos ; )
{
CLibraryFolder* pFolder = LibraryFolders.GetNextFolder( pos );
if ( pAlready.Find( pFolder ) == NULL )
{
Update( pFolder, NULL, m_hRoot, nUpdateCookie, FALSE );
}
}
}
CZGridRow* CDlgParamSet::GetNextRowAfterDel( CZGridRow*pCurItem)
{
CZGridRow* pParaentItem=NULL;
CZGridRow* pNextItem=NULL;
CList<CBCGPGridRow*, CBCGPGridRow*> lst;
//要删除的pRow
//pCurItem = (CZGridRow*)m_wndGridTree.GetRow(nIndex);
//if (pCurItem==NULL) return n;
pParaentItem = (CZGridRow*)pCurItem->GetParent();
pParaentItem->GetSubItems(lst);
POSITION pos =lst.Find(pCurItem);
lst.GetNext (pos);
if (pos==NULL)
pNextItem=pParaentItem;
else
pNextItem=(CZGridRow*)lst.GetAt(pos);
return pNextItem;
}
void CBCGPPlannerPrintMonth::AdjustAppointments ()
{
XBCGPAppointmentArray& arQueryApps = GetQueryedAppointments ();
const int nDays = GetViewDuration ();
if (arQueryApps.GetSize () == 0 || m_ViewRects.GetSize () != nDays)
{
return;
}
for (int i = 0; i < arQueryApps.GetSize (); i++)
{
CBCGPAppointment* pApp = arQueryApps[i];
ASSERT_VALID (pApp);
pApp->ResetPrint ();
}
COleDateTime date (m_DateStart);
COleDateTimeSpan spanDay (1, 0, 0, 0);
const int delta = m_nRowHeight + 2 * m_OnePoint.cy;
for (int nDay = 0; nDay < nDays; nDay ++)
{
CRect rect (m_ViewRects [nDay]);
rect.top += m_nRowHeight + 2 * m_OnePoint.cy;
rect.DeflateRect (m_OnePoint.cx, 0);
BOOL bTopEq = TRUE;
BOOL bBottomEq = TRUE;
if (nDay > 0)
{
bTopEq = m_ViewRects [nDay].top == m_ViewRects [nDay - 1].top;
bBottomEq = m_ViewRects [nDay].bottom == m_ViewRects [nDay - 1].bottom;
}
CList<int, int> lsItems;
for (int i = 0; i < arQueryApps.GetSize (); i++)
{
CBCGPAppointment* pApp = arQueryApps[i];
ASSERT_VALID (pApp);
if (CBCGPPlannerView::IsAppointmentInDate (*pApp, date))
{
CRect rtApp (rect);
int nItem = 0;
while(TRUE)
{
POSITION pos = lsItems.Find (nItem);
if (pos != NULL)
{
nItem++;
}
else
{
break;
}
}
rtApp.top += nItem * delta;
rtApp.bottom = rtApp.top + m_nRowHeight;
BOOL bAllOrMulti = pApp->IsAllDay () || pApp->IsMultiDay ();
// check for add new rect
if (nDay > 0)
{
if (bTopEq && bAllOrMulti)
{
if (!pApp->GetDSPrint ().IsEmpty ())
{
CRect rt;
rt = pApp->GetRectPrint (date - spanDay);
if (!rt.IsRectEmpty () && rtApp.top != rt.top)
{
rtApp.top = rt.top;
rtApp.bottom = rt.bottom;
}
}
}
}
if (((bTopEq && !bBottomEq) ||
(!bAllOrMulti &&
!CBCGPPlannerView::IsOneDay (pApp->GetStart (), pApp->GetFinish ()))) &&
!pApp->GetDSDraw ().IsEmpty ())
{
CRect rtInter;
rtInter.IntersectRect (rtApp, m_ViewRects [nDay]);
if (rtInter.Height () < rtApp.Height () ||
rtInter.bottom >= rect.bottom || !bAllOrMulti)
{
// add impossible rect
rtApp.OffsetRect (0, m_OnePoint.cy);
pApp->SetRectPrint (rtApp, date);
// return rect
rtApp.OffsetRect (0, -m_OnePoint.cy);
}
}
pApp->SetRectPrint (rtApp, date);
lsItems.AddTail ((rtApp.top - rect.top) / delta);
}
}
CheckVisibleAppointments(date, rect, TRUE);
date += spanDay;
}
}
void CBCGPRecurrence::Query (XBCGPAppointmentArray& ar, const COleDateTime& date1, const COleDateTime& date2) const
{
ar.RemoveAll ();
POSITION Pos = m_Exceptions.GetStartPosition ();
COleDateTime Key;
XBCGPRecurrenceException* Val = NULL;
CList<COleDateTime, const COleDateTime&> exceptions;
CBCGPAppointment* pApp = NULL;
while (Pos != NULL)
{
m_Exceptions.GetNextAssoc (Pos, Key, Val);
if (Val != NULL && !Val->m_Deleted)
{
if ((date1 <= Val->m_dtStart && Val->m_dtStart <= date2) ||
(date1 <= Val->m_dtFinish && Val->m_dtFinish <= date2) ||
(Val->m_dtStart < date1 && date2 < Val->m_dtFinish))
{
pApp = CreateClone (Key);
if (pApp != NULL)
{
exceptions.AddTail (Key);
ar.Add (pApp);
}
}
}
}
CBCGPRecurrenceBaseRule* pRule = GetRule ();
ASSERT_VALID(pRule);
if (pRule == NULL)
{
return;
}
BOOL bNext = TRUE;
COleDateTime dt1 (pRule->GetDateStart ());
if (!CBCGPPlannerView::IsOneDay (m_pAppointment->GetStart (),
m_pAppointment->GetFinish ()))
{
if (dt1 < date1)
{
COleDateTimeSpan span ((double)((int)
((double)m_pAppointment->GetDuration () + 0.5)));
COleDateTime d (date1 - span);
if (d > dt1)
{
dt1 = pRule->GetSiblingEventDay (d);
}
bNext = FALSE;
}
}
if (bNext)
{
if (dt1 <= date2)
{
if (dt1 <= date1)
{
dt1 = pRule->GetSiblingEventDay (date1);
}
}
}
if (dt1 == COleDateTime ())
{
return;
}
while (dt1 <= date2)
{
if (exceptions.Find (dt1) == NULL
&& !ExceptionExists (dt1))
{
pApp = CreateClone (dt1);
if (pApp != NULL)
{
if (pApp->GetFinish () != date1 ||
(pApp->GetStart () == pApp->GetFinish () && pApp->GetFinish () == date1))
{
ar.Add (pApp);
}
else
{
delete pApp;
}
}
}
dt1 = pRule->GetNextEventDay (dt1);
if (dt1 == COleDateTime ())
{
break;
}
}
}
void CBCGPPlannerViewMonth::AdjustAppointments ()
{
XBCGPAppointmentArray& arQueryApps = GetQueryedAppointments ();
XBCGPAppointmentArray& arDragApps = GetDragedAppointments ();
const int nDays = GetViewDuration ();
if ((arQueryApps.GetSize () == 0 && arDragApps.GetSize () == 0) ||
m_ViewRects.GetSize () != nDays)
{
ClearVisibleUpDownIcons ();
return;
}
BOOL bDragDrop = IsDragDrop ();
DROPEFFECT dragEffect = GetDragEffect ();
BOOL bDragMatch = IsCaptureMatched ();
bDragDrop = !bDragDrop ||
(bDragDrop && ((dragEffect & DROPEFFECT_COPY) == DROPEFFECT_COPY && bDragMatch) ||
!bDragMatch);
bDragDrop = bDragDrop && arDragApps.GetSize ();
int nApp = 0;
for (nApp = 0; nApp < 2; nApp++)
{
if (!bDragDrop && nApp == 0)
{
continue;
}
XBCGPAppointmentArray& arApps = nApp == 0 ? arDragApps : arQueryApps;
for (int i = 0; i < arApps.GetSize (); i++)
{
CBCGPAppointment* pApp = arApps[i];
ASSERT_VALID (pApp);
pApp->ResetDraw ();
}
}
COleDateTime date (m_DateStart);
COleDateTimeSpan spanDay (1, 0, 0, 0);
const int delta = m_nRowHeight + 2;
XBCGPAppointmentArray arAllOrMulti;
for (nApp = 0; nApp < 2; nApp++)
{
if (!bDragDrop && nApp == 1)
{
continue;
}
XBCGPAppointmentArray& arApps = nApp == 1 ? arDragApps : arQueryApps;
for (int i = 0; i < arApps.GetSize (); i++)
{
CBCGPAppointment* pApp = arApps[i];
ASSERT_VALID (pApp);
if (pApp->IsAllDay () || pApp->IsMultiDay ())
{
arAllOrMulti.Add (pApp);
}
}
}
if (arAllOrMulti.GetSize () > 0)
{
SortAppointments (arAllOrMulti, (int) arAllOrMulti.GetSize ());
}
for (int nDay = 0; nDay < nDays; nDay ++)
{
CRect rect (m_ViewRects [nDay]);
rect.top += m_nRowHeight + 1;
rect.DeflateRect (1, 0);
BOOL bTopEq = TRUE;
BOOL bBottomEq = TRUE;
if (nDay > 0)
{
bTopEq = m_ViewRects [nDay].top == m_ViewRects [nDay - 1].top;
bBottomEq = m_ViewRects [nDay].bottom == m_ViewRects [nDay - 1].bottom;
}
CList<int, int> lsItems;
// first draw all days or multi days
for (int n = 0; n < 2; n++)
{
for (nApp = 0; nApp < 2; nApp++)
{
if (n == 0 && nApp == 1)
{
continue;
}
if (!bDragDrop)
{
if(n == 1 && nApp == 0)
{
continue;
}
}
XBCGPAppointmentArray& arApps =
n == 0
? arAllOrMulti
: (nApp == 0 ? arDragApps : arQueryApps);
for (int i = 0; i < arApps.GetSize (); i++)
{
CBCGPAppointment* pApp = arApps[i];
ASSERT_VALID (pApp);
BOOL bAllOrMulti = pApp->IsAllDay () || pApp->IsMultiDay ();
if (CBCGPPlannerView::IsAppointmentInDate (*pApp, date) &&
((n == 0 && bAllOrMulti) || (n == 1 && !bAllOrMulti)))
{
CRect rtApp (rect);
int nItem = 0;
while(TRUE)
{
POSITION pos = lsItems.Find (nItem);
if (pos != NULL)
{
nItem++;
}
else
{
break;
}
}
rtApp.top += nItem * delta;
rtApp.bottom = rtApp.top + m_nRowHeight;
// check for add new rect
if (nDay > 0)
{
if (bTopEq && bAllOrMulti)
{
if (!pApp->GetDSDraw ().IsEmpty ())
{
CRect rt;
rt = pApp->GetRectDraw (date - spanDay);
if (!rt.IsRectEmpty () && rtApp.top != rt.top)
{
rtApp.top = rt.top;
rtApp.bottom = rt.bottom;
}
}
}
}
if (((bTopEq && !bBottomEq) ||
(!bAllOrMulti &&
!IsOneDay (pApp->GetStart (), pApp->GetFinish ()))) &&
!pApp->GetDSDraw ().IsEmpty ())
{
CRect rtInter;
rtInter.IntersectRect (rtApp, m_ViewRects [nDay]);
if (rtInter.Height () < rtApp.Height () ||
rtInter.bottom >= rect.bottom || !bAllOrMulti)
{
// add impossible rect
rtApp.OffsetRect (0, 1);
pApp->SetRectDraw (rtApp, date);
// return rect
rtApp.OffsetRect (0, -1);
}
}
pApp->SetRectDraw (rtApp, date);
lsItems.AddTail ((rtApp.top - rect.top) / delta);
}
}
}
}
CheckVisibleAppointments(date, rect, TRUE);
date += spanDay;
}
CheckVisibleUpDownIcons (TRUE);
m_bUpdateToolTipInfo = TRUE;
}
void CLibraryFolderCtrl::Update(CLibraryFolder* pFolder, HTREEITEM hFolder, HTREEITEM hParent, DWORD nUpdateCookie, BOOL bRecurse)
{
if ( ! hFolder )
{
DWORD dwStyle = INDEXTOOVERLAYMASK( pFolder->IsShared() ? 0 : SHI_O_LOCKED );
if ( pFolder->m_sPath.CompareNoCase( Settings.Downloads.CompletePath ) == 0 ) dwStyle |= TVIS_BOLD;
if ( m_bMultiSelect && GetFirstSelectedItem() == NULL ) dwStyle |= TVIS_SELECTED;
if ( pFolder->m_bExpanded ) dwStyle |= TVIS_EXPANDED;
CString strName = pFolder->m_sName;
if ( pFolder->m_pParent == NULL )
{
CString strDrive;
if ( pFolder->m_sPath.Find( _T(":\\") ) == 1 || pFolder->m_sPath.GetLength() == 2 )
strDrive.Format( _T(" (%c:)"), pFolder->m_sPath[0] );
else
strDrive = _T(" (Net)");
strName += strDrive;
dwStyle |= TVIS_EXPANDED;
}
hFolder = InsertItem( TVIF_PARAM|TVIF_TEXT|TVIF_IMAGE|TVIF_SELECTEDIMAGE|TVIF_STATE,
strName, SHI_FOLDER_CLOSED, SHI_FOLDER_CLOSED, dwStyle,
TVIS_EXPANDED|TVIS_SELECTED|TVIS_OVERLAYMASK, (LPARAM)pFolder, hParent, TVI_SORT );
}
else
{
DWORD dwMask = TVIS_OVERLAYMASK | TVIS_BOLD;
DWORD dwStyle = INDEXTOOVERLAYMASK( pFolder->IsShared() ? 0 : SHI_O_LOCKED );
if ( pFolder->m_sPath.CompareNoCase( Settings.Downloads.CompletePath ) == 0 ) dwStyle |= TVIS_BOLD;
DWORD dwExisting = GetItemState( hFolder, dwMask ) & dwMask;
if ( dwExisting != dwStyle ) SetItemState( hFolder, dwStyle, dwMask );
}
if ( nUpdateCookie )
{
if ( bRecurse || ( GetItemState( hFolder, TVIS_SELECTED ) & TVIS_SELECTED ) )
{
pFolder->m_nSelectCookie = nUpdateCookie;
bRecurse |= ( GetItemState( hFolder, TVIS_EXPANDED ) & TVIS_EXPANDED ) == 0;
}
}
CList< CLibraryFolder* > pAlready;
for ( HTREEITEM hItem = GetChildItem( hFolder ) ; hItem ; )
{
HTREEITEM hNext = GetNextSiblingItem( hItem );
CLibraryFolder* pChild = (CLibraryFolder*)GetItemData( hItem );
if ( pFolder->CheckFolder( pChild ) )
{
Update( pChild, hItem, NULL, nUpdateCookie, bRecurse );
pAlready.AddTail( pChild );
}
else
{
DeleteItem( hItem );
}
hItem = hNext;
}
for ( POSITION pos = pFolder->GetFolderIterator() ; pos ; )
{
CLibraryFolder* pChild = pFolder->GetNextFolder( pos );
if ( pAlready.Find( pChild ) == NULL )
{
Update( pChild, NULL, hFolder, nUpdateCookie, bRecurse );
}
}
int nOldImage1, nOldImage2;
GetItemImage( hFolder, nOldImage1, nOldImage2 );
int nImage = ItemHasChildren( hFolder ) && ( GetItemState( hFolder, TVIS_EXPANDED ) & TVIS_EXPANDED );
nImage = nImage ? SHI_FOLDER_OPEN : SHI_FOLDER_CLOSED;
if ( nOldImage1 != nImage ) SetItemImage( hFolder, nImage, nImage );
}
int CAICHSyncThread::Run()
{
if ( !theApp.emuledlg->IsRunning() )
return 0;
// we need to keep a lock on this file while the thread is running
CSingleLock lockKnown2Met(&CAICHHashSet::m_mutKnown2File);
lockKnown2Met.Lock();
// we collect all masterhashs which we find in the known2.met and store them in a list
CList<CAICHHash> liKnown2Hashs;
CString fullpath=thePrefs.GetConfigDir();
fullpath.Append(KNOWN2_MET_FILENAME);
CSafeFile file;
CFileException fexp;
uint32 nLastVerifiedPos = 0;
if (!file.Open(fullpath,CFile::modeCreate|CFile::modeReadWrite|CFile::modeNoTruncate|CFile::osSequentialScan|CFile::typeBinary|CFile::shareDenyNone, &fexp)){
if (fexp.m_cause != CFileException::fileNotFound){
CString strError(_T("Failed to load ") KNOWN2_MET_FILENAME _T(" file"));
TCHAR szError[MAX_CFEXP_ERRORMSG];
if (fexp.GetErrorMessage(szError, ARRSIZE(szError))){
strError += _T(" - ");
strError += szError;
}
LogError(LOG_STATUSBAR, _T("%s"), strError);
}
return false;
}
try {
//setvbuf(file.m_pStream, NULL, _IOFBF, 16384);
uint32 nExistingSize = (UINT)file.GetLength();
uint16 nHashCount;
while (file.GetPosition() < nExistingSize){
liKnown2Hashs.AddTail(CAICHHash(&file));
nHashCount = file.ReadUInt16();
if (file.GetPosition() + nHashCount*CAICHHash::GetHashSize() > nExistingSize){
AfxThrowFileException(CFileException::endOfFile, 0, file.GetFileName());
}
// skip the rest of this hashset
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
nLastVerifiedPos = (UINT)file.GetPosition();
}
}
catch(CFileException* error){
if (error->m_cause == CFileException::endOfFile){
LogError(LOG_STATUSBAR,GetResString(IDS_ERR_SERVERMET_BAD));
// truncate the file to the size to the last verified valid pos
try{
file.SetLength(nLastVerifiedPos);
}
catch(CFileException* error2){
error2->Delete();
}
}
else{
TCHAR buffer[MAX_CFEXP_ERRORMSG];
error->GetErrorMessage(buffer, ARRSIZE(buffer));
LogError(LOG_STATUSBAR,GetResString(IDS_ERR_SERVERMET_UNKNOWN),buffer);
}
error->Delete();
return false;
}
// now we check that all files which are in the sharedfilelist have a corresponding hash in out list
// those how don'T are added to the hashinglist
CList<CAICHHash> liUsedHashs;
CSingleLock sharelock(&theApp.sharedfiles->m_mutWriteList);
sharelock.Lock();
for (uint32 i = 0; i < theApp.sharedfiles->GetCount(); i++){
CKnownFile* pCurFile = theApp.sharedfiles->GetFileByIndex(i);
if (pCurFile != NULL && !pCurFile->IsPartFile() ){
if (theApp.emuledlg==NULL || !theApp.emuledlg->IsRunning()) // in case of shutdown while still hashing
return 0;
if (pCurFile->GetAICHHashset()->GetStatus() == AICH_HASHSETCOMPLETE){
bool bFound = false;
for (POSITION pos = liKnown2Hashs.GetHeadPosition();pos != 0;)
{
CAICHHash current_hash = liKnown2Hashs.GetNext(pos);
if (current_hash == pCurFile->GetAICHHashset()->GetMasterHash()){
bFound = true;
liUsedHashs.AddTail(current_hash);
//theApp.QueueDebugLogLine(false, _T("%s - %s"), current_hash.GetString(), pCurFile->GetFileName());
#ifdef _DEBUG
// in debugmode we load and verify all hashsets
ASSERT( pCurFile->GetAICHHashset()->LoadHashSet() );
// pCurFile->GetAICHHashset()->DbgTest();
pCurFile->GetAICHHashset()->FreeHashSet();
#endif
break;
}
}
if (bFound) // hashset is available, everything fine with this file
continue;
}
pCurFile->GetAICHHashset()->SetStatus(AICH_ERROR);
m_liToHash.AddTail(pCurFile);
}
}
sharelock.Unlock();
// removed all unused AICH hashsets from known2.met
if (!thePrefs.IsRememberingDownloadedFiles() && liUsedHashs.GetCount() != liKnown2Hashs.GetCount()){
file.SeekToBegin();
try {
uint32 nExistingSize = (UINT)file.GetLength();
uint16 nHashCount;
ULONGLONG posWritePos = 0;
ULONGLONG posReadPos = 0;
uint32 nPurgeCount = 0;
while (file.GetPosition() < nExistingSize){
CAICHHash aichHash(&file);
nHashCount = file.ReadUInt16();
if (file.GetPosition() + nHashCount*CAICHHash::GetHashSize() > nExistingSize){
AfxThrowFileException(CFileException::endOfFile, 0, file.GetFileName());
}
if (liUsedHashs.Find(aichHash) == NULL){
// unused hashset skip the rest of this hashset
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
nPurgeCount++;
}
else if(nPurgeCount == 0){
// used Hashset, but it does not need to be moved as nothing changed yet
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
posWritePos = file.GetPosition();
}
else{
// used Hashset, move position in file
BYTE* buffer = new BYTE[nHashCount*CAICHHash::GetHashSize()];
file.Read(buffer, nHashCount*CAICHHash::GetHashSize());
posReadPos = file.GetPosition();
file.Seek(posWritePos, CFile::begin);
file.Write(aichHash.GetRawHash(), CAICHHash::GetHashSize());
file.WriteUInt16(nHashCount);
file.Write(buffer, nHashCount*CAICHHash::GetHashSize());
delete[] buffer;
posWritePos = file.GetPosition();
file.Seek(posReadPos, CFile::begin);
}
}
posReadPos = file.GetPosition();
file.SetLength(posWritePos);
theApp.QueueDebugLogLine(false, _T("Cleaned up known2.met, removed %u hashsets (%s)"), nPurgeCount, CastItoXBytes(posReadPos-posWritePos));
file.Flush();
file.Close();
}
catch(CFileException* error){
if (error->m_cause == CFileException::endOfFile){
// we just parsed this files some ms ago, should never happen here
ASSERT( false );
}
else{
TCHAR buffer[MAX_CFEXP_ERRORMSG];
error->GetErrorMessage(buffer, ARRSIZE(buffer));
LogError(LOG_STATUSBAR,GetResString(IDS_ERR_SERVERMET_UNKNOWN),buffer);
}
error->Delete();
return false;
}
}
lockKnown2Met.Unlock();
// warn the user if he just upgraded
if (thePrefs.IsFirstStart() && !m_liToHash.IsEmpty()){
LogWarning(GetResString(IDS_AICH_WARNUSER));
}
if (!m_liToHash.IsEmpty()){
theApp.QueueLogLine(true, GetResString(IDS_AICH_SYNCTOTAL), m_liToHash.GetCount() );
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.SetAICHHashing(m_liToHash.GetCount());
// let first all normal hashing be done before starting out synchashing
CSingleLock sLock1(&theApp.hashing_mut); // only one filehash at a time
while (theApp.sharedfiles->GetHashingCount() != 0){
Sleep(100);
}
sLock1.Lock();
uint32 cDone = 0;
for (POSITION pos = m_liToHash.GetHeadPosition();pos != 0; cDone++)
{
if (theApp.emuledlg==NULL || !theApp.emuledlg->IsRunning()){ // in case of shutdown while still hashing
return 0;
}
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.SetAICHHashing(m_liToHash.GetCount()-cDone);
if (theApp.emuledlg->sharedfileswnd->sharedfilesctrl.m_hWnd != NULL)
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.ShowFilesCount();
CKnownFile* pCurFile = m_liToHash.GetNext(pos);
// just to be sure that the file hasnt been deleted lately
if (!(theApp.knownfiles->IsKnownFile(pCurFile) && theApp.sharedfiles->GetFileByID(pCurFile->GetFileHash())) )
continue;
theApp.QueueLogLine(false, GetResString(IDS_AICH_CALCFILE), pCurFile->GetFileName());
if(!pCurFile->CreateAICHHashSetOnly())
theApp.QueueDebugLogLine(false, _T("Failed to create AICH Hashset while sync. for file %s"), pCurFile->GetFileName());
}
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.SetAICHHashing(0);
if (theApp.emuledlg->sharedfileswnd->sharedfilesctrl.m_hWnd != NULL)
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.ShowFilesCount();
sLock1.Unlock();
}
theApp.QueueDebugLogLine(false, _T("AICHSyncThread finished"));
return 0;
}
BOOL CFileSharingPage::OnInitDialog()
{
CFilePropertiesPage::OnInitDialog();
m_wndTags.AddString( L"" );
{
CQuickLock oLock( UploadQueues.m_pSection );
CList< CString > pAdded;
for ( POSITION pos = UploadQueues.GetIterator(); pos; )
{
CUploadQueue* pQueue = UploadQueues.GetNext( pos );
if ( ! pQueue->m_sShareTag.IsEmpty() )
{
if ( pAdded.Find( pQueue->m_sShareTag ) == NULL )
{
pAdded.AddTail( pQueue->m_sShareTag );
m_wndTags.AddString( pQueue->m_sShareTag );
}
}
}
if ( pAdded.IsEmpty() )
{
m_wndTags.AddString( L"Release" );
m_wndTags.AddString( L"Popular" );
}
}
{
CQuickLock oLock( Library.m_pSection );
if ( CLibraryFile* pSingleFile = GetFile() )
{
m_bOverride = pSingleFile->IsSharedOverride();
m_bShare = pSingleFile->IsShared();
m_sTags = pSingleFile->m_sShareTags;
}
else
{
CLibraryListPtr pList( GetList() );
if ( pList )
{
for ( POSITION pos = pList->GetHeadPosition(); pos; )
{
if ( CLibraryFile* pFile = pList->GetNextFile( pos ) )
{
m_bOverride = pFile->IsSharedOverride();
m_bShare = pFile->IsShared();
m_sTags = pFile->m_sShareTags;
}
}
}
}
}
UpdateData( FALSE );
m_wndShare.EnableWindow( m_bOverride );
return TRUE;
}
int CAICHSyncThread::Run()
{
//MORPH START SLUGFILLER: SafeHash
CReadWriteLock lock(&theApp.m_threadlock);
if (!lock.ReadLock(0))
return 0;
// MORPH END SLUGFILLER: SafeHash
if ( !theApp.emuledlg->IsRunning() )
return 0;
// we need to keep a lock on this file while the thread is running
CSingleLock lockKnown2Met(&CAICHRecoveryHashSet::m_mutKnown2File);
lockKnown2Met.Lock();
CSafeFile file;
bool bJustCreated = ConvertToKnown2ToKnown264(&file);
// we collect all masterhashs which we find in the known2.met and store them in a list
CList<CAICHHash> liKnown2Hashs;
CString fullpath = thePrefs.GetMuleDirectory(EMULE_CONFIGDIR);
fullpath.Append(KNOWN2_MET_FILENAME);
CFileException fexp;
uint32 nLastVerifiedPos = 0;
if (!bJustCreated && !file.Open(fullpath,CFile::modeCreate|CFile::modeReadWrite|CFile::modeNoTruncate|CFile::osSequentialScan|CFile::typeBinary|CFile::shareDenyNone, &fexp)){
if (fexp.m_cause != CFileException::fileNotFound){
CString strError(_T("Failed to load ") KNOWN2_MET_FILENAME _T(" file"));
TCHAR szError[MAX_CFEXP_ERRORMSG];
if (fexp.GetErrorMessage(szError, ARRSIZE(szError))){
strError += _T(" - ");
strError += szError;
}
LogError(LOG_STATUSBAR, _T("%s"), strError);
}
return false;
}
try {
if (file.GetLength() >= 1){
uint8 header = file.ReadUInt8();
if (header != KNOWN2_MET_VERSION){
AfxThrowFileException(CFileException::endOfFile, 0, file.GetFileName());
}
//setvbuf(file.m_pStream, NULL, _IOFBF, 16384);
uint32 nExistingSize = (UINT)file.GetLength();
uint32 nHashCount;
while (file.GetPosition() < nExistingSize){
liKnown2Hashs.AddTail(CAICHHash(&file));
nHashCount = file.ReadUInt32();
if (file.GetPosition() + nHashCount*CAICHHash::GetHashSize() > nExistingSize){
AfxThrowFileException(CFileException::endOfFile, 0, file.GetFileName());
}
// skip the rest of this hashset
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
nLastVerifiedPos = (UINT)file.GetPosition();
}
}
else
file.WriteUInt8(KNOWN2_MET_VERSION);
}
catch(CFileException* error){
if (error->m_cause == CFileException::endOfFile){
LogError(LOG_STATUSBAR,GetResString(IDS_ERR_MET_BAD), KNOWN2_MET_FILENAME);
// truncate the file to the size to the last verified valid pos
try{
file.SetLength(nLastVerifiedPos);
if (file.GetLength() == 0){
file.SeekToBegin();
file.WriteUInt8(KNOWN2_MET_VERSION);
}
}
catch(CFileException* error2){
error2->Delete();
}
}
else{
TCHAR buffer[MAX_CFEXP_ERRORMSG];
error->GetErrorMessage(buffer, ARRSIZE(buffer));
LogError(LOG_STATUSBAR,GetResString(IDS_ERR_SERVERMET_UNKNOWN),buffer);
}
error->Delete();
return false;
}
// now we check that all files which are in the sharedfilelist have a corresponding hash in out list
// those who don'T are added to the hashinglist
CList<CAICHHash> liUsedHashs;
CSingleLock sharelock(&theApp.sharedfiles->m_mutWriteList);
sharelock.Lock();
bool bDbgMsgCreatingPartHashs = true;
for (int i = 0; i < theApp.sharedfiles->GetCount(); i++){
CKnownFile* pCurFile = theApp.sharedfiles->GetFileByIndex(i);
if (pCurFile != NULL && !pCurFile->IsPartFile() )
{
if (theApp.emuledlg==NULL || !theApp.emuledlg->IsRunning()) // in case of shutdown while still hashing
return 0;
if (pCurFile->GetFileIdentifier().HasAICHHash()){
bool bFound = false;
for (POSITION pos = liKnown2Hashs.GetHeadPosition();pos != 0;)
{
CAICHHash current_hash = liKnown2Hashs.GetNext(pos);
if (current_hash == pCurFile->GetFileIdentifier().GetAICHHash()){
bFound = true;
liUsedHashs.AddTail(current_hash);
pCurFile->SetAICHRecoverHashSetAvailable(true);
// Has the file the proper AICH Parthashset? If not probably upgrading, create it
if (!pCurFile->GetFileIdentifier().HasExpectedAICHHashCount())
{
if (bDbgMsgCreatingPartHashs)
{
bDbgMsgCreatingPartHashs = false;
DebugLogWarning(_T("Missing AICH Part Hashsets for known files - maybe upgrading from earlier version. Creating them out of full AICH Recovery Hashsets, shouldn't take too long"));
}
CAICHRecoveryHashSet tempHashSet(pCurFile, pCurFile->GetFileSize());
tempHashSet.SetMasterHash(pCurFile->GetFileIdentifier().GetAICHHash(), AICH_HASHSETCOMPLETE);
if (!tempHashSet.LoadHashSet())
{
ASSERT( false );
DebugLogError(_T("Failed to load full AICH Recovery Hashset - known2.met might be corrupt. Unable to create AICH Part Hashset - %s"), pCurFile->GetFileName());
}
else
{
if (!pCurFile->GetFileIdentifier().SetAICHHashSet(tempHashSet))
{
DebugLogError(_T("Failed to create AICH Part Hashset out of full AICH Recovery Hashset - %s"), pCurFile->GetFileName());
ASSERT( false );
}
ASSERT(pCurFile->GetFileIdentifier().HasExpectedAICHHashCount());
}
}
//theApp.QueueDebugLogLine(false, _T("%s - %s"), current_hash.GetString(), pCurFile->GetFileName());
/*#ifdef _DEBUG
// in debugmode we load and verify all hashsets
CAICHRecoveryHashSet* pTempHashSet = new CAICHRecoveryHashSet(pCurFile);
pTempHashSet->SetFileSize(pCurFile->GetFileSize());
pTempHashSet->SetMasterHash(pCurFile->GetFileIdentifier().GetAICHHash(), AICH_HASHSETCOMPLETE)
ASSERT( pTempHashSet->LoadHashSet() );
delete pTempHashSet;
#endif*/
break;
}
}
if (bFound) // hashset is available, everything fine with this file
continue;
}
pCurFile->SetAICHRecoverHashSetAvailable(false);
m_liToHash.AddTail(pCurFile);
}
}
sharelock.Unlock();
// removed all unused AICH hashsets from known2.met
if (liUsedHashs.GetCount() != liKnown2Hashs.GetCount() &&
// EastShare START - Added by TAHO, .met file control
/*
(!thePrefs.IsRememberingDownloadedFiles() || thePrefs.DoPartiallyPurgeOldKnownFiles()))
*/
(!thePrefs.IsRememberingDownloadedFiles() ||
thePrefs.DoPartiallyPurgeOldKnownFiles() ||
thePrefs.DoCompletlyPurgeOldKnownFiles() ||
thePrefs.DoRemoveAichImmediatly()
)
)
// EastShare END - Added by TAHO, .met file control
{
file.SeekToBegin();
try {
uint8 header = file.ReadUInt8();
if (header != KNOWN2_MET_VERSION){
AfxThrowFileException(CFileException::endOfFile, 0, file.GetFileName());
}
uint32 nExistingSize = (UINT)file.GetLength();
uint32 nHashCount;
ULONGLONG posWritePos = file.GetPosition();
ULONGLONG posReadPos = file.GetPosition();
uint32 nPurgeCount = 0;
uint32 nPurgeBecauseOld = 0;
while (file.GetPosition() < nExistingSize){
CAICHHash aichHash(&file);
nHashCount = file.ReadUInt32();
if (file.GetPosition() + nHashCount*CAICHHash::GetHashSize() > nExistingSize){
AfxThrowFileException(CFileException::endOfFile, 0, file.GetFileName());
}
if (!thePrefs.IsRememberingDownloadedFiles() && liUsedHashs.Find(aichHash) == NULL)
{
// unused hashset skip the rest of this hashset
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
nPurgeCount++;
}
else if (thePrefs.IsRememberingDownloadedFiles() && theApp.knownfiles->ShouldPurgeAICHHashset(aichHash))
{
// EastShare START - Added by TAHO, .met file control
/*
ASSERT( thePrefs.DoPartiallyPurgeOldKnownFiles() );
*/
ASSERT( thePrefs.DoPartiallyPurgeOldKnownFiles() || thePrefs.DoRemoveAichImmediatly());
// EastShare END - Added by TAHO, .met file control
// also unused (purged) hashset skip the rest of this hashset
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
nPurgeCount++;
nPurgeBecauseOld++;
}
else if(nPurgeCount == 0){
// used Hashset, but it does not need to be moved as nothing changed yet
file.Seek(nHashCount*CAICHHash::GetHashSize(), CFile::current);
posWritePos = file.GetPosition();
CAICHRecoveryHashSet::AddStoredAICHHash(aichHash);
}
else{
// used Hashset, move position in file
BYTE* buffer = new BYTE[nHashCount*CAICHHash::GetHashSize()];
file.Read(buffer, nHashCount*CAICHHash::GetHashSize());
posReadPos = file.GetPosition();
file.Seek(posWritePos, CFile::begin);
file.Write(aichHash.GetRawHash(), CAICHHash::GetHashSize());
file.WriteUInt32(nHashCount);
file.Write(buffer, nHashCount*CAICHHash::GetHashSize());
delete[] buffer;
posWritePos = file.GetPosition();
file.Seek(posReadPos, CFile::begin);
CAICHRecoveryHashSet::AddStoredAICHHash(aichHash);
}
}
posReadPos = file.GetPosition();
file.SetLength(posWritePos);
theApp.QueueDebugLogLine(false, _T("Cleaned up known2.met, removed %u hashsets and purged %u hashsets of old known files (%s)")
, nPurgeCount - nPurgeBecauseOld, nPurgeBecauseOld, CastItoXBytes(posReadPos-posWritePos));
file.Flush();
file.Close();
}
catch(CFileException* error){
if (error->m_cause == CFileException::endOfFile){
// we just parsed this files some ms ago, should never happen here
ASSERT( false );
}
else{
TCHAR buffer[MAX_CFEXP_ERRORMSG];
error->GetErrorMessage(buffer, ARRSIZE(buffer));
LogError(LOG_STATUSBAR,GetResString(IDS_ERR_SERVERMET_UNKNOWN),buffer);
}
error->Delete();
return false;
}
}
else
{
// remember (/index) all hashs which are stored in the file for faster checking lateron
for (POSITION pos = liKnown2Hashs.GetHeadPosition();pos != 0;)
{
CAICHRecoveryHashSet::AddStoredAICHHash(liKnown2Hashs.GetNext(pos));
}
}
lockKnown2Met.Unlock();
// warn the user if he just upgraded
if (thePrefs.IsFirstStart() && !m_liToHash.IsEmpty() && !bJustCreated){
LogWarning(GetResString(IDS_AICH_WARNUSER));
}
if (!m_liToHash.IsEmpty()){
theApp.QueueLogLine(true, GetResString(IDS_AICH_SYNCTOTAL), m_liToHash.GetCount() );
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.SetAICHHashing(m_liToHash.GetCount());
// let first all normal hashing be done before starting out synchashing
CSingleLock sLock1(&theApp.hashing_mut); // only one filehash at a time
while (theApp.sharedfiles->GetHashingCount() != 0){
Sleep(100);
if (!CemuleDlg::IsRunning())
return 0;
}
sLock1.Lock();
uint32 cDone = 0;
for (POSITION pos = m_liToHash.GetHeadPosition();pos != 0; cDone++)
{
if (!CemuleDlg::IsRunning()){ // in case of shutdown while still hashing
return 0;
}
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.SetAICHHashing(m_liToHash.GetCount()-cDone);
if (theApp.emuledlg->sharedfileswnd->sharedfilesctrl.m_hWnd != NULL)
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.ShowFilesCount();
CKnownFile* pCurFile = m_liToHash.GetNext(pos);
// just to be sure that the file hasnt been deleted lately
if (!(theApp.knownfiles->IsKnownFile(pCurFile) && theApp.sharedfiles->GetFileByID(pCurFile->GetFileHash())) )
continue;
theApp.QueueLogLine(false, GetResString(IDS_AICH_CALCFILE), pCurFile->GetFileName());
if(!pCurFile->CreateAICHHashSetOnly())
theApp.QueueDebugLogLine(false, _T("Failed to create AICH Hashset while sync. for file %s"), pCurFile->GetFileName());
}
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.SetAICHHashing(0);
if (theApp.emuledlg->sharedfileswnd->sharedfilesctrl.m_hWnd != NULL)
theApp.emuledlg->sharedfileswnd->sharedfilesctrl.ShowFilesCount();
sLock1.Unlock();
}
theApp.QueueDebugLogLine(false, _T("AICHSyncThread finished"));
return 0;
}
