fix TLS proxy scenario (#802) #804

wolfkor · 2025-04-02T21:30:05Z

Fix for #802

mtmk · 2025-04-02T21:36:11Z

src/NATS.Client.Core/Internal/TcpConnection.cs

-    {
-    }
-}
+internal sealed class SocketClosedException(Exception? innerException) : Exception("Socket has been closed.", innerException);


please rollback all the formatting changes. makes the review quite difficult. thanks.

hope it is easier now

mtmk · 2025-04-03T15:25:52Z

src/NATS.Client.Core/Internal/TcpConnection.cs

 #else
-            await _socket.ConnectAsync(host, port, cts.Token).ConfigureAwait(false);
+                await _socket.ConnectAsync(proxyOpts.Host, proxyOpts.Port, cts.Token).ConfigureAwait(false);


if this is giving the ability to swap out the host:port on top of the callback, can you also use OnConnectingAsync to take care of this swap instead?

nats.net/src/NATS.Client.Core/NatsConnection.cs

Line 137 in 70d65fe

public Func<(string Host, int Port), ValueTask<(string Host, int Port)>>? OnConnectingAsync { get; set; }

Isn't OnConnectingAsync intended for swaping the bus address? Why would it be needed for the proxy address as well?

just trying to understand if we can use OnConnectingAsync + OnSocketThing instead of this change.

No, because OnConnecting would require the socket for the proxy, which is created afterward. Furthermore, you would also have to consider the WebSocket case.
I even considered deleting OnSocketAvailable again. But I wasn't sure if there were other scenarios besides proxy where it would make sense.

mtmk · 2025-04-03T15:29:38Z

src/NATS.Client.Core/Internal/TcpConnection.cs

+                {
+                    // Create the CONNECT request with proxy authentication
+                    var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(proxyOpts.Auth));
+                    connectAuth = $"Proxy-Authorization: Basic {auth}\r\n";


other auth methods? Would there be other headers we need to think of?

I've thought about that, too. In my experience with our customers so far, I haven't encountered any other options, but there are certainly other proxy authentication options. Do you have a complete list of the methods to be supported here?

I don't. my concern is how we'd support this going forward. maybe we can have a callback instead?

That would be possible. But I think every methodology has its own fixed format. For additional methods, I would extend properties in NatsProxyOpts. Do you want to leave that entirely up to the user?

Not sure. what's your take? I think if we can support it with reasonable confidence just setting up the proxy host and port would be easy for the application. then the edge cases would require a mew release. (btw we must think of the security implications as well)

mtmk · 2025-04-03T15:30:38Z

src/NATS.Client.Core/Internal/TcpConnection.cs

+                // Validate proxy response
+                var receiveBuffer = new byte[4096];
+                var read = await ReceiveAsync(receiveBuffer).ConfigureAwait(false);
+                var response = Encoding.UTF8.GetString(receiveBuffer, 0, read);


this needs to read the response until whatever. can't rely on a single read which might not return the whole response.

I don't really understand what you're getting at? Isn't the code almost identical to your final example for OnSocketAvailableAsync from #647?

that was just an example. you need to check the read count and read more if you need more etc. e.g. you might only get part of the message 200 Connec first time, then the next.

caleblloyd · 2025-04-05T01:30:50Z

What protocols are you trying to proxy:

NATS Protocol - Unencrypted
NATS Protocol - default Opportunistic TLS - TlsMode.Require
NATS Protocol - Implicit TLS (sometimes called TLS Handshake First) - TlsMode.Implicit
WebSocket - Unencrypted
WebSocket - TLS

And what kind of proxy are you trying to use?

SOCKS Proxy
HTTP Proxy
Something else?

caleblloyd · 2025-04-05T01:40:09Z

src/NATS.Client.Core/Internal/TcpConnection.cs

+                }
+
+                var serverWithPort = $"{host}:{port}";
+                var connectBuffer = Encoding.UTF8.GetBytes($"CONNECT {serverWithPort} HTTP/1.1\r\nHost: {serverWithPort}\r\n{connectAuth}Proxy-Connection: Keep-Alive\r\n\r\n");


I am confused here, this appears to be an HTTP Proxy? Aren't HTTP Proxies only for proxying HTTP(S) connections? But this is in the TcpConnection class which is used for the NATS protocol, which is not a HTTP-based protocol.

For WebSockets, there is NatsWebSocketOpts.ConfigureClientWebSocketOptions which could be used to set the ClientWebSocketOptions.Proxy property to a WebProxy

