Add preindex_size so we can easily figure out how far to seek in file, and

add offset to zck_read_header so we're getting real locations

Signed-off-by: Jonathan Dieter <jdieter@gmail.com>

diff --git a/src/lib/header.c b/src/lib/header.c
index 0d286c8079a620e6b87511753c1210c8d655d403..25c50fc0f71e751162b1a0abebe0769e0fe0e21a 100644 (file)
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -45,6 +45,7 @@ int zck_read_initial(zckCtx *zck, int src_fd) {
 
     if(!zck_hash_setup(&(zck->hash_type), header[5]))
         return False;
+    zck->preindex_size = 6;
 
     return True;
 }
@@ -62,6 +63,7 @@ int zck_read_index_hash(zckCtx *zck, int src_fd) {
         return False;
     }
     zck->index_digest = header;
+    zck->preindex_size += zck->hash_type.digest_size;
     return True;
 }
 
@@ -75,16 +77,18 @@ int zck_read_comp_type(zckCtx *zck, int src_fd) {
         return False;
     if(!zck_comp_init(zck))
         return False;
+
+    zck->preindex_size += 1;
     return True;
 }
 
 int zck_read_index_size(zckCtx *zck, int src_fd) {
     uint64_t index_size;
-
     if(!zck_read(src_fd, (char *)&index_size, sizeof(uint64_t)))
         return False;
 
     zck->comp_index_size = le64toh(index_size);
+    zck->preindex_size += sizeof(uint64_t);
     return True;
 }
 
@@ -108,6 +112,11 @@ int zck_read_index(zckCtx *zck, int src_fd) {
 }
 
 int zck_read_header(zckCtx *zck, int src_fd) {
+    if(zck == NULL) {
+        zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n");
+        return False;
+    }
+    zck->fd = src_fd;
     if(!zck_read_initial(zck, src_fd))
         return False;
     if(!zck_read_index_hash(zck, src_fd))

diff --git a/src/lib/zck.c b/src/lib/zck.c
index feadbf38a60127777181574ceb1ef8dc7a1aa204..c6f9ce1c6f10deaa191d6621d519b62fbf28a62a 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -118,21 +118,16 @@ int zck_set_chunk_hash_type(zckCtx *zck, uint8_t hash_type) {
         zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n");
         return False;
     }
+    memset(&(zck->chunk_hash_type), 0, sizeof(zckHashType));
     zck_log(ZCK_LOG_INFO, "Setting chunk hash to %s\n",
             zck_hash_name_from_type(hash_type));
-    if(zck->index.hash_type == NULL) {
-        zck->index.hash_type = zmalloc(sizeof(zckHashType));
-        if(zck->index.hash_type == NULL) {
-            zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                    sizeof(zckHashType));
-            return False;
-        }
-    }
-    if(!zck_hash_setup(zck->index.hash_type, hash_type)) {
+    if(!zck_hash_setup(&(zck->chunk_hash_type), hash_type)) {
         zck_log(ZCK_LOG_ERROR, "Unable to set chunk hash to %s\n",
                 zck_hash_name_from_type(hash_type));
         return False;
     }
+    zck->index.hash_type = zck->chunk_hash_type.type;
+    zck->index.digest_size = zck->chunk_hash_type.digest_size;
     return True;
 }
 
@@ -143,9 +138,9 @@ int zck_get_full_digest_size(zckCtx *zck) {
 }
 
 int zck_get_chunk_digest_size(zckCtx *zck) {
-    if(zck == NULL)
+    if(zck == NULL || zck->index.digest_size == 0)
         return -1;
-    return zck->index.hash_type->digest_size;
+    return zck->index.digest_size;
 }
 
 int zck_get_full_hash_type(zckCtx *zck) {
@@ -157,7 +152,7 @@ int zck_get_full_hash_type(zckCtx *zck) {
 int zck_get_chunk_hash_type(zckCtx *zck) {
     if(zck == NULL)
         return -1;
-    return zck->index.hash_type->type;
+    return zck->index.hash_type;
 }
 
 int64_t zck_get_index_count(zckCtx *zck) {
@@ -184,6 +179,12 @@ char *zck_get_full_digest(zckCtx *zck) {
     return zck->full_hash_digest;
 }
 
+int64_t zck_get_predata_length(zckCtx *zck) {
+    if(zck == NULL)
+        return -1;
+    return zck->preindex_size + zck->comp_index_size;
+}
+
 int zck_get_tmp_fd() {
     int temp_fd;
     char *fname = NULL;
@@ -264,7 +265,7 @@ int zck_validate_chunk(zckCtx *zck, char *data, size_t size, zckIndex *idx,
     }
 
     /* Check chunk checksum */
-    if(!zck_hash_init(&chunk_hash, zck->index.hash_type)) {
+    if(!zck_hash_init(&chunk_hash, &(zck->chunk_hash_type))) {
         zck_log(ZCK_LOG_ERROR,
                 "Unable to initialize checksum for chunk %i\n", chk_num);
         return False;
@@ -279,13 +280,13 @@ int zck_validate_chunk(zckCtx *zck, char *data, size_t size, zckIndex *idx,
     if(!digest) {
         zck_log(ZCK_LOG_ERROR,
                 "Unable to calculate %s checksum for chunk %i\n",
-                zck_hash_name_from_type(zck->index.hash_type->type), chk_num);
+                zck_hash_name_from_type(zck->index.hash_type), chk_num);
         return False;
     }
-    if(memcmp(digest, idx->digest, zck->index.hash_type->digest_size) != 0) {
+    if(memcmp(digest, idx->digest, zck->index.digest_size) != 0) {
         free(digest);
         zck_log(ZCK_LOG_ERROR, "Chunk %i failed %s checksum\n",
-                chk_num, zck_hash_name_from_type(zck->index.hash_type->type));
+                chk_num, zck_hash_name_from_type(zck->index.hash_type));
         return False;
     }
     free(digest);

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index 93e418ed0ef2040696ae9b20b52c2e0590d9dcea..3cd8989900ef17e35086b41bebe150a6690a2b6d 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -75,7 +75,7 @@ int main (int argc, char *argv[]) {
     while(idx) {
         for(int i=0; i<zck_get_chunk_digest_size(zck); i++)
             printf("%02x", (unsigned char)idx->digest[i]);
-        printf(" %12lu %12lu\n", idx->start, idx->length);
+        printf(" %12lu %12lu\n", idx->start + zck_get_predata_length(zck), idx->length);
         idx = idx->next;
     }