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