Make a number of zckDL fields private

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

diff --git a/include/zck.h b/include/zck.h
index 31f0f4c18ccaa00abd31b795a077af40e6324fc1..e841bfaa0bbedf44288a69d4929a0d8629264a8b 100644 (file)
--- a/include/zck.h
+++ b/include/zck.h
@@ -71,15 +71,11 @@ typedef struct zckHash zckHash;
 typedef struct zckDL {
     size_t dl;
     size_t ul;
-    size_t write_in_chunk;
-    size_t dl_chunk_data;
     int dst_fd;
     char *boundary;
     zckRange info;
     zckDLPriv *priv;
     struct zckCtx *zck;
-    zckIndexItem *tgt_check;
-    zckHash *chunk_hash;
 } zckDL;
 
 /*******************************************************************

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 37907f4fc4a3f9a09aeb4d1708f7695a532ccc2b..6d4830ca369fee1e1fa52b16059c3b7bac1f6e78 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -77,53 +77,58 @@ int zck_dl_write_zero(zckCtx *tgt, zckIndexItem *tgt_idx) {
 
 int zck_dl_write(zckDL *dl, const char *at, size_t length) {
     VALIDATE(dl);
-    if(dl->write_in_chunk < length)
-        length = dl->write_in_chunk;
+    VALIDATE(dl->priv);
+    if(dl->priv->write_in_chunk < length)
+        length = dl->priv->write_in_chunk;
     if(!zck_write(dl->dst_fd, at, length))
         return -1;
-    dl->write_in_chunk -= length;
+    dl->priv->write_in_chunk -= length;
     return length;
 }
 
 int zck_dl_md_write(zckDL *dl, const char *at, size_t length) {
     VALIDATE(dl);
+    VALIDATE(dl->priv);
     int wb = 0;
-    if(dl->write_in_chunk > 0) {
+    if(dl->priv->write_in_chunk > 0) {
         wb = zck_dl_write(dl, at, length);
-        if(!zck_hash_update(dl->chunk_hash, at, wb))
+        if(!zck_hash_update(dl->priv->chunk_hash, at, wb))
             return 0;
         if(wb < 0)
             return 0;
         zck_log(ZCK_LOG_DEBUG, "Writing %lu bytes\n", wb);
-        dl->dl_chunk_data += wb;
+        dl->priv->dl_chunk_data += wb;
     }
     return wb;
 }
 
 int zck_dl_write_chunk(zckDL *dl) {
     VALIDATE(dl);
-    if(dl->chunk_hash == NULL) {
+    VALIDATE(dl->priv);
+    if(dl->priv->chunk_hash == NULL) {
         zck_log(ZCK_LOG_ERROR, "Chunk hash not initialized\n");
         return False;
     }
-    char *digest = zck_hash_finalize(dl->chunk_hash);
-    free(dl->chunk_hash);
-    if(memcmp(digest, dl->tgt_check->digest, dl->tgt_check->digest_size) != 0) {
+    char *digest = zck_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");
-        if(!zck_dl_write_zero(dl->zck, dl->tgt_check))
+        if(!zck_dl_write_zero(dl->zck, dl->priv->tgt_check))
             return False;
     } else {
-        dl->tgt_check->finished = True;
+        dl->priv->tgt_check->finished = True;
     }
-    dl->tgt_check = NULL;
-    dl->chunk_hash = NULL;
+    dl->priv->tgt_check = NULL;
+    dl->priv->chunk_hash = NULL;
     free(digest);
     return True;
 }
 
 int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
     VALIDATE(dl);
+    VALIDATE(dl->priv);
     if(dl->info.index.first == NULL) {
         zck_log(ZCK_LOG_ERROR, "zckDL index not initialized\n");
         return 0;
@@ -133,13 +138,13 @@ int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
         return 0;
     }
     int wb = zck_dl_md_write(dl, at, length);
-    if(dl->write_in_chunk == 0) {
+    if(dl->priv->write_in_chunk == 0) {
         /* Check whether we just finished downloading a chunk and verify it */
-        if(dl->tgt_check && !zck_dl_write_chunk(dl))
+        if(dl->priv->tgt_check && !zck_dl_write_chunk(dl))
             return False;
         zckIndexItem *idx = dl->info.index.first;
         while(idx) {
-            if(dl->dl_chunk_data == idx->start) {
+            if(dl->priv->dl_chunk_data == idx->start) {
                 zckIndexItem *tgt_idx = dl->zck->index.first;
                 while(tgt_idx) {
                     if(tgt_idx->finished)
@@ -147,12 +152,12 @@ int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
                     if(idx->length == tgt_idx->length &&
                        memcmp(idx->digest, tgt_idx->digest,
                               idx->digest_size) == 0) {
-                        dl->tgt_check = tgt_idx;
-                        dl->chunk_hash = zmalloc(sizeof(zckHash));
-                        if(!zck_hash_init(dl->chunk_hash,
+                        dl->priv->tgt_check = tgt_idx;
+                        dl->priv->chunk_hash = zmalloc(sizeof(zckHash));
+                        if(!zck_hash_init(dl->priv->chunk_hash,
                                           &(dl->zck->chunk_hash_type)))
                             return 0;
-                        dl->write_in_chunk = idx->length;
+                        dl->priv->write_in_chunk = idx->length;
                         size_t offset = dl->zck->header_size +
                                         dl->zck->index_size;
                         if(!zck_seek(dl->dst_fd, offset + tgt_idx->start,
@@ -170,7 +175,7 @@ int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
         }
     }
     int wb2 = 0;
-    if(dl->write_in_chunk > 0 && wb < length) {
+    if(dl->priv->write_in_chunk > 0 && wb < length) {
         wb2 = zck_dl_write_range(dl, at+wb, length-wb);
         if(wb2 == 0)
             return 0;

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index c6a2f57d4fc9ccc70f72c32d10c647967b3be446..24f481afdffb8cab34bbe86163444182fc56d9a9 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -50,9 +50,13 @@ typedef struct zckDLPriv {
     zckMP *mp;
     int parser_started;
     int is_chunk;
+    size_t write_in_chunk;
+    size_t dl_chunk_data;
     regex_t *dl_regex;
     regex_t *end_regex;
     regex_t *hdr_regex;
+    zckIndexItem *tgt_check;
+    zckHash *chunk_hash;
 } zckDLPriv;
 
 typedef struct zckComp {