Rename zckIndex to zckIndexItem and zckIndexInfo to zckIndex

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

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 50397a7629ec67a3ab0aaa472aa81a927ecc8eb9..83bc9040c04ac3ba6217cf815a693dd4bff0c202 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -58,7 +58,7 @@ void zck_dl_free_dl_regex(zckDL *dl) {
 }
 
 /* Write zeros to tgt->fd in location of tgt_idx */
-int zck_dl_write_zero(zckCtx *tgt, zckIndex *tgt_idx) {
+int zck_dl_write_zero(zckCtx *tgt, zckIndexItem *tgt_idx) {
     char buf[BUF_SIZE] = {0};
     size_t tgt_data_offset = tgt->header_size + tgt->index_size;
     size_t to_read = tgt_idx->length;
@@ -137,10 +137,10 @@ int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
         /* Check whether we just finished downloading a chunk and verify it */
         if(dl->tgt_check && !zck_dl_write_chunk(dl))
             return False;
-        zckIndex *idx = dl->info.index.first;
+        zckIndexItem *idx = dl->info.index.first;
         while(idx) {
             if(dl->dl_chunk_data == idx->start) {
-                zckIndex *tgt_idx = dl->zck->index.first;
+                zckIndexItem *tgt_idx = dl->zck->index.first;
                 while(tgt_idx) {
                     if(tgt_idx->finished)
                         tgt_idx = tgt_idx->next;
@@ -213,7 +213,7 @@ static size_t write_data(void *ptr, size_t l, size_t c, void *dl_v) {
 }
 
 int zck_dl_write_and_verify(zckRangeInfo *info, zckCtx *src, zckCtx *tgt,
-                            zckIndex *src_idx, zckIndex *tgt_idx) {
+                            zckIndexItem *src_idx, zckIndexItem *tgt_idx) {
     static char buf[BUF_SIZE] = {0};
 
     size_t src_data_offset = src->header_size + src->index_size;
@@ -259,10 +259,10 @@ int zck_dl_write_and_verify(zckRangeInfo *info, zckCtx *src, zckCtx *tgt,
 }
 
 int zck_dl_copy_src_chunks(zckRangeInfo *info, zckCtx *src, zckCtx *tgt) {
-    zckIndexInfo *tgt_info = zck_get_index(tgt);
-    zckIndexInfo *src_info = zck_get_index(src);
-    zckIndex *tgt_idx = tgt_info->first;
-    zckIndex *src_idx = src_info->first;
+    zckIndex *tgt_info = zck_get_index(tgt);
+    zckIndex *src_info = zck_get_index(src);
+    zckIndexItem *tgt_idx = tgt_info->first;
+    zckIndexItem *src_idx = src_info->first;
     while(tgt_idx) {
         int found = False;
         src_idx = src_info->first;
@@ -295,7 +295,7 @@ static size_t get_header(char *b, size_t l, size_t c, void *dl_v) {
     return zck_multipart_get_boundary(dl, b, c*l);
 }
 
-int zck_dl_range(zckDL *dl, char *url, int is_chunk) {
+int zck_dl_range_chk_chunk(zckDL *dl, char *url, int is_chunk) {
     if(dl == NULL || dl->priv == NULL || dl->info.first == NULL) {
         zck_log(ZCK_LOG_ERROR, "Struct not defined\n");
         return False;
@@ -348,12 +348,16 @@ int zck_dl_range(zckDL *dl, char *url, int is_chunk) {
                     url);
             return False;
         }
-        zck_dl_free_regex(dl);
+        zck_dl_clear_regex(dl);
     }
     free(ra);
     return True;
 }
 
+int zck_dl_range(zckDL *dl, char *url) {
+    return zck_dl_range_chk_chunk(dl, url, 1);
+}
+
 int zck_dl_bytes(zckDL *dl, char *url, size_t bytes, size_t start,
                  size_t *buffer_len) {
     if(dl == NULL) {
@@ -361,7 +365,7 @@ int zck_dl_bytes(zckDL *dl, char *url, size_t bytes, size_t start,
         return False;
     }
     if(start + bytes > *buffer_len) {
-        zckIndex idx = {0};
+        zckIndexItem idx = {0};
 
         zck_log(ZCK_LOG_DEBUG, "Seeking to end of temporary file\n");
         if(lseek(dl->dst_fd, 0, SEEK_END) == -1) {
@@ -374,7 +378,7 @@ int zck_dl_bytes(zckDL *dl, char *url, size_t bytes, size_t start,
         idx.length = start+bytes-*buffer_len;
         zck_range_close(&(dl->info));
         zck_range_add(&(dl->info), &idx, NULL);
-        if(!zck_dl_range(dl, url, 0))
+        if(!zck_dl_range_chk_chunk(dl, url, 0))
             return False;
         zck_range_close(&(dl->info));
         *buffer_len = start+bytes;
@@ -471,7 +475,7 @@ int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
         return False;
 
     /* Write zeros to rest of file */
-    zckIndexInfo *info = &(dl->info.index);
+    zckIndex *info = &(dl->info.index);
     info->hash_type = zck->index.hash_type;
     zck_log(ZCK_LOG_DEBUG, "Writing zeros to rest of file: %llu\n", zck->index.length + zck->index_size + start);
     if(!zck_zero_bytes(dl, zck->index.length, zck->header_size + zck->index_size, &buffer_len))
@@ -498,7 +502,7 @@ void zck_dl_global_cleanup() {
 }
 
 /* Free zckDL header regex used for downloading ranges */
-void zck_dl_free_regex(zckDL *dl) {
+void zck_dl_clear_regex(zckDL *dl) {
     if(dl == NULL || dl->priv == NULL)
         return;
 
@@ -550,7 +554,7 @@ void zck_dl_free(zckDL **dl) {
                 free((*dl)->priv->mp->buffer);
             free((*dl)->priv->mp);
         }
-        zck_dl_free_regex(*dl);
+        zck_dl_clear_regex(*dl);
         curl_easy_cleanup((*dl)->priv->curl_ctx);
         free((*dl)->priv);
     }

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index c4e696827b20c1d387ae64b46699c1062d603a0a..24fb44dad06575af755960f3c8060fc57b894370 100644 (file)
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -55,7 +55,7 @@ void zck_range_close(zckRangeInfo *info) {
 
 zckRange *zck_range_insert_new(zckRange *prev, zckRange *next, uint64_t start,
                                uint64_t end, zckRangeInfo *info,
-                               zckIndex *idx, int add_index) {
+                               zckIndexItem *idx, int add_index) {
     zckRange *new = zmalloc(sizeof(zckRange));
     if(!new) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
@@ -98,9 +98,9 @@ void zck_range_merge_combined(zckRangeInfo *info) {
     }
 }
 
-int zck_range_add(zckRangeInfo *info, zckIndex *idx, zckCtx *zck) {
+int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck) {
     if(info == NULL || idx == NULL) {
-        zck_log(ZCK_LOG_ERROR, "zckRangeInfo or zckIndex not allocated\n");
+        zck_log(ZCK_LOG_ERROR, "zckRangeInfo or zckIndexItem not allocated\n");
         return False;
     }
     size_t header_len = 0;
@@ -156,10 +156,10 @@ int zck_range_calc_segments(zckRangeInfo *info, unsigned int max_ranges) {
 }
 
 int zck_range_get_need_dl(zckRangeInfo *info, zckCtx *zck_src, zckCtx *zck_tgt) {
-    zckIndexInfo *tgt_info = zck_get_index(zck_tgt);
-    zckIndexInfo *src_info = zck_get_index(zck_src);
-    zckIndex *tgt_idx = tgt_info->first;
-    zckIndex *src_idx = src_info->first;
+    zckIndex *tgt_info = zck_get_index(zck_tgt);
+    zckIndex *src_info = zck_get_index(zck_src);
+    zckIndexItem *tgt_idx = tgt_info->first;
+    zckIndexItem *src_idx = src_info->first;
     while(tgt_idx) {
         int found = False;
         src_idx = src_info->first;

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index 384f9fe6f0520ecc0780de6c31cd580345c10b4e..35057b07ef5abcf3f094305c966cbe54f289e76f 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -129,14 +129,14 @@ void zck_hash_close(zckHash *hash) {
     return;
 }
 
-/* Returns 1 if full file hash matches, 0 if it doesn't and -1 if failure */
-int zck_hash_check_full_file(zckCtx *zck, int dst_fd) {
+/* Returns 1 if data hash matches, 0 if it doesn't and -1 if failure */
+int zck_hash_check_data(zckCtx *zck, int dst_fd) {
     if(!zck_seek(dst_fd, zck->header_size + zck->index_size, SEEK_SET))
         return -1;
     if(!zck_hash_init(&(zck->check_full_hash), &(zck->hash_type)))
         return -1;
     char buf[BUF_SIZE] = {0};
-    zckIndex *idx = zck->index.first;
+    zckIndexItem *idx = zck->index.first;
     zck_log(ZCK_LOG_INFO, "Checking full hash\n");
     while(idx) {
         size_t to_read = idx->length;

diff --git a/src/lib/index/index_common.c b/src/lib/index/index_common.c
index 41eb9c335901ca14231a1d0e882da39d081f59c7..9435ce326304cdfc86840ffabbd585edf37256ca 100644 (file)
--- a/src/lib/index/index_common.c
+++ b/src/lib/index/index_common.c
@@ -31,13 +31,13 @@
 
 #include "zck_private.h"
 
-void zck_index_clean(zckIndexInfo *index) {
+void zck_index_clean(zckIndex *index) {
     if(index == NULL)
         return;
 
     if(index->first) {
-        zckIndex *next;
-        zckIndex *tmp=index->first;
+        zckIndexItem *next;
+        zckIndexItem *tmp=index->first;
         while(tmp != NULL) {
             next = tmp->next;
             if(tmp->digest)
@@ -46,7 +46,7 @@ void zck_index_clean(zckIndexInfo *index) {
             tmp = next;
         }
     }
-    memset(index, 0, sizeof(zckIndexInfo));
+    memset(index, 0, sizeof(zckIndex));
 }
 
 void zck_index_free(zckCtx *zck) {

diff --git a/src/lib/index/index_create.c b/src/lib/index/index_create.c
index f3494634eaaa637afb5ec2f11557240ec66ddcb4..8ecfcb9dee43d1e90ac2529748439b692e34644b 100644 (file)
--- a/src/lib/index/index_create.c
+++ b/src/lib/index/index_create.c
@@ -48,7 +48,7 @@ int zck_index_finalize(zckCtx *zck) {
     /* Add digest size + MAX_COMP_SIZE bytes for length of each entry in
      * index */
     if(zck->index.first) {
-        zckIndex *tmp = zck->index.first;
+        zckIndexItem *tmp = zck->index.first;
         while(tmp) {
             index_malloc += zck->index.digest_size + MAX_COMP_SIZE;
             tmp = tmp->next;
@@ -62,7 +62,7 @@ int zck_index_finalize(zckCtx *zck) {
     memcpy(index+index_size, zck->full_hash_digest, zck->hash_type.digest_size);
     index_size += zck->hash_type.digest_size;
     if(zck->index.first) {
-        zckIndex *tmp = zck->index.first;
+        zckIndexItem *tmp = zck->index.first;
         while(tmp) {
             memcpy(index+index_size, tmp->digest, zck->index.digest_size);
             index_size += zck->index.digest_size;
@@ -115,7 +115,7 @@ int zck_index_finalize(zckCtx *zck) {
     return True;
 }
 
-int zck_index_new_chunk(zckIndexInfo *index, char *digest, int digest_size,
+int zck_index_new_chunk(zckIndex *index, char *digest, int digest_size,
                         size_t length, int finished) {
     if(index == NULL) {
         zck_log(ZCK_LOG_ERROR, "Invalid index\n");
@@ -125,10 +125,10 @@ int zck_index_new_chunk(zckIndexInfo *index, char *digest, int digest_size,
         zck_log(ZCK_LOG_ERROR, "Digest size 0 too small\n");
         return False;
     }
-    zckIndex *idx = zmalloc(sizeof(zckIndex));
+    zckIndexItem *idx = zmalloc(sizeof(zckIndexItem));
     if(idx == NULL) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                sizeof(zckIndex));
+                sizeof(zckIndexItem));
         return False;
     }
     idx->digest = zmalloc(digest_size);
@@ -145,7 +145,7 @@ int zck_index_new_chunk(zckIndexInfo *index, char *digest, int digest_size,
     if(index->first == NULL) {
         index->first = idx;
     } else {
-        zckIndex *tmp=index->first;
+        zckIndexItem *tmp=index->first;
         while(tmp->next)
             tmp = tmp->next;
         tmp->next = idx;

diff --git a/src/lib/index/index_read.c b/src/lib/index/index_read.c
index 8622b0edd18acc077d205b89edbaade0407644be..422e0f19859200c97d1a547fff8437d153b74d9e 100644 (file)
--- a/src/lib/index/index_read.c
+++ b/src/lib/index/index_read.c
@@ -90,13 +90,13 @@ int zck_index_read(zckCtx *zck, char *data, size_t size) {
     memcpy(zck->full_hash_digest, data + length, zck->hash_type.digest_size);
     length += zck->hash_type.digest_size;
 
-    zckIndex *prev = zck->index.first;
+    zckIndexItem *prev = zck->index.first;
     size_t idx_loc = 0;
     while(length < size) {
-        zckIndex *new = zmalloc(sizeof(zckIndex));
+        zckIndexItem *new = zmalloc(sizeof(zckIndexItem));
         if(!new) {
             zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                    sizeof(zckIndex));
+                    sizeof(zckIndexItem));
             return False;
         }
 

diff --git a/src/lib/zck.c b/src/lib/zck.c
index 4f911eb454f3f898dda2aa7608a8e7a0d37151ab..c9ffda56b603629e6b89971eaae04a4e9877e383 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -163,7 +163,7 @@ ssize_t zck_get_index_count(zckCtx *zck) {
     return zck->index.count;
 }
 
-zckIndexInfo *zck_get_index(zckCtx *zck) {
+zckIndex *zck_get_index(zckCtx *zck) {
     if(zck == NULL)
         return NULL;
     return &(zck->index);
@@ -263,11 +263,11 @@ int zck_import_dict(zckCtx *zck, char *data, size_t size) {
     return True;
 }
 
-int zck_validate_chunk(zckCtx *zck, char *data, size_t size, zckIndex *idx,
+int zck_validate_chunk(zckCtx *zck, char *data, size_t size, zckIndexItem *idx,
                        int chk_num) {
     VALIDATE(zck);
     if(idx == NULL) {
-        zck_log(ZCK_LOG_ERROR, "zckIndex not initialized\n");
+        zck_log(ZCK_LOG_ERROR, "zckIndexItem not initialized\n");
         return False;
     }
     zckHash chunk_hash;
@@ -338,8 +338,8 @@ int zck_decompress_to_file(zckCtx *zck, int src_fd, int dst_fd) {
         return False;
     }
 
-    zckIndexInfo *index = zck_get_index(zck);
-    zckIndex *idx = index->first;
+    zckIndex *index = zck_get_index(zck);
+    zckIndexItem *idx = index->first;
 
     /* Check if zck file is empty */
     for(int count=0; idx; count++) {

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 1632ce24783073f6b71099ecf2b1b47e1c18d261..2a92b7d342242ac539f65bee273b795b89bb514a 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -35,7 +35,7 @@ typedef struct zckHash {
     void *ctx;
 } zckHash;
 
-/*typedef struct zckIndex zckIndex;*/
+/*typedef struct zckIndexItem zckIndexItem;*/
 typedef void CURL;
 
 typedef struct zckMP {
@@ -83,7 +83,7 @@ typedef struct zckCtx {
     size_t header_size;
     char *index_string;
     size_t index_size;
-    zckIndexInfo index;
+    zckIndex index;
     char *index_digest;
     zckHash full_hash;
     zckHash check_full_hash;
@@ -115,10 +115,10 @@ const char *zck_hash_get_printable(const char *digest, zckHashType *type);
 /* index/index.c */
 int zck_index_read(zckCtx *zck, char *data, size_t size);
 int zck_index_finalize(zckCtx *zck);
-int zck_index_new_chunk(zckIndexInfo *index, char *digest, int digest_size,
+int zck_index_new_chunk(zckIndex *index, char *digest, int digest_size,
                         size_t length, int finished);
 int zck_index_add_chunk(zckCtx *zck, char *data, size_t size);
-void zck_index_clean(zckIndexInfo *index);
+void zck_index_clean(zckIndex *index);
 void zck_index_free(zckCtx *zck);
 int zck_write_index(zckCtx *zck);
 
@@ -142,7 +142,7 @@ int zck_write_header(zckCtx *zck);
 
 /* dl/range.c */
 char *zck_range_get_char(zckRange **range, int max_ranges);
-int zck_range_add(zckRangeInfo *info, zckIndex *idx, zckCtx *zck);
+int zck_range_add(zckRangeInfo *info, zckIndexItem *idx, zckCtx *zck);
 
 /* dl/multipart.c */
 size_t zck_multipart_extract(zckDL *dl, char *b, size_t l);
@@ -150,6 +150,7 @@ size_t zck_multipart_get_boundary(zckDL *dl, char *b, size_t size);
 
 /* dl/dl.c */
 int zck_dl_write_range(zckDL *dl, const char *at, size_t length);
+int zck_dl_range_chk_chunk(zckDL *dl, char *url, int is_chunk);
 
 /* compint.c */
 int zck_compint_from_int(char *compint, int val, size_t *length);

diff --git a/src/zck_delta_size.c b/src/zck_delta_size.c
index 2a1314152756c2aab4f4d3ad4cd2eec195042db3..05b3ce01706ca9ffd4e86d2c35296a0db274ee26 100644 (file)
--- a/src/zck_delta_size.c
+++ b/src/zck_delta_size.c
@@ -75,20 +75,20 @@ int main (int argc, char *argv[]) {
         printf("   %s: %s\n", argv[2], zck_hash_name_from_type(zck_get_chunk_hash_type(zck_src)));
         return 1;
     }
-    zckIndexInfo *tgt_info = zck_get_index(zck_tgt);
+    zckIndex *tgt_info = zck_get_index(zck_tgt);
     if(tgt_info == NULL)
         exit(1);
-    zckIndexInfo *src_info = zck_get_index(zck_src);
+    zckIndex *src_info = zck_get_index(zck_src);
     if(src_info == NULL)
         exit(1);
-    zckIndex *tgt_idx = tgt_info->first;
-    zckIndex *src_idx = src_info->first;
+    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)
         printf("WARNING: Dicts don't match\n");
     ssize_t dl_size = zck_get_header_length(zck_tgt);
     if(dl_size < 0)
         exit(1);
-    ssize_t total_size = 0;
+    ssize_t total_size = zck_get_header_length(zck_tgt);
     ssize_t matched_chunks = 0;
     while(tgt_idx) {
         int found = False;

diff --git a/src/zck_dl.c b/src/zck_dl.c
index fca3c952d16d9a21e34f3838a7816ef1c6fdaca0..bb4b24e7e77a47459f4c312ad066e69f6fc55432 100644 (file)
--- a/src/zck_dl.c
+++ b/src/zck_dl.c
@@ -90,12 +90,12 @@ int main (int argc, char *argv[]) {
         exit(1);
 
     lseek(dl->dst_fd, 0, SEEK_SET);
-    if(!zck_dl_range(dl, argv[2], 1))
+    if(!zck_dl_range(dl, argv[2]))
         exit(1);
 
 
     printf("Downloaded %lu bytes\n", zck_dl_get_bytes_downloaded(dl));
-    switch(zck_hash_check_full_file(dl->zck, dl->dst_fd)) {
+    switch(zck_hash_check_data(dl->zck, dl->dst_fd)) {
         case -1:
             exit(1);
             break;

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index 3165c918d3ef1b79a6ea93695d7a826747dcb5b9..6ff9e9c669689dd2a34ce80218264268c68ae286 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -68,10 +68,10 @@ int main (int argc, char *argv[]) {
     printf("\n");
     printf("Index count: %lu\n", zck_get_index_count(zck));
     printf("Chunk checksum type: %s\n", zck_hash_name_from_type(zck_get_chunk_hash_type(zck)));
-    zckIndexInfo *idxi = zck_get_index(zck);
+    zckIndex *idxi = zck_get_index(zck);
     if(idxi == NULL)
         exit(1);
-    zckIndex *idx = idxi->first;
+    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]);