+Unity Runtime codeHEADmaster

1 files changed, 384 insertions, 0 deletions

diff --git a/Runtime/Network/Sockets.cpp b/Runtime/Network/Sockets.cpp
new file mode 100644
index 0000000..cdbc15f
--- /dev/null
+++ b/Runtime/Network/Sockets.cpp
@@ -0,0 +1,384 @@
+#include "UnityPrefix.h"
+
+#if ENABLE_SOCKETS
+#include "Runtime/Network/Sockets.h"
+#include "Runtime/Profiler/TimeHelper.h"
+#include "PlatformDependent/CommonWebPlugin/Verification.h"
+
+#if UNITY_WIN
+#include "PlatformDependent/Win/GetFormattedErrorString.h"
+#endif
+
+#define SUPPORT_NON_BLOCKING !UNITY_FLASH
+
+#include "SocketUtils.h"
+
+#define SocketError(msg, identifier) { DebugStringToFile(Format("Socket: %s, error: %s(%d)", msg, GetSocketErrorMsg(Socket::GetError()).c_str(), Socket::GetError()), 0, __FILE_STRIPPED__, __LINE__, kError, 0, identifier); }
+
+#if !UNITY_WINRT
+
+int Socket::PollAsyncConnection(int socketHandle, time_t timeoutMS)
+{
+#if SUPPORT_NON_BLOCKING
+	// Set timeout on socket connection
+	struct timeval tv;
+	tv.tv_sec = timeoutMS / 1000;
+	tv.tv_usec = (timeoutMS - tv.tv_sec * 1000) * 1000;
+
+	if (timeoutMS == 0)
+		tv.tv_usec = 10;
+
+	fd_set fdset;
+	FD_ZERO(&fdset);
+	FD_SET(socketHandle, &fdset);
+
+	fd_set exceptfds;
+	FD_ZERO(&exceptfds);
+	FD_SET(socketHandle, &exceptfds);
+
+#if UNITY_PS3
+	int selectedDescriptors = socketselect(socketHandle + 1, NULL, &fdset, &exceptfds, &tv);
+#else
+	int selectedDescriptors = select(socketHandle + 1, NULL, &fdset, &exceptfds, &tv);
+#endif
+	// we need one selected descriptor to be able to determine socket state
+	if (selectedDescriptors == 1)
+	{
+	#if USE_WINSOCK_APIS
+		if (FD_ISSET(socketHandle, &fdset) && !FD_ISSET(socketHandle, &exceptfds))
+		{
+			Socket::SetError(0);
+			return 0;
+		}
+		Socket::SetError(WSAECONNREFUSED);
+	#else
+		int so_error = 0;
+		socklen_t len = sizeof (so_error);
+		if (getsockopt(socketHandle, SOL_SOCKET, SO_ERROR, &so_error, &len) > -1)
+			if (Socket::SetError(so_error) == 0)
+				return 0;
+	#endif
+	}
+	// we don't have any writeable or errornous descriptors yet
+	else if (selectedDescriptors == 0)
+	{
+		Socket::SetError(kPlatformConnectWouldBlock);
+	}
+
+	return -1;
+#endif // SUPPORT_NON_BLOCKING
+	return 0;
+}
+
+// ---------------------------------------------------------------
+// Socket::Statics
+// ---------------------------------------------------------------
+int Socket::Close(int socketHandle)
+{
+#if USE_WINSOCK_APIS
+	return closesocket(socketHandle);
+#elif UNITY_PS3
+	return socketclose(socketHandle);
+#else
+	return close(socketHandle);
+#endif
+}
+
+int Socket::Connect(const char* ip, unsigned short port, time_t timeoutMS, bool polling, bool logConnectError)
+{
+	struct sockaddr_in addr;
+	SetupAddress(inet_addr(ip), htons(port), &addr);
+	return Connect((const sockaddr*) &addr, sizeof(addr), timeoutMS, polling, logConnectError);
+}
+
+UInt32 ComputeIdentifier(const sockaddr* addr)
+{
+	if (addr == NULL)
+		return 0;
+
+	UInt32 identifier = CRCBegin();
+	identifier = CRCFeed( identifier, (const UInt8*)&( ((const sockaddr_in*)addr)->sin_addr.s_addr ), sizeof(unsigned long) );
+	identifier = CRCFeed( identifier, (const UInt8*)&( ((const sockaddr_in*)addr)->sin_port ), sizeof(unsigned short) );
+	identifier = CRCDone(identifier);
+
+	return identifier;
+}
+
+int Socket::Connect(const sockaddr* addr, socklen_t addr_len, time_t timeoutMS, bool polling, bool logConnectError)
+{
+	int socketHandle;
+	int identifier = (int)ComputeIdentifier(addr);
+	CheckError(socketHandle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP), polling ? NULL : "failed to create socket", 0, identifier);
+	int so_error = 0;
+#if SUPPORT_NON_BLOCKING
+	if (!SetBlocking(socketHandle, false) && !polling)
+		ErrorStringMsg("unable to set blocking mode");
+	if (CheckError(connect(socketHandle, addr, addr_len), (logConnectError && !polling) ? "connect failed" : NULL, kPlatformConnectWouldBlock, identifier))
+		so_error = -1;
+
+	// Ensure that the connection is alive
+	if (so_error == 0 && timeoutMS != -1)
+	{
+		if (CheckError(PollAsyncConnection(socketHandle, timeoutMS), (logConnectError && !polling) ? "connect failed" : NULL, 0, identifier))
+			so_error = -1;
+	}
+#else
+	if (CheckError(connect(socketHandle, addr, addr_len), (logConnectError && !polling) ? "connect failed" : NULL, 0, identifier))
+		so_error = -1;
+#endif
+	// Handle connection error
+	if (so_error != 0)
+	{
+		if(logConnectError && !polling)
+			DebugStringToFile(Format("connect failed"), 0, __FILE_STRIPPED__, __LINE__, kError, 0, identifier);
+		Close(socketHandle);
+		return -1;
+	}
+
+	RemoveErrorWithIdentifierFromConsole(identifier);
+
+	return socketHandle;
+}
+
+bool Socket::SetBlocking(int socketHandle, bool blocking)
+{
+	bool success = true;
+
+#if !SUPPORT_NON_BLOCKING
+	success = blocking;
+#elif UNITY_PS3
+	int nonBlockingValue = blocking ? 0 : 1;
+	if (setsockopt(socketHandle, SOL_SOCKET, SO_NBIO, &nonBlockingValue, sizeof(nonBlockingValue)) != 0)
+		success = false;
+#elif USE_WINSOCK_APIS
+	u_long nonBlocking = blocking ? 0 : 1;
+	if (ioctlsocket(socketHandle, FIONBIO, &nonBlocking) != 0)
+		success = false;
+#else // unix
+	if ((fcntl(socketHandle, F_SETFL, blocking ? 0 : O_NONBLOCK) == -1))
+		success = false;
+#endif
+	return success;
+}
+
+// ---------------------------------------------------------------
+// Base Socket
+// ---------------------------------------------------------------
+Socket::Socket(int domain, int type, int protocol)
+: m_SocketError(0)
+, m_SendRecvFlags(0)
+{
+	if (!CheckError(m_SocketHandle = socket(domain, type, protocol), "unable to create socket"))
+		SetIgnoreSIGPIPE(true);
+}
+
+int Socket::SetSocketOption(int level, int option, void* value, size_t value_len)
+{
+	return setsockopt(m_SocketHandle, level, option, (char*) value, value_len);
+}
+
+int Socket::SetSocketOption(int level, int option, bool optionValue)
+{
+#if USE_WINSOCK_APIS
+	BOOL val = optionValue ? TRUE : FALSE;
+#else
+	int val = !!optionValue;
+#endif
+	return SetSocketOption(level, option, &val, sizeof(val));
+}
+
+bool Socket::SetReuseAddress(bool reuse)
+{
+	if (CheckError(SetSocketOption(SOL_SOCKET, SO_REUSEADDR, reuse), "set reusable addr failed"))
+		return false;
+#ifdef SO_REUSEPORT
+	if (CheckError(SetSocketOption(SOL_SOCKET, SO_REUSEPORT, reuse), "set reusable port failed"))
+		return false;
+#endif
+	return true;
+}
+
+int Socket::Send(const void* data, size_t data_len, SendUserData* userData)
+{
+	int result;
+	if (userData != NULL)
+	{
+		result = sendto(m_SocketHandle, (char*) data, data_len, userData->flags | m_SendRecvFlags, userData->dstAddr, userData->dstLen);
+	}
+	else
+	{
+		result = sendto(m_SocketHandle, (char*) data, data_len, m_SendRecvFlags, NULL, 0);
+	}
+	CheckError(result);
+	return result;
+}
+
+int Socket::Recv(void* data, size_t data_len, RecvUserData* userData)
+{
+	int result;
+	if (userData != NULL)
+	{
+		result = recvfrom(m_SocketHandle, (char*) data, data_len, userData->flags | m_SendRecvFlags, userData->srcAddr, &userData->srcLen);
+	}
+	else
+	{
+		result = recvfrom(m_SocketHandle, (char*) data, data_len, m_SendRecvFlags, NULL, NULL);
+	}
+	CheckError(result);
+	return result;
+}
+
+bool Socket::WaitForAvailableSendBuffer( time_t timeoutMS )
+{
+	// Set timeout on socket connection
+	struct timeval tv;
+	tv.tv_sec = timeoutMS / 1000;
+	tv.tv_usec = (timeoutMS - tv.tv_sec * 1000) * 1000;
+
+	fd_set fdset;
+	FD_ZERO(&fdset);
+	FD_SET(m_SocketHandle, &fdset);
+
+#if UNITY_PS3
+	return socketselect(m_SocketHandle + 1, NULL, &fdset, NULL, &tv) == 1;
+#else
+	return select(m_SocketHandle + 1, NULL, &fdset, NULL, &tv) == 1;
+#endif
+}
+
+bool Socket::WaitForAvailableRecvData( time_t timeoutMS )
+{
+	// Set timeout on socket connection
+	struct timeval tv;
+	tv.tv_sec = timeoutMS / 1000;
+	tv.tv_usec = (timeoutMS - tv.tv_sec * 1000) * 1000;
+
+	fd_set fdset;
+	FD_ZERO(&fdset);
+	FD_SET(m_SocketHandle, &fdset);
+
+#if UNITY_PS3
+	return socketselect(m_SocketHandle + 1, &fdset, NULL, NULL, &tv) == 1;
+#else
+	return select(m_SocketHandle + 1, &fdset, NULL, NULL, &tv) == 1;
+#endif
+}
+
+#endif // !UNITY_WINRT
+
+std::string GetSocketErrorMsg(int error)
+{
+#if UNITY_WIN
+	return WideToUtf8( GetHResultErrorMessage(error) );
+#elif UNITY_FLASH || UNITY_XENON
+	return "Unknown network error";
+#else
+	return strerror(error);
+#endif
+}
+
+Socket::Socket(TSocketHandle socketHandle)
+: m_SocketError(0)
+, m_SendRecvFlags(0)
+, m_SocketHandle(socketHandle)
+{
+#if UNITY_WINRT
+	AssertBreak(nullptr != m_SocketHandle);
+#else
+	AssertBreak(m_SocketHandle >= 0);
+#endif
+	SetIgnoreSIGPIPE(true);
+}
+
+Socket::~Socket()
+{
+	Close(m_SocketHandle);
+}
+
+bool Socket::WouldBlockError()
+{
+	int error = Socket::GetError();
+	return error == kPlatformConnectWouldBlock
+		|| error == kPlatformStreamWouldBlock
+		|| error == kPlatformAcceptWouldBlock;
+}
+
+bool Socket::SetIgnoreSIGPIPE(bool ignore)
+{
+#if USE_WINSOCK_APIS || UNITY_FLASH || UNITY_PS3 || UNITY_WINRT
+	return true;
+#elif UNITY_OSX || UNITY_IPHONE
+	return !CheckError(SetSocketOption(SOL_SOCKET, SO_NOSIGPIPE, ignore), "failed to install NOSIGPIPE");
+#else // linux
+	m_SendRecvFlags = MSG_NOSIGNAL;
+	return true;
+#endif
+}
+
+bool Socket::SetBlocking(bool blocking)
+{
+	if (!SetBlocking(m_SocketHandle, blocking))
+	{
+		ErrorStringMsg("failed to set blocking mode");
+		return false;
+	}
+	return true;
+}
+
+#if UNITY_WINRT
+// Implemented in MetroSockets.cpp
+int SocketWrapperErrorState(TSocketHandle socketHandle);
+int SocketWrapperErrorState(TSocketHandle socketHandle, int error);
+#endif // UNITY_WINRT
+
+int Socket::GetError()
+{
+#if UNITY_WINRT
+	return SocketWrapperErrorState(m_SocketHandle);
+#elif USE_WINSOCK_APIS
+	return WSAGetLastError();
+#elif UNITY_FLASH
+	return flash_errno();
+#elif UNITY_PS3
+	return sys_net_errno;
+#else
+	return errno;
+#endif
+}
+
+int Socket::SetError(int error)
+{
+#if UNITY_WINRT
+	SocketWrapperErrorState(m_SocketHandle, error);
+#elif USE_WINSOCK_APIS
+	WSASetLastError(error);
+#elif UNITY_FLASH
+	flash_set_errno(error);
+#elif UNITY_PS3
+	sys_net_errno = error;
+#else
+	errno = error;
+#endif
+	return error;
+}
+
+bool Socket::CheckError(int result, const char* msg, int validState, int identifier)
+{
+	if (result < 0)
+	{
+		int error = Socket::GetError();
+		if (error != validState)
+		{
+			if (msg)
+				SocketError(msg, identifier);
+			return true;
+		}
+	}
+	else
+	{
+		Socket::SetError(0);
+	}
+	return false;
+}
+
+#endif // ENABLE_SOCKETS