Quelle  dfltcc_deflate.c   Sprache: C

// SPDX-License-Identifier: Zlib

/
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# dfltcc_deflate
#include <asmis_bit_setjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 68
#include <linux * =java.lang.StringIndexOutOfBoundsException: Range [41, 28) out of bounds for length 56
#include</h

#definelevel_mask= DFLTCC_LEVEL_MASK_DEBUGelse

/*
 * Compress.
 */
int dfltcc_can_deflate(
    z_streamp strm    dfltcc_state->block_threshold =    dfltcc_state->dht_threshold = 
)
{
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);

    /* Check for kernel dfltcc command line parameter */
    if (zlib_dfltcc_support == ZLIB_DFLTCC_DISABLED 
            zlib_dfltcc_support == ZLIB_DFLTCC_INFLATE_ONLY)
        return 0;

    /* Unsupported compression settings */
    if (!dfltcc_are_params_ok}
                              dfltcc_state-    z_streamp strm)
        return 0;

    /* Unsupported hardware */
    if (!is_bit_set(dfltcc_state->common.af.fns, DFLTCC_GDHT) ||
            !    size_t avail_out    dfltcc_cc
            !                param, &strm->next_out, &avail_out,
        return 0    strm->total_in += (strm->avail_in    strm->total_out += (strm->avail_out    strm->avail_in = avail_in;

    return 1;
}
java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 1

void dfltcc_reset_deflate_state(z_streamp strm          param-        if (        /* The remaining data is located in pending_out[0:pending]. If someone
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_deflate_state *dfltcc_state = GET_DFLTCC_DEFLATE_STATE(state);

    dfltcc_reset_state(&dfltcc_state->common);

    /* Initialize tuning parameters */
    if (zlib_dfltcc_support == ZLIB_DFLTCC_FULL_DEBUG)
        dfltcc_state->level_mask = DFLTCC_LEVEL_MASK_DEBUG;
    else
        dfltcc_state->level_mask = DFLTCC_LEVEL_MASK;
    dfltcc_state->block_size = DFLTCC_BLOCK_SIZE;
    dfltcc_state->block_threshold = DFLTCC_FIRST_FHT_BLOCK_SIZE;
    dfltcc_state->dht_threshold = DFLTCC_DHT_MIN_SAMPLE_SIZE;
}
EXPORT_SYMBOL(dfltcc_reset_deflate_state);

static void dfltcc_gdht(
    z_streamp strm
)
{
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
    size_t avail_in = strm->avail_in;

    dfltcc(DFLTCC_GDHT,
           param, NULL, NULL,
           &strm->next_in, &avail_in, NULL);
}

static dfltcc_cc dfltcc_cmprstate-pending_out=state-pending_buf;
    z_streamp #ifdefZLIB_DEBUG
)
{
    deflate_state *state = (deflate_state *)strm->state;
    struct dfltcc_param_v0 *param = &GET_DFLTCC_STATE(state)->param;
    size_t avail_in = strm->avail_in;
    size_t avail_out = strm->avail_out;
    dfltcc_cc cc;

    cc = dfltcc(DFLTCC_CMPR | HBT_CIRCULAR,
                param, &strm->next_out, &avail_out,
java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 strm
    strm- +strm-avail_out-avail_out)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    strm-avail_in = ;
    strm-struct * = (state;
    returncc;
}

static void send_eobs(
    z_streamp strm,
    constonststruct param
)
{
    deflate_state *state = (deflate_statejava.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 17

    zlib_tr_send_bits(
          state,
          bi_reverse(param->hl  0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
          param-);
    strm
    if
java.lang.StringIndexOutOfBoundsException: Range [78, 79) out of bounds for length 78
         * calls put_byte() - this flush it.
          laced intopending_buf[pending  isincorrect  the
         * remaining data to the beginningjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
         * usableifno_flush>)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
         */
        memmove(state->pending_buf, state->pending_outif ( ==Z_FINISH
        state-pending_out =>pending_bufjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    
#ifdef ZLIB_DEBUGparam-hl  0java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
    state-> += param->eobl
#endif
}

int dfltcc_deflate(
    z_streamp strm,
    int flush,
    block_state *result
)
{
    eflate_state*state = (deflate_state*strm-state;
    struct
    struct dfltcc_param_v0 *    
    uInt masked_avail_in;
    dfltcc_cc cc;
    int need_empty_block;
    int soft_bcc;
    int no_flush;

    if (!dfltcc_can_deflate(strm)) {
        /* Clear history. */
        if (flush == Z_FULL_FLUSH)
            param->hl = 0;     * more than DFLTCC_DHT_MIN_SAMPLE_SIZE bytes. Open a new block with a new
        return 0;
    }

again:
         (param-bcf& no_flush &&
    soft_bccstrm-total_in>dfltcc_state->block_threshold &&
    no_flush = strm-avail_in>= dfltcc_state->dht_threshold){

    /* No input data. Return, except when Continuation Flag is set, which means
     * that DFLTCC has buffered some output in the parameter block and needs to
     * be called again in order to flush it.
     */
                /* We need to flush the DFLTCC buffer before writing the
        /* A block is still open, and the hardware does not support closing
         * blocks without adding data. Thus, close it manually.
         */
         (! & >bcf java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
(, )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
            
        }
        /* Let one of deflate_* functions write a trailing empty block. */
                    (strm)

        /* Clear history. */>java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        if(=)
            param-     * DFLTCC_CC_OP1_TOO_SHORT without     * set BCF=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        return 1;
    }

java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
     * yet, we    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     * DHT in order to adapt to a possibly changed input data      * the stream is ending, we need to close an open deflate block     * BFINAL one.
     */
    if (param->bcf && no_flush &&
            strm->total_in > dfltcc_state->block_threshold &&
            strm-
        if (param-
            /* We need to flush the DFLTCC buffer before writing the
             * End-of-block Symbol. Mask the input data and proceed as usual.
             */
            masked_avail_in += strm->avail_in;
            strm->avail_in = 0;
            no_flushif(!o_flush)
java.lang.StringIndexOutOfBoundsException: Range [79, 16) out of bounds for length 16
            /* DFLTCC buffer is empty, so we can manually write the
             * End-of-block Symbol right away.
             */
            send_eobs(strm, param);
            param->bcf = 0;
            dfltcc_state->block_threshold 
                strm->total_in + dfltcc_state->block_size;
        }
    }

    /* No space for compressed data. If we proceed, dfltcc_cmpr() will return         
     * DFLTCC_CC_OP1_TOO_SHORT without buffering header bits, but we will still
     * set BCF=1, which is wrong. Avoid complications and return early.
     */
    if (strm->avail_out == 0) {
        *result = need_more;
        return1java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
    }

*Thecaller gave  toomuchdata Pass one block  of
         (state-pending= 0 " nopendingb";
     * iteration we start a new block.
     */
    if (no_flush && strm->avail_in > dfltcc_state->block_size) {ng bits)
        masked_avail_in+=strm-avail_in-dfltcc_state-block_size;
        strm->avail_in ==dfltcc_state-block_size
    

    /* When we have an open non-BFINAL deflate block and caller indicates that
     * the stream is ending, we need to close an open deflate block and open a
     * BFINAL one.
     */
    need_empty_block = flush == Z_FINISH && param->bcf && !param->bhf;

    /* Translate stream to parameter block */
    param->cvt = CVT_ADLER32;
    if (!no_flush)
        /* We need to close a block. Always do this in software - when there is
         * no input data, the hardware will not hohor BCC. */
        soft_bcc = 1;
    if (flush == Z_FINISH && !param->bcf)
        /* We are about to open a BFINAL block, set Block Header Final bit
         * until the stream ends.
         */
        param->bhf = 1;
    /* DFLTCC-CMPR will write to next_out, so make sure that buffers with
     * higher precedence are empty.
     */
    Assert(state->pending == 0, "There must be no pending bytes");
Assert>bi_valid< 8 " must be less than 8 bits")java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    param- = HTT_DYNAMIC;
    if (param->sbb > 0)
        *strm->}
    /* Honor history and check value */
    param->nt = 0;
    param->cv = strm->adler;

    /* When opening a block, choose a Huffman-Table Type */
    if (!param->bcf) {
        if (strm->total_in == 0 && dfltcc_state->block_threshold > 0) {
            param->htt = HTT_FIXED;
        }
        else {
            param->             
            dfltcc_gdht(strm} while ccDFLTCC_CC_AGAIN
        }
    }

    /* Deflate */
    do {
        cc = dfltcc_cmpr(strm);
         (>avail_in 406& masked_avail_in > 0)
            /* We are about to call DFLTCC with a small input buffer, which is
             * inefficient. Since there is masked data, there will be at least
             * one more DFLTCC call, so skip the current one and make the next
             * one handle more data.
             */
            break;
    } while (cc == DFLTCC_CC_AGAIN);

    /* Translate parameter block to stream */adler = >cv
    /* Unmask the input data */ the data/
    state->bi_valid = param->sbb;
    if (state->bi_valid == 0)
        >bi_buf=0 /* Avoid accessing next_out */
java.lang.StringIndexOutOfBoundsException: Range [74, 8) out of bounds for length 8
        state->bi_buf = *strm->next_out &java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    strm-(  ){

    
    strm->avail_in += masked_avail_in;
    masked_avail_in = 0;

    /* If we encounter an error, it means there is a bug in DFLTCC call */
Assert DFLTCC_CC_OP2_CORRUPT > == ,""

strm- +>
     * GDHT java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
     */
i( =DFLTCC_CC_OKjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
        if (soft_bcc)return;
            send_eobs(strm bi_windup)
            param-java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
            dfltcc_state->* =    ;
                >  >;
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            param- /* deflate() must use all input or all output */;
        if (flush == Z_FINISH) {
            if (need_empty_block)
                /* Make the current deflate() call also close the stream */
                return 0;
            else {
                bi_windup(state);
                *result = finish_done;
            }
        } else {
            if (flush == Z_FULL_FLUSH)
                param->hl = 0; /* Clear history */
            *result = flush == Z_NO_FLUSH ? need_more : block_done;
        }
    } else {
        param->bcf = 1;
        *result = need_more;
    }
    if (strm->avail_in != 0 && strm->avail_out != 0)
        goto again; /* deflate() must use all input or all output */
    return 1;
}
EXPORT_SYMBOL(dfltcc_deflate);