throw new TransportException("Transport is disconnected " + this.name);
        }
        try {
            long timeout = !params.contains(RequestParam.NO_TIMEOUT) ? getResponseTimeout(request) : 0;

            long firstKey = doSend(request, response, params, timeout);

            if ( Thread.currentThread() == this.thread ) {
                // we are in the transport thread, ie. on idle disconnecting

    protected boolean smbTcpNoDelay = false;
    protected int smbResponseTimeout = SmbConstants.DEFAULT_RESPONSE_TIMEOUT;
    protected int smbSocketTimeout = SmbConstants.DEFAULT_SO_TIMEOUT;
    protected int smbConnectionTimeout = SmbConstants.DEFAULT_CONN_TIMEOUT;
    protected int smbSessionTimeout = SmbConstants.DEFAULT_SO_TIMEOUT;
    protected boolean idleTimeoutDisabled = false;
    protected InetAddress smbLocalAddress;

synchronized (transport()) {
        if( response != null ) {
            response.received = false;
        }

        expiration = System.currentTimeMillis() + SmbTransport.SO_TIMEOUT;
        sessionSetup( request, response );
        if( response != null && response.received ) {
            return;
        }

        if (request instanceof SmbComTreeConnectAndX) {

                            long timeout = RESPONSE_TIMEOUT;
                            resp.expiration = System.currentTimeMillis() + timeout;
                            while( resp.hasMoreElements() ) {
                                wait( timeout );
                                timeout = resp.expiration - System.currentTimeMillis();
                                if (timeout <= 0) {

    /**
     * 
     * Property <tt>jcifs.smb.client.soTimeout</tt> (int, default 35000)
     * 
     * @return socket timeout, in milliseconds
     */
    int getSoTimeout ();


    /**
     * 
     * Property <tt>jcifs.smb.client.connTimeout</tt> (int, default 35000)
     * 
     * @return timeout for establishing a socket connection, in milliseconds
     */

    @Override
    public void setConnectTimeout ( int timeout ) {
        this.connection.setConnectTimeout(timeout);
    }


    @Override
    public int getReadTimeout () {
        return this.connection.getReadTimeout();
    }


    @Override
    public void setReadTimeout ( int timeout ) {
        this.connection.setReadTimeout(timeout);
    }


    @Override

    private static final int SO_TIMEOUT = Config.getInt( "jcifs.smb1.netbios.soTimeout", DEFAULT_SO_TIMEOUT );
    private static final int RETRY_COUNT = Config.getInt( "jcifs.smb1.netbios.retryCount", DEFAULT_RETRY_COUNT );
    private static final int RETRY_TIMEOUT = Config.getInt( "jcifs.smb1.netbios.retryTimeout", DEFAULT_RETRY_TIMEOUT);
    private static final int LPORT = Config.getInt( "jcifs.smb1.netbios.lport", 0 );

                long timeout = System.currentTimeMillis() - start;
                assertTrue(
                    String.format(
                        "Timeout %d outside expected range (%f)",
                        timeout,
                        1.5 * ( ctx.getConfig().getConnTimeout() + ctx.getConfig().getResponseTimeout() )),

        String name;

        Properties p = new Properties();
        /*
         * Set jcifs properties we know we want; soTimeout and cachePolicy to 30min.
         */
        p.setProperty("jcifs.smb.client.soTimeout", "1800000");
        p.setProperty("jcifs.netbios.cachePolicy", "1200");
        /*
         * The Filter can only work with NTLMv1 as it uses a man-in-the-middle

        }
        return this.nextNameTrnId;
    }


    void ensureOpen ( int timeout ) throws IOException {
        this.closeTimeout = 0;
        if ( this.transportContext.getConfig().getNetbiosSoTimeout() != 0 ) {
            this.closeTimeout = Math.max(this.transportContext.getConfig().getNetbiosSoTimeout(), timeout);
        }
        // If socket is still good, the new closeTimeout will