}


    private DialectVersion ( int dialectId ) {
        this.smb2 = true;
        this.dialect = dialectId;
    }


    /**
     * @return the smb2
     */
    public final boolean isSMB2 () {
        return this.smb2;
    }


    /**
     * @return the dialect
     */
    public final int getDialect () {
        if ( !this.smb2 ) {
            throw new UnsupportedOperationException();

            try {
                entries = doMsrpcShareEnum(tc, locator, transport.getRemoteAddress());
            }
            catch ( IOException ioe ) {
                if ( th.isSMB2() ) {
                    throw ioe;
                }
                log.debug("doMsrpcShareEnum failed", ioe);
                entries = doNetShareEnum(th);
            }

                }
            }
            catch ( SmbUnsupportedOperationException e ) {
                try ( SmbTreeHandle th = defaultShareRoot.getTreeHandle() ) {
                    Assume.assumeTrue("Not SMB2", th.isSMB2());
                }
                throw e;
            }
            finally {
                if ( !renamed && f.exists() ) {
                    f.delete();
                }
            }

        this.openFlags = openFlags;
        this.access = access;
        this.sharing = sharing;

        try ( SmbTreeHandleInternal th = file.ensureTreeConnected() ) {
            this.smb2 = th.isSMB2();
            if ( file.getType() != SmbConstants.TYPE_NAMED_PIPE ) {
                try ( SmbFileHandle h = ensureOpen() ) {}
                this.openFlags &= ~ ( SmbConstants.O_CREAT | SmbConstants.O_TRUNC );

     * @param th
     * @return whether the handles refer to the same tree
     */
    boolean isSameTree ( SmbTreeHandle th );


    /**
     * @return whether this tree handle uses SMB2+
     */
    boolean isSMB2 ();


    /**
     * @return the remote host name
     */
    String getRemoteHostName ();


    /**
     * @return the tree type
     */
    int getTreeType ();

     */
    static void copyFile ( SmbFile src, SmbFile dest, byte[][] b, int bsize, WriterThread w, SmbTreeHandleImpl sh, SmbTreeHandleImpl dh )
            throws SmbException {

        if ( sh.isSMB2() && dh.isSMB2() && sh.isSameTree(dh) ) {
            try {
                serverSideCopy(src, dest, sh, dh, false);
                return;
            }
            catch ( SmbUnsupportedOperationException e ) {

        this.signingEnforced = signingEnforced;
        setFlags2(config.getFlags2());

        if ( config.getMinimumVersion().isSMB2() ) {
            this.dialects = new String[] {
                "SMB 2.???", "SMB 2.002"
            };
        }
        else if ( config.getMaximumVersion().isSMB2() ) {
            this.dialects = new String[] {
                "NT LM 0.12", "SMB 2.???", "SMB 2.002"
            };
        }

    }


    /**
     * @return whether this tree handle uses SMB2
     */
    @Override
    public boolean isSMB2 () {
        try ( SmbSessionImpl session = this.treeConnection.getSession();
              SmbTransportImpl transport = session.getTransport() ) {
            return transport.isSMB2();
        }
        catch ( SmbException e ) {
            log.debug("Failed to connect for determining SMB2 support", e);

     */
    SmbSession getSmbSession ( CIFSContext tf, String targetHost, String targetDomain );


    /**
     * @return whether this is a SMB2 connection
     * @throws SmbException
     */
    boolean isSMB2 () throws SmbException;


    /**
     * @return number of inflight requests
     */
    int getInflightRequests ();

              SmbTreeInternal tree = sess.unwrap(SmbSessionInternal.class).getSmbTree(getTestShare(), null).unwrap(SmbTreeInternal.class) ) {

            if ( trans.isSMB2() ) {
                Smb2CreateRequest create = new Smb2CreateRequest(sess.getConfig(), "\\foocc");
                create.setCreateDisposition(Smb2CreateRequest.FILE_OPEN_IF);