// Returns ErrInvalidChecksum if a problem with the checksum is found.
func (r *Reader) AddChecksum(req *http.Request, ignoreValue bool) error {
	cs, err := GetContentChecksum(req.Header)
	if err != nil {
		return ErrInvalidChecksum
	}
	if cs == nil {
		return nil
	}
	r.contentHash = *cs
	if cs.Type.Trailing() {
		r.trailer = req.Trailer
	}
	return r.AddNonTrailingChecksum(cs, ignoreValue)
}

     *      jcifs.internal.smb2.ServerMessageBlock2)
     */
    @Override
    protected Smb2CloseResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2CloseResponse> req ) {
        return new Smb2CloseResponse(tc.getConfig(), this.fileId, this.fileName);
    }


    /**
     * @param flags
     *            the flags to set
     */

     *      jcifs.internal.smb2.ServerMessageBlock2Request)
     */
    @Override
    protected Smb2QueryInfoResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2QueryInfoResponse> req ) {
        return new Smb2QueryInfoResponse(tc.getConfig(), this.infoType, this.fileInfoClass);
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()

        this.outputBufferOffset = outputBufferOffset;
    }


    @Override
    protected Smb2ReadResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2ReadResponse> req ) {
        return new Smb2ReadResponse(tc.getConfig(), this.outputBuffer, this.outputBufferOffset);
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.RequestWithFileId#setFileId(byte[])

        return this.response;
    }


    /**
     * @param config2
     * @return
     */
    protected abstract T createResponse ( CIFSContext tc, ServerMessageBlock2Request<T> req );


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

	if !s.IsValid(w, r) {
		return
	}

	var req DeleteBulkReq
	mr := msgpNewReader(r.Body)
	defer readMsgpReaderPoolPut(mr)

	if err := req.DecodeMsg(mr); err != nil {
		s.writeErrorResponse(w, err)
		return
	}

	volume := r.Form.Get(storageRESTVolume)
	keepHTTPResponseAlive(w)(s.getStorage().DeleteBulk(r.Context(), volume, req.Paths...))
}

// ReadMultiple returns multiple files

        super(config, SMB2_FLUSH);
        this.fileId = fileId;
    }


    @Override
    protected Smb2FlushResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2FlushResponse> req ) {
        return new Smb2FlushResponse(tc.getConfig());
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.RequestWithFileId#setFileId(byte[])
     */
    @Override

	if objectAPI == nil {
		return
	}

	var req madmin.SRRemoveReq
	if err := parseJSONBody(ctx, r.Body, &req, ""); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	if err := globalSiteReplicationSys.InternalRemoveReq(ctx, objectAPI, req); err != nil {
		adminLogIf(ctx, err)
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)

func (s *xlStorage) ReadMultiple(ctx context.Context, req ReadMultipleReq, resp chan<- ReadMultipleResp) error {
	defer xioutil.SafeClose(resp)

	volumeDir := pathJoin(s.drivePath, req.Bucket)
	found := 0
	for _, f := range req.Files {
		if contextCanceled(ctx) {
			return ctx.Err()
		}
		r := ReadMultipleResp{
			Bucket: req.Bucket,
			Prefix: req.Prefix,
			File:   f,
		}

        super(config, SMB2_TREE_CONNECT);
        this.path = path;
    }


    @Override
    protected Smb2TreeConnectResponse createResponse ( CIFSContext tc, ServerMessageBlock2Request<Smb2TreeConnectResponse> req ) {
        return new Smb2TreeConnectResponse(tc.getConfig());
    }


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