List<SmbTransportImpl> unhealthy = new ArrayList<>();

        for (SmbTransportImpl transport : connections) {
            try {
                // Perform comprehensive health check
                if (isConnectionUnhealthy(transport)) {
                    unhealthy.add(transport);
                    String key = getConnectionKey(transport);
                    recordConnectionFailure(key);

     * @return a transport connection to the target
     */
    SmbTransport getSmbTransport(CIFSContext tc, Address address, int port, InetAddress localAddr, int localPort, String hostName,
            boolean exclusive, boolean forceSigning);

    /**
     * Removes a transport from the pool.
     *
     * @param trans the transport to remove
     */

    @Test
    @DisplayName("Should remove transport from pool")
    void testRemoveTransport() {
        // Given: A pooled connection
        SmbTransportImpl transport = pool.getSmbTransport(ctx, address, 445, false);
        assertTrue(pool.contains(transport), "Transport should be in pool initially");

        // When: Remove the transport
        pool.removeTransport(transport);

 * <p>
 * This implementation is backed by Maven Resolver API, supported protocols and transport selection depends on it. If
 * resolver preference regarding transport is altered, it will affect this service as well.
 *
 * @since 4.0.0
 */
@Experimental
@Consumer
public interface TransportProvider extends Service {
    /**
     * Provides new {@link Transport} instance for given {@link RemoteRepository}, if possible.
     *

    }

    /**
     * Get the transport for this channel
     *
     * @return SMB transport
     */
    public SmbTransport getTransport() {
        return transport;
    }

    /**
     * Set the transport for this channel
     *
     * @param transport SMB transport
     */
    public void setTransport(SmbTransport transport) {
        this.transport = transport;
    }

    /**

        try (SmbSessionImpl sess = getSession(); SmbTransportImpl transport = sess.getTransport()) {
            synchronized (transport) {

                // this needs to be done before the reference to the remote hostname later
                transport.ensureConnected();

                if (waitForState(transport) == 2) {
                    // already connected
                    return null;

 */
package jcifs;

/**
 * Opaque reference to a SMB transport
 *
 * @author mbechler
 *
 * <p>This interface is intended for internal use.</p>
 */
public interface SmbTransport extends AutoCloseable {

    /**
     * Gets the CIFS context associated with this transport.
     *
     * @return the context this transport is attached to
     */
    CIFSContext getContext();

    /**

            return transport.getNegotiateResponse().getSendBufferSize();
        }
    }

    @Override
    public int getReceiveBufferSize() throws SmbException {
        try (SmbSessionImpl session = this.treeConnection.getSession(); SmbTransportImpl transport = session.getTransport()) {
            return transport.getNegotiateResponse().getReceiveBufferSize();

	cfg.Proxy = proxy

	if transport == nil {
		// when transport is nil, it means we are just validating the
		// inputs not performing any network calls.
		return cfg, nil
	}

	// Make sure to clone the transport before editing the ProxyURL
	if proxyURL != nil {
		if tr, ok := transport.(*http.Transport); ok {
			ctransport := tr.Clone()
			ctransport.Proxy = http.ProxyURL((*url.URL)(proxyURL))

            transport.ensureConnected();

            // Verify multi-channel capability (SMB3+ required)
            if (!transport.isSMB2() || !transport.hasCapability(0x00000008)) { // SMB2_GLOBAL_CAP_MULTI_CHANNEL
                throw new CIFSException("Server does not support SMB multi-channel capability");
            }