#pragma warning restore IDE0052 // Remove unread private members /// <summary> /// Initializes a new instance of the <see cref="MllpServer"/> class. /// </summary> /// <param name="endPoint">The <see cref="IPEndPoint"/> the server will listen on.</param> /// <param name="messageLog">The <see cref="IMessageLog"/> to use for logging incoming messages.</param> /// <param name="middleware">The message handling middleware.</param> /// <param name="cleanupInterval">The interval between cleaning up client connections.</param> /// <param name="parser">The <see cref="PipeParser"/> to use for parsing and encoding.</param> /// <param name="encoding">The <see cref="Encoding"/> to use for network transfers.</param> /// <param name="serverCertificate">The certificates to use for secure connections.</param> /// <param name="userCertificateValidationCallback">Optional certificate validation callback.</param> public MllpServer( IPEndPoint endPoint, IMessageLog messageLog, IHl7MessageMiddleware middleware, TimeSpan cleanupInterval = default, PipeParser?parser = null, Encoding?encoding = null, X509Certificate?serverCertificate = null, RemoteCertificateValidationCallback?userCertificateValidationCallback = null) { _messageLog = messageLog; _middleware = middleware; _parser = parser; _encoding = encoding ?? Encoding.ASCII; _serverCertificate = serverCertificate; _userCertificateValidationCallback = userCertificateValidationCallback; _listener = new TcpListener(endPoint); cleanupInterval = cleanupInterval == default ? TimeSpan.FromSeconds(5) : cleanupInterval; _timer = new Timer( CleanConnections, null, cleanupInterval, cleanupInterval); }
private readonly IDisposable _server; public IheHttpServer(IEnumerable <string> urls, IHl7MessageMiddleware middleware) { _middleware = middleware; var startOptions = new StartOptions(); foreach (var url in urls) { startOptions.Urls.Add(url); } _server = WebApp.Start(startOptions, a => { a.Run(async ctx => { using (var reader = new StreamReader(ctx.Request.Body)) { var hl7 = await reader.ReadToEndAsync().ConfigureAwait(false); var response = await _middleware.Handle(new Hl7Message(hl7, ctx.Request.RemoteIpAddress)) .ConfigureAwait(false); if (!string.IsNullOrWhiteSpace(response)) { var owinResponse = ctx.Response; owinResponse.ContentType = "application/hl7-v2"; owinResponse.StatusCode = 200; using (var writer = new StreamWriter(owinResponse.Body)) { await writer.WriteAsync(response).ConfigureAwait(false); } } } }); }); }
private MllpHost(TcpClient client, Encoding encoding, IHl7MessageMiddleware middleware, Stream stream, CancellationToken cancellationToken) { _client = client; _encoding = encoding; _middleware = middleware; _stream = stream; _token = cancellationToken; }
public MllpServer(ServerConnectionDetails connectionDetails, IHl7MessageMiddleware middleware, CancellationToken cancellationToken = default(CancellationToken)) { IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse(connectionDetails.Address), connectionDetails.Port); _token = cancellationToken; _connectionDetails = connectionDetails; _middleware = middleware; _listener = new TcpListener(endPoint); _timer = new Timer(CleanConnections, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5)); }
#pragma warning restore IDE0052 // Remove unread private members private MllpHost( TcpClient client, IMessageLog messageLog, PipeParser parser, Encoding encoding, IHl7MessageMiddleware middleware) { _client = client; _messageLog = messageLog; _parser = parser; _encoding = encoding; _middleware = middleware; }
public IheHttpServer(IEnumerable <string> urls, IHl7MessageMiddleware middleware, ParserBase parser) { _server = new TestServer(new WebHostBuilder() .UseUrls(urls.ToArray()) .Configure(a => { a.Use(async(HttpContext ctx, RequestDelegate next) => { var charset = ctx.Request.ContentType?.Contains(';') == true ? ctx.Request.ContentType ?.Split( ';', StringSplitOptions .RemoveEmptyEntries) .Last() .Replace( "charset=", "", StringComparison .InvariantCultureIgnoreCase) .Trim() : null; var encoding = string.IsNullOrWhiteSpace(charset) ? Encoding.ASCII : Encoding.GetEncoding(charset); var reader = ctx.Request.BodyReader; var hl7 = await reader.ReadAsync().ConfigureAwait(false); var msg = parser.Parse(encoding.GetString(hl7.Buffer.ToArray())); var response = await middleware.Handle(new Hl7Message(msg, ctx.Connection.RemoteIpAddress?.ToString() ?? string.Empty)) .ConfigureAwait(false); var owinResponse = ctx.Response; owinResponse.StatusCode = (int)HttpStatusCode.OK; owinResponse.ContentType = "application/hl7-v2; charset=" + encoding.WebName; var output = parser.Encode(response); await owinResponse.BodyWriter.WriteAsync( encoding.GetBytes(output) .AsMemory()).ConfigureAwait(false); await owinResponse.CompleteAsync().ConfigureAwait(false); }); })); }
public static async Task <MllpHost> Create( TcpClient tcpClient, IMessageLog messageLog, IHl7MessageMiddleware middleware, PipeParser?parser = null, Encoding?encoding = null, X509Certificate?serverCertificate = null, RemoteCertificateValidationCallback? userCertificateValidationCallback = null) { var host = new MllpHost( tcpClient, messageLog, parser ?? new PipeParser(), encoding ?? Encoding.ASCII, middleware); Stream stream = tcpClient.GetStream(); if (serverCertificate != null) { var ssl = new SslStream( stream, false, userCertificateValidationCallback); await ssl.AuthenticateAsServerAsync( serverCertificate, true, SslProtocols.Tls11 | SslProtocols.Tls12, false) .ConfigureAwait(false); host._stream = ssl; } else { host._stream = stream; } host._readThread = host.ReadStream(host._tokenSource.Token); return(host); }
public static async Task <MllpHost> Create(TcpClient tcpClient, IHl7MessageMiddleware middleware, Encoding encoding = null, ServerSecurityDetails securityDetails = null, CancellationToken cancellationToken = default(CancellationToken)) { Stream stream; NetworkStream networkStream = tcpClient.GetStream(); if (securityDetails != null) { var sslStream = new SslStream(networkStream, true, securityDetails.ClientCertificateValidationCallback, null); try { bool askForClientCertificate = securityDetails.ForceClientAuthentciation; await sslStream.AuthenticateAsServerAsync(securityDetails.ServerCertificate, askForClientCertificate, securityDetails.SupportedSslProtocols, false); if (askForClientCertificate && !sslStream.IsMutuallyAuthenticated) { throw new AuthenticationException("mutual authentication failed."); } } catch (Exception) { sslStream.Dispose(); throw; } stream = sslStream; } else { stream = networkStream; } var host = new MllpHost(tcpClient, encoding ?? Encoding.ASCII, middleware, stream, cancellationToken); host.ReadStream(host._token); return(host); }
public MllpServer CreateServerConnection(ServerConnectionDetails connectionDetails, IHl7MessageMiddleware middleware) { return(new MllpServer(connectionDetails, middleware)); }