private bool IsGoodNode(TrustedNodeInfo node)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
return(node.AllowConnect && node.AllowAutoConnect &&
node.GetConnectableDestinations(network.Core) != null);
}
public Message CreateAuthMessage(INodeConnection connection, TrustedNodeInfo messageTo)
{
var p = new Message(network, MessageType.Auth);
p.To = messageTo.NodeId;
var c = new AuthInfo();
c.ProtocolVersion = Core.ProtocolVersion;
c.NetworkName = network.NetworkName;
c.NickName = network.LocalNode.NickName;
p.Content = c;
return(p);
}
private void ReceivedMessage(IAsyncResult result)
{
try {
if (connectionState == ConnectionState.Disconnected)
{
// Connection has been closed. Ignore the message.
LoggingService.LogWarning("LocalNodeConnection: Ignored message received after connection was closed.");
return;
}
var messageData = transport.EndReceiveMessage(result);
if (messageData == null)
{
return;
}
// Get the next one!
ReceiveMessage();
Message message = null;
string messageFrom = null;
try {
message = Message.Parse(transport.Network, messageData, out messageFrom);
} catch (InvalidSignatureException ex) {
if (string.IsNullOrEmpty(messageFrom) || messageFrom == remoteNodeInfo.NodeId)
{
throw ex;
}
LoggingService.LogWarning("Ignored message with invalid signature from {0}", messageFrom);
return;
}
var info = new ReceivedMessageInfo();
info.Connection = this;
info.Message = message;
transport.Network.Core.RaiseMessageReceived(info);
if (remoteNodeInfo == null)
{
var keyInfo = (KeyInfo)message.Content;
var publicKey = new PublicKey(keyInfo.Info, keyInfo.Key);
var nodeId = publicKey.Fingerprint;
if (nodeId.ToLower() == transport.Network.LocalNode.NodeID.ToLower())
{
throw new Exception("You cannot connect to yourself!");
}
if (!transport.Network.TrustedNodes.ContainsKey(nodeId))
{
var acceptKey = transport.Network.RaiseReceivedKey(this, keyInfo);
if (acceptKey)
{
var trustedNode = new TrustedNodeInfo($"[{nodeId}]", nodeId, keyInfo.Key);
transport.Network.AddTrustedNode(trustedNode);
transport.Network.Core.Settings.SyncNetworkInfoAndSave(transport.Network.Core);
}
else
{
throw new ConnectNotTrustedException();
}
}
if (transport.Network.TrustedNodes[nodeId].AllowConnect == false)
{
throw new ConnectNotAllowedException(nodeId);
}
foreach (var connection in transport.Network.LocalConnections)
{
if (connection != this && connection.NodeRemote != null && connection.NodeRemote.NodeID == nodeId)
{
throw new Exception("Already connected!");
}
}
remoteNodeInfo = transport.Network.TrustedNodes[nodeId];
if (!transport.Network.Nodes.ContainsKey(RemoteNodeInfo.NodeId))
{
var node = new Node(transport.Network, RemoteNodeInfo.NodeId);
node.NickName = RemoteNodeInfo.Identifier;
node.Verified = true;
transport.Network.AddNode(node);
}
NodeRemote = transport.Network.Nodes[RemoteNodeInfo.NodeId];
if (transport.Incoming)
{
SendMessage(transport.Network.MessageBuilder.CreateMyKeyMessage(null));
}
else
{
ConnectionState = ConnectionState.Authenticating;
RaiseConnectionInfoChanged();
var m = transport.Network.MessageBuilder.CreateAuthMessage(this, RemoteNodeInfo);
SendMessage(m);
}
}
else
{
ThreadPool.QueueUserWorkItem(transport.Network.ProcessMessage, info);
}
} catch (Exception ex) {
Disconnect(ex);
}
}
