public override void BeginSend(byte[] buffer, int offset, int size, TransportCallback callback) { if (socket == null) throw new Exception ("Socket is disconnected."); AsyncCallback internalCallback = new AsyncCallback (OnDataSent); socket.BeginSend (buffer, offset, size, SocketFlags.None, internalCallback, callback); }
public override void Connect(TransportCallback callback) { Message message = base.Network.MessageBuilder.CreateTransportConnectMessage (remoteNode, connectionId); base.Network.SendRoutedMessage (message); // Wait for a confirmation now. // MessageProcessor will call ConnectionAccepted this.callback = callback; }
public override void Connect(TransportCallback callback) { if (socket != null) throw new InvalidOperationException("This socket is already connected."); if (address.Equals(IPAddress.Any) || address.Equals(IPAddress.None) || port == 0) throw new Exception("Invalid IP Address/Port"); base.transportState = TransportState.Connecting; connectCallback = callback; if (address.IsIPv6LinkLocal) { address.ScopeId = Core.Settings.IPv6LinkLocalInterfaceIndex; } IPEndPoint remoteEndpoint = new IPEndPoint(address, port); socket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp); socket.BeginConnect(remoteEndpoint, new AsyncCallback(OnConnected), null); }
public abstract void Connect(TransportCallback callback);
internal static void ConnectTo(ITransport transport, TransportCallback connectCallback) { if (transport == null) { throw new ArgumentNullException("transport"); } if (transport.Network == null) { throw new ArgumentNullException("transport.Network"); } if (transport.ConnectionType == ConnectionType.NodeConnection) { // XXX: This doesn't belong here. Have LocalNodeConnection set this up // and call me with the proper callback. LocalNodeConnection connection = new LocalNodeConnection(transport); transport.Operation = connection; transport.Network.AddConnection(connection); transportManager.Add(transport, delegate (ITransport bleh) { connection.Start(); if (connectCallback != null) { connectCallback(transport); } }); } else { transportManager.Add (transport, connectCallback); } }
internal void Add(ITransport transport, TransportCallback connectCallback) { try { // XXX: This should be negotiated as part of the initial handshake. transport.Encryptor = new AESTransportEncryptor(); transports.Add (transport); if (NewTransportAdded != null) NewTransportAdded (transport); LoggingService.LogInfo(String.Format ("Transport {0} added", transport.ToString())); if (transport.Incoming == true) { if (connectCallback != null) throw new ArgumentException ("You can only specify a ConnectCallback for outoging connections!"); if (transport.Encryptor != null) { DiffieHellmanManaged dh = new DiffieHellmanManaged (); byte[] keyxBytes = new byte[transport.Encryptor.KeyExchangeLength]; transport.Receive (keyxBytes, 0, keyxBytes.Length); keyxBytes = dh.DecryptKeyExchange (keyxBytes); byte[] keyBytes = new byte[transport.Encryptor.KeySize]; byte[] ivBytes = new byte[transport.Encryptor.IvSize]; Array.Copy (keyxBytes, 0, keyBytes, 0, keyBytes.Length); Array.Copy (keyxBytes, keyBytes.Length, ivBytes, 0, ivBytes.Length); keyxBytes = dh.CreateKeyExchange (); transport.Send (keyxBytes, 0, keyxBytes.Length); transport.Encryptor.SetKey(keyBytes, ivBytes); } //Receive connection type, which is a ulong (8 bytes) byte[] responseBuffer = new byte[8]; transport.Receive (responseBuffer, 0, 8); ulong connectionType = EndianBitConverter.ToUInt64 (responseBuffer, 0); // Recieve network ID (64 bytes) responseBuffer = new byte[64]; transport.Receive (responseBuffer, 0, 64); string networkId = EndianBitConverter.ToString (responseBuffer).Replace ("-", ""); // Match to one of our known networks! foreach (Network network in Core.Networks) { if (network.NetworkID == networkId) { transport.Network = network; } } if (transport.Network == null) { throw new Exception (String.Format ("Unknown network: {0}.", networkId)); } transport.ConnectionType = connectionType; if (connectionType == ConnectionType.NodeConnection) { LocalNodeConnection connection = new LocalNodeConnection(transport); transport.Operation = connection; transport.Network.AddConnection(connection); connection.Start(); } else if (connectionType == ConnectionType.TransferConnection) { Core.FileTransferManager.NewIncomingConnection(transport); } else { throw new Exception(String.Format("Unknown connection type: {0}.", connectionType.ToString())); } } else { if (connectCallback == null) { throw new ArgumentNullException("connectCallback"); } connectCallbacks.Add (transport, connectCallback); LoggingService.LogInfo("Transport {0} connecting...", transport); TransportCallback callback = new TransportCallback (OnConnected); transport.Connect (callback); } } catch (Exception ex) { transport.Disconnect (ex); RaiseTransportError(transport, ex); } }
public override void BeginSendEncrypted(byte[] buffer, int offset, int size, TransportCallback callback) { throw new NotImplementedException(); }
public void ConnectTo(ITransport transport, TransportCallback callback) { transport.Network = this; Core.ConnectTo(transport, callback); }
// this is rather fake... public override void Connect(TransportCallback callback) { try { base.transportState = TransportState.Connecting; connectCallback = callback; base.transportState = TransportState.Connected; connectCallback (this); } catch (Exception ex) { Disconnect (ex); } }
public override void BeginSendEncrypted(byte[] buffer, int offset, int size, TransportCallback callback) { buffer = base.Encrypt (buffer, offset, size); BeginSend (buffer, 0, buffer.Length, callback); }