internal async Task onConnectionException(InConnection inc, Exception e)
{
Logger.exception(e, Logging.Level.Error, $"Handling {inc}");
if (inc.IsHandled == false)
{
await inc.SetResult(new ConnectResultBase(this, ConnectResultEnum.Failed) {
FailedReason = $"exception: {e.GetType()}: {e.Message}"
});
}
}
public virtual Task HandleConnection(InConnection connection)
{
if (connection is InConnectionTcp tcp)
{
return(this.HandleTcpConnection(tcp));
}
else
{
throw new NotSupportedException("cannot handle this type of connection.");
}
}
public async Task HandleInConnection(InConnection inc, IConnectionHandler outAdapter)
{
try {
if (outAdapter == null)
{
warning($"'{inc.InAdapter.Name}' {inc} -> (no out adapter)");
return;
}
onConnectionBegin(inc, outAdapter);
int redirectCount = 0;
while (true)
{
inc.RunningHandler = outAdapter;
if (outAdapter is IConnectionHandler2 ich2)
{
await ich2.HandleConnection(inc).CAF();
}
else if (inc is InConnectionTcp tcp)
{
await outAdapter.HandleTcpConnection(tcp).CAF();
}
else
{
throw new Exception($"'{outAdapter.Name}' cannot handle this type of connection.");
}
if (inc.IsHandled || !inc.IsRedirected)
{
break;
}
if (++redirectCount >= 10)
{
error($"'{inc.InAdapter.Name}' {inc} too many redirects, last redirect: {outAdapter.Name}");
return;
}
var nextAdapter = inc.Redirected?.Adapter as IConnectionHandler;
if (nextAdapter == null)
{
warning($"'{inc.InAdapter.Name}' {inc} was redirected by '{outAdapter.Name}'" +
$" to '{inc.Redirected}' which can not be found.");
return;
}
outAdapter = nextAdapter;
if (LoggingLevel <= Logging.Level.None)
{
debug($"'{inc.InAdapter.Name}' {inc} was redirected to '{inc.Redirected}'");
}
inc.Redirected = null;
}
} catch (Exception e) {
await onConnectionException(inc, e).CAF();
} finally {
await onConnectionEnd(inc).CAF();
}
}
protected Task HandleIncommingConnection(InConnection inConnection, AdapterRef outRef)
{
if (rdns?.Adapter is DnsInAdapter dnsIn)
{
try {
dnsIn.HandleRdns(inConnection);
} catch (Exception e) {
Logger.exception(e, Logging.Level.Error, "rdns handling");
}
}
return(Controller.HandleInConnection(inConnection, outRef.Adapter as IConnectionHandler));
}
public Task HandleInConnection(InConnection inConnection)
{
if (inConnection == null)
{
throw new ArgumentNullException(nameof(inConnection));
}
if (inConnection.InAdapter is IInAdapter ina)
{
return(HandleInConnection(inConnection, [email protected] as IConnectionHandler));
}
else
{
throw new ArgumentException($"InConnection.InAdapter({inConnection.InAdapter}) does not implement IInAdapter.");
}
}
public Task HandleConnection(InConnection connection)
{
if (connection is InConnectionDns dns)
{
return(ResolveName(dns));
}
else if (connection is InConnectionTcp)
{
throw new NotSupportedException("This is just a dns client and cannot handle regular connection.");
}
else
{
throw new NotSupportedException();
}
}
public Task HandleConnection(InConnection connection)
{
if (connection is InConnectionTcp tcp)
{
return(HandleTcpConnection(tcp));
}
else if (connection is InConnectionDns dns)
{
return(HandleDnsConnection(dns));
}
else
{
throw new NotSupportedException("cannot handle this type of connection");
}
}
private void onConnectionBegin(InConnection inc, IAdapter outAdapter)
{
if (LoggingLevel <= Logging.Level.None)
{
debug($"'{inc.InAdapter.Name}' {inc} -> '{outAdapter.Name}'");
}
try {
lock (InConnectionsLock) {
inc.InAdapter.GetAdapter().CreatedConnections++;
_totalHandledConnections++;
InConnections.Add(inc.Id, inc);
NewConnection?.Invoke(inc);
}
} catch (Exception e) {
Logger.exception(e, Logging.Level.Error, "event NewConnection");
}
}
public Task HandleInConnection(InConnection inc, AdapterRef outAdapterRef)
{
if (outAdapterRef == null)
{
throw new ArgumentNullException(nameof(outAdapterRef));
}
IConnectionHandler adapter = outAdapterRef.Adapter as IConnectionHandler;
if (adapter == null)
{
if (LoggingLevel <= Logging.Level.Warning)
{
warning($"null out adapter reference ({outAdapterRef})");
}
}
return(HandleInConnection(inc, adapter));
}
public Task HandleInConnection(InConnection inc, string outAdapterName)
{
if (string.IsNullOrEmpty(outAdapterName))
{
throw new ArgumentException("outAdapterName is null or empty");
}
IConnectionHandler selectedAdapter = FindOutAdapter(outAdapterName);
if (selectedAdapter == null)
{
if (LoggingLevel <= Logging.Level.Warning)
{
warning($"out adapter '{outAdapterName}' not found");
}
}
return(HandleInConnection(inc, selectedAdapter));
}
public void HandleRdns(InConnection x)
{
if (IPAddress.TryParse(x.Dest.Host, out var ip))
{
string host = null;
if (ip.AddressFamily == AddressFamily.InterNetwork)
{
host = cacheDns.QueryByIp((uint)ip.Address);
}
else if (ip.AddressFamily == AddressFamily.InterNetworkV6)
{
host = cacheDns.QueryByIp6(new Ip6(ip));
}
if (host != null)
{
x.DestOriginalName = host;
}
}
}
public override Task HandleConnection(InConnection connection)
{
if (connection is InConnectionDns dns)
{
if (redirect_dns != null)
{
dns.RedirectTo(redirect_dns);
return(NaiveUtils.CompletedTask);
}
return(ResolveNameCore(dns));
}
if (connection is InConnectionUdp udp)
{
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
return(connection.SetResult(new ConnectResultUdp(this, ConnectResultEnum.OK)
{
UdpSocket = GetMyStreamFromSocket(socket) as IUdpSocket
}));
}
return(base.HandleConnection(connection));
}
internal async Task onConnectionEnd(InConnection inc)
{
inc.RunningHandler = null;
if (LoggingLevel <= Logging.Level.None)
{
debug($"{inc} End.");
}
await inc.Finish();
try {
lock (InConnectionsLock) {
if (inc.ConnectResult?.Result != ConnectResultEnum.OK)
{
_failedConnections++;
}
InConnections.Remove(inc.Id);
EndConnection?.Invoke(inc);
}
} catch (Exception e) {
Logger.exception(e, Logging.Level.Error, "event EndConnection");
}
}
public Task HandleConnection(InConnection connection)
{
var sw = Stopwatch.StartNew();
if (Handle(connection, out var redir))
{
connection.RedirectTo(redir);
}
else
{
connection.RedirectTo(@default);
}
if (logging)
{
var ms = sw.ElapsedMilliseconds;
var dest = connection.GetDestStringWithOriginalName();
if (log_uri && connection.Url != null)
{
dest = connection.Url;
}
Logger.info($"{connection.Redirected} <- {dest} - '{connection.InAdapter?.Name}' ({ms} ms)");
}
return(AsyncHelper.CompletedTask);
}
protected Task HandleIncommingConnection(InConnection inConnection)
{
return(HandleIncommingConnection(inConnection, @out));
}