Ah I see that HTTP CONNECT can work with protocols other than HTTP - MDN docs

Aside from enabling secure access to websites behind proxies, a HTTP tunnel provides a way to allow traffic that would otherwise be restricted (SSH or FTP) over the HTTP(S) protocol.

Our current problem to solve for the customer environment is indeed NATS protocol Unencrypted or default Opportunistic TLS with HTTP proxy. The current code solves it

I'm concerned we won't be able to support the proxy ourselves giving it the attention it deserves with all the different scenarios. Can you instead implement a IScocketConnection factory like suggested below? we can add that to NatsConnection class switching between the blow two blocks of code:

nats.net/src/NATS.Client.Core/NatsConnection.cs

Lines 338 to 357 in b6edd5f

if (uri.IsWebSocket)

{

var conn = new WebSocketConnection();

await conn.ConnectAsync(uri, Opts).ConfigureAwait(false);

_socket = conn;

}

else

{

var conn = new TcpConnection(_logger);

await conn.ConnectAsync(target.Host, target.Port, Opts).ConfigureAwait(false);

_socket = conn;

if (Opts.TlsOpts.EffectiveMode(uri) == TlsMode.Implicit)

{

// upgrade TcpConnection to SslConnection

var sslConnection = conn.UpgradeToSslStreamConnection(Opts.TlsOpts);

await sslConnection.AuthenticateAsClientAsync(uri, Opts.ConnectTimeout).ConfigureAwait(false);

_socket = sslConnection;

}

}

nats.net/src/NATS.Client.Core/NatsConnection.cs

Lines 644 to 666 in b6edd5f

if (url.IsWebSocket)

{

_logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect using WebSocket {Url} [{ReconnectCount}]", url, reconnectCount);

var conn = new WebSocketConnection();

await conn.ConnectAsync(url, Opts).ConfigureAwait(false);

_socket = conn;

}

else

{

_logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect using TCP {Url} [{ReconnectCount}]", url, reconnectCount);

var conn = new TcpConnection(_logger);

await conn.ConnectAsync(url.Host, url.Port, Opts).ConfigureAwait(false);

_socket = conn;

if (Opts.TlsOpts.EffectiveMode(url) == TlsMode.Implicit)

{

// upgrade TcpConnection to SslConnection

_logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect and upgrading to TLS {Url} [{ReconnectCount}]", url, reconnectCount);

var sslConnection = conn.UpgradeToSslStreamConnection(Opts.TlsOpts);

await sslConnection.AuthenticateAsClientAsync(FixTlsHost(url), Opts.ConnectTimeout).ConfigureAwait(false);

_socket = sslConnection;

}

}

I'm very busy at the moment - but hope to do it by the end of the week.

caleblloyd · 2025-04-05T18:34:14Z

I think a more flexible API may be to allow for specifying a SocketConnectionFactory in NatsOpts that has a signature with something like:

Func<NatsUri, NatsOpts, CancellationToken, ValueTask<ISocketConnection>>? SocketConnectionFactory

And that would be responsible for returning an opened ISocketConnection

mtmk · 2025-04-10T13:35:09Z

cc @johannespfeiffer

wolfkor · 2025-04-11T13:59:39Z

For our scenario i had to add

public class ProxyTcpConnection(ILogger<NatsConnection> logger) : TcpConnection(logger)
{
    public new async ValueTask ConnectAsync(string host, int port, TimeSpan timeout)
    {
        SocketProxy proxy = SystemUtilsService.SocketProxy;

        using CancellationTokenSource cts = new CancellationTokenSource(timeout);
        try
        {
            if (proxy.Proxy != null)
            {
                await Socket.ConnectAsync(proxy.ProxyHost, proxy.ProxyPort, cts.Token).ConfigureAwait(false);

                string connectAuth = null;
                if (proxy.ProxyAuth != null)
                {
                    // Create the CONNECT request with proxy authentication
                    string auth = Convert.ToBase64String(Encoding.UTF8.GetBytes(proxy.ProxyAuth));
                    connectAuth = $"Proxy-Authorization: Basic {auth}\r\n";
                }

                string serverWithPort = $"{host}:{port}";
                byte[] connectBuffer = Encoding.UTF8.GetBytes(
                    $"CONNECT {serverWithPort} HTTP/1.1\r\nHost: {serverWithPort}\r\n{connectAuth}Proxy-Connection: Keep-Alive\r\n\r\n");

                // Send CONNECT request to proxy
                await SendAsync(connectBuffer).ConfigureAwait(false);

                // Validate proxy response
                byte[]        receiveBuffer   = new byte[4096];
                StringBuilder responseBuilder = new StringBuilder();
                int           read;
                do
                {
                    read = await ReceiveAsync(receiveBuffer).ConfigureAwait(false);
                    responseBuilder.Append(Encoding.UTF8.GetString(receiveBuffer, 0, read));
                } while (read > 0 && !responseBuilder.ToString().Contains("\r\n\r\n"));

                string response = responseBuilder.ToString();
                if (!response.Contains("200 Connection established"))
                    throw new Exception($"Proxy connection failed. Response: {response}");
            }
            else
                await Socket.ConnectAsync(host, port, cts.Token).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            await DisposeAsync().ConfigureAwait(false);
            if (ex is OperationCanceledException)
                throw new SocketException(10060); // 10060 = connection timeout.

            throw;
        }
    }
}

