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); } } }