public void BroadcastTo(byte[] buffer, int offset, int count, NetworkInfo network)
{
if (network.LocalIP.AddressFamily == AddressFamily.InterNetwork)
{
IPAddress broadcastIP = network.BroadcastIP;
if (_udpListener.AddressFamily == AddressFamily.InterNetworkV6)
{
broadcastIP = NetUtilities.ConvertToIPv4MappedIPv6Address(broadcastIP);
}
try
{
_udpListener.SendTo(buffer, offset, count, SocketFlags.None, new IPEndPoint(broadcastIP, _listenerPort));
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listener.BroadcastTo", ex);
}
}
else
{
try
{
_udpListener.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.MulticastInterface, network.Interface.GetIPProperties().GetIPv6Properties().Index);
_udpListener.SendTo(buffer, offset, count, SocketFlags.None, new IPEndPoint(IPAddress.Parse(IPV6_MULTICAST_IP), _listenerPort));
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listener.BroadcastTo", ex);
}
}
}
private void NetworkWatcher(object state)
{
try
{
List <IPAddress> currentBroadcastIPs = NetUtilities.GetBroadcastIPList();
List <IPAddress> newIPs = new List <IPAddress>();
lock (_broadcastIPs)
{
foreach (IPAddress currentIP in currentBroadcastIPs)
{
if (!_broadcastIPs.Contains(currentIP))
{
newIPs.Add(currentIP);
}
}
_broadcastIPs.Clear();
_broadcastIPs.AddRange(currentBroadcastIPs);
}
BroadcastNetworkDiscovered(newIPs.ToArray());
}
catch
{ }
finally
{
if (_networkWatcher != null)
{
_networkWatcher.Change(NETWORK_WATCHER_INTERVAL, Timeout.Infinite);
}
}
}
public IModel LoadModel(string modelName)
{
if (modelName == null)
{
throw new ArgumentNullException(nameof(modelName));
}
if (_models == null)
{
throw new InvalidOperationException($"Cannot load model \"{modelName}\"; network string list not created yet");
}
var platformModelName = NetUtilities.ConvertToPlatformPath(modelName);
var networkModelName = NetUtilities.ConvertToNetworkPath(modelName);
if (!_nameToIndex.TryGetValue(networkModelName, out var index))
{
//See if it's a server loaded model
index = _models.IndexOf(networkModelName);
index = InternalLoadModel(networkModelName, platformModelName, index != -1 ? index : (int?)null);
}
return(_modelManager[platformModelName]);
}
public void Send(byte[] buffer, int length)
{
// make sure that a default destination IPEndpoint has been configured.
if ((destinationIpAddress == IPv6Any) || (destinationPort == IPPortAny))
{
throw new SocketsException("Socket is not connected.");
}
UdpDatagram udpDatagram = new UdpDatagram();
udpDatagram.DestinationPort = destinationPort;
udpDatagram.SourcePort = sourcePort;
udpDatagram.AddPayload(buffer);
udpDatagram.Checksum = 0;
IPv6Packet packetUDP = new IPv6Packet();
packetUDP.SourceAddress = sourceIpAddress;
packetUDP.DestinationAddress = destinationIpAddress;
packetUDP.NextHeader = IPv6Protocol.Udp;
packetUDP.Payload = udpDatagram;
packetUDP.PayloadLength = udpDatagram.Length;
IPv6PseudoHeader ipv6PseudoHeader = new IPv6PseudoHeader(packetUDP.SourceAddress, packetUDP.DestinationAddress, packetUDP.PayloadLength, (byte)packetUDP.NextHeader);
ushort checkSum = ipv6PseudoHeader.GetCheckSum();
checkSum = NetUtilities.ComputeChecksum(checkSum, udpDatagram.ToBytes(), true);
udpDatagram.Checksum = checkSum;
NetworkingInterface.Send(packetUDP.ToBytes());
}
private void AcceptTcpConnectionAsync(object parameter)
{
Socket tcpListener = parameter as Socket;
try
{
do
{
Socket socket = tcpListener.Accept();
try
{
socket.NoDelay = true;
socket.SendTimeout = SOCKET_SEND_TIMEOUT;
socket.ReceiveTimeout = SOCKET_RECV_TIMEOUT;
IPEndPoint remotePeerEP = socket.RemoteEndPoint as IPEndPoint;
if (NetUtilities.IsIPv4MappedIPv6Address(remotePeerEP.Address))
{
remotePeerEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remotePeerEP.Address), remotePeerEP.Port);
}
ThreadPool.QueueUserWorkItem(AcceptConnectionInitiateProtocolAsync, new object[] { new NetworkStream(socket, true), remotePeerEP });
}
catch
{ }
}while (true);
}
catch
{ }
}
public IModel LoadModel(string modelName)
{
if (modelName == null)
{
throw new ArgumentNullException(nameof(modelName));
}
if (_models == null)
{
throw new InvalidOperationException($"Cannot load model \"{modelName}\"; network string list not created yet");
}
var platformModelName = NetUtilities.ConvertToPlatformPath(modelName);
//TODO: could rework string lists to internally handle this at some point
var networkModelName = NetUtilities.ConvertToNetworkPath(modelName);
var index = _models.IndexOf(networkModelName);
if (index == -1)
{
var model = _modelManager.Load(platformModelName);
//All models loaded by the server are required by default
index = _models.Add(networkModelName, new ModelPrecacheData
{
Flags = (uint)ModelPrecacheFlags.Required
});
}
return(_modelManager[platformModelName]);
}
public void AddNode(EndPoint nodeEP)
{
switch (nodeEP.AddressFamily)
{
case AddressFamily.InterNetwork:
if (!NetUtilities.IsPrivateIPv4((nodeEP as IPEndPoint).Address))
{
_ipv4InternetDhtNode.AddNode(nodeEP);
}
break;
case AddressFamily.InterNetworkV6:
if (NetUtilities.IsPublicIPv6((nodeEP as IPEndPoint).Address))
{
_ipv6InternetDhtNode.AddNode(nodeEP);
}
break;
case AddressFamily.Unspecified:
_torInternetDhtNode?.AddNode(nodeEP);
break;
}
}
public Task <DnsDatagram> ProcessRequestAsync(DnsDatagram request, IPEndPoint remoteEP, string zoneName, uint appRecordTtl, string appRecordData, bool isRecursionAllowed, IDnsServer dnsServer)
{
switch (request.Question[0].Type)
{
case DnsResourceRecordType.A:
case DnsResourceRecordType.AAAA:
dynamic jsonAppRecordData = JsonConvert.DeserializeObject(appRecordData);
dynamic jsonAddresses;
if (NetUtilities.IsPrivateIP(remoteEP.Address))
{
jsonAddresses = jsonAppRecordData.@private;
}
else
{
jsonAddresses = jsonAppRecordData.@public;
}
if (jsonAddresses == null)
{
return(Task.FromResult <DnsDatagram>(null));
}
List <DnsResourceRecord> answers = new List <DnsResourceRecord>();
foreach (dynamic jsonAddress in jsonAddresses)
{
IPAddress address = IPAddress.Parse(jsonAddress.Value);
switch (request.Question[0].Type)
{
case DnsResourceRecordType.A:
if (address.AddressFamily == AddressFamily.InterNetwork)
{
answers.Add(new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.A, DnsClass.IN, appRecordTtl, new DnsARecord(address)));
}
break;
case DnsResourceRecordType.AAAA:
if (address.AddressFamily == AddressFamily.InterNetworkV6)
{
answers.Add(new DnsResourceRecord(request.Question[0].Name, DnsResourceRecordType.AAAA, DnsClass.IN, appRecordTtl, new DnsAAAARecord(address)));
}
break;
}
}
if (answers.Count == 0)
{
return(Task.FromResult <DnsDatagram>(null));
}
return(Task.FromResult(new DnsDatagram(request.Identifier, true, request.OPCODE, true, false, request.RecursionDesired, isRecursionAllowed, false, false, DnsResponseCode.NoError, request.Question, answers)));
default:
return(Task.FromResult <DnsDatagram>(null));
}
}
public byte[] ToBytes()
{
byte[] byteValue;
byte[] payload = Payload.ToBytes();
byte[] ipv6Packet = new byte[Ipv6HeaderLength + payload.Length];
int offset = 0;
ipv6Packet[offset++] = (byte)((Version << 4) | ((TrafficClass >> 4) & 0xF));
ipv6Packet[offset++] = (byte)((uint)((TrafficClass << 4) & 0xF0) | (uint)((Flow >> 16) & 0xF));
ipv6Packet[offset++] = (byte)((Flow >> 8) & 0xFF);
ipv6Packet[offset++] = (byte)(Flow & 0xFF);
byteValue = NetUtilities.FromLittleEndian(PayloadLength);
Array.Copy(byteValue, 0, ipv6Packet, offset, byteValue.Length);
offset += byteValue.Length;
ipv6Packet[offset++] = (byte)NextHeader;
ipv6Packet[offset++] = (byte)HopLimit;
byteValue = SourceAddress.GetAddressBytes();
Array.Copy(byteValue, 0, ipv6Packet, offset, byteValue.Length);
offset += byteValue.Length;
byteValue = DestinationAddress.GetAddressBytes();
Array.Copy(byteValue, 0, ipv6Packet, offset, byteValue.Length);
offset += byteValue.Length;
Array.Copy(payload, 0, ipv6Packet, offset, payload.Length);
return(ipv6Packet);
}
public byte[] ToBytes()
{
byte[] icmpv6message = null;
if (IcmpMessage != null)
{
icmpv6message = IcmpMessage.ToBytes();
}
byte[] icmpv6packet = new byte[Icmpv6HeaderLength];
icmpv6packet[0] = (byte)Icmpv6MessageType;
icmpv6packet[1] = Code;
Array.Copy(NetUtilities.FromLittleEndian(Checksum), 0, icmpv6packet, 2, 2);
if (icmpv6message != null)
{
return(Utilities.CombineArrays(icmpv6packet, icmpv6message));
}
else
{
return(icmpv6packet);
}
}
private void Recover(DriverInformation driverInformation)
{
IPEndPoint driverEndpoint = NetUtilities.ParseIpEndpoint(driverInformation.DriverRemoteIdentifier);
_remoteId = new SocketRemoteIdentifier(driverEndpoint);
_observer = _remoteManager.GetRemoteObserver(new RemoteEventEndPoint <REEFMessage>(_remoteId));
lock (_evaluatorSettings)
{
if (_evaluatorSettings.NameClient != null)
{
try
{
LOGGER.Log(Level.Verbose, "Trying to reset and reconnect to name server" + driverInformation.NameServerId);
_evaluatorSettings.NameClient.Restart(NetUtilities.ParseIpEndpoint(driverInformation.NameServerId));
LOGGER.Log(Level.Info, "Reconnected to name server: " + driverInformation.NameServerId);
}
catch (Exception e)
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
}
}
}
lock (_queuedHeartbeats)
{
bool firstHeartbeatInQueue = true;
while (_queuedHeartbeats.Any())
{
LOGGER.Log(Level.Info, "Sending cached recovery heartbeats to " + _remoteId);
try
{
if (firstHeartbeatInQueue)
{
// first heartbeat is specially construted to include the recovery flag
EvaluatorHeartbeatProto recoveryHeartbeat = ConstructRecoveryHeartBeat(_queuedHeartbeats.Dequeue());
LOGGER.Log(Level.Info, "Recovery heartbeat to be sent:" + recoveryHeartbeat);
_observer.OnNext(new REEFMessage(recoveryHeartbeat));
firstHeartbeatInQueue = false;
}
else
{
_observer.OnNext(new REEFMessage(_queuedHeartbeats.Dequeue()));
}
}
catch (Exception e)
{
// we do not handle failures during RECOVERY
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.CaughtAndThrow(
e,
Level.Error,
string.Format(CultureInfo.InvariantCulture, "Hearbeat attempt failed in RECOVERY mode to Driver {0} , giving up...", _remoteId),
LOGGER);
}
Thread.Sleep(500);
}
}
_evaluatorSettings.OperationState = EvaluatorOperationState.OPERATIONAL;
LOGGER.Log(Level.Info, "=========== Exiting RECOVERY mode. ===========");
}
public void LoadFallbackModel()
{
//The manager needs to know that the fallback model is loaded, so this has to be called explicitly
_modelManager.LoadFallbackModel(NetUtilities.ConvertToPlatformPath(_fallbackModelName));
//Add it to our list
LoadModel(_fallbackModelName);
}
public ushort GetCheckSum()
{
if (pseudoHeader != null)
{
return(NetUtilities.ComputeChecksum(0, pseudoHeader, false));
}
throw new InvalidOperationException("Empty packet array.");
}
public static short SendEchoRequest(IPAddress destionationIPAddress)
{
IPv6PseudoHeader pv6PseudoHeader = new IPv6PseudoHeader(NetworkInterface.IPAddress, destionationIPAddress, 0x10, 58);
ushort checkSum = pv6PseudoHeader.GetCheckSum();
byte[] packet = new byte[16];
packet[0] = 0x80;
packet[1] = 0x00;
packet[2] = 0x00; //Checksum
packet[3] = 0x00; //Checksum
packet[4] = 0x00;
packet[5] = 0x01;
packet[6] = 0x00;
packet[7] = 0x0a;
packet[8] = 0x02;
packet[9] = 0xcd;
packet[10] = 0x21;
packet[11] = 0xf2;
packet[12] = 0x00;
packet[13] = 0x00;
packet[14] = 0x00;
packet[15] = 0x00;
checkSum = NetUtilities.ComputeChecksum(checkSum, packet, true);
Icmpv6Packet icmpv6Packet = new Icmpv6Packet();
int packetIndex = 0;
icmpv6Packet.FromBytes(packet, ref packetIndex);
icmpv6Packet.Checksum = checkSum;
IPv6Packet packetEchoRequest = new IPv6Packet();
packetEchoRequest.DestinationAddress = destionationIPAddress;
packetEchoRequest.SourceAddress = NetworkInterface.IPAddress;
packetEchoRequest.PayloadLength = 0x10;
packetEchoRequest.NextHeader = IPv6Protocol.ICMPv6;
packetEchoRequest.Payload = icmpv6Packet;
pingStart = DateTime.UtcNow;
isResponseTimeout = false;
replyTime = -1;
NetworkInterface.SendAndWait(packetEchoRequest.ToBytes());
pingTimeout.WaitOne(5000, false);
if (replyTime == -1)
{
isResponseTimeout = true;
}
return(replyTime);
}
public static void PacketHandler(IPv6Packet ipv6Packet)
{
Icmpv6Packet icmpv6Handler = (Icmpv6Packet)ipv6Packet.Payload;
if (icmpv6Handler.Icmpv6MessageType == Icmpv6MessageType.EchoRequest)
{
IPv6Packet packetEchoReply = new IPv6Packet();
packetEchoReply.SourceAddress = ipv6Packet.DestinationAddress;
packetEchoReply.DestinationAddress = ipv6Packet.SourceAddress;
packetEchoReply.NextHeader = ipv6Packet.NextHeader;
packetEchoReply.Flow = ipv6Packet.Flow;
packetEchoReply.HopLimit = ipv6Packet.HopLimit;
packetEchoReply.PayloadLength = ipv6Packet.PayloadLength;
packetEchoReply.TrafficClass = ipv6Packet.TrafficClass;
packetEchoReply.Version = ipv6Packet.Version;
icmpv6Handler.Icmpv6MessageType = Icmpv6MessageType.EchoReply;
Icmpv6EchoReply icmpv6EchoReply = new Icmpv6EchoReply((Icmpv6EchoRequest)icmpv6Handler.IcmpMessage);
icmpv6Handler.IcmpMessage = icmpv6EchoReply;
IPv6PseudoHeader ipv6PseudoHeader = new IPv6PseudoHeader(packetEchoReply.SourceAddress, packetEchoReply.DestinationAddress, packetEchoReply.PayloadLength, (byte)packetEchoReply.NextHeader);
ushort checkSum = ipv6PseudoHeader.GetCheckSum();
byte[] icmpData = icmpv6Handler.ToBytes();
icmpData[2] = 0;
icmpData[3] = 0;
checkSum = NetUtilities.ComputeChecksum(checkSum, icmpData, true);
icmpv6Handler.Checksum = checkSum;
packetEchoReply.Payload = icmpv6Handler;
NetworkInterface.Send(packetEchoReply.ToBytes());
}
else if (icmpv6Handler.Icmpv6MessageType == Icmpv6MessageType.EchoReply)
{
if (isResponseTimeout)
{
return;
}
TimeSpan elapsed = DateTime.UtcNow - pingStart;
replyTime = (short)elapsed.TotalMilliseconds;
//#if NETMF
// replyTime = (short)elapsed.Milliseconds;
//#else
// replyTime = (short)elapsed.TotalMilliseconds;
//#endif
pingTimeout.Set();
}
}
private void RelayConnectionKeepAliveTimerCallback(object state)
{
try
{
bool lessRelayNodesAvailable;
//send noop to all connections to keep them alive
lock (_tcpRelayConnections)
{
foreach (Connection relayConnection in _tcpRelayConnections.Values)
{
ThreadPool.QueueUserWorkItem(SendNOOPAsync, relayConnection);
}
lessRelayNodesAvailable = (_tcpRelayConnections.Count < TCP_RELAY_MAX_CONNECTIONS);
}
//if less number of relay node connections available, try to find new relay nodes
if (lessRelayNodesAvailable)
{
IPEndPoint[] nodeEPs = _connectionManager.IPv4DhtNode.GetKClosestRandomNodeEPs();
foreach (IPEndPoint relayNodeEP in nodeEPs)
{
lock (_tcpRelayConnections)
{
if (_tcpRelayConnections.Count >= TCP_RELAY_MAX_CONNECTIONS)
{
return;
}
if (_tcpRelayConnections.ContainsKey(relayNodeEP))
{
continue;
}
}
if (NetUtilities.IsPrivateIP(relayNodeEP.Address))
{
continue;
}
ThreadPool.QueueUserWorkItem(ConnectTcpRelayNodeAsync, relayNodeEP);
}
}
}
catch
{ }
finally
{
if (_tcpRelayConnectionKeepAliveTimer != null)
{
_tcpRelayConnectionKeepAliveTimer.Change(TCP_RELAY_KEEP_ALIVE_INTERVAL, Timeout.Infinite);
}
}
}
public IMessage CreateGameInfoMessage()
{
return(new GameServerInfo
{
//In case the file format/directory ever changes, use the full file name
MapFileName = NetUtilities.ConvertToNetworkPath(_gameServer.MapInfo.Model.Name),
MapCrc = _gameServer.MapInfo.Model.CRC,
AllowCheats = false, //TODO: define cvar
});
}
public void AddNode(IPEndPoint nodeEP)
{
if (!NetUtilities.IsPrivateIP(nodeEP.Address))
{
if (!_routingTable.ContactExists(nodeEP))
{
ThreadPool.QueueUserWorkItem(AddNodeAfterPingAsync, nodeEP);
}
}
}
private void SendResponse(DiscoveryPacket receivedQueryPacket, BinaryNumber networkID, IPAddress remotePeerIP)
{
NetworkInfo network = NetUtilities.GetNetworkInfo(remotePeerIP);
DiscoveryPacket responsePacket = DiscoveryPacket.CreateResponsePacket(_announcePort, receivedQueryPacket.Challenge);
byte[] packet = responsePacket.ToArray(networkID, network.LocalIP);
_listener.SendTo(packet, 0, packet.Length, remotePeerIP);
}
/// <summary>
/// Initialize a new instance of the <see cref="TcpListener"/> class.
/// </summary>
/// <param name="port">
/// It's the local port where the connection requests will be listened.
/// </param>
public TcpListener(int port)
{
_localInterface = "localhost";
if (!NetUtilities.IsValidTcpPort(port))
{
throw new ArgumentOutOfRangeException("port");
}
_port = port;
}
private void ReadResponsePacketsAsync(object parameter)
{
Socket udpClient = parameter as Socket;
EndPoint remoteEP;
FixMemoryStream recvStream = new FixMemoryStream(BUFFER_MAX_SIZE);
byte[] bufferRecv = recvStream.Buffer;
int bytesRecv;
if (udpClient.AddressFamily == AddressFamily.InterNetwork)
{
remoteEP = new IPEndPoint(IPAddress.Any, 0);
}
else
{
remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0);
}
try
{
while (true)
{
bytesRecv = udpClient.ReceiveFrom(bufferRecv, ref remoteEP);
if (bytesRecv > 0)
{
recvStream.SetLength(bytesRecv);
recvStream.Position = 0;
IPEndPoint remoteNodeEP = remoteEP as IPEndPoint;
if (NetUtilities.IsIPv4MappedIPv6Address(remoteNodeEP.Address))
{
remoteNodeEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remoteNodeEP.Address), remoteNodeEP.Port);
}
try
{
DhtRpcPacket response = new DhtRpcPacket(recvStream, remoteNodeEP.Address);
ProcessPacket(response);
}
catch
{ }
}
}
}
catch (Exception ex)
{
Debug.Write("DhtClient.ReadResponsePacketsAsync", ex);
}
}
private void RecvDataAsync(object parameter)
{
Socket udpListener = parameter as Socket;
EndPoint remoteEP = null;
FixMemoryStream dataRecv = new FixMemoryStream(BUFFER_MAX_SIZE);
int bytesRecv;
if (udpListener.AddressFamily == AddressFamily.InterNetwork)
{
remoteEP = new IPEndPoint(IPAddress.Any, 0);
}
else
{
remoteEP = new IPEndPoint(IPAddress.IPv6Any, 0);
}
try
{
while (true)
{
//receive message from remote
bytesRecv = udpListener.ReceiveFrom(dataRecv.Buffer, ref remoteEP);
if (bytesRecv > 0)
{
IPAddress peerIP = (remoteEP as IPEndPoint).Address;
if (NetUtilities.IsIPv4MappedIPv6Address(peerIP))
{
peerIP = NetUtilities.ConvertFromIPv4MappedIPv6Address(peerIP);
}
dataRecv.Position = 0;
dataRecv.SetLength(bytesRecv);
try
{
ReceivedPacket(new DiscoveryPacket(dataRecv), peerIP);
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listner.RecvDataAsync", ex);
}
}
}
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listner.RecvDataAsync", ex);
}
}
public IPv6PseudoHeader(IPAddress sourceAddress, IPAddress destinationAddress, ushort headerLength, byte nextHeader)
{
pseudoHeader = new byte[40]; // Size of IPv6 header
Array.Copy(sourceAddress.GetAddressBytes(), 0, pseudoHeader, 0, 16);
Array.Copy(destinationAddress.GetAddressBytes(), 0, pseudoHeader, 16, 16);
Array.Copy(NetUtilities.FromLittleEndian(headerLength), 0, pseudoHeader, 32, 2);
pseudoHeader[36] = 0; // Reserved 3 zeros
pseudoHeader[37] = 0;
pseudoHeader[38] = 0;
pseudoHeader[39] = nextHeader; //NextHeader
}
public void AddNode(NodeContact contact)
{
if (!NetUtilities.IsPrivateIP(contact.NodeEP.Address) && (contact.NodeEP.AddressFamily == _currentNode.NodeEP.AddressFamily))
{
if (_routingTable.AddContact(contact))
{
ThreadPool.QueueUserWorkItem(delegate(object state)
{
Query(DhtRpcPacket.CreatePingPacket(_currentNode), contact);
});
}
}
}
private bool AllowNewConnection(IPEndPoint existingIP, IPEndPoint newIP)
{
if (existingIP.AddressFamily != newIP.AddressFamily)
{
return(false);
}
if (NetUtilities.IsPrivateIP(existingIP.Address))
{
return(false);
}
return(true);
}
/// <summary>
/// Initialize a new instance of the <see cref="TcpListener"/> class,
/// ready to listen requests over a given IP address and port.
/// </summary>
/// <param name="localAddress">
/// It's the local address where the connection requests will be listened.
/// </param>
/// <param name="port">
/// It's the local port where the connection requests will be listened.
/// </param>
public TcpListener(IPAddress localAddress, int port)
{
if (localAddress == null)
{
throw new ArgumentNullException("localAddress");
}
if (!NetUtilities.IsValidTcpPort(port))
{
throw new ArgumentOutOfRangeException("port");
}
CreateServerSocket(new IPEndPoint(localAddress, port));
}
/// <summary>
/// Sends a message to a remote connection. Default channel = 0
/// </summary>
public void RegisterHosting()
{
OutgoingMessage regMessage = MessagePool.CreateMessage();
IPAddress local = NetUtilities.GetLocalAddress();
regMessage.Write(NATMessageType.INITIATE_HOST);
regMessage.WriteString("hello");
fixed(byte *bytes = regMessage.Data)
{
ENet.MicroSend(Peer, 0, bytes, (IntPtr)regMessage.ByteCount, DeliveryMethod.Reliable);
}
MessagePool.Recycle(regMessage);
}
public Listener(int listenerPort)
{
_listenerPort = listenerPort;
_udpListener = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
_udpListener.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Broadcast, 1);
_udpListener.Bind(new IPEndPoint(0, listenerPort));
_listeningThread = new Thread(RecvDataAsync);
_listeningThread.IsBackground = true;
_listeningThread.Start();
_broadcastIPs = NetUtilities.GetBroadcastIPList();
_networkWatcher = new Timer(NetworkWatcher, null, NETWORK_WATCHER_INTERVAL, Timeout.Infinite);
}
public void SendTo(byte[] buffer, int offset, int count, IPAddress remoteIP)
{
if ((_udpListener.AddressFamily == AddressFamily.InterNetworkV6) && (remoteIP.AddressFamily == AddressFamily.InterNetwork))
{
remoteIP = NetUtilities.ConvertToIPv4MappedIPv6Address(remoteIP);
}
try
{
_udpListener.SendTo(buffer, offset, count, SocketFlags.None, new IPEndPoint(remoteIP, _listenerPort));
}
catch (Exception ex)
{
Debug.Write("LocalPeerDiscovery.Listener.SendTo", ex);
}
}
public Connection MakeVirtualConnection(Connection viaConnection, IPEndPoint remotePeerEP)
{
if (NetUtilities.IsIPv4MappedIPv6Address(remotePeerEP.Address))
{
remotePeerEP = new IPEndPoint(NetUtilities.ConvertFromIPv4MappedIPv6Address(remotePeerEP.Address), remotePeerEP.Port);
}
//prevent multiple virtual connection requests to same remote end-point
lock (_makeVirtualConnectionList)
{
if (_makeVirtualConnectionList.ContainsKey(remotePeerEP))
{
throw new BitChatException("Connection attempt for end-point already in progress.");
}
_makeVirtualConnectionList.Add(remotePeerEP, null);
}
try
{
//check if self
if (remotePeerEP.Equals(this.ExternalEndPoint))
{
throw new IOException("Cannot connect to remote port: self connection.");
}
//check existing connection
Connection existingConnection = GetExistingConnection(remotePeerEP);
if (existingConnection != null)
{
return(existingConnection);
}
//create tunnel via proxy peer
Stream proxyNetworkStream = viaConnection.RequestProxyTunnel(remotePeerEP);
//make new connection protocol begins
return(MakeConnectionInitiateProtocol(proxyNetworkStream, remotePeerEP));
}
finally
{
lock (_makeVirtualConnectionList)
{
_makeVirtualConnectionList.Remove(remotePeerEP);
}
}
}
