CString CIni::GetStringUTF8(LPCTSTR strEntry, LPCTSTR strDefault/*=NULL*/, LPCTSTR strSection/* = NULL*/)
{
USES_CONVERSION;
if(strSection != NULL)
m_strSection = strSection;
CStringA strUTF8;
GetPrivateProfileStringA(T2CA(m_strSection), T2CA(strEntry), T2CA(strDefault),
strUTF8.GetBufferSetLength(MAX_INI_BUFFER), MAX_INI_BUFFER, T2CA(m_strFileName));
strUTF8.ReleaseBuffer();
return OptUtf8ToStr(strUTF8);
}
CString OptUtf8ToStr(const CStringW& rwstr)
{
CStringA astr;
for (int i = 0; i < rwstr.GetLength(); i++)
{
if (rwstr[i] >= 0x100)
{
// this is no UTF8 string (it's already an Unicode string)...
return rwstr; // just return the string
}
astr += (BYTE)rwstr[i];
}
return OptUtf8ToStr(astr);
}
bool CFileMgrDB::LoadAll(CFileMgr * mgr)
{
if(!m_db->Prepare("SELECT id, hash, state, path, url, size, name, ed2klink, filetime, metbakid FROM files"))
return false;
while(m_db->Step())
{
CFileTaskItem * pNewItem = new CFileTaskItem;
FILEKEY key;
INT id = m_db->GetColInt(0);
LPCSTR strHash = (LPCSTR)m_db->GetColText(1);
if(strHash[0] != 0)
strmd4(strHash, key.key);
pNewItem->m_nFileState = m_db->GetColInt(2);
pNewItem->m_strFilePath = OptUtf8ToStr((LPCSTR)m_db->GetColText(3));
pNewItem->m_strUrl = OptUtf8ToStr((LPCSTR)m_db->GetColText(4));
pNewItem->m_FileSize = m_db->GetColInt64(5);
pNewItem->m_FileName = OptUtf8ToStr((LPCSTR)m_db->GetColText(6));
pNewItem->m_strEd2kLink = OptUtf8ToStr((LPCSTR)m_db->GetColText(7));
pNewItem->m_tFiletime = m_db->GetColInt64(8);
pNewItem->m_metBakId = m_db->GetColInt(9);
CDatabase uqdb(m_db);
CStringA strCmd;
strCmd.Format("SELECT url, fromwhere, transnopay, transpay, badsite, pref, needci FROM urls WHERE fid=%d", id);
if(uqdb.Prepare(strCmd))
{
while(uqdb.Step())
{
CUrlSite urlSite;
urlSite.m_strUrl = OptUtf8ToStr((LPCSTR)uqdb.GetColText(0));
urlSite.m_dwFromWhere = uqdb.GetColInt(1);
urlSite.m_dwDataTransferedWithoutPayload = uqdb.GetColInt64(2);
urlSite.m_dwDataTransferedWithPayload = uqdb.GetColInt64(3);
urlSite.m_bBadSite = uqdb.GetColInt(4) > 0;
urlSite.m_dwInitPreference = uqdb.GetColInt(5);
urlSite.m_bNeedCommitted = uqdb.GetColInt(6) > 0;
pNewItem->m_lMetaLinkURLList.AddTail(urlSite);
}
uqdb.Finalize();
}
if(strHash[0] != 0)
mgr->m_FileList.SetAt(key, pNewItem);
else
mgr->m_UrlList.SetAt(pNewItem->m_strUrl, pNewItem);
}
m_db->Finalize();
if(!m_db->Prepare("SELECT path, state FROM hashing"))
return false;
while(m_db->Step())
{
mgr->m_WaitforHashList.SetAt(OptUtf8ToStr((LPCSTR)m_db->GetColText(0)), m_db->GetColInt(1));
}
m_db->Finalize();
return true;
}
/////////////////////////////////////////////
// CED2KFileLink implementation
/////////////////////////////////////////////
CED2KFileLink::CED2KFileLink(const TCHAR* pszName, const TCHAR* pszSize, const TCHAR* pszHash,
const CStringArray& astrParams, const TCHAR* pszSources)
: m_size(pszSize)
{
// Here we have a little problem.. Actually the proper solution would be to decode from UTF8,
// only if the string does contain escape sequences. But if user pastes a raw UTF8 encoded
// string (for whatever reason), we would miss to decode that string. On the other side,
// always decoding UTF8 can give flaws in case the string is valid for Unicode and UTF8
// at the same time. However, to avoid the pasting of raw UTF8 strings (which would lead
// to a greater mess in the network) we always try to decode from UTF8, even if the string
// did not contain escape sequences.
m_name = OptUtf8ToStr(URLDecode(pszName));
m_name.Trim();
if (m_name.IsEmpty())
throw GetResString(IDS_ERR_NOTAFILELINK);
SourcesList = NULL;
m_hashset = NULL;
m_bAICHHashValid = false;
if (_tcslen(pszHash) != 32)
throw GetResString(IDS_ERR_ILLFORMEDHASH);
if (_tstoi64(pszSize)>=4294967295)
throw GetResString(IDS_ERR_TOOLARGEFILE);
if (_tstoi64(pszSize)<=0)
throw GetResString(IDS_ERR_NOTAFILELINK);
for (int idx = 0; idx < 16; ++idx) {
m_hash[idx] = FromHexDigit(*pszHash++)*16;
m_hash[idx] += FromHexDigit(*pszHash++);
}
bool bError = false;
for (int i = 0; !bError && i < astrParams.GetCount(); i++)
{
const CString& strParam = astrParams.GetAt(i);
ASSERT( !strParam.IsEmpty() );
CString strTok;
int iPos = strParam.Find(_T('='));
if (iPos != -1)
strTok = strParam.Left(iPos);
if (strTok == _T("s"))
{
CString strURL = strParam.Mid(iPos + 1);
if (!strURL.IsEmpty())
{
TCHAR szScheme[INTERNET_MAX_SCHEME_LENGTH];
TCHAR szHostName[INTERNET_MAX_HOST_NAME_LENGTH];
TCHAR szUrlPath[INTERNET_MAX_PATH_LENGTH];
TCHAR szUserName[INTERNET_MAX_USER_NAME_LENGTH];
TCHAR szPassword[INTERNET_MAX_PASSWORD_LENGTH];
TCHAR szExtraInfo[INTERNET_MAX_URL_LENGTH];
URL_COMPONENTS Url = {0};
Url.dwStructSize = sizeof(Url);
Url.lpszScheme = szScheme;
Url.dwSchemeLength = ARRSIZE(szScheme);
Url.lpszHostName = szHostName;
Url.dwHostNameLength = ARRSIZE(szHostName);
Url.lpszUserName = szUserName;
Url.dwUserNameLength = ARRSIZE(szUserName);
Url.lpszPassword = szPassword;
Url.dwPasswordLength = ARRSIZE(szPassword);
Url.lpszUrlPath = szUrlPath;
Url.dwUrlPathLength = ARRSIZE(szUrlPath);
Url.lpszExtraInfo = szExtraInfo;
Url.dwExtraInfoLength = ARRSIZE(szExtraInfo);
if (InternetCrackUrl(strURL, 0, 0, &Url) && Url.dwHostNameLength > 0)
{
SUnresolvedHostname* hostname = new SUnresolvedHostname;
hostname->strURL = strURL;
hostname->strHostname = szHostName;
m_HostnameSourcesList.AddTail(hostname);
}
}
else
ASSERT(0);
}
else if (strTok == _T("p"))
{
CString strPartHashs = strParam.Tokenize(_T("="), iPos);
if (m_hashset != NULL){
ASSERT(0);
bError = true;
break;
}
m_hashset = new CSafeMemFile(256);
m_hashset->WriteHash16(m_hash);
m_hashset->WriteUInt16(0);
int iPartHashs = 0;
int iPosPH = 0;
CString strHash = strPartHashs.Tokenize(_T(":"), iPosPH);
while (!strHash.IsEmpty())
{
uchar aucPartHash[16];
if (!strmd4(strHash, aucPartHash)){
bError = true;
break;
}
m_hashset->WriteHash16(aucPartHash);
iPartHashs++;
strHash = strPartHashs.Tokenize(_T(":"), iPosPH);
}
if (bError)
break;
m_hashset->Seek(16, CFile::begin);
m_hashset->WriteUInt16(iPartHashs);
m_hashset->Seek(0, CFile::begin);
}
else if (strTok == _T("h"))
{
CString strHash = strParam.Mid(iPos + 1);
if (!strHash.IsEmpty())
{
if (DecodeBase32(strHash, m_AICHHash.GetRawHash(), CAICHHash::GetHashSize()) == CAICHHash::GetHashSize()){
m_bAICHHashValid = true;
ASSERT( m_AICHHash.GetString().CompareNoCase(strHash) == 0 );
}
else
ASSERT( false );
}
else
ASSERT( false );
}
else
ASSERT(0);
}
if (bError)
{
delete m_hashset;
m_hashset = NULL;
}
if (pszSources)
{
TCHAR* pNewString = _tcsdup(pszSources);
autoFree liberator(pNewString);
TCHAR* pCh = pNewString;
TCHAR* pEnd;
TCHAR* pIP;
TCHAR* pPort;
bool bAllowSources;
TCHAR date[3];
COleDateTime expirationDate;
int nYear,nMonth,nDay;
uint16 nCount = 0;
uint32 dwID;
uint16 nPort;
uint32 dwServerIP = 0;
uint16 nServerPort = 0;
unsigned long ul;
int nInvalid = 0;
pCh = _tcsstr( pCh, _T("sources") );
if( pCh != NULL ) {
pCh = pCh + 7; // point to char after "sources"
pEnd = pCh;
while( *pEnd ) pEnd++; // make pEnd point to the terminating NULL
bAllowSources=true;
// if there's an expiration date...
if( *pCh == _T('@') && (pEnd-pCh) > 7 )
{
pCh++; // after '@'
date[2] = 0; // terminate the two character string
date[0] = *(pCh++); date[1] = *(pCh++);
nYear = _tcstol( date, 0, 10 ) + 2000;
date[0] = *(pCh++); date[1] = *(pCh++);
nMonth = _tcstol( date, 0, 10 );
date[0] = *(pCh++); date[1] = *(pCh++);
nDay = _tcstol( date, 0, 10 );
bAllowSources = ( expirationDate.SetDate(nYear,nMonth,nDay) == 0 );
if (bAllowSources) bAllowSources=(COleDateTime::GetCurrentTime() < expirationDate);
}
// increment pCh to point to the first "ip:port" and check for sources
if ( bAllowSources && ++pCh < pEnd ) {
SourcesList = new CSafeMemFile(256);
SourcesList->WriteUInt16(nCount); // init to 0, we'll fix this at the end.
// for each "ip:port" source string until the end
// limit to prevent overflow (uint16 due to CPartFile::AddClientSources)
while( *pCh != 0 && nCount < MAXSHORT ) {
pIP = pCh;
// find the end of this ip:port string & start of next ip:port string.
if( (pCh = _tcschr(pCh, _T(','))) != NULL ) {
*pCh = 0; // terminate current "ip:port"
pCh++; // point to next "ip:port"
}
else
pCh = pEnd;
// if port is not present for this ip, go to the next ip.
if( (pPort = _tcschr(pIP, _T(':'))) == NULL )
{ nInvalid++; continue; }
*pPort = 0; // terminate ip string
pPort++; // point pPort to port string.
dwID = inet_addr(CStringA(pIP));
ul = _tcstoul( pPort, 0, 10 );
nPort = static_cast<uint16>(ul);
// skip bad ips / ports
if (ul > 0xFFFF || ul == 0 ) // port
{ nInvalid++; continue; }
if( dwID == INADDR_NONE) { // hostname?
if (_tcslen(pIP) > 512)
{ nInvalid++; continue; }
SUnresolvedHostname* hostname = new SUnresolvedHostname;
hostname->nPort = nPort;
hostname->strHostname = pIP;
m_HostnameSourcesList.AddTail(hostname);
continue;
}
//TODO: This will filter out *.*.*.0 clients. Is there a nice way to fix?
if( IsLowID(dwID) ) // ip
{ nInvalid++; continue; }
SourcesList->WriteUInt32(dwID);
SourcesList->WriteUInt16(nPort);
SourcesList->WriteUInt32(dwServerIP);
SourcesList->WriteUInt16(nServerPort);
nCount++;
}
SourcesList->SeekToBegin();
SourcesList->WriteUInt16(nCount);
SourcesList->SeekToBegin();
if (nCount==0) {
delete SourcesList;
SourcesList=NULL;
}
}
}
}
}
/////////////////////////////////////////////
// CED2KSearchLink implementation
/////////////////////////////////////////////
CED2KSearchLink::CED2KSearchLink(const TCHAR* pszSearchTerm)
{
m_strSearchTerm = OptUtf8ToStr(URLDecode(pszSearchTerm));
}