*/
    @Override
    public byte[] getServerEncryptionKey() {
        if (this.negotiated == null) {
            return null;
        }

        if (this.negotiated instanceof SmbComNegotiateResponse) {
            return ((SmbComNegotiateResponse) this.negotiated).getServerData().encryptionKey;
        }
        return null;
    }

    @Override

     * @param selectedMech the selected mechanism OID
     * @return whether the specified mechanism is preferred
     */
    boolean isPreferredMech(ASN1ObjectIdentifier selectedMech);

    /**
     * Gets the negotiated context flags.
     * @return context flags
     */
    int getFlags();

    /**
     * Gets the array of supported security mechanism OIDs.
     * @return array of supported mechanism OIDs
     */

                log.debug("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;

        final int start = bufferIndex;

        pathConsumed = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        /* Samba 2.2.8a will reply with Unicode paths even though
         * ASCII is negotiated so we must use flags2 (probably
         * should anyway).
         */
        if ((flags2 & FLAGS2_UNICODE) != 0) {
            pathConsumed /= 2;
        }
        numReferrals = readInt2(buffer, bufferIndex);

        // Test that ChannelManager initializes properly
        assertNotNull(channelManager);
        assertNotNull(channelManager.getChannels());
        // Note: isUseMultiChannel() checks if actual multi-channel is negotiated with server
        // In mock environment, this will be false until we mock successful negotiation

        // Verify load balancer is initialized
        assertNotNull(channelManager.getLoadBalancer());
    }

            //      e.eaSize = readInt4( buffer, bufferIndex + 64 );
            //      e.shortNameLength = buffer[bufferIndex + 68] & 0xFF;

            /* With NT, the shortName is in Unicode regardless of what is negotiated.
             */

            //      e.shortName = readString( buffer, bufferIndex + 70, e.shortNameLength );
            e.filename = readString(buffer, bufferIndex + 94, e.fileNameLength);

     * both internally supplied passwords are equal. If one {@code NtlmPasswordAuthentication} object has external
     * hashes (meaning negotiated via NTLM HTTP Authentication) and the other does not they will not be equal. This is
     * technically not correct however the server 8 byte challenge would be required to compute and compare the password

   OkHttp.
 * Expose the transport ("http/1.1", "spdy/3", etc.) via magic request headers.
   Use `X-Android-Transports` to write the preferred transports and
   `X-Android-Selected-Transport` to read the negotiated transport.


## Version 1.0.2

_2013-05-11_

 * Fix: Remove use of Java 6-only APIs.
 * Fix: Properly handle exceptions from `NetworkInterface` when querying MTU.

            log.debug("No support or SMB signing is enabled, not enabling large writes");
            this.writeSizeFile = this.writeSize;
        }

        if (log.isDebugEnabled()) {
            log.debug("Negotiated file write size is " + this.writeSizeFile);
        }

        if (this.useNTSmbs) {
            this.reqx = new SmbComWriteAndX(th.getConfig());
            this.rspx = new SmbComWriteAndXResponse(th.getConfig());

        } else {
            log.debug("LARGE_READX disabled");
            this.readSizeFile = this.readSize;
        }

        if (log.isDebugEnabled()) {
            log.debug("Negotiated file read size is " + this.readSizeFile);
        }
    }

    /**
     * Ensures that the file descriptor is openend
     *
     * @throws CIFSException if an error occurs while opening the file
     */