private void ListenLoop()
{
if (scheduler.Verbose)
{
Console.WriteLine("Starting to listen on {0}", myEndpoint);
}
listener = new TcpListener(myEndpoint);
listener.ExclusiveAddressUse = true;
listener.Start();
while (true)
{
if (scheduler.Verbose)
{
Console.WriteLine("Waiting for the next incoming connection");
}
TcpClient client = listener.AcceptTcpClient();
CertificateValidator myValidator = new CertificateValidator(scheduler);
SslStream sslStream = new SslStream(client.GetStream(), leaveInnerStreamOpen: false, myValidator.ValidateSSLCertificate);
sslStream.AuthenticateAsServer(scheduler.MyCert, clientCertificateRequired: true, checkCertificateRevocation: false);
var remoteCert = sslStream.RemoteCertificate as X509Certificate2;
if (scheduler.Verbose)
{
Console.WriteLine("Received an incoming connection from remote certified as {0}",
IoScheduler.CertificateToString(remoteCert));
}
ReceiverThread.Create(scheduler, sslStream);
ServerSenderThread.Create(scheduler, sslStream);
}
}
private void StartServer(PrivateIdentity myIdentity, string localHostNameOrAddress, int localPort)
{
onlyClient = false;
try {
myCert = new X509Certificate2(myIdentity.Pkcs12, "" /* empty password */, X509KeyStorageFlags.Exportable);
}
catch (Exception e) {
Console.Error.WriteLine("Could not import private key. Exception:{0}", e);
throw new Exception("Can't start server because private key not decryptable");
}
// The `local` parameters override the parameters in
// `myIdentity`, unless they're empty or zero.
if (localHostNameOrAddress == null || localHostNameOrAddress.Length == 0)
{
localHostNameOrAddress = myIdentity.HostNameOrAddress;
}
if (localPort == 0)
{
localPort = myIdentity.Port;
}
var address = LookupHostNameOrAddress(localHostNameOrAddress);
if (address == null)
{
Console.Error.WriteLine("ERROR: Could not find any addresses when resolving {0}, which I'm supposed to bind to.");
throw new Exception("Can't resolve binding address");
}
var myEndpoint = new IPEndPoint(address, localPort);
if (verbose)
{
Console.WriteLine("Starting I/O scheduler as server listening to {0} certified as {1}",
myEndpoint, IoScheduler.CertificateToString(myCert));
}
sendDispatchThread = new SendDispatchThread(this);
Thread st = new Thread(sendDispatchThread.Run);
st.Start();
// Start a thread to listen on my binding endpoint.
listenerThread = new ListenerThread(this, myEndpoint);
Thread lt = new Thread(listenerThread.Run);
lt.Start();
}
private void ReceiveLoop()
{
bool success;
if (scheduler.Verbose)
{
Console.WriteLine("Starting receive loop with remote identified as {0}", IoScheduler.CertificateToString(remoteCert));
}
while (true)
{
// Read the next message's size.
UInt64 messageSize;
success = IoEncoder.ReadUInt64(stream, out messageSize);
if (!success)
{
if (scheduler.Verbose)
{
Console.Error.WriteLine("Failed to receive message size from {0}", IoScheduler.CertificateToString(remoteCert));
}
return;
}
if (scheduler.Verbose)
{
Console.WriteLine("Received message size {0} from {1}", messageSize, IoScheduler.CertificateToString(remoteCert));
}
byte[] messageBuf = new byte[messageSize];
success = IoEncoder.ReadBytes(stream, messageBuf, 0, messageSize);
if (!success)
{
if (scheduler.Verbose)
{
Console.Error.WriteLine("Failed to receive message of size {0} from {1}",
messageSize, IoScheduler.CertificateToString(remoteCert));
}
return;
}
if (scheduler.Verbose)
{
Console.WriteLine("Received message of size {0} from {1}", messageSize, IoScheduler.CertificateToString(remoteCert));
}
ReceivedPacket packet = new ReceivedPacket(remoteCert, messageBuf);
scheduler.NoteReceivedPacket(packet);
}
}
public static ServerSenderThread Create(IoScheduler scheduler, SslStream stream)
{
var remoteCert = stream.RemoteCertificate as X509Certificate2;
var destinationPublicKey = IoScheduler.GetCertificatePublicKey(remoteCert);
if (scheduler.Verbose)
{
Console.WriteLine("Creating sender thread to send to remote certified as {0}",
IoScheduler.CertificateToString(remoteCert));
}
ServerSenderThread senderThread = new ServerSenderThread(scheduler, destinationPublicKey, stream, remoteCert);
senderThread.Start();
return(senderThread);
}
private void StartClient()
{
onlyClient = true;
myCert = IronfleetCrypto.CreateTransientClientIdentity();
if (verbose)
{
Console.WriteLine("Starting I/O scheduler as client with certificate {0}",
IoScheduler.CertificateToString(myCert));
}
sendDispatchThread = new SendDispatchThread(this);
Thread st = new Thread(sendDispatchThread.Run);
st.Start();
}
protected override bool Connect()
{
var destinationPublicIdentity = scheduler.LookupPublicKey(destinationPublicKey);
if (destinationPublicIdentity == null)
{
if (scheduler.Verbose)
{
Console.Error.WriteLine("Could not connect to destination public key {0} because we don't know its address.",
IoScheduler.PublicKeyToString(destinationPublicKey));
}
return(false);
}
if (scheduler.Verbose)
{
Console.WriteLine("Starting connection to {0}", IoScheduler.PublicIdentityToString(destinationPublicIdentity));
}
TcpClient client;
try
{
client = new TcpClient(destinationPublicIdentity.HostNameOrAddress, destinationPublicIdentity.Port);
}
catch (Exception e)
{
scheduler.ReportException(e, "connecting to " + IoScheduler.PublicIdentityToString(destinationPublicIdentity));
return(false);
}
var myCertificateCollection = new X509CertificateCollection();
myCertificateCollection.Add(scheduler.MyCert);
var myValidator = new CertificateValidator(scheduler, destinationPublicIdentity);
try {
stream = new SslStream(client.GetStream(), leaveInnerStreamOpen: false, myValidator.ValidateSSLCertificate);
stream.AuthenticateAsClient(destinationPublicIdentity.FriendlyName, myCertificateCollection,
checkCertificateRevocation: false);
}
catch (Exception e) {
scheduler.ReportException(e, "authenticating connection to " + IoScheduler.PublicIdentityToString(destinationPublicIdentity));
return(false);
}
remoteCert = stream.RemoteCertificate as X509Certificate2;
if (!ByteArrayComparer.Default().Equals(IoScheduler.GetCertificatePublicKey(remoteCert), destinationPublicKey))
{
Console.Error.WriteLine("Connected to {0} expecting public key {1} but found public key {2}, so disconnecting.",
IoScheduler.PublicIdentityToString(destinationPublicIdentity),
IoScheduler.PublicKeyToString(destinationPublicKey),
IoScheduler.PublicKeyToString(IoScheduler.GetCertificatePublicKey(remoteCert)));
return(false);
}
if (scheduler.Verbose)
{
Console.WriteLine("Successfully connected to {0} and got certificate identifying it as {1}",
IoScheduler.PublicIdentityToString(destinationPublicIdentity),
IoScheduler.CertificateToString(remoteCert));
}
// Now that the connection is successful, create a thread to
// receive packets on it.
ReceiverThread receiverThread = ReceiverThread.Create(scheduler, stream);
return(true);
}
protected override string EndpointDescription()
{
return(IoScheduler.CertificateToString(remoteCert));
}