and

public class BusSocketConnectionFactory : DefaultSocketConnectionFactory, ISocketConnectionFactory
{
    public new static       BusSocketConnectionFactory       Instance => LazyInstance.Value;
    private static readonly Lazy<BusSocketConnectionFactory> LazyInstance = new(() => new BusSocketConnectionFactory());

    public new async Task<ISocketConnection> OnConnectionAsync(NatsUri uri, NatsConnection natsConnection, ILogger<NatsConnection> logger)
    {
        (string Host, int Port) target = await BeforeConnectingAsync(natsConnection, logger, (uri.Host, uri.Port));

        logger.LogInformation(NatsLogEvents.Connection, $"Try to connect NATS '{uri}' with {nameof(BusSocketConnectionFactory)}");

        ProxyTcpConnection connection = new ProxyTcpConnection(logger);
        await connection.ConnectAsync(target.Host, target.Port, natsConnection.Opts.ConnectTimeout).ConfigureAwait(false);
        return connection;
    }

    public new async Task<ISocketConnection> OnReconnectionAsync(NatsUri uri, NatsConnection natsConnection, ILogger<NatsConnection> logger, int reconnectCount)
    {
        if (natsConnection.OnConnectingAsync != null)
        {
            (string Host, int Port) target = (uri.Host, uri.Port);
            logger.LogInformation(
                NatsLogEvents.Connection,
                $"Try to invoke OnConnectingAsync before connect to NATS [{reconnectCount}] with {nameof(BusSocketConnectionFactory)}",
                reconnectCount);
            (string Host, int Port) newTarget = await natsConnection.OnConnectingAsync(target).ConfigureAwait(false);

            if (newTarget.Host != target.Host || newTarget.Port != target.Port) uri = uri.CloneWith(newTarget.Host, newTarget.Port);
        }

        logger.LogInformation(NatsLogEvents.Connection, $"Tried to connect NATS {uri} [{reconnectCount}] with {nameof(BusSocketConnectionFactory)}");

        NatsOpts opts = natsConnection.Opts;
        logger.LogDebug(NatsLogEvents.Connection, $"Trying to reconnect using TCP {uri} [{reconnectCount}] with {nameof(BusSocketConnectionFactory)}");
        ProxyTcpConnection tcpConnection = new ProxyTcpConnection(logger);
        await tcpConnection.ConnectAsync(uri.Host, uri.Port, opts.ConnectTimeout).ConfigureAwait(false);
        ISocketConnection socket = await AfterReconnectingAsync(natsConnection, uri, opts, logger, reconnectCount, tcpConnection);

        return socket;
    }
}

and in NatsOpts instance
SocketConnectionFactory = BusSocketConnectionFactory.Instance

mtmk

Thanks @wolfkor appreciate the work but I think we can simplify this a little. I want to make sue the changes are minimal to avoid disturbing existing applications in case of unintended behavior changes we might introduce while not opening up internal APIs as much as possible. hope it makes sense.

mtmk · 2025-04-11T14:49:23Z

src/NATS.Client.Core/DefaultSocketConnectionFactory.cs

+
+namespace NATS.Client.Core;
+
+public class DefaultSocketConnectionFactory : ISocketConnectionFactory


Why do we need this all the functionality moved from connection class? Can't we just use the callback Func<NatsUri, NatsOpts, CancellationToken, ValueTask<ISocketConnection>>? SocketConnectionFactory?

no i don't see that. We need a change inside TcpConnection or WebSocketConnection for sending to the proxy. How to hide and give the customer the chance to change it.

