* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.pac.kerberos;


import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.math.BigInteger;
import java.security.GeneralSecurityException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

import javax.security.auth.kerberos.KerberosKey;

        Decodable i = createInformation(this.expectInfoType, this.expectInfoClass);
        if ( i != null ) {
            i.decode(buffer, bufferOffset, bufferLength);
        }
        bufferIndex = Math.max(bufferIndex, bufferOffset + bufferLength);
        this.info = i;
        return bufferIndex - start;
    }

        if ( str.length() % maxLen != 0 ) {
            num++;
        }
        String strings[] = new String[num];
        for ( int i = 0; i < num; i++ ) {
            strings[ i ] = str.substring(i * maxLen, Math.min(str.length() - 1, ( i + 1 ) * maxLen));
        }
        return strings;
    }


    @Test
    public void testUnicode () throws UnknownHostException, CIFSException, MalformedURLException {

        byte[] enc = constant;
        int klen = keybytes.length;
        byte[] dk = new byte[klen];
        for ( int n = 0; n < klen; ) {
            byte[] block = cipher.doFinal(enc);
            int len = Math.min(klen - n, block.length);
            System.arraycopy(block, 0, dk, n, len);
            n += len;
            enc = block;
        }
        return dk;
    }

    }

    public void update( byte[] input, int offset, int len ) {
        if( log.level >= 5 ) {
            log.println( "update: " + updates + " " + offset + ":" + len );
            Hexdump.hexdump( log, input, offset, Math.min( len, 256 ));
            log.flush();
        }
        if( len == 0 ) {
            return; /* CRITICAL */
        }
        digest.update( input, offset, len );
        updates++;
    }

            file.open( openFlags, access, SmbFile.ATTR_NORMAL, 0 );
            this.openFlags &= ~(SmbFile.O_CREAT | SmbFile.O_TRUNC);
        } else {
            file.connect0();
        }
        readSize = Math.min( file.tree.session.transport.rcv_buf_size - 70,
                            file.tree.session.transport.server.maxBufferSize - 70 );
    }

    protected IOException seToIoe(SmbException se) {
        IOException ioe = se;

    /**
     * @param config
     * @param fileId
     */
    public Smb2QueryInfoRequest ( Configuration config, byte[] fileId ) {
        super(config, SMB2_QUERY_INFO);
        this.outputBufferLength = ( Math.min(config.getMaximumBufferSize(),  config.getListSize()) - Smb2QueryInfoResponse.OVERHEAD ) & ~0x7;
        this.fileId = fileId;
    }


    /**
     * {@inheritDoc}
     *

    // open function
    static final int OPEN_FUNCTION_FAIL_IF_EXISTS      = 0x0000;
    static final int OPEN_FUNCTION_OVERWRITE_IF_EXISTS = 0x0020;

    static final int PID = (int)( Math.random() * 65536d );

    static final int SECURITY_SHARE = 0x00;
    static final int SECURITY_USER  = 0x01;

    static final int CMD_OFFSET        = 4;
    static final int ERROR_CODE_OFFSET = 5;

        if ( this.inputData != null ) {
            this.inputData.decode(buffer, inputOffset, inputCount);
        }
        bufferIndex = Math.max(inputOffset + inputCount, bufferIndex);

        if ( this.outputBuffer != null ) {
            if ( outputCount > this.outputBuffer.length ) {

            throw new SMBProtocolDecodingException("Buffer to small for read response");
        }
        System.arraycopy(buffer, dataStart, this.outputBuffer, this.outputBufferOffset, this.dataLength);
        bufferIndex = Math.max(bufferIndex, dataStart + this.dataLength);
        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#isErrorResponseStatus()