private CIFSContext transportContext;


    /**
     * 
     * @param connection
     *            connection to wrap
     * @param tc
     *            context to use
     */
    public NtlmHttpURLConnection ( HttpURLConnection connection, CIFSContext tc ) {
        super(connection.getURL());
        this.connection = connection;
        this.transportContext = tc;
        this.requestProperties = new HashMap<>();

    if (pooled3 != null) return pooled3.connection

    connection.withLock {
      connectionPool.put(connection)
      user.acquireConnectionNoEvents(connection)
    }

    user.connectionAcquired(connection)
    user.connectionConnectionAcquired(connection)
    return connection
  }

  override fun trackFailure(
    call: RealCall,
    e: IOException?,

import okhttp3.internal.ws.RealWebSocket
import okio.BufferedSink
import okio.BufferedSource

/**
 * A connection to a remote web server capable of carrying 1 or more concurrent streams.
 *
 * Connections are shared in a connection pool. Accesses to the connection's state must be guarded
 * by holding a lock on the connection.
 */
class RealConnection(
  val taskRunner: TaskRunner,
  val connectionPool: RealConnectionPool,

      assertThat(result0).isEqualTo(plan1.connection)
    }

    taskFaker.runTasks()
    assertEvents(
      "take plan 0",
      "plan 0 TCP connecting...",
      "plan 0 TCP connected",
      "plan 0 TLS connecting...",
      "plan 0 needs follow-up",
      "plan 1 TCP connecting...",
      "plan 1 TCP connected",
      "plan 1 TLS connecting...",
      "plan 1 TLS connected",
    )

    return null
  }

  override fun connectionReleased(connection: Connection) {
  }

  override fun connectionConnectionAcquired(connection: RealConnection) {
  }

  override fun connectionConnectionReleased(connection: RealConnection) {
  }

  override fun connectionConnectionClosed(connection: RealConnection) {
  }

  override fun noNewExchanges(connection: RealConnection) {
  }

    lock.assertNotHeld()

    val connection = this.connection
    if (connection != null) {
      connection.lock.assertNotHeld()
      val toClose: Socket? =
        connection.withLock {
          // Sets this.connection to null.
          releaseConnectionNoEvents()
        }
      if (this.connection == null) {
        toClose?.closeQuietly()

import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.connection.FastFallbackExchangeFinder
import okhttp3.internal.connection.ForceConnectRoutePlanner
import okhttp3.internal.connection.RealConnectionPool
import okhttp3.internal.connection.RealRoutePlanner
import okhttp3.internal.connection.RouteDatabase

/**
 * Manages reuse of HTTP and HTTP/2 connections for reduced network latency. HTTP requests that

                                    pool connections.
                                  type: string
                                maxConcurrentStreams:
                                  description: The maximum number of concurrent streams
                                    allowed for a peer on one HTTP/2 connection.
                                  format: int32

        }
        throw new TransportException("All connection attempts failed");
    }


    /**
     * 
     * @param trans
     * @return whether (non-exclusive) connection is in the pool
     */
    public boolean contains ( SmbTransport trans ) {
        synchronized ( this.connections ) {
            cleanup();
            return this.connections.contains(trans);
        }
    }

    /**
     * Get transport connection
     * 
     * @param tc
     *            context to use
     * @param address
     * @param port
     * @param exclusive
     *            whether to acquire an unshared connection
     * @param forceSigning
     *            whether to enforce SMB signing on this connection
     * @return a transport connection to the target
     */