SmbComReadAndX() {
        super( null );
        command = SMB_COM_READ_ANDX;
        openTimeout = 0xFFFFFFFF;
    }
    SmbComReadAndX( int fid, long offset, int maxCount, ServerMessageBlock andx ) {
        super( andx );
        this.fid = fid;
        this.offset = offset;
        this.maxCount = minCount = maxCount;
        command = SMB_COM_READ_ANDX;
        openTimeout = 0xFFFFFFFF;
    }

    int openTimeout;
    int maxCount, minCount, remaining;


    /**
     * 
     * @param config
     */
    public SmbComReadAndX ( Configuration config ) {
        super(config, SMB_COM_READ_ANDX);
        this.openTimeout = 0xFFFFFFFF;
    }


    /**
     * 
     * @param config
     * @param fid
     * @param offset
     * @param maxCount
     * @param andx
     */

                }
            } else {
                openFunction = OPEN_FN_OPEN;
            }
        }
    }

    int getBatchLimit( byte command ) {
        return command == SMB_COM_READ_ANDX ? BATCH_LIMIT : 0;
    }
    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        writeInt2( flags, dst, dstIndex );
        dstIndex += 2;

    public final void setWriteMode ( int writeMode ) {
        this.writeMode = writeMode;
    }


    @Override
    protected int getBatchLimit ( Configuration cfg, byte cmd ) {
        if ( cmd == SMB_COM_READ_ANDX ) {
            return cfg.getBatchLimit("WriteAndX.ReadAndX");
        }
        if ( cmd == SMB_COM_CLOSE ) {
            return cfg.getBatchLimit("WriteAndX.Close");
        }
        return 0;
    }

                        * like writeandx will choke if session
                        * closes in between */
    }
    int getBatchLimit( byte command ) {
        if( command == SMB_COM_READ_ANDX ) {
            return READ_ANDX_BATCH_LIMIT;
        }
        if( command == SMB_COM_CLOSE ) {
            return CLOSE_BATCH_LIMIT;
        }
        return 0;
    }

                c = "SMB_COM_NT_CREATE_ANDX";
                break;
            case SMB_COM_OPEN_ANDX:
                c = "SMB_COM_OPEN_ANDX";
                break;
            case SMB_COM_READ_ANDX:
                c = "SMB_COM_READ_ANDX";
                break;
            case SMB_COM_CLOSE:
                c = "SMB_COM_CLOSE";
                break;
            case SMB_COM_WRITE_ANDX:

                this.openFunction = OPEN_FN_OPEN;
            }
        }
    }


    @Override
    protected int getBatchLimit ( Configuration cfg, byte cmd ) {
        return cmd == SMB_COM_READ_ANDX ? cfg.getBatchLimit("OpenAndX.ReadAndX") : 0;
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        ServerMessageBlock.writeInt4(response.signSeq, sequence, 0); 
        update(sequence, 0, sequence.length); 
        index += 8;
        if( response.command == ServerMessageBlock.SMB_COM_READ_ANDX ) {
            /* SmbComReadAndXResponse reads directly from the stream into separate byte[] b.
             */
            SmbComReadAndXResponse raxr = (SmbComReadAndXResponse)response;

            switch( request.command ) {
                case ServerMessageBlock.SMB_COM_OPEN_ANDX:
                case ServerMessageBlock.SMB_COM_NT_CREATE_ANDX:
                case ServerMessageBlock.SMB_COM_READ_ANDX:
                case ServerMessageBlock.SMB_COM_WRITE_ANDX:
                case ServerMessageBlock.SMB_COM_CLOSE:
                case ServerMessageBlock.SMB_COM_TREE_DISCONNECT:
                    break;

            c = "SMB_COM_NT_CREATE_ANDX";
            break;
        case SMB_COM_OPEN_ANDX:
            c = "SMB_COM_OPEN_ANDX";
            break;
        case SMB_COM_READ_ANDX:
            c = "SMB_COM_READ_ANDX";
            break;
        case SMB_COM_CLOSE:
            c = "SMB_COM_CLOSE";
            break;
        case SMB_COM_WRITE_ANDX:
            c = "SMB_COM_WRITE_ANDX";