Change arguments to crcsync code.
authorRusty Russell <rusty@rustcorp.com.au>
Tue, 7 Apr 2009 04:45:02 +0000 (14:15 +0930)
committerRusty Russell <rusty@rustcorp.com.au>
Tue, 7 Apr 2009 04:45:02 +0000 (14:15 +0930)
ccan/crcsync/crcsync.c
ccan/crcsync/crcsync.h
ccan/crcsync/test/run-crash.c
ccan/crcsync/test/run.c

index 459010a760f7e826b7a3780e8ef6491a1ee5213f..b6eb65b007fb891339689ad297f9f03ae0709cfd 100644 (file)
@@ -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;
index 4b25562bbb793d6f1bd9b193d785a963eca5aaf6..f4d6f686f88d9f6ba6173c424cddccfdce54c127 100644 (file)
@@ -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,
index 7fb1df4554ffd5754ff3d5214defbcbf9ad9828f..9987f8dc1d91d34e1d7af3199f532a310bec5651 100644 (file)
@@ -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);
index b21ad01e4b8eb77789c80eeafede7c725d4c4a14..49f203360ca9781503efa5bbcbd635d3eb1b2b1d 100644 (file)
@@ -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) {