First
This commit is contained in:
jeanlemotan
@@ -0,0 +1,603 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// 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
|
||||
Reference in New Issue
Block a user