void StartEndpoint(RemoteForward remoteForward)
{
Uri hybridConnectionUri = null;
EventTraceActivity stopActivity = BridgeEventSource.NewActivity("RemoteForwardBridgeStart", activity);
stopActivity.DiagnosticsActivity.Start();
try
{
BridgeEventSource.Log.RemoteForwardBridgeStarting(stopActivity, this, remoteForward);
var rcbs = remoteForward.RelayConnectionStringBuilder ?? new RelayConnectionStringBuilder(this.config.AzureRelayConnectionString);
rcbs.EntityPath = remoteForward.RelayName;
hybridConnectionUri = new Uri(rcbs.Endpoint, rcbs.EntityPath);
RemoteForwardBridge remoteForwardBridge = null;
try
{
var remoteForwarders = new Dictionary <string, IRemoteForwarder>();
foreach (var binding in remoteForward.Bindings)
{
#if !NETFRAMEWORK
if (!string.IsNullOrEmpty(binding.LocalSocket))
{
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
BridgeEventSource.Log.ThrowingException(
new NotSupportedException("Unix sockets are not supported on Windows"));
}
var socketRemoteForwarder =
new SocketRemoteForwarder(binding.PortName, binding.LocalSocket);
remoteForwarders.Add(socketRemoteForwarder.PortName, socketRemoteForwarder);
}
else
#endif
if (binding.HostPort > 0)
{
var tcpRemoteForwarder =
new TcpRemoteForwarder(this.config, binding.PortName, binding.Host, binding.HostPort);
remoteForwarders.Add(tcpRemoteForwarder.PortName, tcpRemoteForwarder);
}
else if (binding.HostPort < 0)
{
var udpRemoteForwarder =
new UdpRemoteForwarder(this.config, binding.PortName, binding.Host, -binding.HostPort);
remoteForwarders.Add(udpRemoteForwarder.PortName, udpRemoteForwarder);
}
}
remoteForwardBridge = new RemoteForwardBridge(config, rcbs, remoteForwarders);
remoteForwardBridge.Online += (s, e) =>
{
NotifyOnline(hybridConnectionUri, remoteForward);
BridgeEventSource.Log.RemoteForwardBridgeOnline(stopActivity, hybridConnectionUri, remoteForwardBridge);
};
remoteForwardBridge.Offline += (s, e) =>
{
NotifyOffline(hybridConnectionUri, remoteForward);
BridgeEventSource.Log.RemoteForwardBridgeOffline(stopActivity, hybridConnectionUri, remoteForwardBridge);
};
remoteForwardBridge.Connecting += (s, e) =>
{
NotifyConnecting(hybridConnectionUri, remoteForward);
BridgeEventSource.Log.RemoteForwardBridgeConnecting(stopActivity, hybridConnectionUri, remoteForwardBridge);
};
remoteForwardBridge.Open().Wait();
this.forwardBridges.Add(hybridConnectionUri.AbsoluteUri, remoteForwardBridge);
BridgeEventSource.Log.RemoteForwardBridgeStart(stopActivity, hybridConnectionUri.AbsoluteUri);
}
catch (Exception exception)
{
BridgeEventSource.Log.RemoteForwardBridgeStartFailure(stopActivity, hybridConnectionUri, exception);
if (Fx.IsFatal(exception))
{
throw;
}
try
{
if (remoteForwardBridge != null)
{
remoteForwardBridge.Dispose();
}
}
catch (Exception e)
{
if (Fx.IsFatal(exception))
{
throw;
}
BridgeEventSource.Log.HandledExceptionAsWarning(this, e);
}
if (!this.config.ExitOnForwardFailure.HasValue ||
this.config.ExitOnForwardFailure.Value)
{
throw;
}
}
}
finally
{
stopActivity.DiagnosticsActivity.Stop();
}
}
void StartEndpoint(RemoteForward remoteForward)
{
Uri hybridConnectionUri = null;
TcpRemoteForwardBridge tcpRemoteForwardBridge = null;
EventTraceActivity stopActivity = BridgeEventSource.NewActivity("RemoteForwardBridgeStart", activity);
stopActivity.DiagnosticsActivity.Start();
try
{
BridgeEventSource.Log.RemoteForwardBridgeStarting(stopActivity, this, remoteForward);
var rcbs = remoteForward.RelayConnectionStringBuilder ?? new RelayConnectionStringBuilder(this.config.AzureRelayConnectionString);
rcbs.EntityPath = remoteForward.RelayName;
hybridConnectionUri = new Uri(rcbs.Endpoint, rcbs.EntityPath);
try
{
tcpRemoteForwardBridge = new TcpRemoteForwardBridge(rcbs,
remoteForward.Host, remoteForward.HostPort);
tcpRemoteForwardBridge.Online += (s, e) =>
{
NotifyOnline(hybridConnectionUri, remoteForward);
BridgeEventSource.Log.RemoteForwardBridgeOnline(stopActivity, hybridConnectionUri, tcpRemoteForwardBridge);
};
tcpRemoteForwardBridge.Offline += (s, e) =>
{
NotifyOffline(hybridConnectionUri, remoteForward);
BridgeEventSource.Log.RemoteForwardBridgeOffline(stopActivity, hybridConnectionUri, tcpRemoteForwardBridge);
};
tcpRemoteForwardBridge.Connecting += (s, e) =>
{
NotifyConnecting(hybridConnectionUri, remoteForward);
BridgeEventSource.Log.RemoteForwardBridgeConnecting(stopActivity, hybridConnectionUri, tcpRemoteForwardBridge);
};
tcpRemoteForwardBridge.Open().Wait();
this.clientBridges.Add(hybridConnectionUri.AbsoluteUri, tcpRemoteForwardBridge);
BridgeEventSource.Log.RemoteForwardBridgeStart(stopActivity, hybridConnectionUri.AbsoluteUri);
}
catch (Exception exception)
{
BridgeEventSource.Log.RemoteForwardBridgeStartFailure(stopActivity, hybridConnectionUri, exception);
if (Fx.IsFatal(exception))
{
throw;
}
try
{
if (tcpRemoteForwardBridge != null)
{
tcpRemoteForwardBridge.Dispose();
}
}
catch (Exception e)
{
if (Fx.IsFatal(exception))
{
throw;
}
BridgeEventSource.Log.HandledExceptionAsWarning(this, e);
}
if (!this.config.ExitOnForwardFailure.HasValue ||
this.config.ExitOnForwardFailure.Value)
{
throw;
}
}
}
finally
{
stopActivity.DiagnosticsActivity.Stop();
}
}
private void NotifyOnline(Uri hybridConnectionUri, RemoteForward remoteForward)
{
// this hook will write to a named pipe
}
public void SocketBridge()
{
// not yet supported on Windows.
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
return;
}
// set up the bridge first
Config cfg = new Config
{
AzureRelayConnectionString = Utilities.GetConnectionString(),
ExitOnForwardFailure = true
};
var lf = new LocalForward
{
BindLocalSocket = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()),
RelayName = "a2",
PortName = "test"
};
var rf = new RemoteForward
{
LocalSocket = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()),
RelayName = "a2",
PortName = "test"
};
cfg.LocalForward.Add(lf);
cfg.RemoteForward.Add(rf);
Host host = new Host(cfg);
host.Start();
try
{
// now try to use it
var l = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
l.Bind(new UnixDomainSocketEndPoint(rf.LocalSocket));
l.Listen(5);
l.AcceptAsync().ContinueWith((t) =>
{
var c = t.Result;
using (var b = new StreamReader(new NetworkStream(c)))
{
var text = b.ReadLine();
using (var w = new StreamWriter(new NetworkStream(c)))
{
w.WriteLine(text);
w.Flush();
}
}
});
var s = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP);
s.Connect(new UnixDomainSocketEndPoint(lf.BindLocalSocket));
var ns = new NetworkStream(s);
using (var w = new StreamWriter(ns))
{
w.WriteLine("Hello!");
w.Flush();
using (var b = new StreamReader(ns))
{
string line = b.ReadLine();
Assert.Equal("Hello!", line);
}
}
s.Close(0);
l.Close(0);
}
finally
{
host.Stop();
}
}
