jeanlemotan
604 lines
21 KiB
C++
604 lines
21 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
// Copyright (c) Electronic Arts Inc. All rights reserved.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include <EABase/eabase.h>
|
|
#include <EAAssert/eaassert.h>
|
|
#include <EAMain/internal/EAMainChannels.h>
|
|
|
|
#if defined(EA_PLATFORM_IPHONE)
|
|
#define EAMAIN_HAS_NETWORK_CHANNEL 1
|
|
#define EAMAIN_FREOPEN_SUPPORTED 1
|
|
#endif
|
|
|
|
#if defined(EA_PLATFORM_WINRT)
|
|
#define EAMAIN_HAS_NETWORK_CHANNEL 1
|
|
#define EAMAIN_FREOPEN_SUPPORTED 0
|
|
#endif
|
|
|
|
#if defined(EA_PLATFORM_WINDOWS_PHONE) && !defined(EAMAIN_HAS_NETWORK_CHANNEL)
|
|
#define EAMAIN_HAS_NETWORK_CHANNEL 1
|
|
#define EAMAIN_FREOPEN_SUPPORTED 0
|
|
#endif
|
|
|
|
// winrt-arm configurations do not have winsock, so for these configurations
|
|
// we disable the use of the network channel.
|
|
#if defined(_MSC_VER) && !defined(EA_PLATFORM_WINDOWS_PHONE) && defined(EA_PROCESSOR_ARM) && defined(EAMAIN_HAS_NETWORK_CHANNEL)
|
|
#undef EAMAIN_HAS_NETWORK_CHANNEL
|
|
#endif
|
|
|
|
#if defined(EA_PLATFORM_CAPILANO) && !defined(EAMAIN_HAS_NETWORK_CHANNEL)
|
|
#define EAMAIN_HAS_NETWORK_CHANNEL 1
|
|
#define EAMAIN_FREOPEN_SUPPORTED 1
|
|
#endif
|
|
|
|
#if !defined(EAMAIN_HAS_NETWORK_CHANNEL)
|
|
#define EAMAIN_HAS_NETWORK_CHANNEL 0
|
|
#endif
|
|
|
|
#if !defined(EAMAIN_FREOPEN_SUPPORTED)
|
|
#define EAMAIN_FREOPEN_SUPPORTED 0
|
|
#endif
|
|
|
|
#if EAMAIN_HAS_NETWORK_CHANNEL
|
|
|
|
#if defined(_MSC_VER)
|
|
EA_DISABLE_ALL_VC_WARNINGS()
|
|
|
|
#if defined(WINAPI_FAMILY)
|
|
#undef WINAPI_FAMILY
|
|
#endif
|
|
|
|
#define WINAPI_FAMILY WINAPI_FAMILY_DESKTOP_APP
|
|
|
|
#include <WinSock2.h>
|
|
#include <ws2tcpip.h>
|
|
|
|
#pragma comment(lib, "Ws2_32.lib")
|
|
|
|
#if defined(EA_PLATFORM_WINDOWS_PHONE)
|
|
#pragma warning(disable:4265)
|
|
#include <thread>
|
|
#else
|
|
// Restoring VC warnings on Windows Phone causes some warnings to pop
|
|
// up down below, emanating from std::thread. In order to have some
|
|
// coverage of this code, warnings are re-enabled on other platforms.
|
|
EA_RESTORE_ALL_VC_WARNINGS()
|
|
#endif
|
|
|
|
#define SocketGetLastError() WSAGetLastError()
|
|
#define snprintf _snprintf
|
|
#else
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <errno.h>
|
|
#if !defined(EA_PLATFORM_SONY)
|
|
#include <netdb.h>
|
|
#else
|
|
#include <net.h>
|
|
#endif
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
typedef int SOCKET;
|
|
const int INVALID_SOCKET = -1;
|
|
const int SOCKET_ERROR = -1;
|
|
#define SD_SEND SHUT_WR
|
|
#define closesocket close
|
|
#define WSAECONNREFUSED ECONNREFUSED
|
|
#define WSAENETUNREACH ENETUNREACH
|
|
#define SocketGetLastError() errno
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include "eathread/eathread_thread.h"
|
|
#include "EAStdC/EAMemory.h"
|
|
#include "EAStdC/EAString.h"
|
|
#include "EAStdC/EASprintf.h"
|
|
|
|
namespace EA
|
|
{
|
|
namespace EAMain
|
|
{
|
|
namespace Internal
|
|
{
|
|
class NetworkChannel : public IChannel
|
|
{
|
|
SOCKET m_socket;
|
|
char m_serverAddressStorage[128];
|
|
char m_port[6];
|
|
const char *m_serverAddress;
|
|
|
|
static void SleepThread(int milliseconds);
|
|
|
|
public:
|
|
NetworkChannel();
|
|
|
|
virtual ~NetworkChannel();
|
|
virtual void Init();
|
|
virtual void Send(const char8_t *data);
|
|
virtual void Shutdown();
|
|
|
|
void SetServerPort(const char *server, const char *port);
|
|
bool Connect();
|
|
};
|
|
|
|
static NetworkChannel g_NetworkChannelInstance;
|
|
|
|
void NetworkChannel::SleepThread(int milliseconds)
|
|
{
|
|
#if defined(_MSC_VER)
|
|
#if defined(EA_PLATFORM_WINDOWS_PHONE)
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
|
|
#else
|
|
Sleep(milliseconds);
|
|
#endif
|
|
#else
|
|
usleep(milliseconds * 1000);
|
|
#endif
|
|
}
|
|
|
|
NetworkChannel::NetworkChannel()
|
|
: m_socket(INVALID_SOCKET)
|
|
, m_serverAddress(&m_serverAddressStorage[0])
|
|
{
|
|
EA::StdC::Memset8(m_serverAddressStorage, 0, sizeof m_serverAddressStorage);
|
|
EA::StdC::Memset8(m_port, 0, sizeof m_port);
|
|
|
|
#if defined(_MSC_VER)
|
|
WSAData wsaData = {};
|
|
WSAStartup(MAKEWORD(2, 2), &wsaData);
|
|
#endif
|
|
}
|
|
|
|
static void LogNetworkError(const char *format, ...)
|
|
{
|
|
(void)format;
|
|
}
|
|
|
|
NetworkChannel::~NetworkChannel()
|
|
{
|
|
#if defined(_MSC_VER)
|
|
WSACleanup();
|
|
#endif
|
|
}
|
|
|
|
void NetworkChannel::Init()
|
|
{
|
|
}
|
|
|
|
void NetworkChannel::Send(const char8_t *data)
|
|
{
|
|
char *buffer = const_cast<char *>(data);
|
|
ssize_t bufferLength = static_cast<ssize_t>(strlen(buffer));
|
|
ssize_t bytesSent = 0;
|
|
while (bytesSent < bufferLength)
|
|
{
|
|
ssize_t result = send(m_socket, buffer + bytesSent, static_cast<int>(bufferLength - bytesSent), 0);
|
|
|
|
if (result == SOCKET_ERROR)
|
|
{
|
|
bool reconnected = false;
|
|
LogNetworkError("[NetworkChannel::Send] Reconnecting...");
|
|
|
|
for (int i = 0; i < 20; ++i)
|
|
{
|
|
Shutdown();
|
|
|
|
if (!Connect())
|
|
{
|
|
LogNetworkError("[NetworkChannel::Send] Send failed: %d", SocketGetLastError());
|
|
}
|
|
else
|
|
{
|
|
reconnected = true;
|
|
break;
|
|
}
|
|
|
|
SleepThread(500);
|
|
}
|
|
|
|
if (!reconnected)
|
|
{
|
|
LogNetworkError("[NetworkChannel::Send] Unable to connect, aborting.");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bytesSent += result;
|
|
}
|
|
}
|
|
}
|
|
|
|
void NetworkChannel::Shutdown()
|
|
{
|
|
// Closing the socket does not wait for pending data to be sent.
|
|
// To ensure that all data has been sent, the write end of the
|
|
// socket must first be shut down. This sends a FIN packet to
|
|
// the receiver after all data has been sent and acknowledged
|
|
// by the receiver. This must also be paired with a call to
|
|
// recv to ensure that all pending readable data has been
|
|
// read.
|
|
shutdown(m_socket, SD_SEND);
|
|
|
|
char buffer[128];
|
|
|
|
for (;;)
|
|
{
|
|
ssize_t rv = recv(m_socket, buffer, (int)sizeof buffer, 0);
|
|
|
|
if (rv <= 0)
|
|
{
|
|
// We can assume that a graceful shutdown has occurred
|
|
// when rv == 0. If rv < 0 an error has occurred, but
|
|
// we are not at a point where we can easily recover, so
|
|
// this code will just shutdown the socket and exit the
|
|
// program if an error happens here.
|
|
break;
|
|
}
|
|
}
|
|
|
|
closesocket(m_socket);
|
|
m_socket = INVALID_SOCKET;
|
|
}
|
|
|
|
void NetworkChannel::SetServerPort(const char *server, const char *port)
|
|
{
|
|
using namespace EA::StdC;
|
|
|
|
// If, somehow, the server name string is longer than the storge
|
|
// allocated, allocate some space for it on the C-heap. Not ideal,
|
|
// may actually fail some tests, but the alternative would be
|
|
// no output from EAMain at all.
|
|
if (Strlcpy(m_serverAddressStorage, server, sizeof m_serverAddressStorage) > (sizeof m_serverAddressStorage))
|
|
{
|
|
size_t serverNameLength = Strlen(server);
|
|
|
|
char *ptr = static_cast<char *>(calloc(serverNameLength + 1, 1));
|
|
Strlcpy(ptr, server, serverNameLength + 1);
|
|
|
|
m_serverAddress = ptr;
|
|
}
|
|
|
|
// Valid port numbers are in the range [1, 65535] so will have
|
|
// always 5 digits max.
|
|
EA_ASSERT(sizeof m_port == 6);
|
|
Strlcpy(m_port, port, sizeof m_port);
|
|
}
|
|
|
|
bool NetworkChannel::Connect()
|
|
{
|
|
EA_ASSERT(m_serverAddress != NULL);
|
|
EA_ASSERT(m_port != NULL);
|
|
|
|
bool result = false;
|
|
SOCKET remoteSocket = INVALID_SOCKET;
|
|
const int MAX_RETRIES = 250;
|
|
|
|
#if !defined(EA_PLATFORM_SONY)
|
|
struct addrinfo hints = {};
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
addrinfo *p = NULL;
|
|
|
|
if (getaddrinfo(m_serverAddress, m_port, &hints, &p) != 0)
|
|
{
|
|
LogNetworkError("[NetworkChannel::Connect] Cannot connect to %s:%s", m_serverAddress, m_port);
|
|
goto ErrorReturn;
|
|
}
|
|
for (struct addrinfo *endpoint = p; endpoint != NULL; endpoint = endpoint->ai_next)
|
|
#endif
|
|
|
|
{
|
|
#if !defined(EA_PLATFORM_SONY)
|
|
remoteSocket = socket(endpoint->ai_family, endpoint->ai_socktype, endpoint->ai_protocol);
|
|
#else
|
|
remoteSocket = sceNetSocket("EAMain Socket", SCE_NET_AF_INET, SCE_NET_SOCK_STREAM, 0);
|
|
#endif
|
|
if (remoteSocket == INVALID_SOCKET)
|
|
{
|
|
LogNetworkError("[NetworkChannel::Connect] Cannot create socket");
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
#if defined(_MSC_VER)
|
|
if (endpoint->ai_family == AF_INET6)
|
|
{
|
|
DWORD v6only = 0;
|
|
setsockopt(remoteSocket, IPPROTO_IPV6, IPV6_V6ONLY, (char *)&v6only, sizeof v6only);
|
|
}
|
|
#endif
|
|
|
|
for (int i = 0; i < MAX_RETRIES; ++i)
|
|
{
|
|
#if !defined(EA_PLATFORM_SONY)
|
|
int connectResult = connect(remoteSocket, endpoint->ai_addr, (int)endpoint->ai_addrlen);
|
|
#else
|
|
char *p;
|
|
SceNetInPort_t port = strtol(m_port, &p, 10);
|
|
|
|
SceNetSockaddrIn sin;
|
|
EA::StdC::Memset8(&sin, 0, sizeof sin);
|
|
sin.sin_len = sizeof(sin);
|
|
sin.sin_family = SCE_NET_AF_INET;
|
|
if (sceNetInetPton(SCE_NET_AF_INET, m_serverAddress, &sin.sin_addr) <= 0)
|
|
{
|
|
LogNetworkError("[NetworkChannel::Connect] Cannot connect to %s:%s", m_serverAddress, m_port);
|
|
goto ErrorReturn;
|
|
}
|
|
|
|
sin.sin_port = sceNetHtons(port);
|
|
sin.sin_vport = sceNetHtons(SCE_NET_ADHOC_PORT);
|
|
int connectResult = sceNetConnect(remoteSocket, (SceNetSockaddr *)&sin, sizeof(sin));
|
|
#endif
|
|
if (connectResult == 0)
|
|
{
|
|
result = true;
|
|
m_socket = remoteSocket;
|
|
goto SuccessReturn;
|
|
}
|
|
|
|
switch (SocketGetLastError())
|
|
{
|
|
case WSAENETUNREACH:
|
|
SleepThread(20);
|
|
continue;
|
|
default:
|
|
LogNetworkError("[NetworkChannel::Connect] Cannot connect to socket");
|
|
goto ErrorReturn;
|
|
}
|
|
}
|
|
}
|
|
|
|
ErrorReturn:
|
|
if (remoteSocket != INVALID_SOCKET)
|
|
{
|
|
LogNetworkError("[NetworkChannel::Connect] FAILED");
|
|
closesocket(remoteSocket);
|
|
}
|
|
|
|
SuccessReturn:
|
|
#if !defined(EA_PLATFORM_SONY)
|
|
if (p)
|
|
{
|
|
freeaddrinfo(p);
|
|
}
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
static IChannel *CreateNetworkChannelImpl(const char *server, int port)
|
|
{
|
|
char portString[6];
|
|
|
|
if (port > 65536 || port < 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
snprintf(portString, sizeof portString, "%d", port);
|
|
portString[5] = 0;
|
|
|
|
g_NetworkChannelInstance.SetServerPort(server, portString);
|
|
|
|
if (g_NetworkChannelInstance.Connect())
|
|
{
|
|
return &g_NetworkChannelInstance;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#if !EAMAIN_FREOPEN_SUPPORTED
|
|
IChannel *CreateNetworkChannel(const char *server, int port)
|
|
{
|
|
// On platforms where we do not support freopen on standard
|
|
// IO streams, we create a raw network channel.
|
|
return CreateNetworkChannelImpl(server, port);
|
|
}
|
|
#else
|
|
static EA::Thread::Thread g_PrintThread;
|
|
static volatile bool g_PrintThreadDone;
|
|
static FILE *g_RedirectedStdoutHandle;
|
|
static FILE *g_RedirectedStderrHandle;
|
|
|
|
class StdoutWrapperChannel : public IChannel
|
|
{
|
|
NetworkChannel &m_channel;
|
|
bool m_shutdown;
|
|
|
|
StdoutWrapperChannel& operator=(const StdoutWrapperChannel&);
|
|
StdoutWrapperChannel(const StdoutWrapperChannel&);
|
|
|
|
public:
|
|
StdoutWrapperChannel(NetworkChannel &channel)
|
|
: m_channel(channel)
|
|
, m_shutdown(false)
|
|
{
|
|
}
|
|
|
|
virtual ~StdoutWrapperChannel();
|
|
|
|
virtual void Init()
|
|
{
|
|
}
|
|
|
|
virtual void Send(const char8_t *data)
|
|
{
|
|
fputs(data, stdout);
|
|
fflush(stdout);
|
|
}
|
|
|
|
virtual void Shutdown()
|
|
{
|
|
if (g_RedirectedStdoutHandle)
|
|
{
|
|
fclose(g_RedirectedStdoutHandle);
|
|
}
|
|
|
|
if (g_RedirectedStderrHandle)
|
|
{
|
|
fclose(g_RedirectedStderrHandle);
|
|
}
|
|
|
|
g_PrintThreadDone = true;
|
|
|
|
if (g_PrintThread.GetStatus() == EA::Thread::Thread::kStatusRunning)
|
|
{
|
|
g_PrintThread.WaitForEnd();
|
|
}
|
|
|
|
m_channel.Shutdown();
|
|
m_shutdown = true;
|
|
}
|
|
};
|
|
|
|
StdoutWrapperChannel::~StdoutWrapperChannel()
|
|
{
|
|
if (!m_shutdown)
|
|
{
|
|
Shutdown();
|
|
}
|
|
}
|
|
|
|
static bool ReadFromFile(FILE *file)
|
|
{
|
|
static const int BUFFER_SIZE = 1024;
|
|
static char buffer[BUFFER_SIZE + 1];
|
|
bool haveRead = false;
|
|
|
|
// This is a tortuous way of checking to see if there is data
|
|
// available but the goal here is to prevent this thread from
|
|
// blocking if nothing is ready. Blocking could be desirable
|
|
// if we were only reading from one stream but because this
|
|
// code attempts to read from both stdout and stderr we do not
|
|
// want it to block on reading one while the other is receiving
|
|
// important information.
|
|
|
|
// Another possibility would be to use non-blocking IO but this
|
|
// would require different implementations for different
|
|
// platforms.
|
|
long currentPosition = ftell(file);
|
|
fseek(file, 0, SEEK_END);
|
|
long endPosition = ftell(file);
|
|
|
|
if (endPosition > currentPosition)
|
|
{
|
|
size_t bytesAvailable = static_cast<size_t>(endPosition - currentPosition);
|
|
|
|
fseek(file, currentPosition, SEEK_SET);
|
|
while (bytesAvailable > 0)
|
|
{
|
|
size_t bytesToRead = (bytesAvailable > BUFFER_SIZE) ? BUFFER_SIZE : bytesAvailable;
|
|
|
|
size_t bytesRead = fread(buffer, 1, bytesToRead, file);
|
|
buffer[bytesRead] = 0;
|
|
|
|
g_NetworkChannelInstance.Send(buffer);
|
|
|
|
bytesAvailable -= bytesRead;
|
|
}
|
|
|
|
haveRead = true;
|
|
}
|
|
|
|
return haveRead;
|
|
}
|
|
|
|
static char g_StdoutLogPath[256];
|
|
static char g_StderrLogPath[256];
|
|
|
|
static intptr_t PrintFunction(void *)
|
|
{
|
|
FILE *stdoutLog = fopen(g_StdoutLogPath, "rb");
|
|
FILE *stderrLog = fopen(g_StderrLogPath, "rb");
|
|
|
|
while (!g_PrintThreadDone)
|
|
{
|
|
// It might look neater to combine these file reads into
|
|
// the if statement but this was not done because the
|
|
// shortcircuting of the left hand condition prevented
|
|
// the right hand condition from being evaluated, but
|
|
// every iteration should read from both sources.
|
|
bool haveReadStdout = ReadFromFile(stdoutLog);
|
|
bool haveReadStderr = ReadFromFile(stderrLog);
|
|
|
|
if (!haveReadStdout && !haveReadStderr)
|
|
{
|
|
EA::Thread::ThreadSleep(50);
|
|
}
|
|
}
|
|
|
|
fflush(stdout); ReadFromFile(stdoutLog); fclose(stdoutLog);
|
|
fflush(stderr); ReadFromFile(stderrLog); fclose(stderrLog);
|
|
|
|
return 0;
|
|
}
|
|
|
|
IChannel *CreateNetworkChannel(const char *server, int port)
|
|
{
|
|
#if defined(EA_PLATFORM_CAPILANO)
|
|
if (IsDebuggerPresent())
|
|
{
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
EA::Thread::ThreadParameters threadParameters;
|
|
|
|
char *STDOUT_LOG_NAME = "stdout.log";
|
|
const char *STDERR_LOG_NAME = "stderr.log";
|
|
|
|
threadParameters.mnPriority = EA::Thread::kThreadPriorityMax;
|
|
|
|
#if defined EA_PLATFORM_IPHONE
|
|
char temporaryDirectory[256];
|
|
confstr(_CS_DARWIN_USER_TEMP_DIR, temporaryDirectory, sizeof temporaryDirectory);
|
|
|
|
EA::StdC::Snprintf(g_StdoutLogPath, sizeof g_StdoutLogPath, "%s/%s", temporaryDirectory, STDOUT_LOG_NAME);
|
|
EA::StdC::Snprintf(g_StderrLogPath, sizeof g_StderrLogPath, "%s/%s", temporaryDirectory, STDERR_LOG_NAME);
|
|
#elif defined EA_PLATFORM_CAPILANO
|
|
EA::StdC::Snprintf(g_StdoutLogPath, sizeof g_StdoutLogPath, "T:\\%s", STDOUT_LOG_NAME);
|
|
EA::StdC::Snprintf(g_StderrLogPath, sizeof g_StderrLogPath, "T:\\%s", STDERR_LOG_NAME);
|
|
#else
|
|
EA::StdC::Strlcpy(g_StdoutLogPath, STDOUT_LOG_NAME, sizeof g_StdoutLogPath);
|
|
EA::StdC::Strlcpy(g_StderrLogPath, STDERR_LOG_NAME, sizeof g_StderrLogPath);
|
|
#endif
|
|
|
|
fprintf(stdout, ""); fflush(stdout);
|
|
fprintf(stderr, ""); fflush(stderr);
|
|
|
|
g_RedirectedStdoutHandle = freopen(g_StdoutLogPath, "wb", stdout);
|
|
setvbuf(stdout, NULL, _IONBF, 0);
|
|
g_RedirectedStderrHandle = freopen(g_StderrLogPath, "wb", stderr);
|
|
setvbuf(stderr, NULL, _IONBF, 0);
|
|
|
|
if (CreateNetworkChannelImpl(server, port) != NULL)
|
|
{
|
|
g_PrintThread.Begin(PrintFunction, NULL, &threadParameters);
|
|
}
|
|
|
|
return new StdoutWrapperChannel(g_NetworkChannelInstance);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
namespace EA
|
|
{
|
|
namespace EAMain
|
|
{
|
|
namespace Internal
|
|
{
|
|
IChannel *CreateNetworkChannel(const char *server, int port)
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|