From 9e837118e0613742d6a6138fa905899e837b78d5 Mon Sep 17 00:00:00 2001 From: Rusty Russell Date: Tue, 7 Apr 2009 14:15:02 +0930 Subject: [PATCH] Change arguments to crcsync code. --- ccan/crcsync/crcsync.c | 29 ++++++++++++----------------- ccan/crcsync/crcsync.h | 8 ++++---- ccan/crcsync/test/run-crash.c | 4 ++-- ccan/crcsync/test/run.c | 8 ++++---- 4 files changed, 22 insertions(+), 27 deletions(-) diff --git a/ccan/crcsync/crcsync.c b/ccan/crcsync/crcsync.c index 459010a7..b6eb65b0 100644 --- a/ccan/crcsync/crcsync.c +++ b/ccan/crcsync/crcsync.c @@ -35,8 +35,8 @@ struct crc_context { 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]; @@ -66,25 +66,20 @@ static void init_uncrc_tab(uint32_t uncrc_tab[], unsigned int wsize) 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) @@ -123,12 +118,12 @@ static int crc_matches(const struct crc_context *ctx) 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) @@ -197,7 +192,7 @@ size_t crc_read_block(struct crc_context *ctx, long *result, 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; } @@ -217,7 +212,7 @@ size_t crc_read_block(struct crc_context *ctx, long *result, 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; diff --git a/ccan/crcsync/crcsync.h b/ccan/crcsync/crcsync.h index 4b25562b..f4d6f686 100644 --- a/ccan/crcsync/crcsync.h +++ b/ccan/crcsync/crcsync.h @@ -19,14 +19,14 @@ void crc_of_blocks(const void *data, size_t len, unsigned int blocksize, /** * 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, diff --git a/ccan/crcsync/test/run-crash.c b/ccan/crcsync/test/run-crash.c index 7fb1df45..9987f8dc 100644 --- a/ccan/crcsync/test/run-crash.c +++ b/ccan/crcsync/test/run-crash.c @@ -55,14 +55,14 @@ int main(int argc, char *argv[]) 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); diff --git a/ccan/crcsync/test/run.c b/ccan/crcsync/test/run.c index b21ad01e..49f20336 100644 --- a/ccan/crcsync/test/run.c +++ b/ccan/crcsync/test/run.c @@ -65,17 +65,17 @@ static void test_sync(const char *buffer1, size_t len1, 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) { @@ -94,7 +94,7 @@ static void test_sync(const char *buffer1, size_t len1, /* 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) { -- 2.39.2