* 
     * @param dc
     * @param tc
     * @throws CIFSException
     * @deprecated functionality is broken and will be removed at some point,
     *             use actual Active Directory authentication instead
     */
    @Deprecated
    void logon ( CIFSContext tc, Address dc ) throws CIFSException;


    /**
     * Authenticate arbitrary credentials represented by the

    public int encode ( byte[] dst, int dstIndex ) {
        int len = super.encode(dst, dstIndex);
        int exp = size();
        int actual = getLength();
        if ( exp != actual ) {
            throw new IllegalStateException(String.format("Wrong size calculation have %d expect %d", exp, actual));
        }
        return len;
    }


    /**
     * {@inheritDoc}
     *

                 * exporting the volumes, not the one that we will actually
                 * end up performing IO with. If the server hosting the
                 * actual files has a smaller maxBufSize this could be
                 * incorrect. To handle this properly it is necessary
                 * to redirect the tree to the target server first before

            private Address[] wrap ( String hostname, Address[] all ) {
                Address actual = all[ 0 ];
                NetbiosAddress nbt = actual.unwrap(NetbiosAddress.class);

                if ( nbt != null ) {
                    return new Address[] {
                        new UniAddress(this.replacementNetbios), actual
                    };
                }

                return new Address[] {

        bufferIndex += 8;
        
        // read caller available allocation units 
        info.free = readInt8( buffer, bufferIndex );
        bufferIndex += 8;

        // skip actual free units
        bufferIndex += 8;
        
        info.sectPerAlloc = readInt4( buffer, bufferIndex );
        bufferIndex += 4;
        
        info.bytesPerSect = readInt4( buffer, bufferIndex );

            // first remaining path element would be share
            if ( nameParts.length > pos ) {
                this.share = nameParts[ pos++ ];
            }

            // all other remaining path elements are actual path
            if ( nameParts.length > pos ) {
                String[] remainParts = new String[nameParts.length - pos];
                System.arraycopy(nameParts, pos, remainParts, 0, nameParts.length - pos);

        return this.masterKey;
    }


    /**
     * Returns the session key.
     * 
     * This is the encrypted session key included in the message,
     * if the actual session key is desired use {@link #getMasterKey()} instead.
     *
     * @return A <code>byte[]</code> containing the encrypted session key.
     */
    public byte[] getEncryptedSessionKey () {

            }

            byte verify[] = new byte[read];
            ReadWriteTest.randBytes(r, verify);
            byte actual[] = Arrays.copyOfRange(buffer, 0, read);

            assertArrayEquals("Data matches at offset " + p, actual, verify);

            p += read;
        }
        assertEquals("Expecting EOF", -1, is.read(buffer, 0, 1));

        bufferIndex += 8;

        // read caller available allocation units
        this.free = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // skip actual free units
        bufferIndex += 8;

        this.sectPerAlloc = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.bytesPerSect = SMBUtil.readInt4(buffer, bufferIndex);

                fail("Unexpected EOF at " + p);
            }

            byte verify[] = new byte[read];
            randBytes(r, verify);
            byte actual[] = Arrays.copyOfRange(buffer, 0, read);

            assertArrayEquals("Data matches at offset " + p, actual, verify);

            p += read;
        }
        if ( expectEof ) {
            assertEquals("Expecting EOF", -1, is.read(buffer, 0, 1));
        }