Revamp how options are set

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

diff --git a/include/zck.h b/include/zck.h
index 2a37bfe923a06ff1ce9cd93d34620c6e522c47c6..82f311b64ca356a3d12a95a35ed6e013b74dfa92 100644 (file)
--- a/include/zck.h
+++ b/include/zck.h
@@ -7,26 +7,41 @@
 #define ZCK_VER_REVISION 1
 #define ZCK_VER_SUBREVISION 0
 
-#define ZCK_COMP_NONE 0
-#define ZCK_COMP_ZSTD 2
-
-#define ZCK_HASH_SHA1   0
-#define ZCK_HASH_SHA256 1
-
-#define ZCK_COMMON_DICT 1
-#define ZCK_COMMON_DICT_SIZE 2
-
-#define ZCK_ZCK_COMP_LEVEL 20
-
 #define True 1
 #define False 0
 
-typedef enum log_type { ZCK_LOG_DEBUG,
-                        ZCK_LOG_INFO,
-                        ZCK_LOG_WARNING,
-                        ZCK_LOG_ERROR } log_type;
-
-/* Contains an index item */
+typedef enum zck_hash {
+    ZCK_HASH_SHA1,
+    ZCK_HASH_SHA256
+} zck_hash;
+
+typedef enum zck_comp {
+    ZCK_COMP_NONE,
+    ZCK_COMP_GZIP, /* Not implemented yet */
+    ZCK_COMP_ZSTD
+} zck_comp;
+
+typedef enum zck_ioption {
+    ZCK_HASH_FULL_TYPE = 0,     /* Set full file hash type, using zck_hash */
+    ZCK_HASH_CHUNK_TYPE,        /* Set chunk hash type using zck_hash */
+    ZCK_COMP_TYPE = 100,        /* Set compression type using zck_comp */
+    ZCK_COMP_DICT_SIZE,         /* Set compression dictionary size */
+    ZCK_ZSTD_COMP_LEVEL = 1000  /* Set zstd compression level */
+} zck_ioption;
+
+typedef enum zck_soption {
+    ZCK_COMP_DICT = 100         /* Set compression dictionary */
+} zck_soption;
+
+typedef enum zck_log_type {
+    ZCK_LOG_DEBUG,
+    ZCK_LOG_INFO,
+    ZCK_LOG_WARNING,
+    ZCK_LOG_ERROR
+} zck_log_type;
+
+
+/* Contains an index item pointing to a chunk */
 typedef struct zckIndexItem {
     char *digest;
     int digest_size;
@@ -113,28 +128,19 @@ void zck_free(zckCtx **zck);
 
 
 /*******************************************************************
- * Compression
+ * Options
  *******************************************************************/
-/* Set compression type */
-int zck_set_compression_type(zckCtx *zck, int comp_type);
-/* Set compression parameter */
-int zck_set_comp_parameter(zckCtx *zck, int option, const void *value);
-
-
-/*******************************************************************
- * Hashing
- *******************************************************************/
-/* Set overall hash type */
-int zck_set_full_hash_type(zckCtx *zck, int hash_type);
-/* Set chunk hash type */
-int zck_set_chunk_hash_type(zckCtx *zck, int hash_type);
+/* Set string option */
+int zck_set_soption(zckCtx *zck, zck_soption option, const void *value);
+/* Set integer option */
+int zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value);
 
 
 /*******************************************************************
  * Miscellaneous utilities
  *******************************************************************/
 /* Set logging level */
-void zck_set_log_level(log_type ll);
+void zck_set_log_level(zck_log_type ll);
 
 
 /*******************************************************************
@@ -153,6 +159,10 @@ zckCtx *zck_create();
 ssize_t zck_get_header_length(zckCtx *zck);
 /* Get data length */
 ssize_t zck_get_data_length(zckCtx *zck);
+/* Get index digest */
+char *zck_get_header_digest(zckCtx *zck);
+/* Get data digest */
+char *zck_get_data_digest(zckCtx *zck);
 /* Get temporary fd that will disappear when fd is closed */
 int zck_get_tmp_fd();
 
