*/
    byte[] getSessionKey () throws CIFSException;


    /**
     * 
     * @return the transport for this session
     */
    SmbTransport getTransport ();


    /**
     * Connect to the logon share
     * 
     * @throws SmbException
     */
    void treeConnectLogon () throws SmbException;


    /**
     * @param share
     * @param service
     * @return tree instance
     */

    private String path;


    /**
     * @param config
     * @param path
     */
    public Smb2TreeConnectRequest ( Configuration config, String path ) {
        super(config, SMB2_TREE_CONNECT);
        this.path = path;
    }


    @Override
    protected Smb2TreeConnectResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2TreeConnectResponse> req ) {

        return new CurlRequest(Method.OPTIONS, url);
    }

    public static CurlRequest connect(final String url) {
        return new CurlRequest(Method.CONNECT, url);
    }

    public enum Method {
        GET, POST, PUT, DELETE, HEAD, OPTIONS, TRACE, CONNECT;
    }

        int connectionTimeout = (Integer) systemSessionFactory
                .newRepositorySession(request)
                .getConfigProperties()
                .get(ConfigurationProperties.CONNECT_TIMEOUT + "." + server.getId());
        assertEquals(3000, connectionTimeout);
    }

    @Test
    void connectionTimeoutFromHttpConfigurationTest() throws InvalidRepositoryException {

    public void transportReconnects () throws IOException {
        try ( SmbFile f = getDefaultShareRoot() ) {
            // transport disconnects can happen pretty much any time
            assertNotNull(f);
            f.connect();
            f.exists();
            assertNotNull(f);
            try ( SmbTreeHandleInternal treeHandle = (SmbTreeHandleInternal) f.getTreeHandle();

      "Edge %s that was used to generate this set is no longer in the graph.";
  static final String REUSING_EDGE =
      "Edge %s already exists between the following nodes: %s, "
          + "so it cannot be reused to connect the following nodes: %s.";
  static final String MULTIPLE_EDGES_CONNECTING =
      "Cannot call edgeConnecting() when parallel edges exist between %s and %s. Consider calling "
          + "edgesConnecting() instead.";

    return new TunnelingUnixSocket(path, channel);
  }

  @Override public Socket createSocket(String host, int port) throws IOException {
    Socket result = createSocket();

    try {
      result.connect(new InetSocketAddress(host, port));
    } catch (IOException e) {
      result.close();
      throw e;
    }
    return result;
  }

  @Override public Socket createSocket(

                    Hexdump.hexdump( log, sbuf, 4, n );
                }
            }
        }
    }
    public void connect() throws SmbException {
        try {
            super.connect( RESPONSE_TIMEOUT );
        } catch( TransportException te ) {
            throw new SmbException( "Failed to connect: " + address, te );
        }
    }
    protected void doConnect() throws IOException {
        /*

        this.setInstanceFollowRedirects(this.connection.getInstanceFollowRedirects());
    }


    @Override
    public void connect () throws IOException {
        if ( this.connected )
            return;
        this.connection.connect();
        this.connected = true;
    }


    private void handshake () {
        if ( this.handshakeComplete )
            return;

        if (headerList == null) {
            headerList = new ArrayList<>();
        }
        headerList.add(new String[] { key, value });
        return this;
    }

    public void connect(final Consumer<HttpURLConnection> actionListener, final Consumer<Exception> exceptionListener) {
        final Runnable task = () -> {
            if (paramList != null) {
                char sp;