private boolean verifyFailed;
    private Exception exception;
    private boolean asyncHandled;


    /**
     * @param config
     * @param command
     */
    public ServerMessageBlock2Response ( Configuration config, int command ) {
        super(config, command);
    }


    /**
     * @param config
     */
    public ServerMessageBlock2Response ( Configuration config ) {
        super(config);
    }

    AndXServerMessageBlock() {
    }
    AndXServerMessageBlock( ServerMessageBlock andx ) {
        if (andx != null) {
            this.andx = andx;
            andxCommand = andx.command;
        }
    }

    int getBatchLimit( byte command ) {
        /* the default limit is 0 batched messages before this
         * one, meaning this message cannot be batched.
         */
        return 0;
    }

    /* 

 */

package jcifs.smb1.smb1;

class TransWaitNamedPipe extends SmbComTransaction {

    TransWaitNamedPipe( String pipeName ) {
        name = pipeName;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_WAIT_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;
        maxDataCount = 0;
        maxSetupCount = (byte)0x00;
        setupCount = 2;

    private long serverTimeZoneOffset;
    private int fileSize = 0;

    SmbComQueryInformationResponse( long serverTimeZoneOffset ) {
        this.serverTimeZoneOffset = serverTimeZoneOffset;
        command = SMB_COM_QUERY_INFORMATION;
    }

    public int getAttributes() {
        return fileAttributes;
    }
    public long getCreateTime() {
        return lastWriteTime + serverTimeZoneOffset;
    }

        dstIndex += 4;
        if (command == SMB_COM_NT_TRANSACT_SECONDARY) {
            writeInt4( parameterDisplacement, dst, dstIndex );
            dstIndex += 4;
        }
        writeInt4( dataCount, dst, dstIndex );
        dstIndex += 4;
        writeInt4(( dataCount == 0 ? 0 : dataOffset ), dst, dstIndex );
        dstIndex += 4;
        if (command == SMB_COM_NT_TRANSACT_SECONDARY) {

    TransCallNamedPipe( String pipeName, byte[] data, int off, int len ) {
        name = pipeName;
        pipeData = data;
        pipeDataOff = off;
        pipeDataLen = len;
        command = SMB_COM_TRANSACTION;
        subCommand = TRANS_CALL_NAMED_PIPE;
        timeout = 0xFFFFFFFF;
        maxParameterCount = 0;
        maxDataCount = 0xFFFF;
        maxSetupCount = (byte)0x00;
        setupCount = 2;

                            }
                            if (Constants.CRAWLER_PROCESS_COMMAND_THREAD_DUMP.equals(command)) {
                                ThreadDumpUtil.printThreadDump();
                            } else {
                                logger.warn("Unknown process command: {}", command);
                            }

    private byte[] b;

    SmbComWrite() {
        super();
        command = SMB_COM_WRITE;
    }
    SmbComWrite( int fid, int offset, int remaining, byte[] b, int off, int len ) {
        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
        command = SMB_COM_WRITE;
    }

    };

    String domain, lastName = null;
    int serverTypes;

    NetServerEnum2( String domain, int serverTypes ) {
        this.domain = domain;
        this.serverTypes = serverTypes;
        command = SMB_COM_TRANSACTION;
        subCommand = NET_SERVER_ENUM2; // not really true be used by upper logic
        name = "\\PIPE\\LANMAN";

        maxParameterCount = 8;
        maxDataCount = 16384;

        super(config, SMB2_CANCEL);
        setMid(mid);
        setAsyncId(asyncId);
        if ( asyncId != 0 ) {
            addFlags(SMB2_FLAGS_ASYNC_COMMAND);
        }
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.util.transport.Request#getCreditCost()
     */
    @Override
    public int getCreditCost () {
        return 1;
    }