sharedfile.cpp

著名的下载软件核心Shareaza

	if ( CXMLElement* pComment = pXML->GetElementByName( _T("comment") ) )
	{
		m_nRating = -1;
		CString strRating = pComment->GetAttributeValue( _T("rating") );
		_stscanf( strRating, _T("%i"), &m_nRating );
		m_nRating	= max( 0, min( 6, m_nRating + 1 ) );
		m_sComments	= pComment->GetValue();
		Replace( m_sComments, _T("{n}"), _T("\r\n") );
		pComment->Delete();
	}
	
	CSchema* pSchema = SchemaCache.Get( pXML->GetAttributeValue( CXMLAttribute::schemaName, _T("") ) );
	
	if ( pSchema == NULL || pXML->GetFirstElement() == NULL )
	{
		delete pXML;
		return FALSE;
	}
	
	pSchema->Validate( pXML, TRUE );
	
	if ( m_pMetadata != NULL ) delete m_pMetadata;
	
	m_pSchema		= pSchema;
	m_pMetadata		= pXML->GetFirstElement()->Detach();
	m_bMetadataAuto	= FALSE;
	
	delete pXML;
	
	return TRUE;
}

BOOL CLibraryFile::SaveMetadata()
{
	CXMLElement* pXML = NULL;
	
	m_nUpdateCookie++;
	
	if ( m_pFolder == NULL ) return TRUE;
	
	if ( m_pSchema != NULL && m_pMetadata != NULL && ! m_bMetadataAuto )
	{
		pXML = m_pSchema->Instantiate( TRUE );
		pXML->AddElement( m_pMetadata->Clone() );
	}
	
	if ( m_nRating > 0 || m_sComments.GetLength() > 0 )
	{
		if ( pXML == NULL )
		{
			pXML = new CXMLElement( NULL, _T("comments") );
		}
		
		CXMLElement* pComment = pXML->AddElement( _T("comment") );
		
		if ( m_nRating > 0 )
		{
			CString strRating;
			strRating.Format( _T("%i"), m_nRating - 1 );
			pComment->AddAttribute( _T("rating"), strRating );
		}
		
		if ( m_sComments.GetLength() > 0 )
		{
			CString strComments( m_sComments );
			Replace( strComments, _T("\r\n"), _T("{n}") );
			pComment->SetValue( strComments );
		}
	}
	
	CString strMetaFolder	= m_pFolder->m_sPath + _T("\\Metadata");
	CString strMetaFile		= strMetaFolder + _T("\\") + m_sName + _T(".xml");
	
	if ( pXML != NULL )
	{
		pXML->AddAttribute( _T("xmlns:xsi"), CXMLAttribute::xmlnsInstance );
		
		HANDLE hFile = CreateFile( strMetaFile, GENERIC_WRITE, FILE_SHARE_READ, NULL,
			CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
		
		if ( hFile == INVALID_HANDLE_VALUE )
		{
			CreateDirectory( strMetaFolder, NULL );
			SetFileAttributes( strMetaFolder, FILE_ATTRIBUTE_HIDDEN );
			
			hFile = CreateFile( strMetaFile, GENERIC_WRITE, FILE_SHARE_READ, NULL,
				CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
			
			if ( hFile == INVALID_HANDLE_VALUE ) return FALSE;
		}
		
		CString strXML = pXML->ToString( TRUE, TRUE );
		DWORD nWritten;
		delete pXML;
		
#ifdef _UNICODE
		int nASCII = WideCharToMultiByte( CP_UTF8, 0, strXML, strXML.GetLength(), NULL, 0, NULL, NULL );
		LPSTR pszASCII = new CHAR[ nASCII ];
		WideCharToMultiByte( CP_UTF8, 0, strXML, strXML.GetLength(), pszASCII, nASCII, NULL, NULL );
		WriteFile( hFile, pszASCII, nASCII, &nWritten, NULL );
		delete [] pszASCII;
#else
		WriteFile( hFile, (LPCSTR)strXML, strXML.GetLength(), &nWritten, NULL );
#endif
		
		GetFileTime( hFile, NULL, NULL, &m_pMetadataTime );
		CloseHandle( hFile );
	}
	else
	{
		DeleteFile( strMetaFile );
		RemoveDirectory( strMetaFolder );
		ZeroMemory( &m_pMetadataTime, sizeof(FILETIME) );
	}
	
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// CLibraryFile delete handler

void CLibraryFile::OnDelete()
{
	if ( m_pFolder != NULL )
	{
		if ( m_nRating > 0 || m_sComments.GetLength() > 0 )
		{
			Ghost();
			return;
		}
	}
	
	Library.OnFileDelete( this );
	
	delete this;
}

void CLibraryFile::Ghost()
{
	SYSTEMTIME pTime;
	GetSystemTime( &pTime );
	SystemTimeToFileTime( &pTime, &m_pTime );
	Library.RemoveFile( this );
	m_pFolder = NULL;
	Library.AddFile( this );
	Library.OnFileDelete( this );
}

//////////////////////////////////////////////////////////////////////
// CLibraryFile download verification

BOOL CLibraryFile::OnVerifyDownload(const SHA1* pSHA1, const MD4* pED2K, LPCTSTR pszSources)
{
	if ( m_pFolder == NULL ) return FALSE;
	
	if ( Settings.Downloads.VerifyFiles && m_bVerify == TS_UNKNOWN && m_nVirtualSize == 0 )
	{
		if ( m_bSHA1 && pSHA1 != NULL )
		{
			m_bVerify = ( m_pSHA1 == *pSHA1 ) ? TS_TRUE : TS_FALSE;
		}
		else if ( m_bED2K && pED2K != NULL )
		{
			m_bVerify = ( m_pED2K == *pED2K ) ? TS_TRUE : TS_FALSE;
		}
		
		if ( m_bVerify == TS_TRUE )
		{
			theApp.Message( MSG_SYSTEM, IDS_DOWNLOAD_VERIFY_SUCCESS, (LPCTSTR)m_sName );
			Downloads.OnVerify( GetPath(), TRUE );
		}
		else if ( m_bVerify == TS_FALSE )
		{
			m_bShared = TS_FALSE;
			
			theApp.Message( MSG_ERROR, IDS_DOWNLOAD_VERIFY_FAIL, (LPCTSTR)m_sName );
			Downloads.OnVerify( GetPath(), FALSE );
			
			return FALSE;
		}
	}
	
	if ( m_bSHA1 && m_nVirtualSize == 0 && VersionChecker.m_bUpgrade )
	{
		VersionChecker.CheckUpgradeHash( &m_pSHA1, GetPath() );
	}
	
	if ( pszSources != NULL && *pszSources != 0 )
	{
		AddAlternateSources( pszSources );
	}
	
	return TRUE;
}


//////////////////////////////////////////////////////////////////////
// CSharedSource construction

CSharedSource::CSharedSource(LPCTSTR pszURL, FILETIME* pTime)
{
	if ( pszURL != NULL )
	{
		m_sURL = pszURL;
		Freshen( pTime );
	}
}

void CSharedSource::Serialize(CArchive& ar, int nVersion)
{
	if ( ar.IsStoring() )
	{
		ar << m_sURL;
		ar.Write( &m_pTime, sizeof(FILETIME) );
	}
	else
	{
		ar >> m_sURL;

		if ( nVersion >= 10 )
		{
			ar.Read( &m_pTime, sizeof(FILETIME) );
		}
		else
		{
			DWORD nTemp;
			ar >> nTemp;
			Freshen();
		}
	}
}

void CSharedSource::Freshen(FILETIME* pTime)
{
	SYSTEMTIME tNow1;
	GetSystemTime( &tNow1 );
	
	if ( pTime != NULL )
	{
		FILETIME tNow2;
		
		SystemTimeToFileTime( &tNow1, &tNow2 );
		(LONGLONG&)tNow2 += 10000000;
		
		if ( CompareFileTime( pTime, &tNow2 ) <= 0 )
		{
			m_pTime = *pTime;
		}
		else
		{
			SystemTimeToFileTime( &tNow1, &m_pTime );
		}
	}
	else
	{
		SystemTimeToFileTime( &tNow1, &m_pTime );
	}
}

BOOL CSharedSource::IsExpired(FILETIME& tNow)
{
	LONGLONG nElapse = *((LONGLONG*)&tNow) - *((LONGLONG*)&m_pTime);
	return nElapse > (LONGLONG)Settings.Library.SourceExpire * 10000000;
}

//////////////////////////////////////////////////////////////////////
// CLibraryFile automation

IMPLEMENT_DISPATCH(CLibraryFile, LibraryFile)

STDMETHODIMP CLibraryFile::XLibraryFile::get_Application(IApplication FAR* FAR* ppApplication)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*ppApplication = Application.GetApp();
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Library(ILibrary FAR* FAR* ppLibrary)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*ppLibrary = (ILibrary*)Library.GetInterface( IID_ILibrary, TRUE );
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Folder(ILibraryFolder FAR* FAR* ppFolder)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	if ( pThis->m_pFolder == NULL )
		*ppFolder = NULL;
	else
		*ppFolder = (ILibraryFolder*)pThis->m_pFolder->GetInterface( IID_ILibraryFolder, TRUE );
	return *ppFolder != NULL ? S_OK : S_FALSE;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Path(BSTR FAR* psPath)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	pThis->GetPath().SetSysString( psPath );
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Name(BSTR FAR* psPath)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	pThis->m_sName.SetSysString( psPath );
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Shared(STRISTATE FAR* pnValue)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*pnValue = (STRISTATE)pThis->m_bShared;
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::put_Shared(STRISTATE nValue)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	pThis->m_bShared = nValue;
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_EffectiveShared(VARIANT_BOOL FAR* pbValue)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*pbValue = pThis->IsShared() ? VARIANT_TRUE : VARIANT_FALSE;
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Size(LONG FAR* pnSize)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*pnSize = (LONG)pThis->GetSize();
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Index(LONG FAR* pnIndex)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*pnIndex = (LONG)pThis->m_nIndex;
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_URN(BSTR sURN, BSTR FAR* psURN)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	CString strURN( sURN );
	
	if ( strURN.IsEmpty() )
	{
		if ( pThis->m_bTiger && pThis->m_bSHA1 )
			strURN = _T("urn:bitprint");
		else if ( pThis->m_bTiger )
			strURN = _T("urn:tree:tiger/");
		else if ( pThis->m_bSHA1 )
			strURN = _T("urn:sha1");
		else
			return E_FAIL;
	}
	
	if ( strURN.CompareNoCase( _T("urn:bitprint") ) == 0 )
	{
		if ( ! pThis->m_bSHA1 || ! pThis->m_bTiger ) return E_FAIL;
		strURN	= _T("urn:bitprint:")
				+ CSHA::HashToString( &pThis->m_pSHA1 ) + '.'
				+ CTigerNode::HashToString( &pThis->m_pTiger );
	}
	else if ( strURN.CompareNoCase( _T("urn:sha1") ) == 0 )
	{
		if ( ! pThis->m_bSHA1 ) return E_FAIL;
		strURN = CSHA::HashToString( &pThis->m_pSHA1, TRUE );
	}
	else if ( strURN.CompareNoCase( _T("urn:tree:tiger/") ) == 0 )
	{
		if ( ! pThis->m_bTiger ) return E_FAIL;
		strURN = CTigerNode::HashToString( &pThis->m_pTiger, TRUE );
	}
	else if ( strURN.CompareNoCase( _T("urn:md5") ) == 0 )
	{
		if ( ! pThis->m_bMD5 ) return E_FAIL;
		strURN = CMD5::HashToString( &pThis->m_pMD5, TRUE );
	}
	else if ( strURN.CompareNoCase( _T("urn:ed2k") ) == 0 )
	{
		if ( ! pThis->m_bED2K ) return E_FAIL;
		strURN = CED2K::HashToString( &pThis->m_pED2K, TRUE );
	}
	else
	{
		return E_FAIL;
	}
	
	strURN.SetSysString( psURN );
	
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_MetadataAuto(VARIANT_BOOL FAR* pbValue)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*pbValue = pThis->m_bMetadataAuto ? VARIANT_TRUE : VARIANT_FALSE;
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::get_Metadata(ISXMLElement FAR* FAR* ppXML)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	*ppXML = NULL;

	if ( pThis->m_pSchema == NULL || pThis->m_pMetadata == NULL ) return S_OK;
	
	CXMLElement* pXML	= pThis->m_pSchema->Instantiate( TRUE );
	*ppXML				= (ISXMLElement*)CXMLCOM::Wrap( pXML, IID_ISXMLElement );
	
	pXML->AddElement( pThis->m_pMetadata->Clone() );
	
	return S_OK;
}

STDMETHODIMP CLibraryFile::XLibraryFile::put_Metadata(ISXMLElement FAR* pXML)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	
	if ( CXMLElement* pReal = CXMLCOM::Unwrap( pXML ) )
	{
		return pThis->SetMetadata( pReal ) ? S_OK : E_FAIL;
	}
	else
	{
		pThis->SetMetadata( NULL );
		return S_OK;
	}
}

STDMETHODIMP CLibraryFile::XLibraryFile::Execute()
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	return CFileExecutor::Execute( pThis->GetPath(), TRUE ) ? S_OK : E_FAIL;
}

STDMETHODIMP CLibraryFile::XLibraryFile::SmartExecute()
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	return CFileExecutor::Execute( pThis->GetPath(), FALSE ) ? S_OK : E_FAIL;
}

STDMETHODIMP CLibraryFile::XLibraryFile::Delete()
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	return pThis->Delete() ? S_OK : E_FAIL;
}

STDMETHODIMP CLibraryFile::XLibraryFile::Rename(BSTR sNewName)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	return pThis->Rename( CString( sNewName ) ) ? S_OK : E_FAIL;
}

STDMETHODIMP CLibraryFile::XLibraryFile::Copy(BSTR sNewPath)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	return E_NOTIMPL;
}

STDMETHODIMP CLibraryFile::XLibraryFile::Move(BSTR sNewPath)
{
	METHOD_PROLOGUE( CLibraryFile, LibraryFile )
	return E_NOTIMPL;
}