public WsnProtocolAdapter(PiraeusConfig config, GraphManager graphManager, IChannel channel, HttpContext context, ILog logger = null)
{
this.config = config;
this.graphManager = graphManager;
this.Channel = channel;
this.logger = logger;
IdentityDecoder decoder = new IdentityDecoder(config.ClientIdentityNameClaimType, context, config.GetClientIndexes());
identity = decoder.Id;
localIndexes = decoder.Indexes;
MessageUri messageUri = new MessageUri(context.Request);
this.contentType = messageUri.ContentType;
this.cacheKey = messageUri.CacheKey;
this.resource = messageUri.Resource;
this.subscriptions = messageUri.Subscriptions != null ? new List <string>(messageUri.Subscriptions) : null;
this.indexes = messageUri.Indexes != null ? new List <KeyValuePair <string, string> >(messageUri.Indexes) : null;
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol"))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"), AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User);
}
else if (config.AuditConnectionString != null)
{
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User);
}
messageAuditor = auditFactory.GetAuditor(AuditType.Message);
userAuditor = auditFactory.GetAuditor(AuditType.User);
}
private static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureWebHost((options) =>
{
options.UseStartup <Startup>();
options.UseKestrel();
options.ConfigureKestrel(options =>
{
PiraeusConfig config = GetPiraeusConfig();
options.Limits.MaxConcurrentConnections = config.MaxConnections;
options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections;
options.Limits.MaxRequestBodySize = config.MaxBufferSize;
options.Limits.MinRequestBodyDataRate =
new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
options.Limits.MinResponseDataRate =
new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
if (!string.IsNullOrEmpty(config.ServerCertificateFilename))
{
Console.WriteLine("Port for cert with filename");
options.ListenAnyIP(config.GetPorts()[0], (a) => a.UseHttps(config.ServerCertificateFilename, config.ServerCertificatePassword));
}
else if (!string.IsNullOrEmpty(config.ServerCertificateStore))
{
Console.WriteLine("Port for cert with store");
X509Certificate2 cert = config.GetServerCerticate();
options.ListenAnyIP(config.GetPorts()[0], (a) => a.UseHttps(cert));
}
else
{
Console.WriteLine("Hard coded port 8081");
options.ListenAnyIP(8081);
}
});
});
private void InitializeAuditor(PiraeusConfig config)
{
if (!string.IsNullOrEmpty(config.AuditConnectionString) &&
AuditFactory.CreateSingleton().GetAuditor(AuditType.User) == null)
{
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString.ToLowerInvariant().Contains("AccountName="))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "messageaudit"),
AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString, "useraudit"), AuditType.User);
}
else
{
string pathString =
config.AuditConnectionString.LastIndexOf("/") == config.AuditConnectionString.Length - 1
? config.AuditConnectionString
: config.AuditConnectionString + "/";
auditFactory.Add(new FileAuditor(string.Format($"{pathString}messageaudit.txt")),
AuditType.Message);
auditFactory.Add(new FileAuditor(string.Format($"{pathString}useraudit.txt")), AuditType.User);
}
}
}
public static ILoggingBuilder AddLogging(this ILoggingBuilder builder, PiraeusConfig config)
{
LoggerType loggerTypes = config.GetLoggerTypes();
//if (loggerTypes.HasFlag(LoggerType.None))
//{
// return builder;
//}
LogLevel logLevel = Enum.Parse <LogLevel>(config.LogLevel, true);
if (loggerTypes.HasFlag(LoggerType.Console))
{
builder.AddConsole();
}
if (loggerTypes.HasFlag(LoggerType.Debug))
{
builder.AddDebug();
}
builder.SetMinimumLevel(logLevel);
return(builder);
}
public CoapProtocolAdapter(PiraeusConfig config, IAuthenticator authenticator, IChannel channel, ILogger logger, HttpContext context = null)
{
this.context = context;
this.logger = logger;
CoapConfigOptions options = config.ObserveOption && config.NoResponseOption ? CoapConfigOptions.Observe | CoapConfigOptions.NoResponse : config.ObserveOption ? CoapConfigOptions.Observe : config.NoResponseOption ? CoapConfigOptions.NoResponse : CoapConfigOptions.None;
CoapConfig coapConfig = new CoapConfig(authenticator, config.CoapAuthority, options, config.AutoRetry,
config.KeepAliveSeconds, config.AckTimeoutSeconds, config.AckRandomFactor,
config.MaxRetransmit, config.NStart, config.DefaultLeisure, config.ProbingRate, config.MaxLatencySeconds);
coapConfig.IdentityClaimType = config.ClientIdentityNameClaimType;
coapConfig.Indexes = config.GetClientIndexes();
InitializeAuditor(config);
Channel = channel;
Channel.OnClose += Channel_OnClose;
Channel.OnError += Channel_OnError;
Channel.OnOpen += Channel_OnOpen;
Channel.OnReceive += Channel_OnReceive;
Channel.OnStateChange += Channel_OnStateChange;
session = new CoapSession(coapConfig, context);
if (Channel.State != ChannelState.Open)
{
Channel.OpenAsync().GetAwaiter();
Channel.ReceiveAsync();
}
}
public HttpResponseMessage Get()
{
try
{
SkunkLab.Security.Authentication.BasicAuthenticator authn = new SkunkLab.Security.Authentication.BasicAuthenticator();
HttpContext context = HttpContext.Current;
if (context.IsWebSocketRequest ||
context.IsWebSocketRequestUpgrading)
{
PiraeusConfig config = Piraeus.Configuration.PiraeusConfigManager.Settings;
adapter = ProtocolAdapterFactory.Create(config, Request, source.Token);
adapter.OnClose += Adapter_OnClose;
adapter.OnError += Adapter_OnError;
adapter.Init();
return(new HttpResponseMessage(HttpStatusCode.SwitchingProtocols));
}
else //long polling
{
adapter = ProtocolAdapterFactory.Create(config, Request, source.Token);
adapter.OnObserve += Adapter_OnObserve;
adapter.Init();
ThreadPool.QueueUserWorkItem(new WaitCallback(Listen), waitHandles[0]);
WaitHandle.WaitAll(waitHandles);
return(response);
}
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public void ConfigureServices(IServiceCollection services)
{
pconfig = GetPiraeusConfig();
config = GetOrleansConfig();
//services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
.AddJwtBearer(options =>
{
options.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = !string.IsNullOrEmpty(pconfig.ClientIssuer),
ValidateAudience = !string.IsNullOrEmpty(pconfig.ClientAudience),
ValidateLifetime = true,
ValidateIssuerSigningKey = true,
ValidIssuer = pconfig.ClientIssuer,
ValidAudience = pconfig.ClientAudience,
ClockSkew = TimeSpan.FromMinutes(5.0),
IssuerSigningKey = new SymmetricSecurityKey(Convert.FromBase64String(pconfig.ClientSymmetricKey))
};
});
services.AddSingleton <PiraeusConfig>(pconfig);
services.AddSingleton <IClusterClient>(CreateClusterClient);
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
//services.AddPiraeusWebSocket();
services.AddRouting();
services.AddMvcCore();
}
private static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>()
.UseKestrel(options =>
{
PiraeusConfig config = GetPiraeusConfig();
options.Limits.MaxConcurrentConnections = config.MaxConnections;
options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections;
options.Limits.MaxRequestBodySize = config.MaxBufferSize;
options.Limits.MinRequestBodyDataRate =
new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
options.Limits.MinResponseDataRate =
new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
X509Certificate2 cert = config.GetServerCerticate();
int[] ports = config.GetPorts();
foreach (int port in ports)
{
if (cert != null)
{
options.ListenAnyIP(port, (a) => a.UseHttps(cert));
}
else
{
options.ListenAnyIP(port);
}
}
});
public ManageController(PiraeusConfig config, IClusterClient client)
{
this.config = config;
if (!GraphManager.IsInitialized)
{
GraphManager.Initialize(client);
}
}
public UdpGatewayHost(PiraeusConfig config, OrleansConfig orleansConfig, Logger logger)
{
this.config = config;
this.orleansConfig = orleansConfig;
this.logger = logger;
sources = new Dictionary <int, CancellationTokenSource>();
listeners = new Dictionary <int, UdpServerListener>();
}
public PiraeusHttpMiddleware(RequestDelegate next, PiraeusConfig config, IClusterClient client)
{
_next = next;
this.config = config;
if (!GraphManager.IsInitialized)
{
GraphManager.Initialize(client);
}
}
public PiraeusWebSocketMiddleware(RequestDelegate next, PiraeusConfig config, IClusterClient client, Logger logger, IOptions <WebSocketOptions> options)
{
container = new Dictionary <string, ProtocolAdapter>();
_next = next;
_options = options.Value;
this.config = config;
this.graphManager = new GraphManager(client);
this.logger = logger;
}
public TcpGatewayService(PiraeusConfig piraeusConfig, IClusterClient clusterClient, ILogger <TcpGatewayService> logger = null)
{
this.config = piraeusConfig;
this.clusterClient = clusterClient;
this.logger = logger;
if (!GraphManager.IsInitialized)
{
GraphManager.Initialize(this.clusterClient);
}
}
public static IConfigurationBuilder AddPiraeusConfiguration(this IConfigurationBuilder configure, out PiraeusConfig piraeusConfig)
{
configure.AddJsonFile("./piraeusconfig.json")
.AddEnvironmentVariables("PI_");
IConfigurationRoot root = configure.Build();
piraeusConfig = new PiraeusConfig();
ConfigurationBinder.Bind(root, piraeusConfig);
return(configure);
}
public PiraeusWebSocketMiddleware(RequestDelegate next, PiraeusConfig config, IClusterClient client, IOptions <WebSocketOptions> options)
{
_next = next;
_options = options.Value;
this.config = config;
if (!GraphManager.IsInitialized)
{
GraphManager.Initialize(client);
}
}
public ConnectController(PiraeusConfig config, IClusterClient client, ILogger logger)
{
this.config = config;
BasicAuthenticator basicAuthn = new BasicAuthenticator();
SkunkLab.Security.Tokens.SecurityTokenType tokenType = Enum.Parse <SkunkLab.Security.Tokens.SecurityTokenType>(config.ClientTokenType, true);
basicAuthn.Add(tokenType, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience);
authn = basicAuthn;
this.graphManager = new GraphManager(client);
this.logger = logger;
}
public static ProtocolAdapter Create(PiraeusConfig config, GraphManager graphManager,
IAuthenticator authenticator, TcpClient client, ILog logger = null, CancellationToken token = default)
{
TlsPskIdentityManager pskManager = null;
if (!string.IsNullOrEmpty(config.PskStorageType))
{
if (config.PskStorageType.ToLowerInvariant() == "redis")
{
pskManager = TlsPskIdentityManagerFactory.Create(config.PskRedisConnectionString);
}
if (config.PskStorageType.ToLowerInvariant() == "keyvault")
{
pskManager = TlsPskIdentityManagerFactory.Create(config.PskKeyVaultAuthority,
config.PskKeyVaultClientId, config.PskKeyVaultClientSecret);
}
if (config.PskStorageType.ToLowerInvariant() == "environmentvariable")
{
pskManager = TlsPskIdentityManagerFactory.Create(config.PskIdentities, config.PskKeys);
}
}
IChannel channel;
if (pskManager != null)
{
channel = ChannelFactory.Create(config.UsePrefixLength, client, pskManager, config.BlockSize,
config.MaxBufferSize, token);
}
else
{
channel = ChannelFactory.Create(config.UsePrefixLength, client, config.BlockSize, config.MaxBufferSize,
token);
}
IPEndPoint localEP = (IPEndPoint)client.Client.LocalEndPoint;
int port = localEP.Port;
if (port == 5684)
{
return(new CoapProtocolAdapter(config, graphManager, authenticator, channel, logger));
}
if (port == 1883 || port == 8883)
{
return(new MqttProtocolAdapter(config, graphManager, authenticator, channel, logger));
}
throw new ProtocolAdapterPortException("TcpClient port does not map to a supported protocol.");
}
private static PiraeusConfig GetPiraeusConfig()
{
var builder = new ConfigurationBuilder()
.AddJsonFile(Environment.CurrentDirectory + "\\piraeusconfig.json")
.AddEnvironmentVariables("PI_");
IConfigurationRoot root = builder.Build();
PiraeusConfig config = new PiraeusConfig();
ConfigurationBinder.Bind(root, config);
return(config);
}
internal static PiraeusConfig GetPiraeusConfig()
{
var builder = new ConfigurationBuilder()
.AddJsonFile("./piraeusconfig.json")
.AddEnvironmentVariables("PI_");
IConfigurationRoot root = builder.Build();
PiraeusConfig config = new PiraeusConfig();
root.Bind(config);
return(config);
}
private PiraeusConfig GetPiraeusConfig()
{
var builder = new ConfigurationBuilder()
.AddJsonFile("./piraeusconfig.json")
.AddEnvironmentVariables("PI_");
IConfigurationRoot root = builder.Build();
PiraeusConfig pc = new PiraeusConfig();
ConfigurationBinder.Bind(root, pc);
return(pc);
}
public CoapRequestDispatcher(CoapSession session, IChannel channel, PiraeusConfig config, GraphManager graphManager, ILog logger = null)
{
this.channel = channel;
this.session = session;
this.config = config;
this.graphManager = graphManager;
this.logger = logger;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
coapObserved = new Dictionary <string, byte[]>();
coapUnobserved = new HashSet <string>();
adapter = new OrleansAdapter(session.Identity, channel.TypeId, "CoAP", graphManager, logger);
adapter.OnObserve += Adapter_OnObserve;
LoadDurablesAsync().LogExceptions(logger);
}
public UdpServerListener(PiraeusConfig config, IPEndPoint localEP, CancellationToken token)
{
this.config = config;
this.localEP = localEP;
this.token = token;
cache = new Dictionary <string, Tuple <ProtocolAdapter, CancellationTokenSource> >();
container = new Dictionary <string, string>();
SecurityTokenType stt = System.Enum.Parse <SecurityTokenType>(config.ClientTokenType, true);
BasicAuthenticator bauthn = new BasicAuthenticator();
bauthn.Add(stt, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience);
authn = bauthn;
}
public static IServiceCollection AddPiraeusConfiguration(this IServiceCollection services)
{
IConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddJsonFile(Environment.CurrentDirectory + "\\piraeusconfig.json")
.AddEnvironmentVariables("PI_");
IConfigurationRoot root = builder.Build();
PiraeusConfig config = new PiraeusConfig();
ConfigurationBinder.Bind(root, config);
services.AddSingleton <PiraeusConfig>(config);
return(services);
}
public void ConfigureServices(IServiceCollection services)
{
OrleansConfig oconfig = null;
PiraeusConfig pconfig = null;
//LoggerFactory loggerFactory = new LoggerFactory();
IConfigurationBuilder configBuilder = new ConfigurationBuilder();
configBuilder.AddOrleansConfiguration(out oconfig);
configBuilder.AddPiraeusConfiguration(out pconfig);
PiraeusGatewayOptions pgo = new PiraeusGatewayOptions(oconfig);
//services.AddGatewayService(typeof(TcpGatewayService), null);
//services.AddOrleansConfiguration();
//services.AddPiraeusConfiguration();
//services.AddOrleansClusterClient(loggerFactory, options => options.IsLocal = false);
IServiceProvider sp = services.BuildServiceProvider();
LoggerType loggerType = oconfig.GetLoggerTypes();
if (!loggerType.HasFlag(LoggerType.None))
{
services.AddLogging(builder =>
{
if (loggerType.HasFlag(LoggerType.Console))
{
builder.AddConsole();
}
if (loggerType.HasFlag(LoggerType.Debug))
{
builder.AddDebug();
}
if (loggerType.HasFlag(LoggerType.AppInsights) && !string.IsNullOrEmpty(oconfig.AppInsightsKey))
{
builder.AddApplicationInsights(oconfig.AppInsightsKey);
}
builder.SetMinimumLevel(LogLevel.Warning);
});
}
TcpGatewayService tgs = sp.GetRequiredService <TcpGatewayService>();
tgs.Init(oconfig.Dockerized);
//services.AddSingleton<TcpGatewayService>((f) => f.GetRequiredService<TcpGatewayService>());
}
public ConnectController(PiraeusConfig config, IClusterClient client)
{
this.config = config;
BasicAuthenticator basicAuthn = new BasicAuthenticator();
SkunkLab.Security.Tokens.SecurityTokenType tokenType = Enum.Parse<SkunkLab.Security.Tokens.SecurityTokenType>(config.ClientTokenType, true);
basicAuthn.Add(tokenType, config.ClientSymmetricKey, config.ClientIssuer, config.ClientAudience);
authn = basicAuthn;
if (!GraphManager.IsInitialized)
{
GraphManager.Initialize(client);
}
}
public static IServiceCollection AddPiraeusConfiguration(this IServiceCollection services,
out PiraeusConfig config)
{
IConfigurationBuilder builder = new ConfigurationBuilder();
builder.AddJsonFile("./piraeusconfig.json")
.AddEnvironmentVariables("PI_");
IConfigurationRoot root = builder.Build();
config = new PiraeusConfig();
root.Bind(config);
services.AddSingleton(config);
return(services);
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
return(Host.CreateDefaultBuilder(args)
.ConfigureServices(services => services.AddPiraeusConfiguration())
.ConfigureWebHostDefaults(webBuilder =>
{
PiraeusConfig config = WebApiHelpers.GetPiraeusConfig();
webBuilder
.ConfigureKestrel(options =>
{
options.Limits.MaxConcurrentConnections = config.MaxConnections;
options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections;
options.Limits.MaxRequestBodySize = config.MaxBufferSize;
options.Limits.MinRequestBodyDataRate =
new MinDataRate(100, TimeSpan.FromSeconds(10));
options.Limits.MinResponseDataRate =
new MinDataRate(100, TimeSpan.FromSeconds(10));
X509Certificate2 cert = config.GetServerCerticate();
int[] ports = config.GetPorts();
foreach (int port in ports)
{
if (cert != null)
{
options.ListenAnyIP(port, a => a.UseHttps(cert));
}
else
{
IPAddress address = GetIPAddress(Dns.GetHostName());
options.Listen(address, port);
}
}
if (!string.IsNullOrEmpty(config.ServerCertificateFilename))
{
string[] portStrings = config.Ports.Split(";", StringSplitOptions.RemoveEmptyEntries);
foreach (string portString in portStrings)
{
options.ListenAnyIP(Convert.ToInt32(portString),
a => a.UseHttps(config.ServerCertificateFilename,
config.ServerCertificatePassword));
}
}
});
webBuilder.UseStartup <Startup>();
}));
}
/// <summary>
/// Create protocol adapter for rest service or Web socket
/// </summary>
/// <param name="config"></param>
/// <param name="request"></param>
/// <param name="token"></param>
/// <param name="authenticator"></param>
/// <returns></returns>
public static ProtocolAdapter Create(PiraeusConfig config, HttpContext context, ILogger logger = null, IAuthenticator authenticator = null, CancellationToken token = default(CancellationToken))
{
IChannel channel = null;
//HttpContext context = HttpContext.Current;
//if (context.IsWebSocketRequest ||
// context.IsWebSocketRequestUpgrading)
//if (HttpHelper.HttpContext.WebSockets.IsWebSocketRequest)
if (context.WebSockets.IsWebSocketRequest)
{
//WebSocketConfig webSocketConfig = GetWebSocketConfig(config);
WebSocketConfig webSocketConfig = new WebSocketConfig(config.MaxBufferSize, config.BlockSize, config.BlockSize);
channel = ChannelFactory.Create(context, webSocketConfig, token);
//channel = ChannelFactory.Create(request, webSocketConfig, token);
//if (context.WebSocketRequestedProtocols.Contains("mqtt"))
if (context.WebSockets.WebSocketRequestedProtocols.Contains("mqtt"))
{
return(new MqttProtocolAdapter(config, authenticator, channel, logger));
}
else if (context.WebSockets.WebSocketRequestedProtocols.Contains("coapv1")) //(context.WebSocketRequestedProtocols.Contains("coapv1"))
{
return(new CoapProtocolAdapter(config, authenticator, channel, logger));
}
//else if (context.WebSocketRequestedProtocols.Count == 0)
//{
// //wsn protocol
// //return new WsnProtocolAdapter(config, channel);
//}
else
{
throw new InvalidOperationException("invalid web socket subprotocol");
}
}
//if (request.Method != HttpMethod.Post && request.Method != HttpMethod.Get)
if (context.Request.Method.ToUpperInvariant() != "POST" && context.Request.Method.ToUpperInvariant() != "GET")
{
throw new HttpRequestException("Protocol adapter requires HTTP get or post.");
}
else
{
//channel = ChannelFactory.Create(request);
channel = ChannelFactory.Create(context);
return(new RestProtocolAdapter(config, channel, context, logger));
}
}
private void InitializeAuditor(PiraeusConfig config)
{
auditFactory = AuditFactory.CreateSingleton();
if (config.AuditConnectionString != null && config.AuditConnectionString.Contains("DefaultEndpointsProtocol"))
{
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new AzureTableAuditor(config.AuditConnectionString), AuditType.User);
}
else if (config.AuditConnectionString != null)
{
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.Message);
auditFactory.Add(new FileAuditor(config.AuditConnectionString), AuditType.User);
}
userAuditor = auditFactory.GetAuditor(AuditType.User);
}
public static IWebHostBuilder CreateWebHostBuilder(string[] args) =>
WebHost.CreateDefaultBuilder(args)
.UseStartup <Startup>()
.UseKestrel(options =>
{
PiraeusConfig config = GetPiraeusConfig();
options.Limits.MaxConcurrentConnections = config.MaxConnections;
options.Limits.MaxConcurrentUpgradedConnections = config.MaxConnections;
options.Limits.MaxRequestBodySize = config.MaxBufferSize;
options.Limits.MinRequestBodyDataRate =
new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
options.Limits.MinResponseDataRate =
new MinDataRate(bytesPerSecond: 100, gracePeriod: TimeSpan.FromSeconds(10));
X509Certificate2 cert = config.GetServerCerticate();
int[] ports = config.GetPorts();
foreach (int port in ports)
{
if (cert != null)
{
options.ListenAnyIP(port, (a) => a.UseHttps(cert));
}
else
{
IPAddress address = GetIPAddress(Dns.GetHostName());
options.Listen(address, port);
//options.Listen(IPAddress.Loopback, port);
//options.ListenAnyIP(port);
}
}
if (!string.IsNullOrEmpty(config.ServerCertificateFilename))
{
string[] portStrings = config.Ports.Split(";", StringSplitOptions.RemoveEmptyEntries);
foreach (var portString in portStrings)
{
options.ListenAnyIP(Convert.ToInt32(portString), (a) => a.UseHttps(config.ServerCertificateFilename, config.ServerCertificatePassword));
}
}
//else
//{
// options.ListenAnyIP(config.Channels.Http.ListenPort, (a) => a.UseHttps(".\\localhost.pfx", "pass@word1"));
//}
});
