Make sure we're using all function results

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

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index b75f656b0cfe31c14c8425915517285eaee3f2eb..6e61af8cfa048ee7a868cdeb573b5960e92d4e3c 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -115,7 +115,11 @@ int zck_comp_init(zckCtx *zck) {
                 free(dst);
                 return False;
             }
-            zck_index_add_to_chunk(zck, dst, dst_size, zck->comp.dict_size);
+            if(!zck_index_add_to_chunk(zck, dst, dst_size,
+                                       zck->comp.dict_size)) {
+                free(dst);
+                return False;
+            }
             free(dst);
             dst = NULL;
             dst_size = 0;
@@ -126,11 +130,15 @@ int zck_comp_init(zckCtx *zck) {
                 free(dst);
                 return False;
             }
-            zck_index_add_to_chunk(zck, dst, dst_size, 0);
-            zck_index_finish_chunk(zck);
+            if(!zck_index_add_to_chunk(zck, dst, dst_size, 0) ||
+               !zck_index_finish_chunk(zck)) {
+                free(dst);
+                return False;
+            }
             free(dst);
         } else {
-            zck_index_finish_chunk(zck);
+            if(!zck_index_finish_chunk(zck))
+                return False;
         }
     }
     free(zck->comp.dict);
@@ -394,7 +402,8 @@ ssize_t comp_end_dchunk(zckCtx *zck, int use_dict, size_t fd_size) {
         return -1;
     zck->comp.data_loc = 0;
     zck->comp.data_idx = zck->comp.data_idx->next;
-    zck_hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type));
+    if(!zck_hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
+        return -1;
     return rb;
 }
 
@@ -445,7 +454,8 @@ ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict) {
         /* End decompression chunk if we're on a chunk boundary */
         if(zck->comp.data_idx == NULL) {
             zck->comp.data_idx = zck->index.first;
-            zck_hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type));
+            if(!zck_hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
+                goto zck_hash_error;
             zck->comp.data_loc = 0;
         }
         if(zck->comp.data_loc == zck->comp.data_idx->comp_length) {
@@ -480,9 +490,9 @@ ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict) {
             zck_log(ZCK_LOG_DEBUG, "EOF\n");
             finished_rd = True;
         }
-        zck_hash_update(&(zck->check_full_hash), src, rb);
-        zck_hash_update(&(zck->check_chunk_hash), src, rb);
-        if(!zck_comp_add_to_data(&(zck->comp), src, rb))
+        if(!zck_hash_update(&(zck->check_full_hash), src, rb) ||
+           !zck_hash_update(&(zck->check_chunk_hash), src, rb) ||
+           !zck_comp_add_to_data(&(zck->comp), src, rb))
             goto zck_read_error;
     }
     free(src);

diff --git a/src/lib/compint.c b/src/lib/compint.c
index 924ad15d7394130b783abd8ba1f5dc605def3434..e0b40778d51739b2a41c76d41c8bccb273b82d58 100644 (file)
--- a/src/lib/compint.c
+++ b/src/lib/compint.c
@@ -29,7 +29,7 @@
 #include <zck.h>
 #include "zck_private.h"
 