@@ -189,6 +199,8 @@ int zck_read_header(zckCtx *zck);
 ssize_t zck_get_index_count(zckCtx *zck);
 /* Get index */
 zckIndex *zck_get_index(zckCtx *zck);
+/* Get chunk digest */
+char *zck_get_chunk_digest(zckIndexItem *item);
 
 
 /*******************************************************************
@@ -198,10 +210,6 @@ zckIndex *zck_get_index(zckCtx *zck);
 int zck_get_full_hash_type(zckCtx *zck);
 /* Get digest size of overall hash type */
 int zck_get_full_digest_size(zckCtx *zck);
-/* Get index digest (uses overall hash type) */
-char *zck_get_index_digest(zckCtx *zck);
-/* Get index digest (uses overall hash type) */
-char *zck_get_data_digest(zckCtx *zck);
 /* Get chunk hash type */
 int zck_get_chunk_hash_type(zckCtx *zck);
 /* Get digest size of chunk hash type */

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index aa54d4003a048d507296d8b40ec1507cc0ae9843..b75f656b0cfe31c14c8425915517285eaee3f2eb 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -128,13 +128,12 @@ int zck_comp_init(zckCtx *zck) {
             }
             zck_index_add_to_chunk(zck, dst, dst_size, 0);
             zck_index_finish_chunk(zck);
-            free(comp->dict);
-            comp->dict_size = 0;
             free(dst);
         } else {
             zck_index_finish_chunk(zck);
         }
     }
+    free(zck->comp.dict);
     zck->comp.dict = NULL;
     zck->comp.dict_size = 0;
     zck->comp.started = True;
@@ -169,7 +168,7 @@ int zck_comp_close(zckCtx *zck) {
     return zck_comp_reset(zck);
 }
 
