Rename io functions

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

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index df965acdd8eef681611193c98dc259bea85a53b5..891b3b17c3b0520853d7fdb029da0e9e9d78b59a 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -73,7 +73,7 @@ int zck_comp_init(zckCtx *zck) {
             if(!zck->comp.compress(comp, zck->comp.dict, zck->comp.dict_size, &dst,
                                    &dst_size, 0))
                 return False;
-            if(!zck_write(zck->temp_fd, dst, dst_size)) {
+            if(!write_data(zck->temp_fd, dst, dst_size)) {
                 free(dst);
                 return False;
             }
@@ -84,7 +84,7 @@ int zck_comp_init(zckCtx *zck) {
 
             if(!zck->comp.end_chunk(comp, &dst, &dst_size, 0))
                 return False;
-            if(!zck_write(zck->temp_fd, dst, dst_size)) {
+            if(!write_data(zck->temp_fd, dst, dst_size)) {
                 free(dst);
                 return False;
             }
@@ -114,7 +114,7 @@ int zck_compress(zckCtx *zck, const char *src, const size_t src_size) {
     size_t dst_size = 0;
     if(!zck->comp.compress(&(zck->comp), src, src_size, &dst, &dst_size, 1))
         return False;
-    if(dst_size > 0 && !zck_write(zck->temp_fd, dst, dst_size)) {
+    if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
         free(dst);
         return False;
     }
@@ -140,7 +140,7 @@ int zck_end_chunk(zckCtx *zck) {
     size_t dst_size = 0;
     if(!zck->comp.end_chunk(&(zck->comp), &dst, &dst_size, 1))
         return False;
-    if(dst_size > 0 && !zck_write(zck->temp_fd, dst, dst_size)) {
+    if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
         free(dst);
         return False;
     }

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index d0851e59f69848ffcde24ab210c3a1a4095249ea..1d65ad5ee5d1c43471c6c3fd0078e26ca5c766f5 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -62,13 +62,13 @@ 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->comp_length;
-    if(!zck_seek(tgt->fd, tgt_data_offset + tgt_idx->start, SEEK_SET))
+    if(!seek_data(tgt->fd, tgt_data_offset + tgt_idx->start, SEEK_SET))
         return False;
     while(to_read > 0) {
         int rb = BUF_SIZE;
         if(rb > to_read)
             rb = to_read;
-        if(!zck_write(tgt->fd, buf, rb))
+        if(!write_data(tgt->fd, buf, rb))
             return False;
         to_read -= rb;
     }
@@ -80,7 +80,7 @@ int zck_dl_write(zckDL *dl, const char *at, size_t length) {
     VALIDATE(dl->priv);
     if(dl->priv->write_in_chunk < length)
         length = dl->priv->write_in_chunk;
-    if(!zck_write(dl->dst_fd, at, length))
+    if(!write_data(dl->dst_fd, at, length))
         return -1;
     dl->priv->write_in_chunk -= length;
     return length;
@@ -160,7 +160,7 @@ int zck_dl_write_range(zckDL *dl, const char *at, size_t length) {
                         dl->priv->write_in_chunk = idx->comp_length;
                         size_t offset = dl->zck->header_size +
                                         dl->zck->index_size;
-                        if(!zck_seek(dl->dst_fd, offset + tgt_idx->start,
+                        if(!seek_data(dl->dst_fd, offset + tgt_idx->start,
                            SEEK_SET))
                             return 0;
                         idx = NULL;
@@ -224,9 +224,9 @@ int zck_dl_write_and_verify(zckRange *info, zckCtx *src, zckCtx *tgt,
     size_t src_data_offset = src->header_size + src->index_size;
     size_t tgt_data_offset = tgt->header_size + tgt->index_size;
     size_t to_read = src_idx->comp_length;
-    if(!zck_seek(src->fd, src_data_offset + src_idx->start, SEEK_SET))
+    if(!seek_data(src->fd, src_data_offset + src_idx->start, SEEK_SET))
         return False;
-    if(!zck_seek(tgt->fd, tgt_data_offset + tgt_idx->start, SEEK_SET))
+    if(!seek_data(tgt->fd, tgt_data_offset + tgt_idx->start, SEEK_SET))
         return False;
     zckHash check_hash = {0};
     if(!zck_hash_init(&check_hash, &(src->chunk_hash_type)))
@@ -235,11 +235,11 @@ int zck_dl_write_and_verify(zckRange *info, zckCtx *src, zckCtx *tgt,
         int rb = BUF_SIZE;
         if(rb > to_read)
             rb = to_read;
-        if(!zck_read(src->fd, buf, rb))
+        if(!read_data(src->fd, buf, rb))
             return False;
         if(!zck_hash_update(&check_hash, buf, rb))
             return False;
-        if(!zck_write(tgt->fd, buf, rb))
+        if(!write_data(tgt->fd, buf, rb))
             return False;
         to_read -= rb;
     }
@@ -412,7 +412,7 @@ int zck_zero_bytes(zckDL *dl, size_t bytes, size_t start, size_t *buffer_len) {
             size_t wb = BUF_SIZE;
             if(write + wb > start + bytes)
                 wb = (start + bytes) - write;
-            if(!zck_write(dl->dst_fd, buf, wb))
+            if(!write_data(dl->dst_fd, buf, wb))
                 return False;
             write += wb;
         }
@@ -448,7 +448,7 @@ int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
         return False;
     if(!zck_read_initial(zck, dl->dst_fd))
         return False;
-    start = zck_tell(dl->dst_fd);
+    start = tell_data(dl->dst_fd);
 
     /* If we haven't downloaded enough for the index hash plus a few others, do
      * it now */
@@ -469,7 +469,7 @@ int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
     /* Read and store compression type and index size */
     if(!zck_read_ct_is(zck, dl->dst_fd))
         return False;
-    start = zck_tell(dl->dst_fd);
+    start = tell_data(dl->dst_fd);
     zck_log(ZCK_LOG_DEBUG, "Index size: %llu\n", zck->index_size);
 
     /* Download and read rest of index */

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index 6a6ae84313e0b096b5a4b016b4ed199922520579..678c90a2827533ae30f32b3ff7a549992457ccaf 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -131,7 +131,7 @@ void zck_hash_close(zckHash *hash) {
 
 /* 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))
+    if(!seek_data(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;
@@ -144,7 +144,7 @@ int zck_hash_check_data(zckCtx *zck, int dst_fd) {
             size_t rb = BUF_SIZE;
             if(rb > to_read)
                 rb = to_read;
-            if(!zck_read(dst_fd, buf, rb))
+            if(!read_data(dst_fd, buf, rb))
                 return -1;
             zck_hash_update(&(zck->check_full_hash), buf, rb);
             to_read -= rb;

diff --git a/src/lib/header.c b/src/lib/header.c
index aeb0964130587e4ad284a329258d5682aeec6616..671b3cf2116eb4fc3259fbd39f380b1b9fcf6b78 100644 (file)
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -43,7 +43,7 @@ int zck_read_initial(zckCtx *zck, int src_fd) {
     }
 
     zck_log(ZCK_LOG_DEBUG, "Reading magic and hash type\n");
-    if(!zck_read(src_fd, header, 5 + MAX_COMP_SIZE)) {
+    if(!read_data(src_fd, header, 5 + MAX_COMP_SIZE)) {
         free(header);
         return False;
     }
@@ -61,7 +61,7 @@ int zck_read_initial(zckCtx *zck, int src_fd) {
         return False;
     if(!zck_hash_setup(&(zck->hash_type), hash_type))
         return False;
-    if(!zck_seek(src_fd, length, SEEK_SET))
+    if(!seek_data(src_fd, length, SEEK_SET))
         return False;
     zck->header_string = header;
     zck->header_size = length;
@@ -91,7 +91,7 @@ int zck_read_index_hash(zckCtx *zck, int src_fd) {
         return False;
     }
     zck_log(ZCK_LOG_DEBUG, "Reading index hash\n");
-    if(!zck_read(src_fd, digest, zck->hash_type.digest_size)) {
+    if(!read_data(src_fd, digest, zck->hash_type.digest_size)) {
         free(digest);
         free(header);
         return False;
@@ -124,7 +124,7 @@ int zck_read_ct_is(zckCtx *zck, int src_fd) {
         return False;
     }
     zck_log(ZCK_LOG_DEBUG, "Reading compression type and index size\n");
-    if(!zck_read(src_fd, header + length, MAX_COMP_SIZE*2))
+    if(!read_data(src_fd, header + length, MAX_COMP_SIZE*2))
         return False;
 
     int tmp = 0;
@@ -142,7 +142,7 @@ int zck_read_ct_is(zckCtx *zck, int src_fd) {
         return False;
     zck->index_size = tmp;
 
-    if(!zck_seek(src_fd, length, SEEK_SET))
+    if(!seek_data(src_fd, length, SEEK_SET))
         return False;
     zck->header_string = header;
     zck->header_size = length;
@@ -157,7 +157,7 @@ int zck_read_index(zckCtx *zck, int src_fd) {
         return False;
     }
     zck_log(ZCK_LOG_DEBUG, "Reading index\n");
-    if(!zck_read(src_fd, index, zck->index_size)) {
+    if(!read_data(src_fd, index, zck->index_size)) {
         free(index);
         return False;
     }
@@ -230,7 +230,7 @@ int zck_header_create(zckCtx *zck) {
 }
 
 int zck_write_header(zckCtx *zck) {
-    if(!zck_write(zck->fd, zck->header_string, zck->header_size))
+    if(!write_data(zck->fd, zck->header_string, zck->header_size))
         return False;
     return True;
 }

diff --git a/src/lib/index/index_create.c b/src/lib/index/index_create.c
index 17b3fca938c444c5387dc82c5155bc6dca131467..28d877939e6178335f9798b50626d3ff370f997b 100644 (file)
--- a/src/lib/index/index_create.c
+++ b/src/lib/index/index_create.c
@@ -249,5 +249,5 @@ int zck_index_finish_chunk(zckCtx *zck) {
 }
 
 int zck_write_index(zckCtx *zck) {
-    return zck_write(zck->fd, zck->index_string, zck->index_size);
+    return write_data(zck->fd, zck->index_string, zck->index_size);
 }

diff --git a/src/lib/io.c b/src/lib/io.c
index b7dee4030c5f625320fc0836f48d71f2090330d9..ae99b4e14c4ffba2fd0bbaa19f8d24fde9f2e6d9 100644 (file)
--- a/src/lib/io.c
+++ b/src/lib/io.c
@@ -33,7 +33,7 @@
 
 #include "zck_private.h"
 
-int zck_read(int fd, char *data, size_t length) {
+int read_data(int fd, char *data, size_t length) {
     if(length == 0)
         return True;
     if(data == NULL) {
@@ -51,7 +51,7 @@ int zck_read(int fd, char *data, size_t length) {
     return True;
 }
 
-int zck_write(int fd, const char *data, size_t length) {
+int write_data(int fd, const char *data, size_t length) {
     if(length == 0)
         return True;
     if(data == NULL) {
@@ -69,19 +69,19 @@ int zck_write(int fd, const char *data, size_t length) {
     return True;
 }
 
-int zck_write_comp_size(int fd, size_t val) {
+int write_comp_size(int fd, size_t val) {
     char data[sizeof(size_t)*2] = {0};
     size_t length = 0;
     if(!zck_compint_from_size(data, val, &length))
         return False;
-    return zck_write(fd, data, length);
+    return write_data(fd, data, length);
 }
 
-int zck_read_comp_size(int fd, size_t *val, size_t *length) {
+int read_comp_size(int fd, size_t *val, size_t *length) {
     char data[MAX_COMP_SIZE] = {0};
     int i=0;
-    for(char c=zck_read(fd, data+i, 1); c < 128 && i < MAX_COMP_SIZE;
-        i++,c=zck_read(fd, data+i, 1));
+    for(char c=read_data(fd, data+i, 1); c < 128 && i < MAX_COMP_SIZE;
+        i++,c=read_data(fd, data+i, 1));
     if(i == MAX_COMP_SIZE && data[i] < 128) {
         zck_log(ZCK_LOG_ERROR, "Number too large\n");
         *val = 0;
@@ -90,7 +90,7 @@ int zck_read_comp_size(int fd, size_t *val, size_t *length) {
     return !zck_compint_to_size(val, data, length);
 }
 
-int zck_seek(int fd, off_t offset, int whence) {
+int seek_data(int fd, off_t offset, int whence) {
     if(lseek(fd, offset, whence) == -1) {
         char *wh_str = NULL;
 
@@ -110,11 +110,11 @@ int zck_seek(int fd, off_t offset, int whence) {
     return True;
 }
 
-size_t zck_tell(int fd) {
+size_t tell_data(int fd) {
     return lseek(fd, 0, SEEK_CUR);
 }
 
-int zck_chunks_from_temp(zckCtx *zck) {
+int chunks_from_temp(zckCtx *zck) {
     int read_count;
     char *data = zmalloc(BUF_SIZE);
     if(data == NULL)
@@ -124,7 +124,7 @@ int zck_chunks_from_temp(zckCtx *zck) {
         return False;
 
     while((read_count = read(zck->temp_fd, data, BUF_SIZE)) > 0) {
-        if(read_count == -1 || !zck_write(zck->fd, data, read_count)) {
+        if(read_count == -1 || !write_data(zck->fd, data, read_count)) {
             free(data);
             return False;
         }

diff --git a/src/lib/zck.c b/src/lib/zck.c
index 15232eae82fcf09fa6f555a2efcf2aef9f7caf09..a5d0e52aaac51550fb06e771d1a1051f1057411f 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -49,7 +49,7 @@ int zck_write_file(zckCtx *zck) {
     if(!zck_write_index(zck))
         return False;
     zck_log(ZCK_LOG_DEBUG, "Writing chunks\n");
-    if(!zck_chunks_from_temp(zck))
+    if(!chunks_from_temp(zck))
         return False;
     zck_log(ZCK_LOG_DEBUG, "Finished writing file, cleaning up\n");
     zck_index_free(zck);
@@ -373,9 +373,9 @@ int zck_decompress_to_file(zckCtx *zck, int src_fd, int dst_fd) {
             zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", csize);
             return False;
         }
-        if(!zck_seek(src_fd, start + idx->start, SEEK_SET))
+        if(!seek_data(src_fd, start + idx->start, SEEK_SET))
             return False;
-        if(!zck_read(src_fd, cdata, csize)) {
+        if(!read_data(src_fd, cdata, csize)) {
             free(cdata);
             zck_log(ZCK_LOG_ERROR, "Error reading chunk %i\n", count);
             return False;
@@ -398,7 +398,7 @@ int zck_decompress_to_file(zckCtx *zck, int src_fd, int dst_fd) {
                 return False;
             }
         } else {
-            if(!zck_write(dst_fd, data, size)) {
+            if(!write_data(dst_fd, data, size)) {
                 free(data);
                 zck_log(ZCK_LOG_ERROR, "Unable to write chunk %i\n", count);
                 return False;

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 5aa57647722fab70ad6c3f52619c0d9ce28ebb07..f46f1ec04d758bca7113d5141715335052d8b530 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -132,13 +132,13 @@ void zck_index_free_item(zckIndexItem **item);
 int zck_write_index(zckCtx *zck);
 
 /* io.c */
-int zck_seek(int fd, off_t offset, int whence);
-size_t zck_tell(int fd);
-int zck_read(int fd, char *data, size_t length);
-int zck_write(int fd, const char *data, size_t length);
-int zck_write_comp_size(int fd, size_t val);
-int zck_read_comp_size(int fd, size_t *val, size_t *length);
-int zck_chunks_from_temp(zckCtx *zck);
+int seek_data(int fd, off_t offset, int whence);
+size_t tell_data(int fd);
+int read_data(int fd, char *data, size_t length);
+int write_data(int fd, const char *data, size_t length);
+int write_comp_size(int fd, size_t val);
+int read_comp_size(int fd, size_t *val, size_t *length);
+int chunks_from_temp(zckCtx *zck);
 
 /* header.c */
 int zck_read_initial(zckCtx *zck, int src_fd);