return getHeaderFields0();
    }

    public int getHeaderFieldInt(String header, int def) {
        try {
            handshake();
        } catch (IOException ex) { }
        return connection.getHeaderFieldInt(header, def);
    }

    public long getHeaderFieldDate(String header, long def) {
        try {
            handshake();
        } catch (IOException ex) { }

            if ( have != 0 ) {
                NdrBuffer hdrBuf = new NdrBuffer(inB, 0);
                setupReceivedFragment(hdrBuf);
                hdrBuf.setIndex(0);
                msg.decode_header(hdrBuf);
            }

            NdrBuffer msgBuf;
            if ( have != 0 && !msg.isFlagSet(DCERPC_LAST_FRAG) ) {
                msgBuf = new NdrBuffer(receiveMoreFragments(msg, inB), 0);
            }

    {
        int targetInfoLength = targetInfo != null ? targetInfo.length : 0;
        byte[] temp = new byte[28 + targetInfoLength + 4];

        Encdec.enc_uint32le(0x00000101, temp, 0); // Header
        Encdec.enc_uint32le(0x00000000, temp, 4); // Reserved
        Encdec.enc_uint64le(nanos1601, temp, 8);
        System.arraycopy(clientChallenge, 0, temp, 16, 8);

            /*
             * A word about communicating header info to andx smbs
             *
             * This is where we recursively invoke the provided andx smb
             * object to write it's parameter words and bytes to our outgoing
             * array. Incedentally when these andx smbs are created they are not
             * necessarily populated with header data because they're not writing

    static final int NBSTAT = 0x0021;
    static final int IN = 0x0001;
    static final int A = 0x0001;
    static final int NS = 0x0002;
    static final int NULL = 0x000a;

    static final int HEADER_LENGTH = 12;

    // header field offsets
    static final int OPCODE_OFFSET = 2;
    static final int QUESTION_OFFSET = 4;
    static final int ANSWER_OFFSET = 6;
    static final int AUTHORITY_OFFSET = 8;

                    }
                }
                // == 5*128 = 640

                // . and .. entries = 200 byte (includes alignment)

                // + 64 byte header
                // + 8 byte query response overhead
                // + 110 bytes entry
                // -> 1022 predicted message size <= 1023 maximum buffer size
                // 112 bytes to alignment

    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size () {
        int size = Smb2Constants.SMB2_HEADER_LENGTH + 56;
        int nameLen = 2 * this.name.length();
        if ( nameLen == 0 ) {
            nameLen++;
        }

        size += size8(nameLen);
        if ( this.createContexts != null ) {

     * Some fields specify the offset from the beginning of the header. This
     * field should be used for calculating that. This would likely be zero
     * but an implemantation that encorporates the transport header(for
     * efficiency) might use a different initial bufferIndex. For example,
     * to eliminate copying data when writing NbtSession data one might
     * manage that 4 byte header specifically and therefore the initial

    }


    @Override
    public int getHeaderFieldInt ( String header, int def ) {
        handshake();
        return this.connection.getHeaderFieldInt(header, def);
    }


    @Override
    public long getHeaderFieldDate ( String header, long def ) {
        handshake();
        return this.connection.getHeaderFieldDate(header, def);
    }


    @Override

    static final int IN        = 0x0001;
    static final int A         = 0x0001;
    static final int NS        = 0x0002;
    static final int NULL      = 0x000a;

    static final int HEADER_LENGTH = 12;

    // header field offsets
    static final int OPCODE_OFFSET = 2;
    static final int QUESTION_OFFSET = 4;
    static final int ANSWER_OFFSET = 6;
    static final int AUTHORITY_OFFSET = 8;