}
            connection.setRequestProperty(key, value.toString());
        }
        connection.setAllowUserInteraction(allowUserInteraction);
        connection.setDoInput(doInput);
        connection.setDoOutput(doOutput);
        connection.setIfModifiedSince(ifModifiedSince);
        connection.setUseCaches(useCaches);
    }

            tree.send( req, resp );
        }
    }

    /* 0 - not connected
     * 1 - connecting
     * 2 - connected
     * 3 - disconnecting
     */
    int connectionState;
    int uid;
    Vector trees;
    // Transport parameters allows trans to be removed from CONNECTIONS
    private UniAddress address;
    private int port, localPort;
    private InetAddress localAddr;

    };

    static final String[] WINERR_MESSAGES = {
        "The operation completed successfully.", "Access is denied.",
        "No more connections can be made to this remote computer at this time because there are already as many connections as the computer can accept.",
        "The pipe state is invalid.", "All pipe instances are busy.", "The pipe is being closed.", "No process is on the other end of the pipe.",

            case 1:
                // already connecting
                this.thread.wait(timeout); /* wait for doConnect */
                st = this.state;
                switch ( st ) {
                case 1: /* doConnect never returned */
                    this.state = 6;
                    cleanupThread(timeout);
                    throw new ConnectionTimeoutException("Connection timeout");
                case 2:

        }
    }

    /* Build a connection. Only one thread will ever call this method at
     * any one time. If this method throws an exception or the connect timeout
     * expires an encapsulating TransportException will be thrown from connect
     * and the transport will be in error.
     */

    protected abstract void doConnect() throws Exception;

    /* Tear down a connection. If the hard parameter is true, the diconnection

        }
        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);
        }
    }

     */
    boolean isTrustedDomain ( CIFSContext tf, String domain ) throws CIFSException;


    /**
     * Get a connection to the domain controller for a given domain
     * 
     * @param domain
     * @param tf
     * @return connection
     * @throws CIFSException
     * @throws jcifs.smb.SmbAuthException
     */
    SmbTransport getDc ( CIFSContext tf, String domain ) throws CIFSException;

    }


    /**
     * Get a handle to a service
     * 
     * @param url
     * @param tc
     * @param unshared
     *            whether an exclusive connection should be used
     * @return a DCERPC handle for the given url
     * @throws MalformedURLException
     * @throws DcerpcException
     */

     * 
     * Property <tt>jcifs.smb.client.lport</tt> (int)
     * 
     * @return local port to use for outgoing connections
     */
    int getLocalPort ();


    /**
     * 
     * Property <tt>jcifs.smb.client.laddr</tt> (string)
     * 
     * @return local address to use for outgoing connections
     */
    InetAddress getLocalAddr ();


    /**
     * 

    static final int RESPONSE_TIMEOUT =
                Config.getInt( "jcifs.smb1.smb.client.responseTimeout", DEFAULT_RESPONSE_TIMEOUT );

    static final LinkedList CONNECTIONS = new LinkedList();

    static final int SSN_LIMIT =
            Config.getInt( "jcifs.smb1.smb.client.ssnLimit", DEFAULT_SSN_LIMIT );
    static final int SO_TIMEOUT =