probably the only way i see is a callback which returns the pure Socket given by the proxy and put it in the constructor of TcpConnection. But the current OnSocketAvailable imlementations will break with that

I mean we don't need this class. see below.

mtmk · 2025-04-11T14:50:04Z

src/NATS.Client.Core/INatsConnection.cs

-    /// <summary>
-    /// Hook when socket is available.
-    /// </summary>
-    Func<ISocketConnection, ValueTask<ISocketConnection>>? OnSocketAvailableAsync { get; set; }


we can't really change the public API

OnSocketAvailableAsync was implemented for proxy scenario but is simply not working for Proxy+TLS. It must be replaced bei the new functionality

we can leave it but down call it - not a smart way i think

I prefer not to break existing applications

mtmk · 2025-04-11T14:50:22Z

src/NATS.Client.Core/ISocketConnectionFactory.cs

+
+namespace NATS.Client.Core;
+
+public interface ISocketConnectionFactory


same. shouldn't need this.

mtmk · 2025-04-11T14:51:57Z

src/NATS.Client.Core/NatsConnection.cs

@@ -258,6 +259,30 @@ public virtual async ValueTask DisposeAsync()
        }
    }

+    public NatsUri FixTlsHost(NatsUri uri)


if we have to open this up I think we should documented as an internal api.

mtmk · 2025-04-11T14:53:30Z

src/NATS.Client.Core/NatsConnection.cs

-                }
-
-                _logger.LogInformation(NatsLogEvents.Connection, "Try to connect NATS {0}", uri);
-                if (uri.IsWebSocket)


You can switch here. if we have the callback in the options use that to assign to _socket otherwise let the rest of the code stay the same.

here and in reconnect loop add these:

_logger.LogInformation(NatsLogEvents.Connection, "Tried to connect NATS {Url} [{ReconnectCount}]", url, reconnectCount); + if (Opts.SocketConnectionFactory != null) + { + _logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect using SocketFactory {Url} [{ReconnectCount}]", url, reconnectCount); + var conn = await Opts.SocketConnectionFactory(url, Opts, _disposedCancellationTokenSource.Token); + await conn.ConnectAsync(url, Opts).ConfigureAwait(false); + _socket = conn; + } + else if (url.IsWebSocket) - if (url.IsWebSocket) {

these and with the option addition that should be it.

ISocketConnection has no ConnectAsync

that's even better. we can just return a connected socket and avoid the extra connect call.

and the caller has to implement for the return value of SocketConnectionFactory ISocketConnection on his own? That was one point for unsealing TcpConnection

yes, we can start with that. there is very little code in TcpConnection with almost no logic. it's not worth trying to reuse it. creates more unnecessary coupling.

mtmk · 2025-04-11T14:53:51Z

src/NATS.Client.Core/NatsConnection.cs

-                    }
-                }
-
-                if (OnSocketAvailableAsync != null)


same. can't break api

mtmk · 2025-04-11T14:54:28Z

src/NATS.Client.Core/NatsConnection.cs

-                    }
-
-                    _logger.LogInformation(NatsLogEvents.Connection, "Tried to connect NATS {Url} [{ReconnectCount}]", url, reconnectCount);
-                    if (url.IsWebSocket)


same. switch if we have factory defined.

mtmk · 2025-04-11T14:55:07Z

src/NATS.Client.Core/NatsOpts.cs

@@ -97,6 +97,8 @@ public sealed record NatsOpts

    public Encoding SubjectEncoding { get; init; } = Encoding.ASCII;

+    public ISocketConnectionFactory SocketConnectionFactory { get; init; } = DefaultSocketConnectionFactory.Instance;


Change to Func<NatsUri, NatsOpts, CancellationToken, ValueTask<ISocketConnection>>? defaulting to null

mtmk · 2025-04-11T14:57:17Z

src/NATS.Client.Core/TcpConnection.cs

 {
    public SocketClosedException(Exception? innerException)
        : base("Socket has been closed.", innerException)
    {
    }
 }

-internal sealed class TcpConnection : ISocketConnection
+public class TcpConnection : ISocketConnection


I don't know if we should open these up. there isn't a lot of code here to be reused. implementations can copy paste the bits they need.

mtmk · 2025-04-11T14:58:45Z

src/NATS.Client.Core/WebSocketConnection.cs


-internal sealed class WebSocketConnection : ISocketConnection
+public class WebSocketConnection : ISocketConnection