-int zck_compint_from_size(char *compint, size_t val, size_t *length) {
+void zck_compint_from_size(char *compint, size_t val, size_t *length) {
     for(unsigned char *i = (unsigned char *)compint; ; i++) {
         i[0] = val % 128;
         val = (val - i[0]) / 128;
@@ -39,7 +39,7 @@ int zck_compint_from_size(char *compint, size_t val, size_t *length) {
             break;
         }
     }
-    return True;
+    return;
 }
 
 int zck_compint_to_size(size_t *val, const char *compint, size_t *length) {
@@ -81,7 +81,8 @@ int zck_compint_from_int(char *compint, int val, size_t *length) {
         return False;
     }
 
-    return zck_compint_from_size(compint, (size_t)val, length);
+    zck_compint_from_size(compint, (size_t)val, length);
+    return True;
 }
 
 int zck_compint_to_int(int *val, const char *compint, size_t *length) {

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 093a413333b72f3b70e6ec5510a39606af9f0d2d..0e0f4bfa81ed85c17cb61aec66f072c4fd78de90 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -383,7 +383,8 @@ int zck_dl_bytes(zckDL *dl, char *url, size_t bytes, size_t start,
         idx.start = *buffer_len;
         idx.comp_length = start+bytes-*buffer_len;
         zck_range_close(&(dl->info));
-        zck_range_add(&(dl->info), &idx, NULL);
+        if(!zck_range_add(&(dl->info), &idx, NULL))
+            return False;
         if(!zck_dl_range_chk_chunk(dl, url, 0))
             return False;
         zck_range_close(&(dl->info));

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index 0f2b90fbf3d74c3b6e36f4f7fb017c77f6980fbf..1fb7f6fe41361fdca6c683d6338ae71df89bcd8c 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -150,7 +150,8 @@ int PUBLIC zck_hash_check_data(zckCtx *zck, int dst_fd) {
                 rb = to_read;
             if(!read_data(dst_fd, buf, rb))
                 return -1;
-            zck_hash_update(&(zck->check_full_hash), buf, rb);
+            if(!zck_hash_update(&(zck->check_full_hash), buf, rb))
+                return -1;
             to_read -= rb;
         }
         idx = idx->next;

diff --git a/src/lib/header.c b/src/lib/header.c
index 902e8e1d2d8d8a39a438e70ba7dd35e2aecf1055..8e3c3c9f4b5a7d81ab72315736b49fd52c5fc07c 100644 (file)
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -225,10 +225,7 @@ int zck_header_create(zckCtx *zck) {
     size_t length = 0;
     memcpy(header+length, "\0ZCK1", 5);
     length += 5;
-    if(!zck_compint_from_size(header+length, zck->hash_type.type, &length)) {
-        free(header);
-        return False;
-    }
+    zck_compint_from_size(header+length, zck->hash_type.type, &length);
 
     /* If we have the digest, write it in, otherwise write zeros */
     if(zck->index_digest)
@@ -241,10 +238,7 @@ int zck_header_create(zckCtx *zck) {
         free(header);
         return False;
     }
-    if(!zck_compint_from_size(header+length, zck->index_size, &length)) {
-        free(header);
-        return False;
-    }
+    zck_compint_from_size(header+length, zck->index_size, &length);
     header = realloc(header, length);
     if(header == NULL) {
         zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n", length);

diff --git a/src/lib/io.c b/src/lib/io.c
index bde56be617a9b258804a609825fa550113b6ca9b..cdca83b44ffa819daa3040ed389e7f6818053a6d 100644 (file)
--- a/src/lib/io.c
+++ b/src/lib/io.c
@@ -69,8 +69,7 @@ int write_data(int fd, const char *data, size_t length) {
 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;
+    zck_compint_from_size(data, val, &length);
     return write_data(fd, data, length);
 }
 

diff --git a/src/lib/zck.c b/src/lib/zck.c
index 1c5312fa7fc065a2844671124f80da5566416e80..9b2c8190f7d5c11001f73e32e6dece119eb94b75 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -87,7 +87,8 @@ int PUBLIC zck_close(zckCtx *zck) {
     if(zck->mode == ZCK_MODE_WRITE) {
         if(zck_end_chunk(zck) < 0)
             return False;
-        zck_index_finalize(zck);
+        if(!zck_index_finalize(zck))
+            return False;
         zck_log(ZCK_LOG_DEBUG, "Writing header\n");
         if(!zck_write_header(zck))
             return False;
@@ -98,7 +99,8 @@ int PUBLIC zck_close(zckCtx *zck) {
         if(!chunks_from_temp(zck))
             return False;
         zck_log(ZCK_LOG_DEBUG, "Finished writing file, cleaning up\n");
-        zck_comp_close(zck);
+        if(!zck_comp_close(zck))
+            return False;
         if(zck->temp_fd) {
             close(zck->temp_fd);
             zck->temp_fd = 0;
@@ -120,7 +122,8 @@ void zck_clear(zckCtx *zck) {
     if(zck == NULL)
         return;
     zck_index_free(zck);
-    zck_comp_close(zck);
+    if(!zck_comp_close(zck))
+        zck_log(ZCK_LOG_WARNING, "Unable to close compression\n");
     zck_hash_close(&(zck->full_hash));
     zck_hash_close(&(zck->check_full_hash));
     zck_hash_close(&(zck->check_chunk_hash));

diff --git a/src/unzck.c b/src/unzck.c
index d792f1f696ca2154b1e1b26cc9e976d87e4eba66..faa58366054af23c1dd32585d142a23b076bfdb2 100644 (file)
--- a/src/unzck.c
+++ b/src/unzck.c
@@ -83,13 +83,14 @@ int main (int argc, char *argv[]) {
             goto error;
         }
     }
+    if(!zck_close(zck))
+        goto error;
     good_exit = True;
 error:
     free(data);
     if(!good_exit)
         unlink(out_name);
     free(out_name);
-    zck_close(zck);
     close(src_fd);
     close(dst_fd);
     zck_free(&zck);

diff --git a/src/zck.c b/src/zck.c
index 16729eed1b74969319f86e5fe652df4416c4520a..bf58eedf678a178f557566a292dbf8847992f502 100644 (file)
--- a/src/zck.c
+++ b/src/zck.c
@@ -69,7 +69,11 @@ int main (int argc, char *argv[]) {
             exit(1);
         }
         dict = malloc(dict_size);
-        read(dict_fd, dict, dict_size);
+        if(read(dict_fd, dict, dict_size) < dict_size) {
+            free(dict);
+            perror("Error reading dict:");
+            exit(1);
+        }
         close(dict_fd);
     }
 

diff --git a/src/zck_delta_size.c b/src/zck_delta_size.c
index 2ce467f306e1c40f07b8f305eaca7d2659431531..ba335b5c2abeef83927ac1aa3c9021d4519906ec 100644 (file)
--- a/src/zck_delta_size.c
+++ b/src/zck_delta_size.c
@@ -51,7 +51,8 @@ int main (int argc, char *argv[]) {
         printf("Unable to open %s\n", argv[1]);
         exit(1);
     }
-    zck_close(zck_src);
+    if(!zck_close(zck_src))
+        exit(1);
 
     int tgt_fd = open(argv[2], O_RDONLY);
     if(tgt_fd < 0) {
@@ -64,7 +65,8 @@ int main (int argc, char *argv[]) {
         printf("Unable to open %s\n", argv[2]);
         exit(1);
     }
-    zck_close(zck_tgt);
+    if(!zck_close(zck_tgt))
+        exit(1);
 
     if(zck_get_chunk_hash_type(zck_tgt) != zck_get_chunk_hash_type(zck_src)) {
         printf("ERROR: Chunk hash types don't match:\n");

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index 2c2189196f475edb5a1e2995cefed3400e339c1f..5f2fa295bd04c346f6027fd099ead632c9c0b3e9 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -52,7 +52,8 @@ int main (int argc, char *argv[]) {
         perror("Unable to read header\n");
         exit(1);
     }
-    zck_close(zck);
+    if(!zck_close(zck))
+        exit(1);
     close(src_fd);
 
     printf("Overall checksum type: %s\n", zck_hash_name_from_type(zck_get_full_hash_type(zck)));