Logging improvements

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

diff --git a/include/zck.h b/include/zck.h
index 2892b622dfc4844acff6abf445078346ec5673aa..bc1daba67b74d5b55a19a077bfd1db08ab3f9756 100644 (file)
--- a/include/zck.h
+++ b/include/zck.h
@@ -37,6 +37,7 @@ typedef enum zck_soption {
 } zck_soption;
 
 typedef enum zck_log_type {
+    ZCK_LOG_DDEBUG = -1,
     ZCK_LOG_DEBUG,
     ZCK_LOG_INFO,
     ZCK_LOG_WARNING,

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 12bcdb305597a3082dd6808e7acb2a983b90d8ba..9a0a7e12a19ed3abb01515257e38a207b843bae1 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -84,7 +84,8 @@ static int set_chunk_valid(zckDL *dl) {
     VALIDATE(dl);
     VALIDATE(dl->priv);
 
-    int retval = validate_chunk(dl->zck, dl->priv->tgt_check, ZCK_LOG_WARNING);
+    int retval = validate_chunk(dl->zck, dl->priv->tgt_check, ZCK_LOG_WARNING,
+                                dl->priv->tgt_number);
     if(retval < 1) {
         if(!zero_chunk(dl->zck, dl->priv->tgt_check))
             return False;
@@ -193,14 +194,16 @@ int dl_write_range(zckDL *dl, const char *at, size_t length) {
 
         for(zckIndexItem *idx = dl->range->index.first; idx; idx = idx->next) {
             if(dl->priv->dl_chunk_data == idx->start) {
+                int count = 0;
                 for(zckIndexItem *tgt_idx = dl->zck->index.first; tgt_idx;
-                    tgt_idx = tgt_idx->next) {
+                    tgt_idx = tgt_idx->next, count++) {
                     if(tgt_idx->valid == 1)
                         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->tgt_number = count;
                         if(!hash_init(&(dl->zck->check_chunk_hash),
                                           &(dl->zck->chunk_hash_type)))
                             return 0;

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index de9277fa2949d51bbc60a72d4cc01ed90dcdb5f9..5b670a07bca67157fd14d906b16e39dceb864a11 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -85,7 +85,8 @@ static int validate_checksums(zckCtx *zck, zck_log_type bad_checksums) {
 
     /* Check each chunk checksum */
     int all_good = True;
-    for(zckIndexItem *idx = zck->index.first; idx; idx = idx->next) {
+    int count = 0;
+    for(zckIndexItem *idx = zck->index.first; idx; idx = idx->next, count++) {
         if(idx == zck->index.first && idx->length == 0) {
             idx->valid = 1;
             continue;
@@ -107,7 +108,7 @@ static int validate_checksums(zckCtx *zck, zck_log_type bad_checksums) {
                 return 0;
             rlen += rsize;
         }
-        int valid_chunk = validate_chunk(zck, idx, bad_checksums);
+        int valid_chunk = validate_chunk(zck, idx, bad_checksums, count);
         if(!valid_chunk)
             return 0;
         idx->valid = valid_chunk;
@@ -152,11 +153,15 @@ int hash_setup(zckHashType *ht, int h) {
             memset(ht, 0, sizeof(zckHashType));
             ht->type = ZCK_HASH_SHA1;
             ht->digest_size = SHA1_DIGEST_LENGTH;
+            zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s\n",
+                    zck_hash_name_from_type(ht->type));
             return True;
         }else if(h == ZCK_HASH_SHA256) {
             memset(ht, 0, sizeof(zckHashType));
             ht->type = ZCK_HASH_SHA256;
             ht->digest_size = SHA256_DIGEST_SIZE;
+            zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s\n",
+                    zck_hash_name_from_type(ht->type));
             return True;
         }
         zck_log(ZCK_LOG_ERROR, "Unsupported hash type: %s\n",
@@ -182,7 +187,7 @@ void hash_close(zckHash *hash) {
 int hash_init(zckHash *hash, zckHashType *hash_type) {
     if(hash && hash_type) {
         if(hash_type->type == ZCK_HASH_SHA1) {
-            zck_log(ZCK_LOG_DEBUG, "Initializing SHA-1 hash\n");
+            zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-1 hash\n");
             hash->ctx = zmalloc(sizeof(SHA_CTX));
             hash->type = hash_type;
             if(hash->ctx == NULL)
@@ -190,7 +195,7 @@ int hash_init(zckHash *hash, zckHashType *hash_type) {
             SHA1_Init((SHA_CTX *) hash->ctx);
             return True;
         }else if(hash_type->type == ZCK_HASH_SHA256) {
-            zck_log(ZCK_LOG_DEBUG, "Initializing SHA-256 hash\n");
+            zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-256 hash\n");
             hash->ctx = zmalloc(sizeof(sha256_ctx));
             hash->type = hash_type;
             if(hash->ctx == NULL)
@@ -287,7 +292,7 @@ int set_chunk_hash_type(zckCtx *zck, int hash_type) {
 
 /* 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) {
+                       zck_log_type bad_checksum, int chunk_number) {
     VALIDATE(zck);
     if(idx == NULL) {
         zck_log(ZCK_LOG_ERROR, "Index not initialized\n");
@@ -302,19 +307,25 @@ int validate_chunk(zckCtx *zck, zckIndexItem *idx,
     }
     if(idx->comp_length == 0)
         memset(digest, 0, idx->digest_size);
-    zck_log(ZCK_LOG_DEBUG, "Checking chunk checksum\n");
     char *pdigest = zck_get_chunk_digest(idx);
-    zck_log(ZCK_LOG_DEBUG, "Expected chunk checksum:   %s\n", pdigest);
+    zck_log(ZCK_LOG_DDEBUG, "Expected chunk checksum:   %s\n", pdigest);
     free(pdigest);
     pdigest = get_digest_string(digest, idx->digest_size);
-    zck_log(ZCK_LOG_DEBUG, "Calculated chunk checksum: %s\n", pdigest);
+    zck_log(ZCK_LOG_DDEBUG, "Calculated chunk checksum: %s\n", pdigest);
     free(pdigest);
     if(memcmp(digest, idx->digest, idx->digest_size) != 0) {
         free(digest);
-        zck_log(bad_checksum, "Chunk checksum failed!\n");
+        if(chunk_number == -1)
+            zck_log(bad_checksum, "Chunk checksum: FAILED!\n");
+        else
+            zck_log(bad_checksum, "Chunk %i's checksum: FAILED\n",
+                    chunk_number);
         return -1;
     }
-    zck_log(ZCK_LOG_DEBUG, "Chunk checksum valid\n");
+    if(chunk_number == -1)
+        zck_log(ZCK_LOG_DEBUG, "Chunk checksum: valid\n");
+    else
+        zck_log(ZCK_LOG_DEBUG, "Chunk %i's checksum: valid\n", chunk_number);
     free(digest);
     return 1;
 }
@@ -322,7 +333,7 @@ int validate_chunk(zckCtx *zck, zckIndexItem *idx,
 int validate_current_chunk(zckCtx *zck) {
     VALIDATE(zck);
 
-    return validate_chunk(zck, zck->comp.data_idx, ZCK_LOG_ERROR);
+    return validate_chunk(zck, zck->comp.data_idx, ZCK_LOG_ERROR, -1);
 }
 
 int validate_file(zckCtx *zck, zck_log_type bad_checksums) {

diff --git a/src/lib/log.c b/src/lib/log.c
index 91edd14cbd9e3f153318dc01dafa947b9f220223..56ea7eba607e7fc3f894c07edbead83053ae445b 100644 (file)
--- a/src/lib/log.c
+++ b/src/lib/log.c
@@ -38,10 +38,11 @@ void PUBLIC zck_set_log_level(zck_log_type ll) {
     log_level = ll;
 }
 
-void zck_log(zck_log_type lt, const char *format, ...) {
+void zck_log_wf(const char *function, zck_log_type lt, const char *format, ...) {
     if(lt >= log_level) {
         va_list args;
         va_start(args, format);
+        dprintf(STDERR_FILENO, "%s: ", function);
         vdprintf(STDERR_FILENO, format, args);
         va_end(args);
     }

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index fff79b309e2cb41810043f08941aa2d5693a11bf..1d17be8ba9aab6a14b81795c0ec43d9bd5db4975 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -16,6 +16,8 @@
 
 #define PUBLIC __attribute__((visibility("default")))
 
+#define zck_log(...) zck_log_wf(__func__, __VA_ARGS__)
+
 struct zckComp;
 
 typedef int (*finit)(struct zckComp *comp);
@@ -63,6 +65,7 @@ typedef struct zckDLPriv {
     regex_t *end_regex;
     regex_t *hdr_regex;
     zckIndexItem *tgt_check;
+    int tgt_number;
 } zckDLPriv;
 
 typedef struct zckComp {
@@ -172,7 +175,8 @@ int hash_update(zckHash *hash, const char *message, const size_t size)
 char *hash_finalize(zckHash *hash)
     __attribute__ ((warn_unused_result));
 void hash_close(zckHash *hash);
-int validate_chunk(zckCtx *zck, zckIndexItem *idx, zck_log_type bad_checksum)
+int validate_chunk(zckCtx *zck, zckIndexItem *idx, zck_log_type bad_checksum,
+                   int chunk_number)
     __attribute__ ((warn_unused_result));
 int validate_file(zckCtx *zck, zck_log_type bad_checksums)
     __attribute__ ((warn_unused_result));
@@ -272,5 +276,5 @@ int compint_to_size(size_t *val, const char *compint, size_t *length,
 
 
 /* log.c */
-void zck_log(zck_log_type lt, const char *format, ...);
+void zck_log_wf(const char *function, zck_log_type lt, const char *format, ...);
 #endif

diff --git a/src/unzck.c b/src/unzck.c
index a55172ca5acb853f2895aecc090b72931695e5ac..816c0dc74dccde658b8298043422b18f7d98275a 100644 (file)
--- a/src/unzck.c
+++ b/src/unzck.c
@@ -59,9 +59,9 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
 
     switch (key) {
         case 'v':
-            arguments->log_level -= 1;
-            if(arguments->log_level < ZCK_LOG_DEBUG)
-                arguments->log_level = ZCK_LOG_DEBUG;
+            arguments->log_level--;
+            if(arguments->log_level < ZCK_LOG_DDEBUG)
+                arguments->log_level = ZCK_LOG_DDEBUG;
             break;
         case 'q':
             arguments->log_level = ZCK_LOG_ERROR;

diff --git a/src/zck.c b/src/zck.c
index a3e2a869350343e057bf97572e28b45af9eddaee..9046987418607faf387321123b3d7a0e5bb4d101 100644 (file)
--- a/src/zck.c
+++ b/src/zck.c
@@ -65,9 +65,9 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
 
     switch (key) {
         case 'v':
-            arguments->log_level -= 1;
-            if(arguments->log_level < ZCK_LOG_DEBUG)
-                arguments->log_level = ZCK_LOG_DEBUG;
+            arguments->log_level--;
+            if(arguments->log_level < ZCK_LOG_DDEBUG)
+                arguments->log_level = ZCK_LOG_DDEBUG;
             break;
         case 'q':
             arguments->log_level = ZCK_LOG_ERROR;

diff --git a/src/zck_delta_size.c b/src/zck_delta_size.c
index 584b879e14c84b8a0550c1738ceef6cb9f31f598..f72cf513e7c96fd7e97cfb8c3afd9cedc53bc820 100644 (file)
--- a/src/zck_delta_size.c
+++ b/src/zck_delta_size.c
@@ -60,9 +60,9 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
 
     switch (key) {
         case 'v':
-            arguments->log_level -= 1;
-            if(arguments->log_level < ZCK_LOG_DEBUG)
-                arguments->log_level = ZCK_LOG_DEBUG;
+            arguments->log_level--;
+            if(arguments->log_level < ZCK_LOG_DDEBUG)
+                arguments->log_level = ZCK_LOG_DDEBUG;
             break;
         case 'q':
             arguments->log_level = ZCK_LOG_ERROR;

diff --git a/src/zck_dl.c b/src/zck_dl.c
index 8b7f6fc4aeca9bdcad0587b2f7bf62b0e6b2c70f..c2f9e9270cdd50959c9d80076cd85f02d8d277a4 100644 (file)
--- a/src/zck_dl.c
+++ b/src/zck_dl.c
@@ -75,7 +75,11 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
 
     switch (key) {
         case 'v':
-            arguments->log_level = ZCK_LOG_DEBUG;
+            if(arguments->log_level > ZCK_LOG_INFO)
+                arguments->log_level = ZCK_LOG_INFO;
+            arguments->log_level--;
+            if(arguments->log_level < ZCK_LOG_DDEBUG)
+                arguments->log_level = ZCK_LOG_DDEBUG;
             break;
         case 'q':
             if(arguments->log_level < ZCK_LOG_INFO)

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index de18b001646b292452b3f9a26535a33b1d69199d..be0a189bd64e061539d1b7403c970c8ac99123c8 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -60,9 +60,9 @@ static error_t parse_opt (int key, char *arg, struct argp_state *state) {
 
     switch (key) {
         case 'v':
-            arguments->log_level -= 1;
-            if(arguments->log_level < ZCK_LOG_DEBUG)
-                arguments->log_level = ZCK_LOG_DEBUG;
+            arguments->log_level--;
+            if(arguments->log_level < ZCK_LOG_DDEBUG)
+                arguments->log_level = ZCK_LOG_DDEBUG;
             break;
         case 'q':
             arguments->log_level = ZCK_LOG_ERROR;
@@ -116,48 +116,57 @@ int main (int argc, char *argv[]) {
     }
     zckCtx *zck = zck_init_read(src_fd);
     if(zck == NULL) {
-        printf("Unable to read header\n");
+        printf("Unable to read zchunk header\n");
         exit(1);
     }
 
     int valid_cks = 1;
     if(arguments.verify) {
         valid_cks = zck_validate_checksums(zck);
-        if(valid_cks < 0)
+        if(!valid_cks)
             exit(1);
     }
     close(src_fd);
 
-    printf("Overall checksum type: %s\n", zck_hash_name_from_type(zck_get_full_hash_type(zck)));
-    char *digest = zck_get_header_digest(zck);
-    printf("Header checksum: %s\n", digest);
-    free(digest);
-    digest = zck_get_data_digest(zck);
-    printf("Data checksum: %s\n", digest);
-    free(digest);
-    printf("Index count: %lu\n", (long unsigned)zck_get_index_count(zck));
-    printf("Chunk checksum type: %s\n", zck_hash_name_from_type(zck_get_chunk_hash_type(zck)));
-
-    zckIndex *idxi = zck_get_index(zck);
-    if(idxi == NULL)
-        exit(1);
-    zckIndexItem *idx = idxi->first;
-    while(idx) {
-        char *digest = zck_get_chunk_digest(idx);
-        if(digest == NULL)
+    if(arguments.log_level <= ZCK_LOG_WARNING) {
+        printf("Overall checksum type: %s\n",
+               zck_hash_name_from_type(zck_get_full_hash_type(zck)));
+        char *digest = zck_get_header_digest(zck);
+        printf("Header checksum: %s\n", digest);
+        free(digest);
+        digest = zck_get_data_digest(zck);
+        printf("Data checksum: %s\n", digest);
+        free(digest);
+        printf("Index count: %lu\n", (long unsigned)zck_get_index_count(zck));
+        printf("Chunk checksum type: %s\n", zck_hash_name_from_type(zck_get_chunk_hash_type(zck)));
+    }
+
+    if(arguments.log_level <= ZCK_LOG_INFO) {
+        zckIndex *idxi = zck_get_index(zck);
+        if(idxi == NULL)
             exit(1);
-        printf("%s %12lu %12lu %12lu", digest,
-               (long unsigned)(idx->start + zck_get_header_length(zck)),
-               (long unsigned)idx->comp_length, (long unsigned)idx->length);
-        if(arguments.verify) {
-            if(idx->valid)
-                printf("  +");
-            else
-                printf("  !");
+        for(zckIndexItem *idx = idxi->first; idx; idx=idx->next) {
+            char *digest = zck_get_chunk_digest(idx);
+            if(digest == NULL)
+                exit(1);
+            printf("%s %12lu %12lu %12lu", digest,
+                   (long unsigned)(idx->start + zck_get_header_length(zck)),
+                   (long unsigned)idx->comp_length, (long unsigned)idx->length);
+            if(arguments.verify) {
+                if(idx->valid)
+                    printf("  +");
+                else
+                    printf("  !");
+            }
+            printf("\n");
+            free(digest);
         }
-        printf("\n");
-        free(digest);
-        idx = idx->next;
+    }
+    if(arguments.verify) {
+        if(valid_cks == 1 && arguments.log_level <= ZCK_LOG_WARNING)
+            printf("All checksums are valid\n");
+        else if(valid_cks == -1)
+            printf("Some checksums failed\n");
     }
     zck_free(&zck);
     return 1-valid_cks;