Remove extra logging and simplify code

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

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 2bec9c26ef87e7469cf346ad8b6d474016473e0f..39f84665e3367e45c79dbeceaa642d8d120fd257 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -80,28 +80,21 @@ static int zero_chunk(zckCtx *tgt, zckIndexItem *tgt_idx) {
 }
 
 /* Check whether last downloaded chunk is valid and zero it out if it isn't */
-static int validate_chunk(zckDL *dl) {
+static int set_chunk_valid(zckDL *dl) {
     VALIDATE(dl);
     VALIDATE(dl->priv);
-    if(dl->priv->chunk_hash == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Chunk hash not initialized\n");
-        return False;
-    }
-    char *digest = hash_finalize(dl->priv->chunk_hash);
-    free(dl->priv->chunk_hash);
-    if(memcmp(digest, dl->priv->tgt_check->digest,
-              dl->priv->tgt_check->digest_size) != 0) {
-        zck_log(ZCK_LOG_WARNING,
-                "Downloaded chunk failed hash check\n");
+
+    int retval = validate_chunk(dl->zck, dl->priv->tgt_check, ZCK_LOG_WARNING);
+    if(retval < 1) {
         if(!zero_chunk(dl->zck, dl->priv->tgt_check))
             return False;
         dl->priv->tgt_check->valid = -1;
+        if(retval == 0)
+            return False;
     } else {
         dl->priv->tgt_check->valid = 1;
     }
     dl->priv->tgt_check = NULL;
-    dl->priv->chunk_hash = NULL;
-    free(digest);
     return True;
 }
 
@@ -118,7 +111,7 @@ static int dl_write(zckDL *dl, const char *at, size_t length) {
         if(!write_data(dl->zck->fd, at, wb))
             return -1;
         dl->priv->write_in_chunk -= wb;
-        if(!hash_update(dl->priv->chunk_hash, at, wb))
+        if(!hash_update(&(dl->zck->check_chunk_hash), at, wb))
             return -1;
         zck_log(ZCK_LOG_DEBUG, "Writing %lu bytes\n", wb);
         dl->priv->dl_chunk_data += wb;
@@ -148,23 +141,20 @@ int dl_write_range(zckDL *dl, const char *at, size_t length) {
         return 0;
     if(dl->priv->write_in_chunk == 0) {
         /* Check whether we just finished downloading a chunk and verify it */
-        if(dl->priv->tgt_check && !validate_chunk(dl)) {
-            dl->priv->tgt_check->valid = -1;
+        if(dl->priv->tgt_check && !set_chunk_valid(dl))
             return False;
-        }
-        zckIndexItem *idx = dl->range->index.first;
-        while(idx) {
+
+        for(zckIndexItem *idx = dl->range->index.first; idx; idx = idx->next) {
             if(dl->priv->dl_chunk_data == idx->start) {
-                zckIndexItem *tgt_idx = dl->zck->index.first;
-                while(tgt_idx) {
+                for(zckIndexItem *tgt_idx = dl->zck->index.first; tgt_idx;
+                    tgt_idx = tgt_idx->next) {
                     if(tgt_idx->valid == 1)
-                        tgt_idx = tgt_idx->next;
+                        continue;
                     if(idx->comp_length == tgt_idx->comp_length &&
                        memcmp(idx->digest, tgt_idx->digest,
                               idx->digest_size) == 0) {
                         dl->priv->tgt_check = tgt_idx;
-                        dl->priv->chunk_hash = zmalloc(sizeof(zckHash));
-                        if(!hash_init(dl->priv->chunk_hash,
+                        if(!hash_init(&(dl->zck->check_chunk_hash),
                                           &(dl->zck->chunk_hash_type)))
                             return 0;
                         dl->priv->write_in_chunk = idx->comp_length;
@@ -174,13 +164,12 @@ int dl_write_range(zckDL *dl, const char *at, size_t length) {
                             return 0;
                         idx = NULL;
                         tgt_idx = NULL;
-                    } else {
-                        tgt_idx = tgt_idx->next;
+                        break;
                     }
                 }
             }
-            if(idx)
-                idx = idx->next;
+            if(!idx)
+                break;
         }
     }
     int wb2 = 0;

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index d078fb5009bd9ab425b991bec5956fbe6e407502..61d0213c5c964d4426e6cead2b07498e4f87467e 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -179,7 +179,7 @@ int set_full_hash_type(zckCtx *zck, int hash_type) {
 int set_chunk_hash_type(zckCtx *zck, int hash_type) {
     VALIDATE(zck);
     memset(&(zck->chunk_hash_type), 0, sizeof(zckHashType));
-    zck_log(ZCK_LOG_INFO, "Setting chunk hash to %s\n",
+    zck_log(ZCK_LOG_DEBUG, "Setting chunk hash to %s\n",
             zck_hash_name_from_type(hash_type));
     if(!hash_setup(&(zck->chunk_hash_type), hash_type)) {
         zck_log(ZCK_LOG_ERROR, "Unable to set chunk hash to %s\n",
@@ -191,7 +191,7 @@ int set_chunk_hash_type(zckCtx *zck, int hash_type) {
     return True;
 }
 
-/* Returns 1 if data hash matches, 0 if it doesn't and -1 if failure */
+/* Returns 1 if data hash matches, -1 if it doesn't and 0 if error */
 int PUBLIC zck_validate_data_checksum(zckCtx *zck) {
     hash_close(&(zck->check_full_hash));
     if(!seek_data(zck->fd, zck->data_offset, SEEK_SET))
@@ -200,7 +200,7 @@ int PUBLIC zck_validate_data_checksum(zckCtx *zck) {
         return -1;
     char buf[BUF_SIZE] = {0};
     zckIndexItem *idx = zck->index.first;
-    zck_log(ZCK_LOG_INFO, "Checking full hash\n");
+    zck_log(ZCK_LOG_DEBUG, "Checking full hash\n");
     while(idx) {
         size_t to_read = idx->comp_length;
         while(to_read > 0) {
@@ -215,7 +215,7 @@ int PUBLIC zck_validate_data_checksum(zckCtx *zck) {
         }
         idx = idx->next;
     }
-    return validate_file(zck);
+    return validate_file(zck, ZCK_LOG_WARNING);
 }
 
 const char PUBLIC *zck_hash_name_from_type(int hash_type) {

diff --git a/src/lib/header.c b/src/lib/header.c
index 2ce9ea792f444996243939e3d3c57ae4075c499d..fe60e73419cc89c5a35a23137855e6c6d90eca9c 100644 (file)
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -208,7 +208,7 @@ int read_header_from_file(zckCtx *zck) {
         return False;
     if(!hash_update(&(zck->check_full_hash), header, zck->header_length))
         return False;
-    if(!validate_header(zck))
+    if(validate_header(zck) < 1)
         return False;
     return True;
 }

diff --git a/src/lib/zck.c b/src/lib/zck.c
index f69b2502616b07f6c253672a790f2e15dda869c8..515d65275287a231e48ad2c01856e3232c6f4180 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -214,7 +214,7 @@ int PUBLIC zck_close(zckCtx *zck) {
             zck->temp_fd = 0;
         }
     } else {
-        if(!validate_file(zck))
+        if(validate_file(zck, ZCK_LOG_WARNING) < 1)
             return False;
     }
 
@@ -227,6 +227,7 @@ void zck_clear(zckCtx *zck) {
     index_free(zck);
     if(zck->header)
         free(zck->header);
+    zck->fd = -1;
     zck->header = NULL;
     zck->header_size = 0;
     if(!comp_close(zck))
@@ -477,19 +478,20 @@ int import_dict(zckCtx *zck) {
     return True;
 }
 
+/* Validate chunk, returning -1 if checksum fails, 1 if good, 0 if error */
 int validate_chunk(zckCtx *zck, zckIndexItem *idx,
                        zck_log_type bad_checksum) {
     VALIDATE(zck);
     if(idx == NULL) {
         zck_log(ZCK_LOG_ERROR, "Index not initialized\n");
-        return -1;
+        return 0;
     }
 
     char *digest = hash_finalize(&(zck->check_chunk_hash));
     if(digest == NULL) {
         zck_log(ZCK_LOG_ERROR,
                 "Unable to calculate %s checksum for chunk\n");
-        return -1;
+        return 0;
     }
     if(idx->comp_length == 0)
         memset(digest, 0, idx->digest_size);
@@ -503,7 +505,7 @@ int validate_chunk(zckCtx *zck, zckIndexItem *idx,
     if(memcmp(digest, idx->digest, idx->digest_size) != 0) {
         free(digest);
         zck_log(bad_checksum, "Chunk checksum failed!\n");
-        return 0;
+        return -1;
     }
     zck_log(ZCK_LOG_DEBUG, "Chunk checksum valid\n");
     free(digest);
@@ -516,26 +518,26 @@ int validate_current_chunk(zckCtx *zck) {
     return validate_chunk(zck, zck->comp.data_idx, ZCK_LOG_ERROR);
 }
 
-int validate_file(zckCtx *zck) {
+int validate_file(zckCtx *zck, zck_log_type bad_checksums) {
     VALIDATE(zck);
     char *digest = hash_finalize(&(zck->check_full_hash));
     if(digest == NULL) {
         zck_log(ZCK_LOG_ERROR,
                 "Unable to calculate %s checksum for full file\n");
-        return -1;
+        return 0;
     }
     zck_log(ZCK_LOG_DEBUG, "Checking data checksum\n");
     char *cks = get_digest_string(zck->full_hash_digest,
                                   zck->hash_type.digest_size);
-    zck_log(ZCK_LOG_INFO, "Expected data checksum:   %s\n", cks);
+    zck_log(ZCK_LOG_DEBUG, "Expected data checksum:   %s\n", cks);
     free(cks);
     cks = get_digest_string(digest, zck->hash_type.digest_size);
-    zck_log(ZCK_LOG_INFO, "Calculated data checksum: %s\n", cks);
+    zck_log(ZCK_LOG_DEBUG, "Calculated data checksum: %s\n", cks);
     free(cks);
     if(memcmp(digest, zck->full_hash_digest, zck->hash_type.digest_size) != 0) {
         free(digest);
-        zck_log(ZCK_LOG_ERROR, "Data checksum failed!\n");
-        return 0;
+        zck_log(bad_checksums, "Data checksum failed!\n");
+        return -1;
     }
     zck_log(ZCK_LOG_DEBUG, "Data checksum valid\n");
     free(digest);
@@ -548,57 +550,56 @@ int validate_header(zckCtx *zck) {
     if(digest == NULL) {
         zck_log(ZCK_LOG_ERROR,
                 "Unable to calculate %s checksum for header\n");
-        return -1;
+        return 0;
     }
     zck_log(ZCK_LOG_DEBUG, "Checking header checksum\n");
     char *cks = get_digest_string(zck->header_digest,
                                   zck->hash_type.digest_size);
-    zck_log(ZCK_LOG_INFO, "Expected header checksum:   %s\n", cks);
+    zck_log(ZCK_LOG_DEBUG, "Expected header checksum:   %s\n", cks);
     free(cks);
     cks = get_digest_string(digest, zck->hash_type.digest_size);
-    zck_log(ZCK_LOG_INFO, "Calculated header checksum: %s\n", cks);
+    zck_log(ZCK_LOG_DEBUG, "Calculated header checksum: %s\n", cks);
     free(cks);
     if(memcmp(digest, zck->header_digest, zck->hash_type.digest_size) != 0) {
         free(digest);
         zck_log(ZCK_LOG_ERROR, "Header checksum failed!\n");
-        return 0;
+        return -1;
     }
     zck_log(ZCK_LOG_DEBUG, "Header checksum valid\n");
     free(digest);
 
     if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
-        return -1;
+        return 0;
 
     return 1;
 }
 
-int PUBLIC zck_validate_checksums(zckCtx *zck) {
+int validate_checksums(zckCtx *zck, zck_log_type bad_checksums) {
     VALIDATE_READ(zck);
     char buf[BUF_SIZE];
 
     if(zck->data_offset == 0) {
         zck_log(ZCK_LOG_ERROR, "Header hasn't been read yet\n");
-        return -1;
+        return 0;
     }
 
     hash_close(&(zck->check_full_hash));
     if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
-        return -1;
+        return 0;
 
     if(!seek_data(zck->fd, zck->data_offset, SEEK_SET))
-        return -1;
+        return 0;
 
     /* Check each chunk checksum */
-    zckIndexItem *idx = zck->index.first;
     int all_good = True;
-    while(idx) {
+    for(zckIndexItem *idx = zck->index.first; idx; idx = idx->next) {
         if(idx == zck->index.first && idx->length == 0) {
             idx->valid = 1;
             continue;
         }
 
         if(!hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
-            return -1;
+            return 0;
 
         size_t rlen = 0;
         while(rlen < idx->comp_length) {
@@ -606,40 +607,54 @@ int PUBLIC zck_validate_checksums(zckCtx *zck) {
             if(BUF_SIZE > idx->comp_length - rlen)
                 rsize = idx->comp_length - rlen;
             if(read_data(zck->fd, buf, rsize) != rsize)
-                return 0;
+                zck_log(ZCK_LOG_DEBUG, "No more data\n");
             if(!hash_update(&(zck->check_chunk_hash), buf, rsize))
-                return -1;
+                return 0;
             if(!hash_update(&(zck->check_full_hash), buf, rsize))
-                return -1;
+                return 0;
             rlen += rsize;
         }
-        int valid_chunk = validate_chunk(zck, idx, ZCK_LOG_ERROR);
-        if(valid_chunk < 0)
-            return -1;
+        int valid_chunk = validate_chunk(zck, idx, bad_checksums);
+        if(!valid_chunk)
+            return 0;
         idx->valid = valid_chunk;
-        if(all_good && !valid_chunk)
+        if(all_good && valid_chunk != 1)
             all_good = False;
-        idx = idx->next;
     }
-    if(!all_good)
-        return 0;
-
-    /* Check data checksum */
-    int valid_file = validate_file(zck);
-    if(valid_file < 0)
-        return -1;
+    int valid_file = -1;
+    if(all_good) {
+        /* Check data checksum */
+        valid_file = validate_file(zck, bad_checksums);
+        if(!valid_file)
+            return 0;
+
+        /* If data checksum failed, invalidate *all* chunks */
+        if(valid_file == -1)
+            for(zckIndexItem *idx = zck->index.first; idx; idx = idx->next)
+                idx->valid = -1;
+    }
 
     /* Go back to beginning of data section */
     if(!seek_data(zck->fd, zck->data_offset, SEEK_SET))
-        return -1;
+        return 0;
 
     /* Reinitialize data checksum */
     if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
-        return -1;
+        return 0;
 
     return valid_file;
 }
 
+/* Returns 1 if all chunks are valid, -1 if even one isn't and 0 if error */
+int PUBLIC zck_find_valid_chunks(zckCtx *zck) {
+    return validate_checksums(zck, ZCK_LOG_DEBUG);
+}
+
+/* Returns 1 if all checksums matched, -1 if even one doesn't and 0 if error */
+int PUBLIC zck_validate_checksums(zckCtx *zck) {
+    return validate_checksums(zck, ZCK_LOG_WARNING);
+}
+
 int PUBLIC zck_get_fd(zckCtx *zck) {
     return zck->fd;
 }

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index e485a8f33a46707d0ddc94d2a85711068718fdb2..d252c3414a0a1308313dec0cb240520bcad0daa5 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -63,7 +63,6 @@ typedef struct zckDLPriv {
     regex_t *end_regex;
     regex_t *hdr_regex;
     zckIndexItem *tgt_check;
-    zckHash *chunk_hash;
 } zckDLPriv;
 
 typedef struct zckComp {
@@ -161,7 +160,9 @@ int get_tmp_fd()
     __attribute__ ((warn_unused_result));
 int import_dict(zckCtx *zck)
     __attribute__ ((warn_unused_result));
-int validate_file(zckCtx *zck)
+int validate_chunk(zckCtx *zck, zckIndexItem *idx, zck_log_type bad_checksum)
+    __attribute__ ((warn_unused_result));
+int validate_file(zckCtx *zck, zck_log_type bad_checksums)
     __attribute__ ((warn_unused_result));
 int validate_current_chunk(zckCtx *zck)
     __attribute__ ((warn_unused_result));
@@ -232,8 +233,6 @@ int chunks_from_temp(zckCtx *zck)
     __attribute__ ((warn_unused_result));
 
 /* header.c */
-int validate_header(zckCtx *zck)
-    __attribute__ ((warn_unused_result));
 int read_preface(zckCtx *zck)
     __attribute__ ((warn_unused_result));
 int read_index(zckCtx *zck)

diff --git a/src/zck_dl.c b/src/zck_dl.c
index aed1c027be2afe9f99b4d61734ae5ba28eee84c8..35a252649670d4eab9e04fefb6189358711631dc 100644 (file)
--- a/src/zck_dl.c
+++ b/src/zck_dl.c
@@ -221,7 +221,6 @@ int dl_bytes(dlCtx *dl_ctx, char *url, size_t bytes, size_t start,
                    strerror(errno));
             return 0;
         }
-        printf("Seeking to location %lu\n", start);
     }
     return 1;
 }
@@ -246,7 +245,6 @@ int dl_header(CURL *curl, zckDL *dl, char *url, int fail_no_ranges,
     if(!zck_read_lead(dl->zck))
         return 0;
     start = zck_get_lead_length(dl->zck);
-    printf("Now we need %lu bytes\n", zck_get_header_length(dl->zck) - start);
     if(!dl_bytes(&dl_ctx, url, zck_get_header_length(dl->zck) - start,
                  start, &buffer_len, log_level))
         return 0;
@@ -342,17 +340,24 @@ int main (int argc, char *argv[]) {
         }
     } else {
         /* If file is already fully downloaded, let's get out of here! */
-        if(zck_validate_checksums(zck_tgt)) {
+        int retval = zck_find_valid_chunks(zck_tgt);
+        if(retval == 0) {
+            exit_val = 10;
+            goto out;
+        }
+        if(retval == 1) {
+            printf("Missing chunks: 0\n");
             printf("Downloaded %lu bytes\n",
                 (long unsigned)zck_dl_get_bytes_downloaded(dl));
             ftruncate(dst_fd, zck_get_length(zck_tgt));
             exit_val = 0;
-            //goto out;
+            goto out;
         }
         if(zck_src && !zck_copy_chunks(zck_src, zck_tgt)) {
             exit_val = 10;
             goto out;
         }
+        zck_reset_failed_chunks(zck_tgt);
         dlCtx dl_ctx = {0};
         dl_ctx.dl = dl;
         dl_ctx.curl = curl_ctx;