using System;

using System.Net;

using System.Net.Sockets;

using System.Threading;

namespace LiteNetLib

{

internal sealed class NetSocket

{

private Socket _udpSocketv4;

private Socket _udpSocketv6;

private Thread _threadv4;

private Thread _threadv6;

private bool _running;

private readonly NetManager.OnMessageReceived _onMessageReceived;

private static readonly IPAddress MulticastAddressV6 = IPAddress.Parse (NetConstants.MulticastGroupIPv6);

internal static readonly bool IPv6Support;

private const int SocketReceivePollTime = 100000;

private const int SocketSendPollTime = 1000;

public int LocalPort { get; private set; }

public short Ttl

{

get { return _udpSocketv4.Ttl; }

set

{

_udpSocketv4.Ttl = value;

}

}

static NetSocket()

{

#if UNITY_4 || UNITY_5 || UNITY_5_3_OR_NEWER

IPv6Support = Socket.SupportsIPv6;

#elif DISABLE_IPV6

IPv6Support = false;

#else

IPv6Support = Socket.OSSupportsIPv6;

#endif

}

public NetSocket(NetManager.OnMessageReceived onMessageReceived)

{

_onMessageReceived = onMessageReceived;

}

private void ReceiveLogic(object state)

{

Socket socket = (Socket)state;

EndPoint bufferEndPoint = new IPEndPoint(socket.AddressFamily == AddressFamily.InterNetwork ? IPAddress.Any : IPAddress.IPv6Any, 0);

byte[] receiveBuffer = new byte[NetConstants.MaxPacketSize];

while (_running)

{

int result;

//Reading data

try

{

if (!socket.Poll(SocketReceivePollTime, SelectMode.SelectRead))

{

continue;

}

result = socket.ReceiveFrom(receiveBuffer, 0, receiveBuffer.Length, SocketFlags.None, ref bufferEndPoint);

}

catch (SocketException ex)

{

if (ex.SocketErrorCode == SocketError.ConnectionReset ||

ex.SocketErrorCode == SocketError.MessageSize)

{

//10040 - message too long

//10054 - remote close (not error)

//Just UDP

NetUtils.DebugWrite(ConsoleColor.DarkRed, "[R] Ingored error: {0} - {1}", (int)ex.SocketErrorCode, ex.ToString() );

continue;

}

NetUtils.DebugWriteError("[R]Error code: {0} - {1}", (int)ex.SocketErrorCode, ex.ToString());

_onMessageReceived(null, 0, (int) ex.SocketErrorCode, (IPEndPoint)bufferEndPoint);

continue;

}

//All ok!

NetUtils.DebugWrite(ConsoleColor.Blue, "[R]Received data from {0}, result: {1}", bufferEndPoint.ToString(), result);

_onMessageReceived(receiveBuffer, result, 0, (IPEndPoint)bufferEndPoint);

}

}

public bool Bind(IPAddress addressIPv4, IPAddress addressIPv6, int port, bool reuseAddress)

{

_udpSocketv4 = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);

_udpSocketv4.Blocking = false;

_udpSocketv4.ReceiveBufferSize = NetConstants.SocketBufferSize;

_udpSocketv4.SendBufferSize = NetConstants.SocketBufferSize;

_udpSocketv4.Ttl = NetConstants.SocketTTL;

if(reuseAddress)

_udpSocketv4.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

#if !NETCORE

_udpSocketv4.DontFragment = true;

#endif

try

{

_udpSocketv4.EnableBroadcast = true;

}

catch (SocketException e)

{

NetUtils.DebugWriteError("Broadcast error: {0}", e.ToString());

}

if (!BindSocket(_udpSocketv4, new IPEndPoint(addressIPv4, port)))

{

return false;

}

LocalPort = ((IPEndPoint) _udpSocketv4.LocalEndPoint).Port;

_running = true;

_threadv4 = new Thread(ReceiveLogic);

_threadv4.Name = "SocketThreadv4(" + LocalPort + ")";

_threadv4.IsBackground = true;

_threadv4.Start(_udpSocketv4);

//Check IPv6 support

if (!IPv6Support)

return true;

_udpSocketv6 = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp);

_udpSocketv6.Blocking = false;

_udpSocketv6.ReceiveBufferSize = NetConstants.SocketBufferSize;

_udpSocketv6.SendBufferSize = NetConstants.SocketBufferSize;

//_udpSocketv6.Ttl = NetConstants.SocketTTL;

if (reuseAddress)

_udpSocketv6.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

//Use one port for two sockets

if (BindSocket(_udpSocketv6, new IPEndPoint(addressIPv6, LocalPort)))

{

try

{

#if !ENABLE_IL2CPP

_udpSocketv6.SetSocketOption(

SocketOptionLevel.IPv6,

SocketOptionName.AddMembership,

new IPv6MulticastOption(MulticastAddressV6));

#endif

}

catch(Exception)

{

// Unity3d throws exception - ignored

}

_threadv6 = new Thread(ReceiveLogic);

_threadv6.Name = "SocketThreadv6(" + LocalPort + ")";

_threadv6.IsBackground = true;

_threadv6.Start(_udpSocketv6);

}

return true;

}

