// before following deeper ones. Otherwise e.g. samba will return a broken
            // referral.
            synchronized ( trans ) {
                try {
                    // ensure connected
                    trans.ensureConnected();
                    refServerName = trans.getRemoteHostName();
                }
                catch ( IOException e ) {

        if ( len <= 0 ) {
            return 0;
        }
        long start = this.fp;

        if ( this.tmp == null ) {
            throw new IOException("Bad file descriptor");
        }
        // ensure file is open
        try ( SmbFileHandleImpl fd = ensureOpen();
              SmbTreeHandleImpl th = fd.getTree() ) {

            /*
             * Read AndX Request / Response
             */

        // only do this if a WINS server is enabled
        getRequiredProperty("jcifs.netbios.wins");

        CIFSContext bctx = withAnonymousCredentials();

        // ensure that the domain name gets resolved through WINS so that
        // it gets the workgroup type.
        CIFSContext ctx = withConfig(bctx, new DelegatingConfiguration(bctx.getConfig()) {

            @Override

import org.ietf.jgss.Oid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.CIFSException;
import jcifs.spnego.NegTokenInit;


/**
 * This class used to provide Kerberos feature when setup GSSContext.
 * 
 * @author Shun
 */
class Kerb5Context implements SSPContext {

    private static final Logger log = LoggerFactory.getLogger(Kerb5Context.class);

        }
    }


    /**
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen () throws CIFSException {
        // ensure file is open
        if ( this.handle == null || !this.handle.isValid() ) {
            // one extra acquire to keep this open till the stream is released

                }
                else {
                    dc = nameServiceClient.getByName(server, possibleWorkgroup);
                }

                req.getSession(); /* ensure session id is set for cluster env. */
                challenge = getTransportContext().getTransportPool().getChallenge(getTransportContext(), dc);

                    dc = UniAddress.getByName( mb );
                } else {
                    dc = UniAddress.getByName( server, possibleWorkgroup );
                }

                req.getSession(); /* ensure session id is set for cluster env. */
                challenge = SmbSession.getChallenge( dc );
                if(( ntlm = NtlmSsp.authenticate( req, resp, challenge )) == null ) {
                    return;

        return read( b, 0, b.length );
    }
    public int read( byte b[], int off, int len ) throws SmbException {
        if( len <= 0 ) {
            return 0;
        }
        long start = fp;

        // ensure file is open
        if( file.isOpen() == false ) {
            file.open( openFlags, 0, SmbFile.ATTR_NORMAL, options );
        }

        int r, n;

import jcifs.spnego.NegTokenTarg;
import jcifs.spnego.SpnegoException;
import jcifs.spnego.SpnegoToken;
import jcifs.util.Hexdump;


/**
 * This class used to wrap a {@link SSPContext} to provide SPNEGO feature.
 * 
 * @author Shun
 *
 */
class SpnegoContext implements SSPContext {

    private static final Logger log = LoggerFactory.getLogger(SpnegoContext.class);

            /* Yes, there is the potential to drop packets
             * because we might close the socket during a
             * request. However the chances are slim and the
             * retry code should ensure the overall request
             * is serviced. The alternative complicates things
             * more than I think is worth it.
             */

            if( socket != null ) {
                socket.close();