public void Can_resolve_internal_ip()
{
var ipResolver = new IPResolver(new NetworkConfig(), LimboLogs.Instance);
var address = ipResolver.LocalIp;
Assert.IsNotNull(address);
}
public bool Connect(string remoteIP, int remotePort)
{
PeerEvents listener = new PeerEvents();
listener.OnConnect += OnConnect;
listener.OnDisconnect += OnDisconnent;
listener.OnException += OnException;
listener.OnReceive += OnReceive;
listener.OnUpdateRTT += OnUpdateRTT;
IPEndPoint address = IPResolver.TryParse(remoteIP, remotePort);
if (address == null)
{
return(false);
}
PeerConfig config = new PeerConfig()
{
ConnectAttempts = 40,
ConnectDelay = 200,
DisconnectDelay = 1000,
DuplicateTimeout = 3000,
PingDelay = 2000
};
Peer = Host.Connect(address, config, listener);
return(true);
}
public async Task Can_resolve_internal_ip()
{
var ipResolver = new IPResolver(new NetworkConfig(), LimboLogs.Instance);
await ipResolver.Initialize();
var address = ipResolver.LocalIp;
Assert.IsNotNull(address);
}
public void Can_resolve_local_ip_with_override()
{
string ipOverride = "99.99.99.99";
INetworkConfig networkConfig = new NetworkConfig();
networkConfig.LocalIp = ipOverride;
var ipResolver = new IPResolver(networkConfig, LimboLogs.Instance);
var address = ipResolver.LocalIp;
Assert.AreEqual(IPAddress.Parse(ipOverride), address);
}
public void IPTest5()
{
string ip = "qwe.rt.yui.op";
IPResolver.IPInfo expected = new IPResolver.IPInfo()
{
Organization = "Not Found"
};
IPResolver.IPInfo result = IPResolver.GetInfo(ip).Result;
Assert.AreEqual(expected, result);
}
public async Task Can_resolve_external_ip_with_override(string ipOverride)
{
INetworkConfig networkConfig = new NetworkConfig();
networkConfig.ExternalIp = ipOverride;
var ipResolver = new IPResolver(networkConfig, LimboLogs.Instance);
await ipResolver.Initialize();
var address = ipResolver.ExternalIp;
Assert.AreEqual(IPAddress.Parse(ipOverride), address);
}
public void IPTest3()
{
string ip = "167.40.79.24";
IPResolver.IPInfo expected = new IPResolver.IPInfo()
{
Country = "Canada",
Latitude = 43.6319m,
Longitude = -79.3716m
};
IPResolver.IPInfo result = IPResolver.GetInfo(ip).Result;
Assert.AreEqual(expected, result);
}
public void IPTest2()
{
string ip = "185.53.179.6";
IPResolver.IPInfo expected = new IPResolver.IPInfo()
{
Country = "Germany",
Latitude = 51.2993m,
Longitude = 9.490997m
};
IPResolver.IPInfo result = IPResolver.GetInfo(ip).Result;
Assert.AreEqual(expected, result);
}
public void IPTest1()
{
string ip = "172.217.0.99";
IPResolver.IPInfo expected = new IPResolver.IPInfo()
{
Country = "United States",
Latitude = 37.75101m,
Longitude = -97.822m
};
IPResolver.IPInfo result = IPResolver.GetInfo(ip).Result;
Assert.AreEqual(expected, result);
}
public void IPTest4()
{
string ip = "70.35.123.53";
IPResolver.IPInfo expected = new IPResolver.IPInfo()
{
City = "Redmond",
Country = "United States",
Latitude = 47.6718m,
Longitude = -122.1232m,
StateProvince = "WA"
};
IPResolver.IPInfo result = IPResolver.GetInfo(ip).Result;
Assert.AreEqual(expected, result);
}
/// <summary>
/// Audit Trail at every login or logout attempt. Do not set the second parameter
/// if it was possible at all to retrieve the user. In that case, just bundle the user in session.
/// We'll pick it up from there.
/// </summary>
/// <param name="action">The action.</param>
/// <param name="userName">Name of the user.</param>
/// <param name="remarks">Remarks.</param>
public virtual void AuditLogin(EventType action, string userName = null, string remarks = null, string institutionCode = null)
{
//NOTE: A' + B' = (AB)' in boolean algebra
if (!(ConfigurationHelper.AppSettingsItem <bool>("EnableAuditTrail") && ConfigurationHelper.AppSettingsItem <bool>("TrailLogins")))
{
return;
}
if (action != EventType.Login && action != EventType.Logout && action != EventType.FailedLogin)
{
return;
}
AuditLog auditTrail = new AuditLog
{
EventType = action,
EventDate = DateTime.Now.GetLocalTime(),
Remark = remarks,
InstitutionCode = institutionCode,
};
try
{
if (HttpContext.Current != null)
{
if (!string.IsNullOrWhiteSpace(userName)) // usuall when the user fails to type in the right username (action == AuditAction.FAILEDLOGIN)
{
auditTrail.UserName = userName;
}
else
{
var user = WebUtilities.GetCurrentlyLoggedInUser();
if (user != null)
{
auditTrail.UserName = user.UserName;
auditTrail.UserId = user.Id;
}
}
auditTrail.ClientIpAddress = IPResolver.GetIP4Address();
auditTrail.ClientName = HttpContext.Current.Request.UserHostName;
}
}
catch
{
auditTrail.ClientName = "[Could not resolve Client Name]";
}
}
private void InitDiscovery()
{
if (_ctx.NodeStatsManager == null)
{
throw new StepDependencyException(nameof(_ctx.NodeStatsManager));
}
if (_ctx.Timestamper == null)
{
throw new StepDependencyException(nameof(_ctx.Timestamper));
}
if (_ctx.NodeKey == null)
{
throw new StepDependencyException(nameof(_ctx.NodeKey));
}
if (_ctx.CryptoRandom == null)
{
throw new StepDependencyException(nameof(_ctx.CryptoRandom));
}
if (!_ctx.Config <IInitConfig>().DiscoveryEnabled)
{
_ctx.DiscoveryApp = new NullDiscoveryApp();
return;
}
IDiscoveryConfig discoveryConfig = _ctx.Config <IDiscoveryConfig>();
SameKeyGenerator privateKeyProvider = new SameKeyGenerator(_ctx.NodeKey.Unprotect());
DiscoveryMessageFactory discoveryMessageFactory = new DiscoveryMessageFactory(_ctx.Timestamper);
NodeIdResolver nodeIdResolver = new NodeIdResolver(_ctx.EthereumEcdsa);
IPResolver ipResolver = new IPResolver(_networkConfig, _ctx.LogManager);
IDiscoveryMsgSerializersProvider msgSerializersProvider = new DiscoveryMsgSerializersProvider(
_ctx._messageSerializationService,
_ctx.EthereumEcdsa,
privateKeyProvider,
discoveryMessageFactory,
nodeIdResolver);
msgSerializersProvider.RegisterDiscoverySerializers();
NodeDistanceCalculator nodeDistanceCalculator = new NodeDistanceCalculator(discoveryConfig);
NodeTable nodeTable = new NodeTable(nodeDistanceCalculator, discoveryConfig, _networkConfig, _ctx.LogManager);
EvictionManager evictionManager = new EvictionManager(nodeTable, _ctx.LogManager);
NodeLifecycleManagerFactory nodeLifeCycleFactory = new NodeLifecycleManagerFactory(
nodeTable,
discoveryMessageFactory,
evictionManager,
_ctx.NodeStatsManager,
discoveryConfig,
_ctx.LogManager);
SimpleFilePublicKeyDb discoveryDb = new SimpleFilePublicKeyDb("DiscoveryDB", DiscoveryNodesDbPath.GetApplicationResourcePath(_ctx.Config <IInitConfig>().BaseDbPath), _ctx.LogManager);
NetworkStorage discoveryStorage = new NetworkStorage(
discoveryDb,
_ctx.LogManager);
DiscoveryManager discoveryManager = new DiscoveryManager(
nodeLifeCycleFactory,
nodeTable,
discoveryStorage,
discoveryConfig,
_ctx.LogManager,
ipResolver
);
NodesLocator nodesLocator = new NodesLocator(
nodeTable,
discoveryManager,
discoveryConfig,
_ctx.LogManager);
_ctx.DiscoveryApp = new DiscoveryApp(
nodesLocator,
discoveryManager,
nodeTable,
_ctx._messageSerializationService,
_ctx.CryptoRandom,
discoveryStorage,
_networkConfig,
discoveryConfig,
_ctx.Timestamper,
_ctx.LogManager);
_ctx.DiscoveryApp.Initialize(_ctx.NodeKey.PublicKey);
}
protected override async void Handle(TcpClient client, CancellationToken cancellationToken)
{
TcpClient outgoingClient = null;
CQRSProtocolType? protocolType = null;
RelayConnectedService service = null;
Stopwatch stopwatch = null;
bool responseStarted = false;
var bufferOwner = BufferArrayPool <byte> .Rent(bufferLength);
var buffer = bufferOwner.AsMemory();
Stream incommingStream = null;
Stream incommingBodyStream = null;
Stream outgoingWritingBodyStream = null;
Stream outgoingStream = null;
Stream outgoingBodyStream = null;
Stream incommingWritingBodyStream = null;
try
{
incommingStream = client.GetStream();
var headerPosition = 0;
var headerLength = 0;
var headerEnd = false;
while (headerLength < TcpCommon.MaxProtocolHeaderPrefixLength)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(TcpRelay)} Header Too Long");
}
headerLength += await incommingStream.ReadAsync(buffer.Slice(headerPosition, buffer.Length - headerPosition), cancellationToken);
}
protocolType = TcpCommon.ReadProtocol(buffer.Span);
string providerType;
switch (protocolType.Value)
{
case CQRSProtocolType.TcpRaw:
{
headerEnd = TcpRawCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
while (!headerEnd)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(TcpRelay)} Header Too Long");
}
headerLength += await incommingStream.ReadAsync(buffer.Slice(headerLength, buffer.Length - headerLength), cancellationToken);
headerEnd = TcpRawCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
}
var header = TcpRawCommon.ReadHeader(buffer, headerPosition, headerLength);
providerType = header.ProviderType;
incommingBodyStream = new TcpRawProtocolBodyStream(incommingStream, header.BodyStartBuffer, true);
break;
}
case CQRSProtocolType.Http:
{
headerEnd = HttpCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
while (!headerEnd)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(TcpRelay)} Header Too Long");
}
headerLength += await incommingStream.ReadAsync(buffer.Slice(headerLength, buffer.Length - headerLength), cancellationToken);
headerEnd = HttpCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
}
var header = HttpCommon.ReadHeader(buffer, headerPosition, headerLength);
providerType = header.ProviderType;
incommingBodyStream = new HttpProtocolBodyStream(header.ContentLength, incommingStream, header.BodyStartBuffer, true);
if (header.RelayServiceAddRemove.HasValue)
{
if (header.RelayKey != relayKey)
{
throw new SecurityException("Invalid Relay Key");
}
var serviceInfo = await System.Text.Json.JsonSerializer.DeserializeAsync <ServiceInfo>(incommingBodyStream);
await incommingBodyStream.DisposeAsync();
incommingBodyStream = null;
if (header.RelayServiceAddRemove == true)
{
RelayConnectedServicesManager.AddOrUpdate(serviceInfo);
}
else
{
RelayConnectedServicesManager.Remove(serviceInfo.Url);
}
var requestHeaderLength = HttpCommon.BufferOkHeader(buffer);
await incommingStream.WriteAsync(buffer.Slice(0, requestHeaderLength), cancellationToken);
await incommingStream.FlushAsync();
await incommingStream.DisposeAsync();
incommingStream = null;
client.Dispose();
return;
}
break;
}
default: throw new NotImplementedException();
}
while (outgoingClient == null)
{
service = RelayConnectedServicesManager.GetBestService(providerType);
if (service == null)
{
break;
}
try
{
_ = Log.TraceAsync($"Relaying {providerType} to {service.Url}");
var outgoingEndpoint = IPResolver.GetIPEndPoints(service.Url, 80).First();
if (outgoingEndpoint != null)
{
outgoingClient = new TcpClient(outgoingEndpoint.AddressFamily);
outgoingClient.NoDelay = true;
await outgoingClient.ConnectAsync(outgoingEndpoint.Address, outgoingEndpoint.Port);
service.FlagConnectionSuccess();
}
else
{
service.FlagConnectionFailed();
}
}
catch
{
service.FlagConnectionFailed();
}
}
if (outgoingClient == null)
{
_ = Log.TraceAsync($"Destination not found {providerType}");
switch (protocolType.Value)
{
case CQRSProtocolType.TcpRaw:
{
var requestHeaderLength = HttpCommon.BufferNotFoundHeader(buffer);
await incommingStream.WriteAsync(buffer.Slice(0, requestHeaderLength));
return;
}
case CQRSProtocolType.Http:
{
var requestHeaderLength = TcpRawCommon.BufferErrorHeader(buffer, null, default);
await incommingStream.WriteAsync(buffer.Slice(0, requestHeaderLength));
return;
}
default: throw new NotImplementedException();
}
}
outgoingStream = outgoingClient.GetStream();
stopwatch = service.StartRequestRunning();
responseStarted = true;
await outgoingStream.WriteAsync(buffer.Slice(0, headerPosition), cancellationToken);
switch (protocolType.Value)
{
case CQRSProtocolType.TcpRaw:
{
outgoingWritingBodyStream = new TcpRawProtocolBodyStream(outgoingStream, null, true);
await incommingBodyStream.CopyToAsync(outgoingWritingBodyStream, cancellationToken);
await outgoingWritingBodyStream.FlushAsync();
break;
}
case CQRSProtocolType.Http:
{
outgoingWritingBodyStream = new HttpProtocolBodyStream(null, outgoingStream, null, true);
await incommingBodyStream.CopyToAsync(outgoingWritingBodyStream, cancellationToken);
await outgoingWritingBodyStream.FlushAsync();
break;
}
default: throw new NotImplementedException();
}
await incommingBodyStream.DisposeAsync();
incommingBodyStream = null;
await outgoingWritingBodyStream.DisposeAsync();
outgoingWritingBodyStream = null;
//Response
//-----------------------------------------------------------------------------------------------------------------------
headerPosition = 0;
headerLength = 0;
headerEnd = false;
switch (protocolType.Value)
{
case CQRSProtocolType.TcpRaw:
{
while (!headerEnd)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(TcpRelay)} Header Too Long");
}
headerLength += await outgoingStream.ReadAsync(buffer.Slice(headerLength, buffer.Length - headerLength));
headerEnd = TcpRawCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
}
outgoingBodyStream = new TcpRawProtocolBodyStream(outgoingStream, buffer.Slice(headerPosition, headerLength - headerPosition), false);
break;
}
case CQRSProtocolType.Http:
{
while (!headerEnd)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(TcpRelay)} Header Too Long");
}
headerLength += await outgoingStream.ReadAsync(buffer.Slice(headerLength, buffer.Length - headerLength));
headerEnd = HttpCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
}
var header = HttpCommon.ReadHeader(buffer, headerPosition, headerLength);
outgoingBodyStream = new HttpProtocolBodyStream(header.ContentLength, outgoingStream, header.BodyStartBuffer, false);
break;
}
}
await incommingStream.WriteAsync(buffer.Slice(0, headerPosition), cancellationToken);
switch (protocolType.Value)
{
case CQRSProtocolType.TcpRaw:
{
incommingWritingBodyStream = new TcpRawProtocolBodyStream(incommingStream, null, false);
await outgoingBodyStream.CopyToAsync(incommingWritingBodyStream, cancellationToken);
await incommingWritingBodyStream.FlushAsync();
break;
}
case CQRSProtocolType.Http:
{
incommingWritingBodyStream = new HttpProtocolBodyStream(null, incommingStream, null, false);
await outgoingBodyStream.CopyToAsync(incommingWritingBodyStream, cancellationToken);
await incommingWritingBodyStream.FlushAsync();
break;
}
default: throw new NotImplementedException();
}
await outgoingBodyStream.DisposeAsync();
outgoingBodyStream = null;
await incommingWritingBodyStream.DisposeAsync();
incommingWritingBodyStream = null;
outgoingClient.Dispose();
client.Dispose();
}
catch (Exception ex)
{
if (ex is IOException ioException)
{
if (ioException.InnerException != null && ioException.InnerException is SocketException socketException)
{
if (socketException.SocketErrorCode == SocketError.ConnectionAborted)
{
return;
}
}
}
_ = Log.ErrorAsync(null, ex);
if (!responseStarted && incommingStream != null && protocolType.HasValue)
{
try
{
switch (protocolType.Value)
{
case CQRSProtocolType.TcpRaw:
{
var requestHeaderLength = HttpCommon.BufferErrorHeader(buffer, null);
await incommingStream.WriteAsync(buffer.Slice(0, requestHeaderLength), cancellationToken);
break;
}
case CQRSProtocolType.Http:
{
var requestHeaderLength = TcpRawCommon.BufferErrorHeader(buffer, null, default);
await incommingStream.WriteAsync(buffer.Slice(0, requestHeaderLength), cancellationToken);
break;
}
default: throw new NotImplementedException();
}
}
catch (Exception ex2)
{
_ = Log.ErrorAsync(null, ex2);
}
}
if (outgoingWritingBodyStream != null)
{
await outgoingWritingBodyStream.DisposeAsync();
}
if (outgoingBodyStream != null)
{
await outgoingBodyStream.DisposeAsync();
}
if (outgoingStream != null)
{
await outgoingStream.DisposeAsync();
}
if (incommingWritingBodyStream != null)
{
await incommingWritingBodyStream.DisposeAsync();
}
if (incommingBodyStream != null)
{
await incommingBodyStream.DisposeAsync();
}
if (incommingStream != null)
{
await incommingStream.DisposeAsync();
}
if (outgoingClient != null)
{
outgoingClient.Dispose();
}
client.Dispose();
}
finally
{
BufferArrayPool <byte> .Return(bufferOwner);
if (service != null && stopwatch != null)
{
service.EndRequestRunning(stopwatch);
}
}
}