private bool BindSocket(Socket socket, IPEndPoint ep)

{

try

{

socket.Bind(ep);

NetUtils.DebugWrite(ConsoleColor.Blue, "[B]Succesfully binded to port: {0}", ((IPEndPoint)socket.LocalEndPoint).Port);

}

catch (SocketException ex)

{

NetUtils.DebugWriteError("[B]Bind exception: {0}", ex.ToString());

//TODO: very temporary hack for iOS (Unity3D)

if (ex.SocketErrorCode == SocketError.AddressFamilyNotSupported)

{

return true;

}

return false;

}

return true;

}

public bool SendBroadcast(byte[] data, int offset, int size, int port)

{

bool success;

try

{

success = _udpSocketv4.SendTo(

data,

offset,

size,

SocketFlags.None,

new IPEndPoint(IPAddress.Broadcast, port)) > 0;

if (IPv6Support)

{

success = success || _udpSocketv6.SendTo(

data,

offset,

size,

SocketFlags.None,

new IPEndPoint(MulticastAddressV6, port)) > 0;

}

}

catch (Exception ex)

{

NetUtils.DebugWriteError("[S][MCAST]" + ex);

return false;

}

return success;

}

public int SendTo(byte[] data, int offset, int size, IPEndPoint remoteEndPoint, ref int errorCode)

{

try

{

var socket = _udpSocketv4;

if (remoteEndPoint.AddressFamily == AddressFamily.InterNetworkV6 && IPv6Support)

{

socket = _udpSocketv6;

}

int result;

if (!socket.Poll(SocketSendPollTime, SelectMode.SelectWrite))

return -1;

result = socket.SendTo(data, offset, size, SocketFlags.None, remoteEndPoint);

NetUtils.DebugWrite(ConsoleColor.Blue, "[S]Send packet to {0}, result: {1}", remoteEndPoint, result);

return result;

}

catch (SocketException ex)

{

if (ex.SocketErrorCode == SocketError.NoBufferSpaceAvailable)

{

return 0;

}

if (ex.SocketErrorCode != SocketError.MessageSize)

{

NetUtils.DebugWriteError("[S]" + ex);

}

errorCode = (int)ex.SocketErrorCode;

return -1;

}

catch (Exception ex)

{

NetUtils.DebugWriteError("[S]" + ex);

return -1;

}

}

public void Close()

{

_running = false;

//Close IPv4

if (Thread.CurrentThread != _threadv4)

{

_threadv4.Join();

}

if (_udpSocketv4 != null)

{

_udpSocketv4.Close();

_udpSocketv4 = null;

}

_threadv4 = null;

//No ipv6

if (_udpSocketv6 == null)

return;

//Close IPv6

if (Thread.CurrentThread != _threadv6)

{

_threadv6.Join();

}

if (_udpSocketv6 != null)

{

_udpSocketv6.Close();

_udpSocketv6 = null;

}

_threadv6 = null;

}

}

}