-int PUBLIC zck_set_compression_type(zckCtx *zck, int type) {
+static int set_comp_type(zckCtx *zck, ssize_t type) {
     VALIDATE(zck);
 
     zckComp *comp = &(zck->comp);
@@ -182,7 +181,14 @@ int PUBLIC zck_set_compression_type(zckCtx *zck, int type) {
     }
 
     /* Set all values to 0 before setting compression type */
+    char *dc_data = comp->dc_data;
+    size_t dc_data_loc = comp->dc_data_loc;
+    size_t dc_data_size = comp->dc_data_size;
     memset(comp, 0, sizeof(zckComp));
+    comp->dc_data = dc_data;
+    comp->dc_data_loc = dc_data_loc;
+    comp->dc_data_size = dc_data_size;
+
     zck_log(ZCK_LOG_DEBUG, "Setting compression to %s\n",
             zck_comp_name_from_type(type));
     if(type == ZCK_COMP_NONE) {
@@ -199,7 +205,31 @@ int PUBLIC zck_set_compression_type(zckCtx *zck, int type) {
     return True;
 }
 
-int PUBLIC zck_set_comp_parameter(zckCtx *zck, int option, const void *value) {
+int comp_ioption(zckCtx *zck, zck_ioption option, ssize_t value) {
+    VALIDATE(zck);
+
+    /* Cannot change compression parameters after compression has started */
+    if(zck && zck->comp.started) {
+        zck_log(ZCK_LOG_ERROR,
+                "Unable to set compression parameters after initialization\n");
+        return False;
+    }
+    if(option == ZCK_COMP_TYPE) {
+        return set_comp_type(zck, value);
+    } else if(option == ZCK_COMP_DICT_SIZE) {
+        zck->comp.dict_size = value;
+    } else {
+        if(zck && zck->comp.set_parameter)
+            return zck->comp.set_parameter(&(zck->comp), option, &value);
+
+        zck_log(ZCK_LOG_ERROR, "Unsupported compression parameter: %i\n",
+                option);
+        return False;
+    }
+    return True;
+}
+
+int comp_soption(zckCtx *zck, zck_soption option, const void *value) {
     VALIDATE(zck);
 
     /* Cannot change compression parameters after compression has started */
@@ -208,7 +238,7 @@ int PUBLIC zck_set_comp_parameter(zckCtx *zck, int option, const void *value) {
                 "Unable to set compression parameters after initialization\n");
         return False;
     }
-    if(option == ZCK_COMMON_DICT) {
+    if(option == ZCK_COMP_DICT) {
         if(zck->comp.dict_size == 0) {
             zck_log(ZCK_LOG_ERROR,
                     "Dict size must be set before adding dict\n");
@@ -222,9 +252,7 @@ int PUBLIC zck_set_comp_parameter(zckCtx *zck, int option, const void *value) {
         }
         memcpy(dict, value, zck->comp.dict_size);
         zck->comp.dict = dict;
-    }else if(option == ZCK_COMMON_DICT_SIZE) {
-        zck->comp.dict_size = *(size_t*)value;
-    }else {
+    } else {
         if(zck && zck->comp.set_parameter)
             return zck->comp.set_parameter(&(zck->comp), option, value);
 

diff --git a/src/lib/comp/zstd/zstd.c b/src/lib/comp/zstd/zstd.c
index bd020de7a27db42a69bba7cbac524eb1b2ab0546..0f88610aa074dec4b0cd8a71842e9c3db6535abc 100644 (file)
--- a/src/lib/comp/zstd/zstd.c
+++ b/src/lib/comp/zstd/zstd.c
@@ -178,7 +178,7 @@ static int close(zckComp *comp) {
 }
 
 static int set_parameter(zckComp *comp, int option, const void *value) {
-    if(option == ZCK_ZCK_COMP_LEVEL) {
+    if(option == ZCK_ZSTD_COMP_LEVEL) {
         if(*(int*)value >= 0 && *(int*)value <= ZSTD_maxCLevel()) {
             comp->level = *(int*)value;
             return True;
@@ -191,7 +191,7 @@ static int set_parameter(zckComp *comp, int option, const void *value) {
 static int set_default_parameters(zckComp *comp) {
     /* Set default compression level to 16 */
     int level=16;
-    return set_parameter(comp, ZCK_ZCK_COMP_LEVEL, &level);
+    return set_parameter(comp, ZCK_ZSTD_COMP_LEVEL, &level);
 }
 
 int zck_zstd_setup(zckComp *comp) {

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 8cec72a6fc63c5dce6c6228b438988b9bb5b7de3..093a413333b72f3b70e6ec5510a39606af9f0d2d 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -246,10 +246,12 @@ int zck_dl_write_and_verify(zckRange *info, zckCtx *src, zckCtx *tgt,
     char *digest = zck_hash_finalize(&check_hash);
     /* If chunk is invalid, overwrite with zeros and add to download range */
     if(memcmp(digest, src_idx->digest, src_idx->digest_size) != 0) {
-        zck_log(ZCK_LOG_WARNING, "Source hash: %s\n",
-                zck_hash_get_printable(src_idx->digest, &(src->chunk_hash_type)));
-        zck_log(ZCK_LOG_WARNING, "Target hash: %s\n",
-                zck_hash_get_printable(digest, &(src->chunk_hash_type)));
+        char *pdigest = zck_get_chunk_digest(src_idx);
+        zck_log(ZCK_LOG_WARNING, "Source hash: %s\n", pdigest);
+        free(pdigest);
+        pdigest = get_digest_string(digest, src_idx->digest_size);
+        zck_log(ZCK_LOG_WARNING, "Target hash: %s\n", pdigest);
+        free(pdigest);
         if(!zck_dl_write_zero(tgt, tgt_idx))
             return False;
         if(!zck_range_add(info, tgt_idx, tgt))
@@ -275,7 +277,7 @@ int PUBLIC zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt) {
         while(src_idx) {
             if(tgt_idx->comp_length == src_idx->comp_length &&
                memcmp(tgt_idx->digest, src_idx->digest,
-                      zck_get_chunk_digest_size(tgt)) == 0) {
+                      tgt_idx->digest_size) == 0) {
                 found = True;
                 break;
             }
@@ -458,9 +460,9 @@ int PUBLIC zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
     if(!zck_read_index_hash(zck))
         return False;
     start += zck->hash_type.digest_size;
-    zck_log(ZCK_LOG_DEBUG, "Index hash: (%s)",
+    zck_log(ZCK_LOG_DEBUG, "Header hash: (%s)",
             zck_hash_name_from_type(zck_get_full_hash_type(zck)));
-    char *digest = zck_get_index_digest(zck);
+    char *digest = zck_get_header_digest(zck);
     zck_log(ZCK_LOG_DEBUG, "%s\n", digest);
     free(digest);
 

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index d11103718cdec925dc7dfd6d37411fd387c88470..5e687c660ad67c25438949a33a633ed6e9e68940 100644 (file)
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -165,7 +165,7 @@ int zck_range_get_need_dl(zckRange *info, zckCtx *zck_src, zckCtx *zck_tgt) {
         src_idx = src_info->first;
 
         while(src_idx) {
-            if(memcmp(tgt_idx->digest, src_idx->digest, zck_get_chunk_digest_size(zck_tgt)) == 0) {
+            if(memcmp(tgt_idx->digest, src_idx->digest, tgt_idx->digest_size) == 0) {
                 found = True;
                 break;
             }

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index 03fc0532b865b579a71698153a36143efcf78b28..0f2b90fbf3d74c3b6e36f4f7fb017c77f6980fbf 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -34,8 +34,12 @@
 #include "sha1/sha1.h"
 #include "sha2/sha2.h"
 
+#define VALIDATE(f)     if(!f) { \
+                            zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n"); \
+                            return False; \
+                        }
+
 static char unknown[] = "Unknown(\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-static char hash_text[BUF_SIZE] = {0};
 
 const static char *HASH_NAME[] = {
     "SHA-1",
@@ -183,17 +187,34 @@ const char PUBLIC *zck_hash_name_from_type(int hash_type) {
     return HASH_NAME[hash_type];
 }
 
-const char *zck_hash_get_printable(const char *digest, zckHashType *type) {
-    if(digest == NULL || type == NULL) {
-        zck_log(ZCK_LOG_ERROR,
-                "digest or zckHashType haven't been initialized\n");
+int set_full_hash_type(zckCtx *zck, int hash_type) {
+    VALIDATE(zck);
+    zck_log(ZCK_LOG_INFO, "Setting full hash to %s\n",
+            zck_hash_name_from_type(hash_type));
+    if(!zck_hash_setup(&(zck->hash_type), hash_type)) {
+        zck_log(ZCK_LOG_ERROR, "Unable to set full hash to %s\n",
+                zck_hash_name_from_type(hash_type));
         return False;
     }
-    for(int i=0; i<type->digest_size; i++) {
-        if(snprintf(hash_text + (i*2), 3, "%02x", (unsigned char)digest[i]) < 0) {
-            zck_log(ZCK_LOG_ERROR, "Unable to generate printable hash\n");
-            return NULL;
-        }
+    zck_hash_close(&(zck->full_hash));
+    if(!zck_hash_init(&(zck->full_hash), &(zck->hash_type))) {
+        zck_log(ZCK_LOG_ERROR, "Unable initialize full hash\n");
+        return False;
+    }
+    return True;
+}
+
+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_hash_name_from_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;
     }
-    return hash_text;
+    zck->index.hash_type = zck->chunk_hash_type.type;
+    zck->index.digest_size = zck->chunk_hash_type.digest_size;
+    return True;
 }

diff --git a/src/lib/header.c b/src/lib/header.c
index 1cd1b1458c28e23969a04c118692b4d1e8028e82..902e8e1d2d8d8a39a438e70ba7dd35e2aecf1055 100644 (file)
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -159,7 +159,7 @@ int zck_read_ct_is(zckCtx *zck) {
     /* Read and initialize compression type */
     if(!zck_compint_to_int(&tmp, header + length, &length))
         return False;
-    if(!zck_set_compression_type(zck, tmp))
+    if(!zck_set_ioption(zck, ZCK_COMP_TYPE, tmp))
         return False;
     if(!zck_comp_init(zck))
         return False;

diff --git a/src/lib/index/index_read.c b/src/lib/index/index_read.c
index ca2d3c14e0fe2b97968b23bee901d8e029d2cd51..31d7da03177ea5252c30d670cec2619248b68432 100644 (file)
--- a/src/lib/index/index_read.c
+++ b/src/lib/index/index_read.c
@@ -71,7 +71,7 @@ int zck_index_read(zckCtx *zck, char *data, size_t size) {
     int hash_type;
     if(!zck_compint_to_int(&hash_type, data + length, &length))
         return False;
-    if(!zck_set_chunk_hash_type(zck, hash_type))
+    if(!zck_set_ioption(zck, ZCK_HASH_CHUNK_TYPE, hash_type))
         return False;
 
     /* Read number of index entries */

diff --git a/src/lib/log.c b/src/lib/log.c
index 8572ad6a1e498afb9e76c83ecc37f25804016604..6409f34d139e50c37e924fceeff9f2a61a42fca0 100644 (file)
--- a/src/lib/log.c
+++ b/src/lib/log.c
@@ -31,13 +31,13 @@
 
 #include "zck_private.h"
 
-static log_type log_level = ZCK_LOG_ERROR;
+static zck_log_type log_level = ZCK_LOG_ERROR;
 
-void PUBLIC zck_set_log_level(log_type ll) {
+void PUBLIC zck_set_log_level(zck_log_type ll) {
     log_level = ll;
 }
 
-void PUBLIC zck_log(log_type lt, const char *format, ...) {
+void PUBLIC zck_log(zck_log_type lt, const char *format, ...) {
     if(lt >= log_level) {
         va_list args;
         va_start(args, format);

diff --git a/src/lib/zck.c b/src/lib/zck.c
index eb48165f4c5f4048f57159736ed48446fc67ddc7..c7ee1108079e8c2d012b1ea5e598dd9c8dc666bb 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -40,6 +40,47 @@
                             return False; \
                         }
 
+int PUBLIC zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) {
+    /* Set hash type */
+    if(option == ZCK_HASH_FULL_TYPE) {
+        return set_full_hash_type(zck, value);
+    } else if(option == ZCK_HASH_CHUNK_TYPE) {
+        return set_chunk_hash_type(zck, value);
+
+    /* Hash options */
+    } else if(option < 100) {
+        /* Currently no hash options other than setting hash type, so bail */
+        zck_log(ZCK_LOG_ERROR, "Unknown option %lu\n", value);
+        return False;
+
+    /* Compression options */
+    } else if(option < 2000) {
+        return comp_ioption(zck, option, value);
+
+    /* Unknown options */
+    } else {
+        zck_log(ZCK_LOG_ERROR, "Unknown option %lu\n", value);
+        return False;
+    }
+}
+
+int PUBLIC zck_set_soption(zckCtx *zck, zck_soption option, const void *value) {
+    /* Hash options */
+    if(option < 100) {
+        /* Currently no hash options other than setting hash type, so bail */
+        zck_log(ZCK_LOG_ERROR, "Unknown option %lu\n", value);
+        return False;
+
+    /* Compression options */
+    } else if(option < 2000) {
+        return comp_soption(zck, option, value);
+
+    /* Unknown options */
+    } else {
+        zck_log(ZCK_LOG_ERROR, "Unknown option %lu\n", value);
+        return False;
+    }
+}
 int PUBLIC zck_close(zckCtx *zck) {
     VALIDATE(zck);
 
@@ -147,15 +188,15 @@ zckCtx PUBLIC *zck_init_write (int dst_fd) {
 
     /* Set defaults */
 #ifdef ZCHUNK_ZSTD
-    if(!zck_set_compression_type(zck, ZCK_COMP_ZSTD))
+    if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_ZSTD))
         goto iw_error;
 #else
-    if(!zck_set_compression_type(zck, ZCK_COMP_NONE))
+    if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_NONE))
         goto iw_error;
 #endif
-    if(!zck_set_full_hash_type(zck, ZCK_HASH_SHA256))
+    if(!zck_set_ioption(zck, ZCK_HASH_FULL_TYPE, ZCK_HASH_SHA256))
         goto iw_error;
-    if(!zck_set_chunk_hash_type(zck, ZCK_HASH_SHA1))
+    if(!zck_set_ioption(zck, ZCK_HASH_CHUNK_TYPE, ZCK_HASH_SHA1))
         goto iw_error;
     zck->fd = dst_fd;
 
@@ -165,50 +206,6 @@ iw_error:
     return NULL;
 }
 
-int PUBLIC zck_set_full_hash_type(zckCtx *zck, int hash_type) {
-    VALIDATE(zck);
-    zck_log(ZCK_LOG_INFO, "Setting full hash to %s\n",
-            zck_hash_name_from_type(hash_type));
-    if(!zck_hash_setup(&(zck->hash_type), hash_type)) {
-        zck_log(ZCK_LOG_ERROR, "Unable to set full hash to %s\n",
-                zck_hash_name_from_type(hash_type));
-        return False;
-    }
-    zck_hash_close(&(zck->full_hash));
-    if(!zck_hash_init(&(zck->full_hash), &(zck->hash_type))) {
-        zck_log(ZCK_LOG_ERROR, "Unable initialize full hash\n");
-        return False;
-    }
-    return True;
-}
-
-int PUBLIC zck_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_hash_name_from_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;
-}
-
-int PUBLIC zck_get_full_digest_size(zckCtx *zck) {
-    if(zck == NULL)
-        return -1;
-    return zck->hash_type.digest_size;
-}
-
-int PUBLIC zck_get_chunk_digest_size(zckCtx *zck) {
-    if(zck == NULL || zck->index.digest_size == 0)
-        return -1;
-    return zck->index.digest_size;
-}
-
 int PUBLIC zck_get_full_hash_type(zckCtx *zck) {
     if(zck == NULL)
         return -1;
@@ -241,7 +238,7 @@ char *get_digest_string(const char *digest, int size) {
     return str;
 }
 
-char PUBLIC *zck_get_index_digest(zckCtx *zck) {
+char PUBLIC *zck_get_header_digest(zckCtx *zck) {
     if(zck == NULL)
         return NULL;
     return get_digest_string(zck->index_digest, zck->hash_type.digest_size);
@@ -253,6 +250,12 @@ char PUBLIC *zck_get_data_digest(zckCtx *zck) {
     return get_digest_string(zck->full_hash_digest, zck->hash_type.digest_size);
 }
 
+char PUBLIC *zck_get_chunk_digest(zckIndexItem *item) {
+    if(item == NULL)
+        return NULL;
+    return get_digest_string(item->digest, item->digest_size);
+}
+
 ssize_t PUBLIC zck_get_header_length(zckCtx *zck) {
     if(zck == NULL)
         return -1;
@@ -322,10 +325,10 @@ int zck_import_dict(zckCtx *zck) {
     if(!zck_comp_reset(zck))
         return False;
     zck_log(ZCK_LOG_DEBUG, "Setting dict size\n");
-    if(!zck_set_comp_parameter(zck, ZCK_COMMON_DICT_SIZE, &size))
+    if(!zck_set_ioption(zck, ZCK_COMP_DICT_SIZE, size))
         return False;
     zck_log(ZCK_LOG_DEBUG, "Setting dict\n");
-    if(!zck_set_comp_parameter(zck, ZCK_COMMON_DICT, data))
+    if(!zck_set_soption(zck, ZCK_COMP_DICT, data))
         return False;
     if(!zck_comp_init(zck))
         return False;
@@ -386,16 +389,15 @@ int zck_validate_current_chunk(zckCtx *zck) {
                 "Unable to calculate %s checksum for chunk\n");
         return False;
     }
+    if(zck->comp.data_idx->comp_length == 0)
+        memset(digest, 0, zck->comp.data_idx->digest_size);
     zck_log(ZCK_LOG_DEBUG, "Checking chunk checksum\n");
-    zck_log(ZCK_LOG_DEBUG, "Expected chunk checksum: ");
-    for(int i=0; i<zck->chunk_hash_type.digest_size; i++)
-        zck_log(ZCK_LOG_DEBUG, "%02x",
-                (unsigned char)zck->comp.data_idx->digest[i]);
-    zck_log(ZCK_LOG_DEBUG, "\n");
-    zck_log(ZCK_LOG_DEBUG, "Calculated chunk checksum: ");
-    for(int i=0; i<zck->chunk_hash_type.digest_size; i++)
-        zck_log(ZCK_LOG_DEBUG, "%02x", (unsigned char)digest[i]);
-    zck_log(ZCK_LOG_DEBUG, "\n");
+    char *pdigest = zck_get_chunk_digest(zck->comp.data_idx);
+    zck_log(ZCK_LOG_DEBUG, "Expected chunk checksum: %s\n", pdigest);
+    free(pdigest);
+    pdigest = get_digest_string(digest, zck->comp.data_idx->digest_size);
+    zck_log(ZCK_LOG_DEBUG, "Calculated chunk checksum: %s\n", pdigest);
+    free(pdigest);
     if(memcmp(digest, zck->comp.data_idx->digest,
               zck->chunk_hash_type.digest_size) != 0) {
         free(digest);

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index f745dc97bc04bb90f08d59183cb7db403c3e71e4..9a540835194def3a70c6a7c320105b4aa06baf2b 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -30,7 +30,7 @@ typedef int (*fdcompend)(struct zckComp *comp, const int use_dict,
                          const size_t fd_size);
 typedef int (*fcclose)(struct zckComp *comp);
 
-typedef enum log_type log_type;
+typedef enum zck_log_type zck_log_type;
 
 typedef struct zckHashType {
     int type;
@@ -129,6 +129,7 @@ int zck_import_dict(zckCtx *zck);
 int zck_validate_file(zckCtx *zck);
 int zck_validate_current_chunk(zckCtx *zck);
 void zck_clear_work_index(zckCtx *zck);
+char *get_digest_string(const char *digest, int size);
 
 /* hash/hash.h */
 int zck_hash_setup(zckHashType *ht, int h);
@@ -137,6 +138,8 @@ int zck_hash_update(zckHash *hash, const char *message, const size_t size);
 char *zck_hash_finalize(zckHash *hash);
 void zck_hash_close(zckHash *hash);
 const char *zck_hash_get_printable(const char *digest, zckHashType *type);
+int set_full_hash_type(zckCtx *zck, int hash_type);
+int set_chunk_hash_type(zckCtx *zck, int hash_type);
 
 /* index/index.c */
 int zck_index_read(zckCtx *zck, char *data, size_t size);
@@ -175,6 +178,8 @@ int zck_comp_add_to_dc(zckComp *comp, const char *src, size_t src_size);
 int zck_comp_add_to_data(zckComp *comp, const char *src, size_t src_size);
 size_t zck_comp_read_from_dc(zckComp *comp, char *dst, size_t dst_size);
 ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict);
+int comp_ioption(zckCtx *zck, zck_ioption option, ssize_t value);
+int comp_soption(zckCtx *zck, zck_soption option, const void *value);
 
 /* dl/range.c */
 char *zck_range_get_char(zckRangeItem **range, int max_ranges);
@@ -196,5 +201,5 @@ int zck_compint_to_size(size_t *val, const char *compint, size_t *length);
 
 
 /* log.c */
-void zck_log(log_type lt, const char *format, ...);
+void zck_log(zck_log_type lt, const char *format, ...);
 #endif

diff --git a/src/zck.c b/src/zck.c
index ad7cf999444c386228df7c350111187cebffb9ba..16729eed1b74969319f86e5fe652df4416c4520a 100644 (file)
--- a/src/zck.c
+++ b/src/zck.c
@@ -92,14 +92,14 @@ int main (int argc, char *argv[]) {
         exit(1);
     }
 
-    /*if(!zck_set_compression_type(zck, ZCK_COMP_NONE)) {
+    /*if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_NONE)) {
         perror("Unable to set compression type\n");
         exit(1);
     }*/
     if(dict_size > 0) {
-        if(!zck_set_comp_parameter(zck, ZCK_COMMON_DICT_SIZE, &dict_size))
+        if(!zck_set_ioption(zck, ZCK_COMP_DICT_SIZE, dict_size))
             exit(1);
-        if(!zck_set_comp_parameter(zck, ZCK_COMMON_DICT, dict))
+        if(!zck_set_soption(zck, ZCK_COMP_DICT, dict))
             exit(1);
     }
     free(dict);

diff --git a/src/zck_delta_size.c b/src/zck_delta_size.c
index 12ddc3bea92a5cfcad953b8a91946f3aee1200f7..2ce467f306e1c40f07b8f305eaca7d2659431531 100644 (file)
--- a/src/zck_delta_size.c
+++ b/src/zck_delta_size.c
@@ -80,7 +80,7 @@ int main (int argc, char *argv[]) {
         exit(1);
     zckIndexItem *tgt_idx = tgt_info->first;
     zckIndexItem *src_idx = src_info->first;
-    if(memcmp(tgt_idx->digest, src_idx->digest, zck_get_chunk_digest_size(zck_tgt)) != 0)
+    if(memcmp(tgt_idx->digest, src_idx->digest, tgt_idx->digest_size) != 0)
         printf("WARNING: Dicts don't match\n");
     ssize_t dl_size = zck_get_header_length(zck_tgt);
     if(dl_size < 0)
@@ -92,7 +92,7 @@ int main (int argc, char *argv[]) {
         src_idx = src_info->first;
 
         while(src_idx) {
-            if(memcmp(tgt_idx->digest, src_idx->digest, zck_get_chunk_digest_size(zck_tgt)) == 0) {
+            if(memcmp(tgt_idx->digest, src_idx->digest, tgt_idx->digest_size) == 0) {
                 found = True;
                 break;
             }

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index a70574dcded59ef8d166bf19bf6bfccd3b1bbcf2..2c2189196f475edb5a1e2995cefed3400e339c1f 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -56,7 +56,7 @@ int main (int argc, char *argv[]) {
     close(src_fd);
 
     printf("Overall checksum type: %s\n", zck_hash_name_from_type(zck_get_full_hash_type(zck)));
-    char *digest = zck_get_index_digest(zck);
+    char *digest = zck_get_header_digest(zck);
     printf("Header checksum: %s\n", digest);
     free(digest);
     digest = zck_get_data_digest(zck);
@@ -69,11 +69,12 @@ int main (int argc, char *argv[]) {
         exit(1);
     zckIndexItem *idx = idxi->first;
     while(idx) {
-        for(int i=0; i<zck_get_chunk_digest_size(zck); i++)
-            printf("%02x", (unsigned char)idx->digest[i]);
-        printf(" %12lu %12lu %12lu\n", idx->start + zck_get_header_length(zck), idx->comp_length, idx->length);
+        char *digest = zck_get_chunk_digest(idx);
+        if(digest == NULL)
+            exit(1);
+        printf("%s %12lu %12lu %12lu\n", digest, idx->start + zck_get_header_length(zck), idx->comp_length, idx->length);
+        free(digest);
         idx = idx->next;
     }
-
     zck_free(&zck);
 }