/**
* Creates the project file
*
* @param
* @return
* @exception -
* @see
*/
HRESULT CProjectWizardData::CreateProjectFile()
{
int i;
HRESULT hrResult;
FILE *pProjectFile;
CString sFilename;
// Create project file.
//---------------------
sFilename.Format (_T ("%s." FILE_EXT_PROJECT), m_strProjectName);
hrResult = CreateFile (sFilename, &pProjectFile);
if (hrResult != S_OK)
return (hrResult);
CString strProjectGuid;
hrResult = CreateGuid(&strProjectGuid);
// Write [Attributes] section (Alias, UserText1, UserText2, UserText3, UserURL)
//-----------------------------------------------------------------------------------
fprintf (pProjectFile, "[Attributes]\r\n");
fprintf (pProjectFile, "GUID=\"%s\"\r\n", strProjectGuid);
if (!m_strAlias.IsEmpty())
{
fprintf (pProjectFile, "Alias=%s\r\n", m_strAlias);
}
if (!m_strUserText1.IsEmpty())
{
fprintf (pProjectFile, "UserText1=%s\r\n", m_strUserText1);
}
if (!m_strUserText2.IsEmpty())
{
fprintf (pProjectFile, "UserText2=%s\r\n", m_strUserText2);
}
if (!m_strUserText3.IsEmpty())
{
fprintf (pProjectFile, "UserText3=%s\r\n", m_strUserText3);
}
if (!m_strURL.IsEmpty())
{
fprintf (pProjectFile, "UserURL=%s\r\n", m_strURL);
}
fprintf(pProjectFile, "\r\n");
// Write [Format] section (version)
//---------------------------------
fprintf (pProjectFile, "[Format]\r\n");
fprintf (pProjectFile, "version=V2.0\r\n\r\n");
// Write [Classes.GVLs] section (.gvl file entries)
//-------------------------------------------------
fprintf (pProjectFile, "[Classes.GVLs]\r\n");
for (i = 0; i < GetResourceCount (); ++i)
{
fprintf (pProjectFile, "file=%s." FILE_EXT_GLOBAL_VARIABLES "\r\n",
GetResource (i)->GetResource ());
};
fprintf(pProjectFile,"\r\n");
// Write [Classes.Configurations] section (configuration .con file entries)
//-----------------------------------------------------------
fprintf (pProjectFile, "[Classes.Configurations]\r\n");
fprintf (pProjectFile, "file=%s.con\r\n", CONFIGURATION_FILE_NAME);
fprintf (pProjectFile, "\r\n");
// Write [Classes.Constants] section (constant files)
//---------------------------------------------------
fprintf (pProjectFile, "[Classes.Constants]\r\n");
for (i = 0; i < GetResourceCount (); ++i)
{
fprintf (pProjectFile, "file=%s." FILE_EXT_CONSTANTS "\r\n",
GetResource (i)->GetResource ());
};
fprintf (pProjectFile,"\r\n");
// Write [Classes.Programs] section (program files)
//-------------------------------------------------
fprintf (pProjectFile, "[Classes.Programs]\r\n");
for (i = 0; i < GetResourceCount (); ++i)
{
CProjectWizardResource *pResource;
int k;
pResource = GetResource (i);
ASSERT (pResource != NULL);
if (pResource== NULL)
continue;
for (k = 0; k < pResource->GetTaskCount (); ++k)
{
CProjectWizardTask *pTask;
pTask = pResource->GetTask (k);
ASSERT (pTask != NULL);
if (pTask == NULL)
continue;
fprintf (pProjectFile, "file=%s\r\n", (LPCTSTR)BuildProgramFileName (pTask));
};
};
fprintf (pProjectFile,"\r\n");
// Write [Libs] section (library files)
//-------------------------------------
fprintf (pProjectFile, "[Libs]\r\n");
for (i = 0; i < GetLibraryCount (); ++i)
if (m_Libraries[i].GetSelectFlag ())
fprintf (pProjectFile, "file=%s\\%s\r\n", _T("$(LIBDIR)"), m_Libraries[i].GetLibraryName ());
fprintf (pProjectFile,"\r\n");
// Write [Targets] section (target files)
//---------------------------------------
fprintf (pProjectFile,"[Targets]\r\n");
for (i = 0; i < GetResourceCount (); ++i)
fprintf (pProjectFile, "file=%s\r\n", BuildTargetFileName (GetResource (i)));
fprintf (pProjectFile, "\r\n");
fclose (pProjectFile);
return (S_OK);
}
AnsiString __fastcall DesignerHook::UniqueName(const AnsiString BaseName)
{
return BaseName + "-"+CreateGuid();
}
std::string CallHprose::DownloadHprose( std::string strHproseDownloadUrl, std::string strFileDir, std::string strFileName )
{
CInternetSession sess;
CHttpFile* pHttpFile;
try
{
pHttpFile=(CHttpFile*)sess.OpenURL(strHproseDownloadUrl.c_str());
}
catch(CException* e)
{
pHttpFile = 0;
TCHAR msg[1024];
memset(msg, 0, 1024);
e->GetErrorMessage(msg, 1023, NULL);
ZTools::WriteZToolsFormatLog("打开URL失败：%s", msg);
return "";
}
DWORD dwStatus;
DWORD dwBuffLen = sizeof(dwStatus);
BOOL bSuccess = pHttpFile->QueryInfo(HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &dwStatus, &dwBuffLen);
int nReadBlockSize = 256*1024;
char* pBuffer = new char[nReadBlockSize];
if( bSuccess && dwStatus>= 200&& dwStatus<300 )
{
if (strFileName.length() == 0)
{
CString sContentDisposition;
DWORD dwIndex = 0;
bSuccess = pHttpFile->QueryInfo(HTTP_QUERY_CONTENT_DISPOSITION, sContentDisposition, &dwIndex);
std::string strContentDisposition((LPCTSTR)sContentDisposition);
std::string strKeyBegin("filename=\"");
std::string strKeyEnd("\"");
if (!strContentDisposition.empty())
{
size_t nBegin = strContentDisposition.find(strKeyBegin) + strKeyBegin.length();
if (nBegin < strContentDisposition.length())
{
size_t nEnd = strContentDisposition.find(strKeyEnd, nBegin);
strFileName = strContentDisposition.substr(nBegin, nEnd - nBegin);
}
strFileName = deescapeURL(strFileName);
ZTools::UTF8ToMB(strFileName);
}
}
if (strFileName.length() == 0)
{
delete[] pBuffer;
pBuffer = NULL;
pHttpFile->Close();
//delete pHttpFile;
sess.Close();
ZTools::WriteZToolsFormatLog("没有找到文件名");
return "";
}
std::replace(strFileDir.begin(), strFileDir.end(), '/', '\\');
strFileDir.erase(strFileDir.find_last_not_of('\\') + 1);
std::replace(strFileName.begin(), strFileName.end(), '/', '\\');
strFileName.erase(0, strFileName.find_first_not_of('\\'));
std::string strFilePath = ZTools::FormatString("%s\\%s", strFileDir.c_str(), strFileName.c_str());
//先下载到临时文件中，下载成功后重命名
std::string strFilePathTemp = ZTools::FormatString("%s\\%s", strFileDir.c_str(), GuidToString(CreateGuid()).c_str());
if (!MakeSureDirectoryPathExists(strFilePath.c_str()))
{
delete[] pBuffer;
pBuffer = NULL;
pHttpFile->Close();
//delete pHttpFile;
sess.Close();
ZTools::WriteZToolsFormatLog("创建文件夹失败：%s", strFilePath.c_str());
return "";
}
CFile fileWrite;
ULONGLONG dwFileLen = 0;
DWORD dwWriteIndex = 0;
dwFileLen = pHttpFile->SeekToEnd();
pHttpFile->SeekToBegin();
if(fileWrite.Open(strFilePathTemp.c_str(), CFile::modeWrite|CFile::modeCreate))
{
int nCount = 0;
while(dwWriteIndex < dwFileLen)
{
nCount = pHttpFile->Read(pBuffer, nReadBlockSize);
fileWrite.Write(pBuffer, nCount);
dwWriteIndex += nCount;
}
fileWrite.Close();
rename(strFilePathTemp.c_str(), strFilePath.c_str());
delete[] pBuffer;
pBuffer = NULL;
pHttpFile->Close();
delete pHttpFile;
sess.Close();
if (PathFileExists(strFilePath.c_str()))
{
return strFilePath;
}
else
{
return "";
}
}
else
{
delete[] pBuffer;
pBuffer = NULL;
pHttpFile->Close();
//delete pHttpFile;
sess.Close();
ZTools::WriteZToolsFormatLog("本地文件%s打开出错", strFilePath.c_str());
return "";
}
}
else
{
delete[] pBuffer;
pBuffer = NULL;
pHttpFile->Close();
//delete pHttpFile;
sess.Close();
ZTools::WriteZToolsFormatLog("打开网页文件出错，错误码：%d", dwStatus);
return "";
}
delete[] pBuffer;
pBuffer = NULL;
pHttpFile->Close();
//delete pHttpFile;
sess.Close();
return "";
}
bool ff::Value::Convert(Type type, Value **ppValue) const
{
assertRetVal(ppValue, false);
*ppValue = nullptr;
if (type == GetType())
{
*ppValue = GetAddRef(const_cast<Value *>(this));
return true;
}
wchar_t buf[256];
switch (GetType())
{
case Type::Null:
switch (type)
{
case Type::String:
CreateString(String(L"null"), ppValue);
break;
}
break;
case Type::Bool:
switch (type)
{
case Type::Double:
CreateDouble(AsBool() ? 1.0 : 0.0, ppValue);
break;
case Type::Float:
CreateFloat(AsBool() ? 1.0f : 0.0f, ppValue);
break;
case Type::Int:
CreateInt(AsBool() ? 1 : 0, ppValue);
break;
case Type::String:
CreateString(AsBool() ? String(L"true") : String(L"false"), ppValue);
break;
}
break;
case Type::Double:
switch (type)
{
case Type::Bool:
CreateBool(AsDouble() != 0, ppValue);
break;
case Type::Float:
CreateFloat((float)AsDouble(), ppValue);
break;
case Type::Int:
CreateInt((int)AsDouble(), ppValue);
break;
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"%g", AsDouble());
CreateString(String(buf), ppValue);
break;
}
break;
case Type::Float:
switch (type)
{
case Type::Bool:
CreateBool(AsFloat() != 0, ppValue);
break;
case Type::Double:
CreateDouble((double)AsFloat(), ppValue);
break;
case Type::Int:
CreateInt((int)AsFloat(), ppValue);
break;
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"%g", AsFloat());
CreateString(String(buf), ppValue);
break;
}
break;
case Type::Int:
switch (type)
{
case Type::Bool:
CreateBool(AsInt() != 0, ppValue);
break;
case Type::Double:
CreateDouble((double)AsInt(), ppValue);
break;
case Type::Float:
CreateFloat((float)AsInt(), ppValue);
break;
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"%d", AsInt());
CreateString(String(buf), ppValue);
break;
}
break;
case Type::Point:
switch (type)
{
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"(%d,%d)", AsPoint().x, AsPoint().y);
CreateString(String(buf), ppValue);
break;
}
break;
case Type::PointF:
switch (type)
{
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"(%g,%g)", AsPointF().x, AsPointF().y);
CreateString(String(buf), ppValue);
break;
}
break;
case Type::Rect:
switch (type)
{
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"(%d,%d,%d,%d)",
AsRect().left, AsRect().top, AsRect().right, AsRect().bottom);
CreateString(String(buf), ppValue);
break;
}
break;
case Type::RectF:
switch (type)
{
case Type::String:
_snwprintf_s(buf, _countof(buf), _TRUNCATE, L"(%g,%g,%g,%g)",
AsRectF().left, AsRectF().top, AsRectF().right, AsRectF().bottom);
CreateString(String(buf), ppValue);
break;
}
break;
case Type::String:
switch (type)
{
case Type::Bool:
if (AsString().empty() || AsString() == L"false" || AsString() == L"no" || AsString() == L"0")
{
CreateBool(false, ppValue);
}
else if (AsString() == L"true" || AsString() == L"yes" || AsString() == L"1")
{
CreateBool(true, ppValue);
}
break;
case Type::Double:
{
const wchar_t *start = AsString().c_str();
wchar_t *end = nullptr;
double val = wcstod(start, &end);
if (end > start && !*end)
{
CreateDouble(val, ppValue);
}
} break;
case Type::Float:
{
const wchar_t *start = AsString().c_str();
wchar_t *end = nullptr;
double val = wcstod(start, &end);
if (end > start && !*end)
{
CreateFloat((float)val, ppValue);
}
} break;
case Type::Int:
{
const wchar_t *start = AsString().c_str();
wchar_t *end = nullptr;
long val = wcstol(start, &end, 10);
if (end > start && !*end)
{
CreateInt((int)val, ppValue);
}
} break;
case Type::Guid:
{
GUID guid;
if (StringToGuid(AsString(), guid))
{
CreateGuid(guid, ppValue);
}
} break;
}
break;
case Type::Object:
switch (type)
{
case Type::Bool:
CreateBool(AsObject() != nullptr, ppValue);
break;
}
break;
case Type::Guid:
switch (type)
{
case Type::String:
CreateString(StringFromGuid(AsGuid()), ppValue);
break;
}
break;
case Type::Data:
switch (type)
{
case Type::SavedData:
{
ff::ComPtr<ff::ISavedData> savedData;
if (ff::CreateLoadedDataFromMemory(AsData(), false, &savedData))
{
CreateSavedData(savedData, ppValue);
}
}
break;
}
break;
case Type::SavedData:
switch (type)
{
case Type::Data:
{
ff::ComPtr<ff::ISavedData> savedData;
if (AsSavedData()->Clone(&savedData))
{
ff::ComPtr<ff::IData> data = savedData->Load();
if (data)
{
CreateData(data, ppValue);
}
}
}
break;
}
break;
case Type::Dict:
switch (type)
{
case Type::Data:
case Type::SavedData:
case Type::SavedDict:
{
ff::ComPtr<ff::IData> data;
ff::ComPtr<ff::ISavedData> savedData;
if (ff::SaveDict(AsDict(), true, false, &data))
{
if (type == Type::Data)
{
CreateData(data, ppValue);
}
else if (ff::CreateLoadedDataFromMemory(data, true, &savedData))
{
if (type == Type::SavedData)
{
CreateSavedData(savedData, ppValue);
}
else
{
CreateSavedDict(savedData, ppValue);
}
}
}
}
break;
}
break;
case Type::SavedDict:
switch (type)
{
case Type::Data:
{
ff::ComPtr<ff::ISavedData> savedData;
if (AsSavedData()->Clone(&savedData))
{
ff::ComPtr<ff::IData> data = savedData->Load();
if (data)
{
CreateData(data, ppValue);
}
}
}
break;
case Type::SavedData:
CreateSavedData(AsSavedData(), ppValue);
break;
case Type::Dict:
{
ff::ComPtr<ff::ISavedData> savedData;
if (AsSavedData()->Clone(&savedData))
{
ff::ComPtr<ff::IData> data = savedData->Load();
ff::ComPtr<ff::IDataReader> dataReader;
Dict dict;
if (data && ff::CreateDataReader(data, 0, &dataReader) && ff::LoadDict(dataReader, dict))
{
CreateDict(std::move(dict), ppValue);
}
}
}
break;
}
break;
case Type::Resource:
AsResource()->GetValue()->Convert(type, ppValue);
break;
case Type::IntVector:
switch (type)
{
case Type::Point:
if (AsIntVector().Size() == 2)
{
PointInt point(
AsIntVector().GetAt(0),
AsIntVector().GetAt(1));
CreatePoint(point, ppValue);
}
break;
case Type::Rect:
if (AsIntVector().Size() == 4)
{
RectInt rect(
AsIntVector().GetAt(0),
AsIntVector().GetAt(1),
AsIntVector().GetAt(2),
AsIntVector().GetAt(3));
CreateRect(rect, ppValue);
}
break;
}
break;
case Type::FloatVector:
switch (type)
{
case Type::PointF:
if (AsFloatVector().Size() == 2)
{
PointFloat point(
AsFloatVector().GetAt(0),
AsFloatVector().GetAt(1));
CreatePointF(point, ppValue);
}
break;
case Type::RectF:
if (AsFloatVector().Size() == 4)
{
RectFloat rect(
AsFloatVector().GetAt(0),
AsFloatVector().GetAt(1),
AsFloatVector().GetAt(2),
AsFloatVector().GetAt(3));
CreateRectF(rect, ppValue);
}
break;
}
break;
case Type::ValueVector:
switch (type)
{
case Type::Point:
if (AsValueVector().Size() == 2)
{
ValuePtr newValues[2];
const Vector<ValuePtr> &values = AsValueVector();
if (values[0]->Convert(Type::Int, &newValues[0]) &&
values[1]->Convert(Type::Int, &newValues[1]))
{
CreatePoint(PointInt(newValues[0]->AsInt(), newValues[1]->AsInt()), ppValue);
}
}
break;
case Type::PointF:
if (AsValueVector().Size() == 2)
{
ValuePtr newValues[2];
const Vector<ValuePtr> &values = AsValueVector();
if (values[0]->Convert(Type::Float, &newValues[0]) &&
values[1]->Convert(Type::Float, &newValues[1]))
{
CreatePointF(PointFloat(newValues[0]->AsFloat(), newValues[1]->AsFloat()), ppValue);
}
}
break;
case Type::Rect:
if (AsValueVector().Size() == 4)
{
ValuePtr newValues[4];
const Vector<ValuePtr> &values = AsValueVector();
if (values[0]->Convert(Type::Int, &newValues[0]) &&
values[1]->Convert(Type::Int, &newValues[1]) &&
values[2]->Convert(Type::Int, &newValues[2]) &&
values[3]->Convert(Type::Int, &newValues[3]))
{
CreateRect(RectInt(
newValues[0]->AsInt(),
newValues[1]->AsInt(),
newValues[2]->AsInt(),
newValues[3]->AsInt()), ppValue);
}
}
break;
case Type::RectF:
if (AsValueVector().Size() == 4)
{
ValuePtr newValues[4];
const Vector<ValuePtr> &values = AsValueVector();
if (values[0]->Convert(Type::Float, &newValues[0]) &&
values[1]->Convert(Type::Float, &newValues[1]) &&
values[2]->Convert(Type::Float, &newValues[2]) &&
values[3]->Convert(Type::Float, &newValues[3]))
{
CreateRectF(RectFloat(
newValues[0]->AsFloat(),
newValues[1]->AsFloat(),
newValues[2]->AsFloat(),
newValues[3]->AsFloat()), ppValue);
}
}
break;
case Type::StringVector:
{
bool valid = true;
Vector<String> newValues;
const Vector<ValuePtr> &values = AsValueVector();
for (ValuePtr oldValue : values)
{
ValuePtr newValue;
valid = oldValue->Convert(Type::String, &newValue);
if (valid)
{
newValues.Push(newValue->AsString());
}
else
{
break;
}
}
if (valid)
{
CreateStringVector(std::move(newValues), ppValue);
}
}
break;
case Type::IntVector:
{
bool valid = true;
Vector<int> newValues;
const Vector<ValuePtr> &values = AsValueVector();
for (ValuePtr oldValue : values)
{
ValuePtr newValue;
valid = oldValue->Convert(Type::Int, &newValue);
if (valid)
{
newValues.Push(newValue->AsInt());
}
else
{
break;
}
}
if (valid)
{
CreateIntVector(std::move(newValues), ppValue);
}
}
break;
case Type::DoubleVector:
{
bool valid = true;
Vector<double> newValues;
const Vector<ValuePtr> &values = AsValueVector();
for (ValuePtr oldValue : values)
{
ValuePtr newValue;
valid = oldValue->Convert(Type::Double, &newValue);
if (valid)
{
newValues.Push(newValue->AsDouble());
}
else
{
break;
}
}
if (valid)
{
CreateDoubleVector(std::move(newValues), ppValue);
}
}
break;
case Type::FloatVector:
{
bool valid = true;
Vector<float> newValues;
const Vector<ValuePtr> &values = AsValueVector();
for (ValuePtr oldValue : values)
{
ValuePtr newValue;
valid = oldValue->Convert(Type::Float, &newValue);
if (valid)
{
newValues.Push(newValue->AsFloat());
}
else
{
break;
}
}
if (valid)
{
CreateFloatVector(std::move(newValues), ppValue);
}
}
break;
}
break;
}
if (*ppValue)
{
return true;
}
return false;
}
static DWORD
__ProcessFile(LPVOID pParam)
{
auto p = static_cast<ProcessParam *>(pParam);
DWORD dwAllTime = 0;
ProcessLine processLine;
processLine.line = 0;
processLine.process = 0;
auto startProcess = timeGetTime();
std::ifstream file(p->szFileName);
std::string line;
std::vector<std::string> parts;
if (p->database_name.size() == 0) {
p->database_name = std::toString(CreateGuid());
gProp->setString(Constants::DatabaseName, p->database_name.c_str());
}
Sqlite::Database database(p->database_name + std::string(".db"), SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE);
std::getline(file, line);
split_string(line, ';', parts);
auto i = 0;
auto query{ std::string("CREATE TABLE IF NOT EXISTS '") + p->table_name + std::string("' (\r\n") };
auto insert_start{ std::string("INSERT INTO '") + p->table_name + std::string("'( ") };
auto insert_end{ std::string("VALUES(") };
for (auto it = parts.begin(); it != parts.end(); ++it) {
auto item = (*it);
std::transform(item.begin(), item.end(), item.begin(), ::tolower);
std::trim(item);
if (i > 0) {
query += std::string(", \r\n");
insert_start += std::string(", ");
insert_end += std::string(", ");
}
if (item == std::string("frame")) {
query += std::string(" 'frame' TEXT NOT NULL");
insert_start += std::string("'frame'");
} else {
query += std::string(" '") + item + std::string("' TEXT DEFAULT NULL");
insert_start += std::string("'") + item + std::string("'");
}
insert_end += std::string("?");
++i;
}
query += std::string(")");
insert_start += std::string(") ");
insert_end += std::string(") ");
auto insert_query{ insert_start + insert_end };
try {
database.exec(query);
} catch (Sqlite::Exception ex) {
SendMessage(p->hwnd, WM_PROCESS_ERROR, 0, reinterpret_cast<LPARAM>(ex.what()));
is_processing = false;
return -1;
}
is_processing = true;
Sqlite::Statement insert{ database, insert_query.c_str() };
database.begin_transaction();
try {
while (std::getline(file, line) && is_processing) {
auto start = timeGetTime();
processLine.line++;
processLine.process += line.size() + 2;
parts.clear();
split_string(line, ';', parts);
for (auto it = parts.begin(); it != parts.end(); ++it) {
auto &item = (*it);
insert.bind_text(item.c_str());
}
insert.execute();
dwAllTime += (timeGetTime() - start);
processLine.dwMiddleTime = processLine.process > 0 ? (dwAllTime / processLine.process) : 0;
processLine.dwProcessTime = timeGetTime() - startProcess;
SendMessage(p->hwnd, WM_PROCESS_LINE, 0, reinterpret_cast<LPARAM>(&processLine));
}
database.commit();
} catch (Sqlite::Exception ex) {
SendMessage(p->hwnd, WM_PROCESS_ERROR, 0, reinterpret_cast<LPARAM>(ex.what()));
}
try {
database.exec(std::string("CREATE UNIQUE INDEX IF NOT EXISTS 'frame_index' ON '") + p->table_name + std::string("'('frame')"));
} catch (Sqlite::Exception ex) {
SendMessage(p->hwnd, WM_PROCESS_ERROR, 0, reinterpret_cast<LPARAM>(ex.what()));
}
is_processing = false;
SendMessage(p->hwnd, WM_PROCESS_COMPLETE, 0, 0);
return 0;
}
void LoginSession::StartSsoLogin(XMLPacket *Packet)
{
rapidxml::xml_node<>* requestNode = Packet->m_XMLDocument.first_node("Request");
char password[1024];
char passwordToken[1024];
memset(password, 0, 1024);
memset(passwordToken, 0, 1024);
int passwordLength = -1;
int passwordTokenLength = -1;
char* emailaddress = nullptr;
char* passwordBase64 = nullptr;
char* passwordTokenBase64 = nullptr;
std::string sha256Password;
std::string guid;
std::string username;
std::string decodedToken;
try {
emailaddress = requestNode->first_node("LoginName")->value();
if (requestNode->first_node("PasswordToken") != nullptr) {
passwordTokenBase64 = requestNode->first_node("PasswordToken")->value();
auto bio = BIO_new_mem_buf(passwordTokenBase64, -1);
auto b64 = BIO_new(BIO_f_base64());
bio = BIO_push(b64, bio);
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
passwordTokenLength = BIO_read(bio, passwordToken, (int)strlen(passwordTokenBase64));
BIO_free_all(bio);
}
else if (requestNode->first_node("Password") != nullptr) {
passwordBase64 = requestNode->first_node("Password")->value();
auto bio = BIO_new_mem_buf(passwordBase64, -1);
auto b64 = BIO_new(BIO_f_base64());
bio = BIO_push(b64, bio);
BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
passwordLength = BIO_read(bio, password, (int)strlen(passwordBase64));
BIO_free_all(bio);
}
else {
int sequence = Packet->m_Meta[2] - '0';
QueueLoginErrorMessage(sequence);
m_LogoutRequested = true;
printf("Unsupported authentication method.\n");
return;
}
auto userQuery = Database::Get().PrepareQuery("SELECT * FROM cligate.Users where userEmail = %0q;");
auto result = userQuery.store(emailaddress);
if (result.size() != 0) {
if (result.size() > 1) {
printf("Data consistency error, an email address appear's more than once in the users table.");
}
sha256Password = std::string(result.front()["userPassword"]).c_str();
guid = std::string(result.front()["userGuid"]).c_str();
username = std::string(result.front()["userName"]).c_str();
}
}
catch(std::exception ex)
{
printf("Unexpected authentication error: %s.\n", ex.what());
int sequence = Packet->m_Meta[2] - '0';
QueueLoginErrorMessage(sequence);
m_LogoutRequested = true;
return;
}
catch (const mysqlpp::BadQuery& er) {
std::cerr << "Query error: " << er.what() << std::endl;
m_LogoutRequested = true;
return;
}
catch (const mysqlpp::BadConversion& er) {
std::cerr << "Conversion error: " << er.what() << std::endl <<
"\tretrieved data size: " << er.retrieved <<
", actual size: " << er.actual_size << std::endl;
m_LogoutRequested = true;
return;
}
catch (const mysqlpp::Exception& er) {
std::cerr << "Error: " << er.what() << std::endl;
m_LogoutRequested = true;
return;
}
// Check if there is no password present, if so try using the password token, then try
// using a password
if (passwordTokenBase64 != nullptr) {
if (CheckResumeToken(guid.c_str(), passwordToken)) {
printf("Client %s using resume token %s\n", guid.c_str(), passwordToken);
} else {
printf("Resume token %s failed\n", passwordToken);
int sequence = Packet->m_Meta[2] - '0';
QueueLoginErrorMessage(sequence);
m_LogoutRequested = true;
return;
}
} else if (passwordBase64 != nullptr) {
eSHA256::SHA256 sha256;
if (sha256(password).compare(sha256Password) != 0) {
int sequence = Packet->m_Meta[2] - '0';
QueueLoginErrorMessage(sequence);
m_LogoutRequested = true;
return;
}
} else {
printf("Unexpected authentication error\n");
int sequence = Packet->m_Meta[2] - '0';
QueueLoginErrorMessage(sequence);
m_LogoutRequested = true;
}
// Ugly hack to get the sequence number
int sequence = Packet->m_Meta[2] - '0';
// Persist the ResumeToken to the DB
std::string resumetoken = CreateGuid();
SaveResumeToken(guid.c_str(), resumetoken.c_str());
GW2Packet replyPacket("", sequence, PT_REPLY);
replyPacket.AddElement("UserId", guid.c_str());
replyPacket.AddElement("UserCenter", "5");
replyPacket.AddElement("UserName", username.c_str());
replyPacket.AddElement("Parts", "");
replyPacket.AddElement("ResumeToken", resumetoken.c_str());
replyPacket.AddElement("EmailVerified", "1");
SessionSendPacket packet;
memset(packet.m_TLSSendBuffer, 0, 4096);
sprintf(packet.m_TLSSendBuffer, replyPacket.Payload());
packet.m_TLSSendBufferLength = (int)strlen(packet.m_TLSSendBuffer);
packet.m_TLSSendNeeded = true;
m_SendPackets.push_back(packet);
// Assume that the login information was correct, persist the email address for this client.
m_ClientEmail = std::string(emailaddress);
}
