int have_match;
/* Final block is special (if a different size) */
- size_t final_size;
- uint32_t final_crc;
+ size_t tail_size;
+ uint32_t tail_crc;
/* Uncrc tab. */
uint32_t uncrc_tab[256];
struct crc_context *crc_context_new(size_t block_size, unsigned crcbits,
const uint32_t crc[], unsigned num_crcs,
- size_t final_size)
+ size_t tail_size)
{
struct crc_context *ctx;
assert(num_crcs > 0);
assert(block_size > 0);
- assert(final_size > 0);
- assert(final_size <= block_size);
+ assert(tail_size < block_size);
ctx = malloc(sizeof(*ctx) + sizeof(crc[0])*num_crcs);
if (ctx) {
ctx->block_size = block_size;
- if (final_size != block_size) {
- ctx->final_size = final_size;
- ctx->final_crc = crc[--num_crcs];
- } else {
- /* If this is 0, we never compare against it. */
- ctx->final_size = 0;
- }
+ ctx->tail_size = tail_size;
+ if (tail_size)
+ ctx->tail_crc = crc[--num_crcs];
/* Technically, 1 << 32 is undefined. */
if (crcbits >= 32)
return -1;
}
-static bool final_matches(const struct crc_context *ctx)
+static bool tail_matches(const struct crc_context *ctx)
{
- if (ctx->literal_bytes != ctx->final_size)
+ if (ctx->literal_bytes != ctx->tail_size)
return false;
- return (ctx->running_crc & ctx->crcmask) == ctx->final_crc;
+ return (ctx->running_crc & ctx->crcmask) == ctx->tail_crc;
}
static uint32_t crc_add_byte(uint32_t crc, uint8_t newbyte)
old = buf;
/* We don't roll this csum, we only look for it after
* a block match. It's simpler and faster. */
- if (final_matches(ctx)) {
+ if (tail_matches(ctx)) {
crcmatch = ctx->num_crcs;
goto have_match;
}
have_match:
*result = -crcmatch-1;
if (crcmatch == ctx->num_crcs)
- assert(ctx->literal_bytes == ctx->final_size);
+ assert(ctx->literal_bytes == ctx->tail_size);
else
assert(ctx->literal_bytes == ctx->block_size);
ctx->literal_bytes = 0;
/**
* crc_context_new - allocate and initialize state for crc_find_block
- * @blocksize: the sie of each block
+ * @blocksize: the size of each block
* @crcbits: the bits valid in the CRCs (<= 32)
- * @crc: array of block crcs
+ * @crc: array of block crcs (including final block, if any)
* @num_crcs: number of block crcs
- * @final_size: the final block size (<= blocksize).
+ * @tail_size: the size of final partial block, if any (< blocksize).
*
* Returns an allocated pointer to the structure for crc_find_block,
- * or NULL. Makes a copy of @crc and @num_crcs.
+ * or NULL. Makes a copy of @crc.
*/
struct crc_context *crc_context_new(size_t blocksize, unsigned crcbits,
const uint32_t crc[], unsigned num_crcs,
size_t ndigested;
size_t offset = 0;
size_t len2 = strlen(data2);
- size_t finalsize = strlen(data1) % BLOCKSIZE ?: BLOCKSIZE;
+ size_t tailsize = strlen(data1) % BLOCKSIZE;
int expected_i = 0;
plan_tests(ARRAY_SIZE(expected) + 2);
crcblocks(&crc_info1, data1, strlen(data1), BLOCKSIZE);
crcctx = crc_context_new(BLOCKSIZE, 30, crc_info1.crcs, crc_info1.block_count,
- finalsize);
+ tailsize);
while ( offset < len2)
{
ndigested = crc_read_block(crcctx, &result, data2+offset, len2 - offset);
const struct result results[], size_t num_results)
{
struct crc_context *ctx;
- size_t used, ret, i, curr_literal, finalsize;
+ size_t used, ret, i, curr_literal, tailsize;
long result;
uint32_t crcs[num_blocks(len1, block_size)];
crc_of_blocks(buffer1, len1, block_size, 32, crcs);
- finalsize = len1 % block_size ?: block_size;
+ tailsize = len1 % block_size;
/* Normal method. */
ctx = crc_context_new(block_size, 32, crcs, ARRAY_SIZE(crcs),
- finalsize);
+ tailsize);
curr_literal = 0;
for (used = 0, i = 0; used < len2; used += ret) {
/* Byte-at-a-time method. */
ctx = crc_context_new(block_size, 32, crcs, ARRAY_SIZE(crcs),
- finalsize);
+ tailsize);
curr_literal = 0;
for (used = 0, i = 0; used < len2; used += ret) {