/**
* Downloads the save file from CloudyWeb.
*
* @param Filename Filename of the save game file.
* @param PlayerControllerId Player controller ID of the player who requested the file.
*
* @return Returns true if the file download was successful. Else, returns false.
*
*/
bool CloudyWebConnectorImpl::DownloadFile(FString Filename, int32 PlayerControllerId)
{
CURL *curl;
FILE *fp;
CURLcode res;
errno_t err;
std::string SaveFileURLCString;
if (GetGameId() == -1 || GetUsername(PlayerControllerId).Equals("") ||
PlayerControllerId < 0 || SaveFileUrls.Num() <= PlayerControllerId)
{
UE_LOG(CloudyWebConnectorLog, Error, TEXT("The game ID, username, or player controller ID is invalid"));
return false;
}
// Use the game id and username of the player to GET the save file URL from CloudyWeb
// Then populate SaveFileUrls (TArray)
GetSaveFileUrl(GetGameId(), GetUsername(PlayerControllerId), PlayerControllerId);
// Read the URL from the SaveFileUrls TArray to download the file and write to disk
FString* SaveFileUrlsData = SaveFileUrls.GetData();
if (!SaveFileUrlsData[PlayerControllerId].Equals(""))
{
UE_LOG(CloudyWebConnectorLog, Log, TEXT("File URL obtained! Writing to disk."));
SaveFileURLCString = TCHAR_TO_UTF8(*SaveFileUrlsData[PlayerControllerId]);
// Filepath of .sav file
FString Filepath = FPaths::GameDir();
Filepath += "Saved/SaveGames/" + Filename + "-" +
FString::FromInt(PlayerControllerId) + ".sav";
std::string filePath(TCHAR_TO_UTF8(*Filepath));
curl = curl_easy_init();
if (curl) {
if ((err = fopen_s(&fp, filePath.c_str(), "wb")) == 0)
{
curl_easy_setopt(curl, CURLOPT_URL, SaveFileURLCString.c_str());
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
fclose(fp);
}
else
{
UE_LOG(CloudyWebConnectorLog, Error, TEXT("Could not create save file!"));
}
}
return true;
}
else
{
UE_LOG(CloudyWebConnectorLog, Warning, TEXT("There was no save file URL!"));
return false;
}
}
NS_IMETHODIMP nsPop3IncomingServer::MarkMessages()
{
nsresult rv;
if (m_runningProtocol)
rv = m_runningProtocol->MarkMessages(&m_uidlsToMark);
else
{
nsCString hostName;
nsCString userName;
nsCOMPtr<nsIFile> localPath;
GetLocalPath(getter_AddRefs(localPath));
GetHostName(hostName);
GetUsername(userName);
// do it all in one fell swoop
rv = nsPop3Protocol::MarkMsgForHost(hostName.get(), userName.get(), localPath, m_uidlsToMark);
}
uint32_t count = m_uidlsToMark.Length();
for (uint32_t i = 0; i < count; i++)
{
Pop3UidlEntry *ue = m_uidlsToMark[i];
PR_Free(ue->uidl);
PR_Free(ue);
}
m_uidlsToMark.Clear();
return rv;
}
void PrintInfo()
{
std::cout << "system information" << std::endl;
log::Indenter indenter;
if (*CVAR(logHost))
{
try
{
std::string
user(GetUsername()),
host(GetHostname());
std::cout << "host is " << user << " on " << host << std::endl;
}
catch (...) {}
}
try
{
std::string platform(GetOs());
std::cout << "platform is " << platform << std::endl;
}
catch (...) {}
try
{
std::string machine(GetCpu());
std::cout << "machine is " << machine << std::endl;
}
catch (...) {}
}
void OrthancPeerParameters::ToJson(Json::Value& value) const
{
value = Json::arrayValue;
value.append(GetUrl());
value.append(GetUsername());
value.append(GetPassword());
}
nsCString
nsSmtpServer::GetServerURIInternal(const bool aIncludeUsername)
{
nsCString uri(NS_LITERAL_CSTRING("smtp://"));
nsresult rv;
if (aIncludeUsername)
{
nsCString username;
rv = GetUsername(username);
if (NS_SUCCEEDED(rv) && !username.IsEmpty()) {
nsCString escapedUsername;
MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
// not all servers have a username
uri.Append(escapedUsername);
uri.AppendLiteral("@");
}
}
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
MsgEscapeString(hostname, nsINetUtil::ESCAPE_URL_PATH, escapedHostname);
// not all servers have a hostname
uri.Append(escapedHostname);
}
return uri;
}
NS_IMETHODIMP
nsUserInfo::GetEmailAddress(char * *aEmailAddress)
{
// use username + "@" + domain for the email address
nsresult rv;
nsCAutoString emailAddress;
nsXPIDLCString username;
nsXPIDLCString domain;
rv = GetUsername(getter_Copies(username));
if (NS_FAILED(rv)) return rv;
rv = GetDomain(getter_Copies(domain));
if (NS_FAILED(rv)) return rv;
if (!username.IsEmpty() && !domain.IsEmpty()) {
emailAddress = (const char *)username;
emailAddress += "@";
emailAddress += (const char *)domain;
}
else {
return NS_ERROR_FAILURE;
}
*aEmailAddress = ToNewCString(emailAddress);
return NS_OK;
}
NS_IMETHODIMP
nsSmtpServer::GetServerURI(nsACString &aResult)
{
nsCAutoString uri(NS_LITERAL_CSTRING("smtp://"));
nsCString username;
nsresult rv = GetUsername(username);
if (NS_SUCCEEDED(rv) && !username.IsEmpty()) {
nsCString escapedUsername;
MsgEscapeString(username, nsINetUtil::ESCAPE_XALPHAS, escapedUsername);
// not all servers have a username
uri.Append(escapedUsername);
uri.AppendLiteral("@");
}
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
*((char **)getter_Copies(escapedHostname)) =
nsEscape(hostname.get(), url_Path);
// not all servers have a hostname
uri.Append(escapedHostname);
}
aResult = uri;
return NS_OK;
}
NS_IMETHODIMP
nsSmtpServer::GetUsernamePasswordWithUI(const PRUnichar * aPromptMessage, const
PRUnichar *aPromptTitle,
nsIAuthPrompt* aDialog,
nsACString &aUsername,
nsACString &aPassword)
{
nsresult rv;
if (!m_password.IsEmpty())
{
rv = GetUsername(aUsername);
NS_ENSURE_SUCCESS(rv, rv);
return GetPassword(aPassword);
}
NS_ENSURE_ARG_POINTER(aDialog);
nsCString serverUri;
rv = GetServerURI(serverUri);
NS_ENSURE_SUCCESS(rv, rv);
nsString uniUsername;
nsString uniPassword;
bool okayValue = true;
rv = aDialog->PromptUsernameAndPassword(aPromptTitle, aPromptMessage,
NS_ConvertASCIItoUTF16(serverUri).get(),
nsIAuthPrompt::SAVE_PASSWORD_PERMANENTLY,
getter_Copies(uniUsername),
getter_Copies(uniPassword),
&okayValue);
NS_ENSURE_SUCCESS(rv, rv);
// If the user pressed cancel, just return emtpy strings.
if (!okayValue)
{
aUsername.Truncate();
aPassword.Truncate();
return rv;
}
// We got a username and password back...so remember them.
NS_LossyConvertUTF16toASCII username(uniUsername);
rv = SetUsername(username);
NS_ENSURE_SUCCESS(rv, rv);
NS_LossyConvertUTF16toASCII password(uniPassword);
rv = SetPassword(password);
NS_ENSURE_SUCCESS(rv, rv);
aUsername = username;
aPassword = password;
return NS_OK;
}
NS_IMETHODIMP
nsSmtpServer::ForgetPassword()
{
nsresult rv;
nsCOMPtr<nsILoginManager> loginMgr =
do_GetService(NS_LOGINMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Get the current server URI without the username
nsCAutoString serverUri(NS_LITERAL_CSTRING("smtp://"));
nsCString hostname;
rv = GetHostname(hostname);
if (NS_SUCCEEDED(rv) && !hostname.IsEmpty()) {
nsCString escapedHostname;
*((char **)getter_Copies(escapedHostname)) =
nsEscape(hostname.get(), url_Path);
// not all servers have a hostname
serverUri.Append(escapedHostname);
}
PRUint32 count;
nsILoginInfo** logins;
NS_ConvertUTF8toUTF16 currServer(serverUri);
nsCString serverCUsername;
rv = GetUsername(serverCUsername);
NS_ENSURE_SUCCESS(rv, rv);
NS_ConvertUTF8toUTF16 serverUsername(serverCUsername);
rv = loginMgr->FindLogins(&count, currServer, EmptyString(),
currServer, &logins);
NS_ENSURE_SUCCESS(rv, rv);
// There should only be one-login stored for this url, however just in case
// there isn't.
nsString username;
for (PRUint32 i = 0; i < count; ++i)
{
if (NS_SUCCEEDED(logins[i]->GetUsername(username)) &&
username.Equals(serverUsername))
{
// If this fails, just continue, we'll still want to remove the password
// from our local cache.
loginMgr->RemoveLogin(logins[i]);
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(count, logins);
rv = SetPassword(EmptyCString());
m_logonFailed = PR_TRUE;
return rv;
}
//------------------------------------------------------------------------------
void PostHandle::_OnStart()
{
SmartPtr<PostJob> pPostJob( NEW PostJob );
pPostJob->SetUrl(GetUrl());
pPostJob->SetPostContent(_GetPostContent().c_str());
pPostJob->SetUsername(GetUsername());
pPostJob->SetPassword(GetPassword());
pPostJob->Connect();
pPostJob->SetCallback( MEMBER_FUNC_PTR( &PostHandle::JobDoneCallBack ));
_PushJob( pPostJob );
}
NS_IMETHODIMP
nsNntpUrl::GetServer(nsIMsgIncomingServer **aServer)
{
NS_ENSURE_ARG_POINTER(aServer);
nsresult rv;
nsAutoCString scheme, user, host;
GetScheme(scheme);
GetUsername(user);
GetHost(host);
// No authority -> no server
if (host.IsEmpty())
{
*aServer = nullptr;
return NS_OK;
}
// Looking up the server...
// news-message is used purely internally, so it can never refer to the real
// attribute. nntp is never used internally, so it probably refers to the real
// one. news is used both internally and externally, so it could refer to
// either one. We'll assume it's an internal one first, though.
bool isNews = scheme.EqualsLiteral("news") || scheme.EqualsLiteral("snews");
bool isNntp = scheme.EqualsLiteral("nntp") || scheme.EqualsLiteral("nntps");
bool tryReal = isNntp;
nsCOMPtr<nsIMsgAccountManager> accountManager =
do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Ignoring return results: it is perfectly acceptable for the server to not
// exist, but FindServer (and not FindRealServer) throws NS_ERROR_UNEXPECTED
// in this case.
*aServer = nullptr;
if (tryReal)
accountManager->FindRealServer(user, host, NS_LITERAL_CSTRING("nntp"), 0,
aServer);
else
accountManager->FindServer(user, host, NS_LITERAL_CSTRING("nntp"), aServer);
if (!*aServer && (isNews || isNntp))
{
// Didn't find it, try the other option
if (tryReal)
accountManager->FindServer(user, host, NS_LITERAL_CSTRING("nntp"),
aServer);
else
accountManager->FindRealServer(user, host, NS_LITERAL_CSTRING("nntp"), 0,
aServer);
}
return NS_OK;
}
// mscott - i think this function can be obsoleted and its functionality
// moved into SetSpec or an init method....
nsresult nsSmtpUrl::ParseUrl()
{
nsresult rv = NS_OK;
// set the username
nsCAutoString userName;
rv = GetUsername(userName);
if (NS_FAILED(rv)) return rv;
m_userName = userName;
return NS_OK;
}
nsresult
nsSmtpServer::GetPasswordWithoutUI()
{
nsresult rv;
nsCOMPtr<nsILoginManager> loginMgr(do_GetService(NS_LOGINMANAGER_CONTRACTID,
&rv));
NS_ENSURE_SUCCESS(rv, rv);
NS_ConvertASCIItoUTF16 serverUri(GetServerURIInternal(false));
uint32_t numLogins = 0;
nsILoginInfo** logins = nullptr;
rv = loginMgr->FindLogins(&numLogins, serverUri, EmptyString(),
serverUri, &logins);
// Login manager can produce valid fails, e.g. NS_ERROR_ABORT when a user
// cancels the master password dialog. Therefore handle that here, but don't
// warn about it.
if (NS_FAILED(rv))
return rv;
// Don't abort here, if we didn't find any or failed, then we'll just have
// to prompt.
if (numLogins > 0)
{
nsCString serverCUsername;
rv = GetUsername(serverCUsername);
NS_ConvertASCIItoUTF16 serverUsername(serverCUsername);
nsString username;
for (uint32_t i = 0; i < numLogins; ++i)
{
rv = logins[i]->GetUsername(username);
NS_ENSURE_SUCCESS(rv, rv);
if (username.Equals(serverUsername))
{
nsString password;
rv = logins[i]->GetPassword(password);
NS_ENSURE_SUCCESS(rv, rv);
LossyCopyUTF16toASCII(password, m_password);
break;
}
}
}
NS_FREE_XPCOM_ISUPPORTS_POINTER_ARRAY(numLogins, logins);
return NS_OK;
}
void clSSH::Connect(int seconds)
{
m_session = ssh_new();
if(!m_session) { throw clException("ssh_new failed!"); }
ssh_set_blocking(m_session, 0);
int verbosity = SSH_LOG_NOLOG;
ssh_options_set(m_session, SSH_OPTIONS_HOST, m_host.mb_str(wxConvUTF8).data());
ssh_options_set(m_session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
ssh_options_set(m_session, SSH_OPTIONS_PORT, &m_port);
ssh_options_set(m_session, SSH_OPTIONS_USER, GetUsername().mb_str().data());
// Connect the session
int retries = seconds * 100;
if(retries < 0) { retries = 1; }
DoConnectWithRetries(retries);
ssh_set_blocking(m_session, 1);
}
void DefaultKeyboard::Setup(const Frontend::KeyboardConfig& config) {
SoftwareKeyboard::Setup(config);
auto cfg = Service::CFG::GetModule(Core::System::GetInstance());
ASSERT_MSG(cfg, "CFG Module missing!");
std::string username = Common::UTF16ToUTF8(cfg->GetUsername());
switch (this->config.button_config) {
case ButtonConfig::None:
case ButtonConfig::Single:
Finalize(username, 0);
break;
case ButtonConfig::Dual:
Finalize(username, 1);
break;
case ButtonConfig::Triple:
Finalize(username, 2);
break;
default:
UNREACHABLE();
}
}
/**
* The main entry point for the application.
*/
int APIENTRY _tWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
UNREFERENCED_PARAMETER(hPrevInstance);
UNREFERENCED_PARAMETER(lpCmdLine);
// Initialize global strings
LoadString(hInstance, IDS_APP_TITLE, gWindowTitle, sizeof(gWindowTitle));
LoadString(hInstance, IDC_STREAMING, gWindowClass, sizeof(gWindowClass));
// Register the window class
RegisterWindowClass(hInstance);
// Perform application initialization:
if ( !InitInstance(hInstance, nCmdShow) )
{
return FALSE;
}
// Set the view to the default position
ResetView();
// Cache the last mouse position
GetCursorPos(&gLastMousePos);
// Initialize the Twitch SDK
InitializeStreaming("<username>", "<password>", "<clientId>", "<clientSecret>", GetIntelDllPath());
// Main message loop
MSG msg;
while (true)
{
// Check to see if any messages are waiting in the queue
while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
{
// Process window messages
TranslateMessage(&msg);
DispatchMessage(&msg);
// Received a quit message
if (msg.message == WM_QUIT)
{
break;
}
}
// Received a quit message so exit the app
if (msg.message == WM_QUIT)
{
break;
}
if (gReinitializeRequired)
{
gReinitializeRequired = false;
InitializeRendering();
}
// Draw the scene
RenderScene();
UpdateWaveMesh();
// Process user input independent of the event queue
if (gFocused)
{
HandleInput();
}
// Record the frame time
unsigned __int64 curTime = GetSystemTimeMs();
// Begin streaming when ready
if (gStreamingDesired &&
!IsStreaming() &&
IsReadyToStream())
{
StartStreaming(gBroadcastWidth, gBroadcastHeight, gBroadcastFramesPerSecond);
gLastCaptureTime = 0;
}
// If you send frames too quickly to the SDK (based on the broadcast FPS you configured) it will not be able
// to make use of them all. In that case, it will simply release buffers without using them which means the
// game wasted time doing the capture. To mitigate this, the app should pace the captures to the broadcast FPS.
unsigned __int64 captureDelta = curTime - gLastCaptureTime;
bool isTimeForNextCapture = (captureDelta / 1000.0) >= (1.0 / gBroadcastFramesPerSecond);
// streaming is in progress so try and capture a frame
if (IsStreaming() &&
!gPaused &&
isTimeForNextCapture)
{
// capture a snapshot of the back buffer
unsigned char* pBgraFrame = nullptr;
int width = 0;
int height = 0;
bool gotFrame = false;
switch (gCaptureMethod)
{
case CaptureMethod::Slow:
gotFrame = CaptureFrame_Slow(gBroadcastWidth, gBroadcastHeight, pBgraFrame);
break;
case CaptureMethod::Fast:
gotFrame = CaptureFrame_Fast(gBroadcastWidth, gBroadcastHeight, pBgraFrame, width, height);
break;
}
// send a frame to the stream
if (gotFrame)
{
SubmitFrame(pBgraFrame);
}
}
// The SDK may generate events that need to be handled by the main thread so we should handle them
FlushStreamingEvents();
unsigned __int64 timePerFrame = curTime - gLastFrameTime;
unsigned int fps = 0;
if (timePerFrame > 0)
{
fps = static_cast<int>(1000 / timePerFrame);
}
gLastFrameTime = curTime;
// Update the window title to show the state
#undef STREAM_STATE
#define STREAM_STATE(__state__) #__state__,
char buffer[128];
const char* streamStates[] =
{
STREAM_STATE_LIST
};
#undef STREAM_STATE
sprintf_s(buffer, sizeof(buffer), "Twitch Direct3D Streaming Sample - %s - %s FPS=%d", GetUsername().c_str(), streamStates[GetStreamState()], fps);
SetWindowTextA(gWindowHandle, buffer);
}
// Shutdown the Twitch SDK
StopStreaming();
ShutdownStreaming();
// Cleanup the rendering method
switch (gCaptureMethod)
{
case CaptureMethod::Slow:
DeinitRendering_Slow();
break;
case CaptureMethod::Fast:
DeinitRendering_Fast();
break;
}
// Shutdown the app
gGraphicsDevice->Release();
gDirect3D->Release();
// Cleanup the mesh
DestroyWaveMesh();
return (int)msg.wParam;
}
NS_IMETHODIMP
nsSmtpServer::GetPassword(nsACString& aPassword)
{
if (m_password.IsEmpty() && !m_logonFailed)
{
// try to avoid prompting the user for another password. If the user has set
// the appropriate pref, we'll use the password from an incoming server, if
// the user has already logged onto that server.
// if this is set, we'll only use this, and not the other prefs
// user_pref("mail.smtpserver.smtp1.incomingAccount", "server1");
// if this is set, we'll accept an exact match of user name and server
// user_pref("mail.smtp.useMatchingHostNameServer", true);
// if this is set, and we don't find an exact match of user and host name,
// we'll accept a match of username and domain, where domain
// is everything after the first '.'
// user_pref("mail.smtp.useMatchingDomainServer", true);
nsCString accountKey;
bool useMatchingHostNameServer = false;
bool useMatchingDomainServer = false;
mPrefBranch->GetCharPref("incomingAccount", getter_Copies(accountKey));
nsCOMPtr<nsIMsgAccountManager> accountManager = do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID);
nsCOMPtr<nsIMsgIncomingServer> incomingServerToUse;
if (accountManager)
{
if (!accountKey.IsEmpty())
accountManager->GetIncomingServer(accountKey, getter_AddRefs(incomingServerToUse));
else
{
nsresult rv;
nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv,rv);
prefBranch->GetBoolPref("mail.smtp.useMatchingHostNameServer", &useMatchingHostNameServer);
prefBranch->GetBoolPref("mail.smtp.useMatchingDomainServer", &useMatchingDomainServer);
if (useMatchingHostNameServer || useMatchingDomainServer)
{
nsCString userName;
nsCString hostName;
GetHostname(hostName);
GetUsername(userName);
if (useMatchingHostNameServer)
// pass in empty type and port=0, to match imap and pop3.
accountManager->FindRealServer(userName, hostName, EmptyCString(), 0, getter_AddRefs(incomingServerToUse));
int32_t dotPos = -1;
if (!incomingServerToUse && useMatchingDomainServer
&& (dotPos = hostName.FindChar('.')) != kNotFound)
{
hostName.Cut(0, dotPos);
nsCOMPtr<nsISupportsArray> allServers;
accountManager->GetAllServers(getter_AddRefs(allServers));
if (allServers)
{
uint32_t count = 0;
allServers->Count(&count);
uint32_t i;
for (i = 0; i < count; i++)
{
nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(allServers, i);
if (server)
{
nsCString serverUserName;
nsCString serverHostName;
server->GetRealUsername(serverUserName);
server->GetRealHostName(serverHostName);
if (serverUserName.Equals(userName))
{
int32_t serverDotPos = serverHostName.FindChar('.');
if (serverDotPos != kNotFound)
{
serverHostName.Cut(0, serverDotPos);
if (serverHostName.Equals(hostName))
{
incomingServerToUse = server;
break;
}
}
}
}
}
}
}
}
}
}
if (incomingServerToUse)
return incomingServerToUse->GetPassword(aPassword);
}
aPassword = m_password;
return NS_OK;
}
/* Get the next eventlog message */
char * EventlogNext(EventList ignore_list[MAX_IGNORED_EVENTS], int log, int * level)
{
BOOL reopen = FALSE;
DWORD errnum;
DWORD needed;
DWORD loglevel;
EVENTLOGRECORD * event;
char * cp;
char * current;
char * formatted_string;
char * message_file;
char * source;
char * string_array[EVENTLOG_ARRAY_SZ];
char * username;
char hostname[HOSTNAME_SZ];
char defmsg[ERRMSG_SZ];
int event_id;
int i;
char *index;
static char message[SYSLOG_DEF_SZ-17];
static char tstamped_message[SYSLOG_DEF_SZ];
/* Initialize array to prevent memory exceptions with bad message definitions */
for(i = 0; i < EVENTLOG_ARRAY_SZ; i++)
string_array[i]="*";
/* Are there any records left in buffer */
while (EventlogList[log].pos == EventlogList[log].count) {
/* Reset input position */
EventlogList[log].count = 0;
EventlogList[log].pos = 0;
/* Read a record */
needed = 0;
if (ReadEventLog(EventlogList[log].handle, EVENTLOG_FORWARDS_READ | EVENTLOG_SEEK_READ, EventlogList[log].recnum, EventlogList[log].buffer, sizeof(EventlogList[log].buffer), &EventlogList[log].count, &needed) == 0) {
/* Check error */
errnum = GetLastError();
switch (errnum) {
/* Message too large... skip over */
case ERROR_INSUFFICIENT_BUFFER:
Log(LOG_WARNING, "Eventlog message size too large: \"%s\": %u bytes", EventlogList[log].name, needed);
EventlogList[log].recnum++;
break;
/* Eventlog corrupted (?)... Reopen */
case ERROR_EVENTLOG_FILE_CORRUPT:
Log(LOG_INFO, "Eventlog was corrupted: \"%s\"", EventlogList[log].name);
reopen = TRUE;
break;
/* Eventlog files are clearing... Reopen */
case ERROR_EVENTLOG_FILE_CHANGED:
Log(LOG_INFO, "Eventlog was cleared: \"%s\"", EventlogList[log].name);
reopen = TRUE;
break;
/* Record not available (yet) */
case ERROR_INVALID_PARAMETER:
return NULL;
/* Normal end of eventlog messages */
case ERROR_HANDLE_EOF:
return NULL;
/* Eventlog probably closing down */
case RPC_S_UNKNOWN_IF:
return NULL;
/* Unknown condition */
default:
Log(LOG_ERROR|LOG_SYS, "Eventlog \"%s\" returned error: ", EventlogList[log].name);
ServiceIsRunning = FALSE;
return NULL;
}
/* Process reopen */
if (reopen) {
EventlogClose(log);
if (EventlogOpen(log)) {
ServiceIsRunning = FALSE;
return NULL;
}
reopen = FALSE;
}
}
}
/* Increase record number */
EventlogList[log].recnum++;
/* Get position into buffer */
current = EventlogList[log].buffer + EventlogList[log].pos;
/* Get pointer to current event record */
event = (EVENTLOGRECORD *) current;
/* Advance position */
EventlogList[log].pos += event->Length;
/* Get source and event id */
source = current + sizeof(*event);
event_id = (int) HRESULT_CODE(event->EventID);
/* Check Event Info Against Ignore List */
if (IgnoreSyslogEvent(ignore_list, source, event_id)) {
if (LogInteractive)
printf("IGNORING_EVENT: SOURCE=%s & ID=%i\n", source, event_id);
return NULL;
}
/* Check number of strings */
if (event->NumStrings > COUNT_OF(string_array)) {
/* Too many strings */
Log(LOG_WARNING, "Eventlog message has too many strings to print message: \"%s\": %u strings", EventlogList[log].name, event->NumStrings);
formatted_string = NULL;
} else {
/* Convert strings to arrays */
cp = current + event->StringOffset;
for (i = 0; i < event->NumStrings; i++) {
string_array[i] = cp;
while (*cp++ != '\0');
}
message_file = LookupMessageFile(EventlogList[log].name, source, event->EventID);
if (message_file == NULL) {
/* Cannot load resources */
formatted_string = NULL;
} else {
/* Format eventlog message */
formatted_string = FormatLibraryMessage(message_file, event->EventID, string_array);
}
}
/* Create a default message if resources or formatting didn't work */
if (formatted_string == NULL) {
_snprintf_s(defmsg, sizeof(defmsg), _TRUNCATE,
"(Facility: %u, Status: %s)",
HRESULT_FACILITY(event->EventID),
FAILED(event->EventID) ? "Failure" : "Success"
);
formatted_string = defmsg;
}
/* replace every space in source by underscores */
index = source;
while( *index ) {
if( *index == ' ' ) {
*index = '_';
}
index++;
}
/* Format source and event ID number */
if(SyslogIncludeTag) {
_snprintf_s(message, sizeof(message), _TRUNCATE,
"%s: %s: %u: ",
SyslogTag,
source,
HRESULT_CODE(event->EventID)
);
} else {
_snprintf_s(message, sizeof(message), _TRUNCATE,
"%s: %u: ",
source,
HRESULT_CODE(event->EventID)
);
}
/* Convert user */
if (event->UserSidLength > 0) {
username = GetUsername((SID *) (current + event->UserSidOffset));
if (username) {
strncat_s(message, sizeof(message), username, _TRUNCATE);
strncat_s(message, sizeof(message), ": ", _TRUNCATE);
}
}
/* Add formatted string to base message */
strncat_s(message, sizeof(message), formatted_string, _TRUNCATE);
/* Select syslog level */
switch (event->EventType) {
case EVENTLOG_ERROR_TYPE:
loglevel = SYSLOG_ERR;
*level = SYSLOG_BUILD(SyslogFacility, loglevel);
break;
case EVENTLOG_WARNING_TYPE:
loglevel = SYSLOG_WARNING;
*level = SYSLOG_BUILD(SyslogFacility, loglevel);
break;
case EVENTLOG_INFORMATION_TYPE:
loglevel = SYSLOG_NOTICE;
*level = SYSLOG_BUILD(SyslogFacility, loglevel);
break;
case EVENTLOG_AUDIT_SUCCESS:
strncat_s(message, sizeof(message), "AUDIT_SUCCESS ", _TRUNCATE);
loglevel = SYSLOG_NOTICE;
*level = SYSLOG_BUILD(SyslogFacility, loglevel);
break;
case EVENTLOG_AUDIT_FAILURE:
strncat_s(message, sizeof(message), "AUDIT_FAILURE ", _TRUNCATE);
loglevel = SYSLOG_ERR;
*level = SYSLOG_BUILD(SyslogFacility, loglevel);
break;
/* Everything else */
case EVENTLOG_SUCCESS:
default:
loglevel = SYSLOG_NOTICE;
*level = SYSLOG_BUILD(SyslogFacility, loglevel);
break;
}
/* If event is not being ignored, make sure it is severe enough to be logged */
if (SyslogLogLevel != 0)
if (SyslogLogLevel < loglevel-1)
return NULL;
/* Add hostname for RFC compliance (RFC 3164) */
/* if -a then use the fqdn bound to our IP address. If none, use the IP address */
if (ProgramUseIPAddress == TRUE) {
strcpy_s(hostname, HOSTNAME_SZ, ProgramHostName);
} else {
if (ExpandEnvironmentStrings("%COMPUTERNAME%", hostname, COUNT_OF(hostname)) == 0) {
strcpy_s(hostname, COUNT_OF(hostname), "HOSTNAME_ERR");
Log(LOG_ERROR|LOG_SYS, "Cannot expand %COMPUTERNAME%");
}
}
/* Query and Add timestamp from EventLog, add hostname, */
/* and finally the message to the string */
_snprintf_s(tstamped_message, sizeof(tstamped_message), _TRUNCATE,
"%s %s %s",
TimeToString(event->TimeGenerated),
hostname,
message
);
/* Return formatted message */
return tstamped_message;
}
/**
* Uploads the save file to CloudyWeb.
*
* @param Filename Filename of the save game file.
* @param PlayerControllerId PlayerControllerId of the player who is saving the game.
*
* @return Returns true if the file upload was successful. Else, returns false.
*
*/
bool CloudyWebAPIImpl::UploadFile(FString Filename, int32 PlayerControllerId)
{
bool RequestSuccess = false;
CURL *curl;
CURLcode res;
std::string readBuffer;
FString Url = BaseUrl + SaveDataUrl;
std::string UrlCString(TCHAR_TO_UTF8(*Url));
// Filepath of .sav file
FString Filepath = FPaths::GameDir();
Filepath += "Saved/SaveGames/" + Filename + ".sav";
std::string filePath(TCHAR_TO_UTF8(*Filepath));
// Get game name
FString GameName = FApp::GetGameName();
std::string gameName(TCHAR_TO_UTF8(*GameName));
// Get game ID
FString GameID = FString::FromInt(GetGameId());
std::string GameIDCString(TCHAR_TO_UTF8(*GameID));
// Get username
FString Username = GetUsername(PlayerControllerId);
std::string UsernameCString(TCHAR_TO_UTF8(*Username));
// Convert PlayerControllerId
FString playerControllerIdFString = FString::FromInt(PlayerControllerId);
std::string playerControllerId(TCHAR_TO_UTF8(*playerControllerIdFString));
if (GetGameId() == -1 || Username.Equals("") || PlayerControllerId < 0)
{
UE_LOG(CloudyWebAPILog, Error, TEXT("The game ID, username, or player controller ID is invalid"));
return false;
}
struct curl_httppost *formpost = NULL;
struct curl_httppost *lastptr = NULL;
struct curl_slist *headerlist = NULL;
FString AuthHeader = "Authorization: Token " + Token;
std::string AuthHeaderCString(TCHAR_TO_UTF8(*AuthHeader));
curl_global_init(CURL_GLOBAL_ALL);
/* Fill in the file upload field */
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "saved_file",
CURLFORM_FILE, filePath.c_str(),
CURLFORM_END);
/* Fill in the player controller ID field */
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "user",
CURLFORM_COPYCONTENTS, UsernameCString.c_str(),
CURLFORM_END);
/* Fill in the game name field */
curl_formadd(&formpost, &lastptr,
CURLFORM_COPYNAME, "game",
CURLFORM_COPYCONTENTS, GameIDCString.c_str(),
CURLFORM_END);
curl = curl_easy_init();
/* initialize custom header list (stating that Expect: 100-continue is not
wanted */
headerlist = curl_slist_append(headerlist, AuthHeaderCString.c_str());
if (curl) {
/* what URL that receives this POST */
curl_easy_setopt(curl, CURLOPT_URL, UrlCString.c_str());
/* only disable 100-continue header if explicitly requested */
curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
/* What form to send */
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
/* Set up string to write response into */
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
/* Perform the request, res will get the return code */
res = curl_easy_perform(curl);
/* Check if the request was successful */
if (res == CURLE_OK)
{
RequestSuccess = true;
}
/* always cleanup */
curl_easy_cleanup(curl);
/* then cleanup the formpost chain */
curl_formfree(formpost);
/* free slist */
curl_slist_free_all(headerlist);
UE_LOG(CloudyWebAPILog, Warning, TEXT("Response data: %s"), UTF8_TO_TCHAR(readBuffer.c_str()));
ReadAndStoreSaveFileURL(readBuffer.c_str(), PlayerControllerId);
}
return RequestSuccess;
}
