log.error("Multiple preauth negotiate contexts");
                return false;
            }
        }

        if ( !foundPreauth ) {
            log.error("Missing preauth negotiate context");
            return false;
        }
        if ( !foundEnc && ( caps & Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION ) != 0 ) {
            log.error("Missing encryption negotiate context");
            return false;
        }

        return tc.getSIDResolver().getGroupMemberSids(tc, authorityServerName, getDomainSid(), getRid(), flags);
    }


    /**
     * @param context
     * @param server
     */
    public void initContext ( String server, CIFSContext context ) {
        this.origin_ctx = context;
        this.origin_server = server;
    }

     */
    int getMaxXmit () {
        return this.max_xmit;
    }


    /**
     * Get a handle to a service
     * 
     * @param url
     * @param tc
     *            context to use
     * @return a DCERPC handle for the given url
     * @throws MalformedURLException
     * @throws DcerpcException
     */

    @Test
    public void resolveDomains () throws CIFSException {
        CIFSContext context = getContext();
        context = withTestNTLMCredentials(context);
        DfsResolver dfs = context.getDfs();

        String testDomain = getTestDomain();
        assertTrue(dfs.isTrustedDomain(context, testDomain));
        assertTrue(dfs.isTrustedDomain(context, testDomain.toLowerCase(Locale.ROOT)));

     *
     * @param context
     *            The local security context.
     */
    public void setContext ( byte[] context ) {
        this.context = context;
    }


    @Override
    public byte[] toByteArray () throws IOException {
        int size = 48;
        int flags = getFlags();
        String targetName = getTarget();
        byte[] targetInformationBytes = getTargetInformation();

    }


    /**
     * Get lifetime of this context.
     *
     * @return the remaining lifetime in seconds. If the default lifetime is
     *         used, this value have no meaning.
     */
    public int getLifeTime () {
        return this.contextLifetime;
    }


    /**
     * Set the lifetime for this context.
     *
     * @param time
     *            the lifetime in seconds

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Address;
import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.Config;
import jcifs.config.PropertyConfiguration;
import jcifs.context.BaseContext;
import jcifs.netbios.UniAddress;
import jcifs.smb.NtStatus;
import jcifs.smb.NtlmChallenge;
import jcifs.smb.NtlmPasswordAuthentication;
import jcifs.smb.SmbAuthException;
import jcifs.smb.SmbException;

    SmbFile file;

    private boolean largeReadX;

    private final boolean unsharedFile;

    private boolean smb2;


    /**
     * @param url
     * @param tc
     *            context to use
     * @throws SmbException
     * @throws MalformedURLException
     */
    @SuppressWarnings ( "resource" )
    public SmbFileInputStream ( String url, CIFSContext tc ) throws SmbException, MalformedURLException {

import jcifs.CloseableIterator;
import jcifs.ResolverType;
import jcifs.SmbConstants;
import jcifs.SmbResource;
import jcifs.SmbTreeHandle;
import jcifs.config.DelegatingConfiguration;
import jcifs.context.CIFSContextWrapper;
import jcifs.netbios.NameServiceClientImpl;
import jcifs.smb.DosFileFilter;
import jcifs.smb.SmbException;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbFilenameFilter;

         */
        if ( EXT_GSS_CONTEXT_CLASS == null || INQUIRE_SEC_CONTEXT == null || INQUIRE_TYPE_SESSION_KEY == null ) {
            throw new SmbException("ExtendedGSSContext support not available from JRE");
        }
        else if ( EXT_GSS_CONTEXT_CLASS.isAssignableFrom(this.gssContext.getClass()) ) {
            try {
                Key k = (Key) INQUIRE_SEC_CONTEXT.invoke(this.gssContext, new Object[] {