same as tcp connection. no a lot of code to reuse. I'd rather not open too much. if we have to we must document as internal API.

…n>>? SocketConnectionFactory (nats-io#804)

mtmk · 2025-04-12T04:17:45Z

thanks for the changes @wolfkor!

btw you need to sign your commits. you will have to force push with a new commit. otherwise repo is set to block unsigned commits. all commits in a pr must be signed.

mtmk

LGTM thanks @wolfkor

(after commits signed)

will give @caleblloyd a chance to review.

…n>>? SocketConnectionFactory (nats-io#804)

* Update docs and example links * Hide docs folder [nats:update-docs]

[nats:update-docs]

* Fix docs workflow * Disable conditional check for docfx workflow trigger Make sure this runs every time so that if it breaks, we know straightaway.

* Fix example code paths and reorg * Revert readme nats by example link

…n>>? SocketConnectionFactory (nats-io#804)

caleblloyd

I think something happened with the diff, it appears a folder was moved and now there are a bunch of changes in here due to that. Can you revert that?

caleblloyd · 2025-04-13T15:36:01Z

Oh maybe it was caused by merging main into this PR, I think this may need to be squashed and rebased

mtmk · 2025-04-13T15:40:57Z

Oh maybe it was caused by merging main into this PR, I think this may need to be squashed and rebased

yes looks like we need a rebase @wolfkor. changes for this PR are only in NatsConnection, NatsOpts and NatsUri classes.

wolfkor · 2025-04-13T18:03:04Z

I had to sign all my commits including the main merge by amend command. Give me a hint what to do. Making changes again in new branch?

mtmk · 2025-04-13T18:06:02Z

I had to sign all my commits including the main merge by amend command. Give me a hint what to do. Making changes again in new branch?

yes, opening a new pr and reference this one in comments. that might be easier.

…ats-io#804)

mtmk · 2025-04-13T18:48:37Z

replaced by Fix proxy with TLS scenario with SocketConnectionFactory #826

mtmk reviewed Apr 2, 2025

View reviewed changes

mtmk reviewed Apr 3, 2025

View reviewed changes

wolfkor added a commit to wolfkor/nats.net that referenced this pull request Apr 3, 2025

Receive do while (nats-io#804)

34175b4

caleblloyd reviewed Apr 5, 2025

View reviewed changes

wolfkor added a commit to wolfkor/nats.net that referenced this pull request Apr 11, 2025

SocketConnectionFactory (nats-io#804)

85ad377

mtmk requested changes Apr 11, 2025

View reviewed changes

wolfkor added a commit to wolfkor/nats.net that referenced this pull request Apr 11, 2025

Func<NatsUri, NatsOpts, CancellationToken, ValueTask<ISocketConnectio…

90e7472

…n>>? SocketConnectionFactory (nats-io#804)

mtmk approved these changes Apr 12, 2025

View reviewed changes

mtmk requested a review from caleblloyd April 12, 2025 04:21

wolfkor added a commit to wolfkor/nats.net that referenced this pull request Apr 12, 2025

Func<NatsUri, NatsOpts, CancellationToken, ValueTask<ISocketConnectio…

8bdaaba

…n>>? SocketConnectionFactory (nats-io#804)

wolfkor force-pushed the proxy-tls branch from 90e7472 to 8bdaaba Compare April 12, 2025 18:02

wolfkor and others added 12 commits April 12, 2025 20:50

fix TLS proxy scenario (nats-io#802)

ab3fabf

reverse ReSharper formatting and issues (nats-io#802)

c4a97f9

Receive do while (nats-io#804)

77f8afa

SocketConnectionFactory (nats-io#804)

83976cf

Update README.md: add doc badge (nats-io#805)

6c3b355

Update docs links and examples folder (nats-io#806)

ee21b29

* Update docs and example links * Hide docs folder [nats:update-docs]

Update docs workflow (nats-io#807)

ab95686

[nats:update-docs]

Fix docs

96e4f86

Trigger docs

40dfd6c

[nats:update-docs]

Fix docs workflow (nats-io#808)

c803845

* Fix docs workflow * Disable conditional check for docfx workflow trigger Make sure this runs every time so that if it breaks, we know straightaway.

Fix example code paths and reorg (nats-io#809)

8a2eed6

* Fix example code paths and reorg * Revert readme nats by example link

Fix docs link (nats-io#810)

102fd03

mtmk and others added 3 commits April 12, 2025 20:50

Fix handling for OnNoData when ignoring deletes (nats-io#790)

cbd67ea

Fix reader buffer bug with typo (nats-io#799)

f8a34cc

Func<NatsUri, NatsOpts, CancellationToken, ValueTask<ISocketConnectio…

77043e3

…n>>? SocketConnectionFactory (nats-io#804)

wolfkor force-pushed the proxy-tls branch from 8bdaaba to 77043e3 Compare April 12, 2025 18:55

caleblloyd requested changes Apr 13, 2025

View reviewed changes

wolfkor added a commit to wolfkor/nats.net that referenced this pull request Apr 13, 2025

fix proxy with TLS scenario ba SocketConnectionFactory (nats-io#802) (n…

2b65b81

…ats-io#804)

wolfkor mentioned this pull request Apr 13, 2025

Fix proxy with TLS scenario with SocketConnectionFactory #826

Open

mtmk closed this Apr 13, 2025

wolfkor deleted the proxy-tls branch April 14, 2025 06:38

	if (uri.IsWebSocket)
	{
	var conn = new WebSocketConnection();
	await conn.ConnectAsync(uri, Opts).ConfigureAwait(false);
	_socket = conn;
	}
	else
	{
	var conn = new TcpConnection(_logger);
	await conn.ConnectAsync(target.Host, target.Port, Opts).ConfigureAwait(false);
	_socket = conn;

	if (Opts.TlsOpts.EffectiveMode(uri) == TlsMode.Implicit)
	{
	// upgrade TcpConnection to SslConnection
	var sslConnection = conn.UpgradeToSslStreamConnection(Opts.TlsOpts);
	await sslConnection.AuthenticateAsClientAsync(uri, Opts.ConnectTimeout).ConfigureAwait(false);
	_socket = sslConnection;
	}
	}

	if (url.IsWebSocket)
	{
	_logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect using WebSocket {Url} [{ReconnectCount}]", url, reconnectCount);
	var conn = new WebSocketConnection();
	await conn.ConnectAsync(url, Opts).ConfigureAwait(false);
	_socket = conn;
	}
	else
	{
	_logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect using TCP {Url} [{ReconnectCount}]", url, reconnectCount);
	var conn = new TcpConnection(_logger);
	await conn.ConnectAsync(url.Host, url.Port, Opts).ConfigureAwait(false);
	_socket = conn;

	if (Opts.TlsOpts.EffectiveMode(url) == TlsMode.Implicit)
	{
	// upgrade TcpConnection to SslConnection
	_logger.LogDebug(NatsLogEvents.Connection, "Trying to reconnect and upgrading to TLS {Url} [{ReconnectCount}]", url, reconnectCount);
	var sslConnection = conn.UpgradeToSslStreamConnection(Opts.TlsOpts);
	await sslConnection.AuthenticateAsClientAsync(FixTlsHost(url), Opts.ConnectTimeout).ConfigureAwait(false);
	_socket = sslConnection;
	}
	}


		namespace NATS.Client.Core;

		public class DefaultSocketConnectionFactory : ISocketConnectionFactory


		namespace NATS.Client.Core;

		public interface ISocketConnectionFactory

		@@ -97,6 +97,8 @@ public sealed record NatsOpts

		public Encoding SubjectEncoding { get; init; } = Encoding.ASCII;

		public ISocketConnectionFactory SocketConnectionFactory { get; init; } = DefaultSocketConnectionFactory.Instance;


		internal sealed class WebSocketConnection : ISocketConnection
		public class WebSocketConnection : ISocketConnection

fix TLS proxy scenario (#802) #804

fix TLS proxy scenario (#802) #804

Conversation

wolfkor commented Apr 2, 2025

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mtmk Apr 3, 2025 • edited Loading

Choose a reason for hiding this comment

caleblloyd commented Apr 5, 2025

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

caleblloyd commented Apr 5, 2025

mtmk commented Apr 10, 2025

wolfkor commented Apr 11, 2025

mtmk left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mtmk Apr 11, 2025 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

mtmk commented Apr 12, 2025

mtmk left a comment

Choose a reason for hiding this comment

caleblloyd left a comment

Choose a reason for hiding this comment

caleblloyd commented Apr 13, 2025

mtmk commented Apr 13, 2025

wolfkor commented Apr 13, 2025

mtmk commented Apr 13, 2025

mtmk commented Apr 13, 2025

mtmk Apr 3, 2025 •

edited

Loading

mtmk Apr 11, 2025 •

edited

Loading