bool Utf8ToUpperOnlyLatin(std::string& utf8String)
{
std::wstring wstr;
if (!Utf8toWStr(utf8String, wstr))
return false;
std::transform(wstr.begin(), wstr.end(), wstr.begin(), wcharToUpperOnlyLatin);
return WStrToUtf8(wstr, utf8String);
}
bool AccountMgr::normalizeString(std::string& utf8str)
{
wchar_t wstr_buf[MAX_ACCOUNT_STR + 1];
size_t wstr_len = MAX_ACCOUNT_STR;
if (!Utf8toWStr(utf8str, wstr_buf, wstr_len))
return false;
std::transform(&wstr_buf[0], wstr_buf + wstr_len, &wstr_buf[0], wcharToUpperOnlyLatin);
return WStrToUtf8(wstr_buf, wstr_len, utf8str);
}
bool AccountMgr::normalizeString(std::string& utf8String)
{
wchar_t buffer[MAX_ACCOUNT_STR+1];
size_t maxLength = MAX_ACCOUNT_STR;
if (!Utf8toWStr(utf8String, buffer, maxLength))
return false;
std::transform(&buffer[0], buffer+maxLength, &buffer[0], wcharToUpperOnlyLatin);
return WStrToUtf8(buffer, maxLength, utf8String);
}
bool AccountMgr::normalizeString(std::string& utf8str)
{
std::wstring wstr_buf;
if (!Utf8toWStr(utf8str, wstr_buf))
return false;
if (wstr_buf.size() > MAX_ACCOUNT_STR)
return false;
std::transform(wstr_buf.begin(), wstr_buf.end(), wstr_buf.begin(), wcharToUpperOnlyLatin);
return WStrToUtf8(wstr_buf, utf8str);
}
bool consoleToUtf8(const std::string& conStr, std::string& utf8str) {
#if PLATFORM == PLATFORM_WINDOWS
std::wstring wstr;
wstr.resize(conStr.size());
OemToCharBuffW(&conStr[0], &wstr[0], conStr.size());
return WStrToUtf8(wstr, utf8str);
#else
// not implemented yet
utf8str = conStr;
return true;
#endif
}
void utf8truncate(std::string& utf8str, size_t len)
{
try
{
std::wstring wstr;
Utf8toWStr(utf8str, wstr, len);
WStrToUtf8(wstr, utf8str);
}
catch (std::exception)
{
utf8str = "";
}
}
bool AccountMgr::normalizeString(std::string& utf8str)
{
wchar_t wstr_buf[MAX_ACCOUNT_STR + 1];
size_t wstr_len = MAX_ACCOUNT_STR;
if (!Utf8toWStr(utf8str, wstr_buf, wstr_len))
{ return false; }
for (uint32 i = 0; i <= wstr_len; ++i)
wstr_buf[i] = wcharToUpperOnlyLatin(wstr_buf[i]);
return WStrToUtf8(wstr_buf, wstr_len, utf8str);
}
bool normalizeString(std::string& utf8String)
{
wchar_t buffer[MAX_ACCOUNT_STR+1];
size_t maxLength = MAX_ACCOUNT_STR;
if (!Utf8toWStr(utf8String, buffer, maxLength))
return false;
#ifdef _MSC_VER
#pragma warning(disable: 4996)
#endif
std::transform(&buffer[0], buffer+maxLength, &buffer[0], wcharToUpperOnlyLatin);
#ifdef _MSC_VER
#pragma warning(default: 4996)
#endif
return WStrToUtf8(buffer, maxLength, utf8String);
}
bool AccountMgr::normalizeString(std::string& utf8str)
{
wchar_t wstr_buf[MAX_ACCOUNT_STR+1];
size_t wstr_len = MAX_ACCOUNT_STR;
if (!Utf8toWStr(utf8str,wstr_buf,wstr_len))
return false;
#ifdef _MSC_VER
#pragma warning(disable: 4996)
#endif
std::transform(&wstr_buf[0], wstr_buf+wstr_len, &wstr_buf[0], wcharToUpperOnlyLatin);
#ifdef _MSC_VER
#pragma warning(default: 4996)
#endif
return WStrToUtf8(wstr_buf,wstr_len,utf8str);
}
void FilterMessage(std::string &message)
{
std::wstring _message;
std::vector<std::wstring> tokens;
if (!Utf8toWStr(message, _message))
{
message = "";
return;
}
std::wstringstream ss(_message);
std::copy(std::istream_iterator<std::wstring, wchar_t>(ss), std::istream_iterator<std::wstring, wchar_t>(), std::back_inserter<std::vector<std::wstring> >(tokens));
for (std::vector<std::wstring>::iterator itr = tokens.begin(); itr != tokens.end(); ++itr)
{
std::wstring token = *itr;
std::transform(token.begin(), token.end(), token.begin(), ::toupper);
token.erase(token.begin(), std::find_if(token.begin(), token.end(), std::not1(std::ptr_fun(istrimmable))));
token.erase(std::find_if(token.rbegin(), token.rend(), std::not1(std::ptr_fun(istrimmable))).base(), token.end());
if (m_DisableMessageMap.find(token) != m_DisableMessageMap.end())
*itr = std::wstring(std::min(4, (int)(*itr).length()), '*');
}
ss.clear();
ss.str(L"");
copy(tokens.begin(), tokens.end(), std::ostream_iterator<std::wstring, wchar_t>(ss, L" "));
_message = ss.str();
WStrToUtf8(_message, message);
if (!message.empty())
{
message.resize(message.length() - 1);
}
}
// -------------------------------------------------------------------
// UploadValuesAsync
// -------------------------------------------------------------------
void SFSWebClient::UploadValuesAsync (boost::shared_ptr<string> uriHost, unsigned short int uriPort, boost::shared_ptr<string> paramName, boost::shared_ptr<string> encodedData)
{
boost::shared_ptr<TCPClient> client = boost::shared_ptr<TCPClient>();
try {
client = boost::shared_ptr<TCPClient>(new TCPClient(boostIoService));
boost::shared_ptr<IPAddress> address (new IPAddress(IPAddress::IPADDRESSTYPE_IPV4, *uriHost));
client->SynchConnect(address, uriPort);
}
catch (exception e) {
boost::shared_ptr<string> messageException (new string(e.what()));
boost::shared_ptr<string> message (new string("Http error creating http connection: " + (*messageException)));
OnHttpResponse()->Invoke(true, message);
try {
client->Shutdown();
}
catch (exception e) {
boost::shared_ptr<string> messageException (new string(e.what()));
boost::shared_ptr<string> message (new string("Error during http scocket shutdown: " + (*messageException)));
OnHttpResponse()->Invoke(true, message);
}
return;
}
try {
string data = (*paramName) + "=" + (*encodedData);
boost::shared_ptr<wstring> dataAsNative (new wstring());
dataAsNative->assign(data.begin(), data.end());
boost::shared_ptr<string> dataAsUtf8 (new string());
WStrToUtf8(dataAsNative, dataAsUtf8);
string sb;
sb.append("POST /" + (*BBClient::BB_SERVLET) + " HTTP/1.0\r\n");
sb.append("Content-Type: application/x-www-form-urlencoded; charset=utf-8\r\n");
boost::shared_ptr<string> valueContentLength (new string());
boost::shared_ptr<string> format (new string ("Content-Length: %ld\r\n"));
StringFormatter<long int> (valueContentLength, format, dataAsUtf8->size());
sb.append(*valueContentLength);
sb.append("\r\n");
sb.append(data);
boost::shared_ptr<vector<unsigned char> > outputData (new vector<unsigned char>(sb.begin(), sb.end()));
outputData->push_back('\0');
client->SynchWrite(outputData);
string responseFromServer;
do
{
boost::shared_ptr<vector<unsigned char> > receive = client->SynchRead();
if (receive->size() == 0)
{
break;
}
boost::shared_ptr<string> src (new string(receive->begin(), receive->end()));
boost::shared_ptr<wstring> dest (new wstring());
Utf8toWStr(src, dest);
responseFromServer.append(dest->begin(), dest->end());
} while (true);
// Remove http header and trim whitespaces at the end
std::vector<string> parts;
/*
boost::regex re("\\r\\n\\r\\n");
boost::sregex_token_iterator i(responseFromServer.begin(), responseFromServer.end(), re, -1);
boost::sregex_token_iterator j;
while (i != j)
{
parts.push_back(*i++);
}
*/
const char* chunkCurrent = responseFromServer.c_str();
const char* chunkNext = chunkCurrent;
while ((chunkNext = strstr(chunkCurrent, "\r\n\r\n")) != NULL)
{
string tokenizedValue (chunkCurrent, chunkNext - chunkCurrent);
parts.push_back(tokenizedValue);
chunkCurrent = chunkNext + 4;
}
string tokenizedValueLast (chunkCurrent);
if (tokenizedValueLast.length() > 0)
{
parts.push_back(tokenizedValueLast);
}
if ((responseFromServer.size() > 4) && (responseFromServer.compare(responseFromServer.size() - 4, 4, "\r\n\r\n") == 0))
{
parts.push_back("");
}
if (parts.size() < 2) {
OnHttpResponse()->Invoke(true, boost::shared_ptr<string>(new string ("Error during http response: connection closed by remote side")));
return;
}
string charsToTrim = " ";
string dataPayload = parts[1].substr(0, parts[1].find_last_not_of(charsToTrim) + 1);
// Sending to the higher layer
boost::shared_ptr<string> payload (new string(dataPayload));
OnHttpResponse()->Invoke(false, payload);
}
catch (exception e) {
boost::shared_ptr<string> messageException (new string(e.what()));
boost::shared_ptr<string> message (new string("Error during http request: " + (*messageException)));
OnHttpResponse()->Invoke(true, message);
}
try {
client->Shutdown();
}
catch (exception e) {
boost::shared_ptr<string> messageException (new string(e.what()));
boost::shared_ptr<string> message (new string("Error during http scocket shutdown: " + (*messageException)));
OnHttpResponse()->Invoke(true, message);
}
}
/// %Thread start
void CliThread()
{
///- Display the list of available CLI functions then beep
//TC_LOG_INFO("server.worldserver", "");
#if TRINITY_PLATFORM != TRINITY_PLATFORM_WINDOWS
rl_attempted_completion_function = cli_completion;
rl_event_hook = cli_hook_func;
#endif
if (sConfigMgr->GetBoolDefault("BeepAtStart", true))
printf("\a"); // \a = Alert
// print this here the first time
// later it will be printed after command queue updates
printf("TC>");
///- As long as the World is running (no World::m_stopEvent), get the command line and handle it
while (!World::IsStopped())
{
fflush(stdout);
std::string command;
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
wchar_t commandbuf[256];
if (fgetws(commandbuf, sizeof(commandbuf), stdin))
{
if (!WStrToUtf8(commandbuf, wcslen(commandbuf), command))
{
printf("TC>");
continue;
}
}
#else
char* command_str = readline("TC>");
rl_bind_key('\t', rl_complete);
if (command_str != nullptr)
{
command = command_str;
free(command_str);
}
#endif
if (!command.empty())
{
std::size_t nextLineIndex = command.find_first_of("\r\n");
if (nextLineIndex != std::string::npos)
{
if (nextLineIndex == 0)
{
#if TRINITY_PLATFORM == TRINITY_PLATFORM_WINDOWS
printf("TC>");
#endif
continue;
}
command.erase(nextLineIndex);
}
fflush(stdout);
sWorld->QueueCliCommand(new CliCommandHolder(nullptr, command.c_str(), &utf8print, &commandFinished));
#if TRINITY_PLATFORM != TRINITY_PLATFORM_WINDOWS
add_history(command.c_str());
#endif
}
else if (feof(stdin))
{
World::StopNow(SHUTDOWN_EXIT_CODE);
}
}
}
