Error handling cleanup

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

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index 1a9d14f6d5a66ce0ee0c280c4fb7d5bfe0bbc04a..5f540462af4b9f9ea766c77e29e93f45aa1a0698 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -95,8 +95,8 @@ static bool set_comp_type(zckCtx *zck, ssize_t type) {
 static size_t comp_read_from_dc(zckCtx *zck, zckComp *comp, char *dst,
                                 size_t dst_size) {
     VALIDATE_INT(zck);
-    ALLOCD_INT(comp);
-    ALLOCD_INT(dst);
+    ALLOCD_INT(zck, comp);
+    ALLOCD_INT(zck, dst);
 
     size_t dl_size = dst_size;
     if(dl_size > comp->dc_data_size - comp->dc_data_loc)
@@ -112,8 +112,8 @@ static size_t comp_read_from_dc(zckCtx *zck, zckComp *comp, char *dst,
 static bool comp_add_to_data(zckCtx *zck, zckComp *comp, const char *src,
                              size_t src_size) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
-    ALLOCD_BOOL(src);
+    ALLOCD_BOOL(zck, comp);
+    ALLOCD_BOOL(zck, src);
 
     comp->data = realloc(comp->data, comp->data_size + src_size);
     if(comp->data == NULL) {
@@ -261,7 +261,7 @@ bool comp_init(zckCtx *zck) {
 }
 
 bool comp_reset(zckCtx *zck) {
-    ALLOCD_BOOL(zck);
+    ALLOCD_BOOL(zck, zck);
 
     zck->comp.started = 0;
     if(zck->comp.dc_data) {
@@ -276,7 +276,7 @@ bool comp_reset(zckCtx *zck) {
 }
 
 bool comp_close(zckCtx *zck) {
-    ALLOCD_BOOL(zck);
+    ALLOCD_BOOL(zck, zck);
 
     zck_log(ZCK_LOG_DEBUG, "Closing compression");
     if(zck->comp.data) {
@@ -385,8 +385,8 @@ bool comp_soption(zckCtx *zck, zck_soption option, const void *value,
 bool comp_add_to_dc(zckCtx *zck, zckComp *comp, const char *src,
                     size_t src_size) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
-    ALLOCD_BOOL(src);
+    ALLOCD_BOOL(zck, comp);
+    ALLOCD_BOOL(zck, src);
 
     /* Get rid of any already read data and allocate space for new data */
     char *temp = zmalloc(comp->dc_data_size - comp->dc_data_loc + src_size);

diff --git a/src/lib/comp/nocomp/nocomp.c b/src/lib/comp/nocomp/nocomp.c
index 539b94b2dffd2a104e5289d878f41c975d79c55c..f46fbaa4814947ce712a130baa57db6c077638d6 100644 (file)
--- a/src/lib/comp/nocomp/nocomp.c
+++ b/src/lib/comp/nocomp/nocomp.c
@@ -34,7 +34,7 @@
 
 static bool init(zckCtx *zck, zckComp *comp) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     return true;
 }
@@ -43,7 +43,7 @@ static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
                         const size_t src_size, char **dst, size_t *dst_size,
                         bool use_dict) {
     VALIDATE_INT(zck);
-    ALLOCD_INT(comp);
+    ALLOCD_INT(zck, comp);
 
     *dst = zmalloc(src_size);
     if(dst == NULL) {
@@ -60,7 +60,7 @@ static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
 static bool end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
                        bool use_dict) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     *dst = NULL;
     *dst_size = 0;
@@ -70,7 +70,7 @@ static bool end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
 
 static bool decompress(zckCtx *zck, zckComp *comp, const bool use_dict) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     char *src = comp->data;
     size_t src_size = comp->data_size;

diff --git a/src/lib/comp/zstd/zstd.c b/src/lib/comp/zstd/zstd.c
index 21188e35f64573ba67f5d08038f46b46972909e8..b723f031a5cdee5c45db9dac4a837bc30135f0fa 100644 (file)
--- a/src/lib/comp/zstd/zstd.c
+++ b/src/lib/comp/zstd/zstd.c
@@ -35,7 +35,7 @@
 
 static bool init(zckCtx *zck, zckComp *comp) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     comp->cctx = ZSTD_createCCtx();
     comp->dctx = ZSTD_createDCtx();
@@ -58,6 +58,9 @@ static bool init(zckCtx *zck, zckComp *comp) {
 }
 
 static bool close(zckCtx *zck, zckComp *comp) {
+    VALIDATE_BOOL(zck);
+    ALLOCD_BOOL(zck, comp);
+
     if(comp->cdict_ctx) {
         ZSTD_freeCDict(comp->cdict_ctx);
         comp->cdict_ctx = NULL;
@@ -84,7 +87,7 @@ static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
                         const size_t src_size, char **dst, size_t *dst_size,
                         bool use_dict) {
     VALIDATE_INT(zck);
-    ALLOCD_INT(comp);
+    ALLOCD_INT(zck, comp);
 
     comp->dc_data = realloc(comp->dc_data, comp->dc_data_size + src_size);
     if(comp->dc_data == NULL) {
@@ -101,7 +104,7 @@ static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
 static bool end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
                        bool use_dict) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     size_t max_size = ZSTD_compressBound(comp->dc_data_size);
     if(ZSTD_isError(max_size)) {
@@ -144,7 +147,7 @@ static bool end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
 
 static bool decompress(zckCtx *zck, zckComp *comp, const bool use_dict) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     return true;
 }
@@ -152,7 +155,7 @@ static bool decompress(zckCtx *zck, zckComp *comp, const bool use_dict) {
 static bool end_dchunk(zckCtx *zck, zckComp *comp, const bool use_dict,
                        const size_t fd_size) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(comp);
+    ALLOCD_BOOL(zck, comp);
 
     char *src = comp->data;
     size_t src_size = comp->data_size;

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 1bfc58c7565e98f0f0a75b90fc4e39c71f1fa8ed..44d3c5afa8ff028f6c20d75bb616aa33f5824355 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -77,7 +77,7 @@ static bool zero_chunk(zckCtx *tgt, zckChunk *tgt_idx) {
 
 /* Check whether last downloaded chunk is valid and zero it out if it isn't */
 static bool set_chunk_valid(zckDL *dl) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
     VALIDATE_BOOL(dl->zck);
 
     int retval = validate_chunk(dl->zck, dl->tgt_check, ZCK_LOG_WARNING,
@@ -96,7 +96,7 @@ static bool set_chunk_valid(zckDL *dl) {
 
 /* Write length or to end of current chunk, whichever comes first */
 static int dl_write(zckDL *dl, const char *at, size_t length) {
-    ALLOCD_INT(dl);
+    ALLOCD_INT(NULL, dl);
     VALIDATE_INT(dl->zck);
 
     int wb = 0;
@@ -168,7 +168,7 @@ static bool write_and_verify_chunk(zckCtx *src, zckCtx *tgt,
 
 /* Split current read into the appropriate chunks and write appropriately */
 int dl_write_range(zckDL *dl, const char *at, size_t length) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
     VALIDATE_BOOL(dl->zck);
 
     if(dl->range == NULL) {
@@ -270,13 +270,13 @@ bool PUBLIC zck_copy_chunks(zckCtx *src, zckCtx *tgt) {
 }
 
 ssize_t PUBLIC zck_dl_get_bytes_downloaded(zckDL *dl) {
-    ALLOCD_INT(dl);
+    ALLOCD_INT(NULL, dl);
 
     return dl->dl;
 }
 
 ssize_t PUBLIC zck_dl_get_bytes_uploaded(zckDL *dl) {
-    ALLOCD_INT(dl);
+    ALLOCD_INT(NULL, dl);
 
     return dl->ul;
 }
@@ -331,53 +331,53 @@ void PUBLIC zck_dl_free(zckDL **dl) {
 }
 
 zckCtx PUBLIC *zck_dl_get_zck(zckDL *dl) {
-    ALLOCD_PTR(dl);
+    ALLOCD_PTR(NULL, dl);
 
     return dl->zck;
 }
 
 bool PUBLIC zck_dl_set_zck(zckDL *dl, zckCtx *zck) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
 
     dl->zck = zck;
     return true;
 }
 bool PUBLIC zck_dl_set_range(zckDL *dl, zckRange *range) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
 
     dl->range = range;
     return true;
 }
 
 zckRange PUBLIC *zck_dl_get_range(zckDL *dl) {
-    ALLOCD_PTR(dl);
+    ALLOCD_PTR(NULL, dl);
 
     return dl->range;
 }
 
 bool PUBLIC zck_dl_set_header_cb(zckDL *dl, zck_wcb func) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
 
     dl->header_cb = func;
     return true;
 }
 
 bool PUBLIC zck_dl_set_header_data(zckDL *dl, void *data) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
 
     dl->header_data = data;
     return true;
 }
 
 bool PUBLIC zck_dl_set_write_cb(zckDL *dl, zck_wcb func) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
 
     dl->write_cb = func;
     return true;
 }
 
 bool PUBLIC zck_dl_set_write_data(zckDL *dl, void *data) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
 
     dl->write_data = data;
     return true;
@@ -388,7 +388,7 @@ bool PUBLIC zck_dl_set_write_data(zckDL *dl, void *data) {
  *******************************************************************/
 
 size_t PUBLIC zck_header_cb(char *b, size_t l, size_t c, void *dl_v) {
-    ALLOCD_BOOL(dl_v);
+    ALLOCD_BOOL(NULL, dl_v);
     zckDL *dl = (zckDL*)dl_v;
 
     if(multipart_get_boundary(dl, b, c*l) == 0)
@@ -401,7 +401,7 @@ size_t PUBLIC zck_header_cb(char *b, size_t l, size_t c, void *dl_v) {
 
 size_t PUBLIC zck_write_zck_header_cb(void *ptr, size_t l, size_t c,
                                       void *dl_v) {
-    ALLOCD_BOOL(dl_v);
+    ALLOCD_BOOL(NULL, dl_v);
     zckDL *dl = (zckDL*)dl_v;
 
     size_t wb = 0;
@@ -415,7 +415,7 @@ size_t PUBLIC zck_write_zck_header_cb(void *ptr, size_t l, size_t c,
 }
 
 size_t PUBLIC zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v) {
-    ALLOCD_BOOL(dl_v);
+    ALLOCD_BOOL(NULL, dl_v);
     zckDL *dl = (zckDL*)dl_v;
 
     size_t wb = 0;

diff --git a/src/lib/dl/multipart.c b/src/lib/dl/multipart.c
index bd3c5aefcbe49b12709841e8e8310356349d6f22..ce6a04e97bce7948f4efacc77d7187ab5da94a13 100644 (file)
--- a/src/lib/dl/multipart.c
+++ b/src/lib/dl/multipart.c
@@ -71,7 +71,7 @@ static bool create_regex(zckCtx *zck, regex_t *reg, const char *regex) {
 }
 
 static bool gen_regex(zckDL *dl) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
     VALIDATE_BOOL(dl->zck);
 
     char *next = "\r\n--%s\r\ncontent-type:.*\r\n" \
@@ -107,7 +107,7 @@ void reset_mp(zckMP *mp) {
 }
 
 size_t multipart_extract(zckDL *dl, char *b, size_t l) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
     VALIDATE_BOOL(dl->zck);
 
     if(dl == NULL || dl->mp == NULL)
@@ -216,7 +216,7 @@ end:
 }
 
 size_t multipart_get_boundary(zckDL *dl, char *b, size_t size) {
-    ALLOCD_BOOL(dl);
+    ALLOCD_BOOL(NULL, dl);
     VALIDATE_BOOL(dl->zck);
 
     if(dl == NULL)

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index 18e9ec6c030ce3bc747620c9829c38a797e1dff2..eb25b16bb7438f83a0cb4e6e6288a02c5d40b436 100644 (file)
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -231,7 +231,7 @@ char PUBLIC *zck_get_range(size_t start, size_t end) {
 }
 
 int PUBLIC zck_get_range_count(zckRange *range) {
-    ALLOCD_INT(range);
+    ALLOCD_INT(NULL, range);
 
     return range->count;
 }

diff --git a/src/lib/error.c b/src/lib/error.c
index 2bc572b3a440d3cf1737efd4e12e96a712ec372a..b04d61fd69ee69f332d1eae8baf28e1e644d04ce 100644 (file)
--- a/src/lib/error.c
+++ b/src/lib/error.c
@@ -35,14 +35,18 @@
 
 static const char *empty_error = "";
 
+zckCtx zck_none = {0};
+
 void set_error_wf(zckCtx *zck, int fatal, const char *function,
                   const char *format, ...) {
     va_list args;
     int size = 0;
     char *old_msg = NULL;
     int old_size = 0;
-    assert(zck != NULL && format != NULL);
+    assert(format != NULL);
 
+    if(zck == NULL)
+        zck = &zck_none;
 
     zck->error_state = 1 + (fatal > 0 ? 1 : 0);
     va_start(args, format);
@@ -75,14 +79,14 @@ void set_error_wf(zckCtx *zck, int fatal, const char *function,
 
 int PUBLIC zck_is_error(zckCtx *zck) {
     if(zck == NULL)
-        return 1;
+        zck = &zck_none;
 
     return zck->error_state;
 }
 
 const char PUBLIC *zck_get_error(zckCtx *zck) {
     if(zck == NULL)
-        return "zckCtx is NULL\n";
+        zck = &zck_none;
 
     if(zck->msg == NULL)
         return empty_error;
@@ -90,9 +94,12 @@ const char PUBLIC *zck_get_error(zckCtx *zck) {
 }
 
 bool PUBLIC zck_clear_error(zckCtx *zck) {
-    if(zck == NULL || zck->error_state > 1)
+    if(zck != NULL && zck->error_state > 1)
         return false;
 
+    if(zck == NULL)
+        zck = &zck_none;
+
     free(zck->msg);
     zck->msg = NULL;
     zck->error_state = 0;

diff --git a/src/lib/index/index_create.c b/src/lib/index/index_create.c
index b6bb783a169e418c2de2a3e11254380cfca38105..ec09192161506267d3945a632b6700c4ed632c4d 100644 (file)
--- a/src/lib/index/index_create.c
+++ b/src/lib/index/index_create.c
@@ -50,8 +50,8 @@ static bool create_chunk(zckCtx *zck) {
 static bool finish_chunk(zckIndex *index, zckChunk *item, char *digest,
                         bool valid, zckCtx *zck) {
     VALIDATE_BOOL(zck);
-    ALLOCD_BOOL(index);
-    ALLOCD_BOOL(item);
+    ALLOCD_BOOL(zck, index);
+    ALLOCD_BOOL(zck, item);
 
     item->digest = zmalloc(index->digest_size);
     if(item->digest == NULL) {

diff --git a/src/lib/index/index_read.c b/src/lib/index/index_read.c
index 29f109e3dd90d3753b7381e00f573684fbaaafb6..136c1bd4eb193195d1d2f17fabc8b54564ec978b 100644 (file)
--- a/src/lib/index/index_read.c
+++ b/src/lib/index/index_read.c
@@ -134,43 +134,76 @@ zckChunk PUBLIC *zck_get_first_chunk(zckCtx *zck) {
 }
 
 zckChunk PUBLIC *zck_get_next_chunk(zckChunk *idx) {
-    ALLOCD_PTR(idx);
+    if(idx && idx->zck) {
+        VALIDATE_PTR(idx->zck);
+        ALLOCD_PTR(idx->zck, idx);
+    } else {
+        ALLOCD_PTR(NULL, idx);
+    }
 
     return idx->next;
 }
 
 ssize_t PUBLIC zck_get_chunk_start(zckChunk *idx) {
-    ALLOCD_INT(idx);
-
-    if(idx->zck) {
+    if(idx && idx->zck) {
         VALIDATE_INT(idx->zck);
-        return idx->start + zck_get_header_length(idx->zck);
+        ALLOCD_INT(idx->zck, idx);
     } else {
-        return idx->start;
+        ALLOCD_INT(NULL, idx);
     }
+
+    if(idx->zck)
+        return idx->start + zck_get_header_length(idx->zck);
+    else
+        return idx->start;
 }
 
 ssize_t PUBLIC zck_get_chunk_size(zckChunk *idx) {
-    ALLOCD_INT(idx);
+    if(idx && idx->zck) {
+        VALIDATE_INT(idx->zck);
+        ALLOCD_INT(idx->zck, idx);
+    } else {
+        ALLOCD_INT(NULL, idx);
+    }
 
     return idx->length;
 }
 
 ssize_t PUBLIC zck_get_chunk_comp_size(zckChunk *idx) {
-    ALLOCD_INT(idx);
+    if(idx && idx->zck) {
+        VALIDATE_INT(idx->zck);
+        ALLOCD_INT(idx->zck, idx);
+    } else {
+        ALLOCD_INT(NULL, idx);
+    }
 
     return idx->comp_length;
 }
 
 int PUBLIC zck_get_chunk_valid(zckChunk *idx) {
-    ALLOCD_INT(idx);
+    if(idx && idx->zck) {
+        VALIDATE_INT(idx->zck);
+        ALLOCD_INT(idx->zck, idx);
+    } else {
+        ALLOCD_INT(NULL, idx);
+    }
 
     return idx->valid;
 }
 
 bool PUBLIC zck_compare_chunk_digest(zckChunk *a, zckChunk *b) {
-    ALLOCD_BOOL(a);
-    ALLOCD_BOOL(b);
+    if(a && a->zck) {
+        VALIDATE_BOOL(a->zck);
+        ALLOCD_BOOL(a->zck, a);
+    } else {
+        ALLOCD_BOOL(NULL, a);
+    }
+    if(b && b->zck) {
+        VALIDATE_BOOL(b->zck);
+        ALLOCD_BOOL(b->zck, b);
+    } else {
+        ALLOCD_BOOL(NULL, b);
+    }
 
     if(a->digest_size != b->digest_size)
         return false;

diff --git a/src/lib/zck.c b/src/lib/zck.c
index 216a4c1ba18675b581f583cf8c5e25460f314c19..a3359ea7a877494e8e7d8dbc891caa2537285eec 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -322,10 +322,10 @@ void PUBLIC zck_free(zckCtx **zck) {
 zckCtx PUBLIC *zck_create() {
     zckCtx *zck = zmalloc(sizeof(zckCtx));
     if(zck == NULL) {
-        zck_log(ZCK_LOG_NONE, "Unable to allocate %lu bytes",
-                sizeof(zckCtx));
+        set_error(NULL, "Unable to allocate %lu bytes", sizeof(zckCtx));
         return NULL;
     }
+    zck_clear_error(NULL);
     zck->prep_hash_type = -1;
     zck->prep_hdr_size = -1;
     return zck;

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 2502c13081d7269484a7a5433f58c4c3d3664cc3..0a3afad6e7ee0c216b62e1e1f56d6a8eee2dca19 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -28,26 +28,26 @@
 #define set_error(zck, ...) set_error_wf(zck, 0, __func__, __VA_ARGS__)
 #define set_fatal_error(zck, ...) set_error_wf(zck, 1, __func__, __VA_ARGS__)
 
-#define ALLOCD_BOOL(f)      if(!f) { \
-                                zck_log(ZCK_LOG_NONE, \
+#define ALLOCD_BOOL(z, f)   if(!f) { \
+                                set_error(z, \
                                         "Object not initialized"); \
                                 return false; \
                             }
-#define ALLOCD_INT(f)       if(!f) { \
-                                zck_log(ZCK_LOG_NONE, \
+#define ALLOCD_INT(z, f)    if(!f) { \
+                                set_error(z, \
                                         "Object not initialized"); \
                                 return -1; \
                             }
-#define ALLOCD_PTR(f)       if(!f) { \
-                                zck_log(ZCK_LOG_NONE, \
+#define ALLOCD_PTR(z, f)    if(!f) { \
+                                set_error(z, \
                                         "Object not initialized"); \
                                 return NULL; \
                             }
-#define VALIDATE_BOOL(f)    ALLOCD_BOOL(f) \
+#define VALIDATE_BOOL(f)    ALLOCD_BOOL(f, f) \
                             if((f)->error_state > 0) return false;
-#define VALIDATE_INT(f)     ALLOCD_INT(f) \
+#define VALIDATE_INT(f)     ALLOCD_INT(f, f) \
                             if((f)->error_state > 0) return -1;
-#define VALIDATE_PTR(f)     ALLOCD_PTR(f) \
+#define VALIDATE_PTR(f)     ALLOCD_PTR(f, f) \
                             if((f)->error_state > 0) return NULL;
 
 #define VALIDATE_READ_BOOL(f)   VALIDATE_BOOL(f); \

diff --git a/src/unzck.c b/src/unzck.c
index dc15ba9dd4a09d5ca38c1d51da934a44391b979c..a848c5dabc4a4fdcf426ed9f3a452ec652a611e7 100644 (file)
--- a/src/unzck.c
+++ b/src/unzck.c
@@ -110,7 +110,7 @@ int main (int argc, char *argv[]) {
 
     int src_fd = open(arguments.args[0], O_RDONLY);
     if(src_fd < 0) {
-        printf("Unable to open %s\n", arguments.args[0]);
+        dprintf(STDERR_FILENO, "Unable to open %s\n", arguments.args[0]);
         perror("");
         exit(1);
     }
@@ -122,7 +122,7 @@ int main (int argc, char *argv[]) {
     if(!arguments.stdout) {
         dst_fd = open(out_name, O_TRUNC | O_WRONLY | O_CREAT, 0644);
         if(dst_fd < 0) {
-            printf("Unable to open %s", out_name);
+            dprintf(STDERR_FILENO, "Unable to open %s", out_name);
             perror("");
             free(out_name);
             exit(1);
@@ -132,8 +132,11 @@ int main (int argc, char *argv[]) {
     bool good_exit = false;
 
     zckCtx *zck = zck_create();
-    if(zck == NULL)
+    if(zck == NULL) {
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         goto error1;
+    }
 
     char *data = malloc(BUF_SIZE);
     if(!zck_init_read(zck, src_fd))
@@ -142,7 +145,7 @@ int main (int argc, char *argv[]) {
     int ret = zck_validate_data_checksum(zck);
     if(ret < 1) {
         if(ret == -1)
-            printf("Data checksum failed verification\n");
+            dprintf(STDERR_FILENO, "Data checksum failed verification\n");
         goto error2;
     }
 
@@ -154,7 +157,7 @@ int main (int argc, char *argv[]) {
         if(read == 0)
             break;
         if(write(dst_fd, data, read) != read) {
-            printf("Error writing to %s\n", out_name);
+            dprintf(STDERR_FILENO, "Error writing to %s\n", out_name);
             goto error2;
         }
         total += read;
@@ -162,12 +165,12 @@ int main (int argc, char *argv[]) {
     if(!zck_close(zck))
         goto error2;
     if(arguments.log_level <= ZCK_LOG_INFO)
-        printf("Decompressed %lu bytes\n", (unsigned long)total);
+        dprintf(STDERR_FILENO, "Decompressed %lu bytes\n", (unsigned long)total);
     good_exit = true;
 error2:
     free(data);
     if(!good_exit)
-        printf("%s", zck_get_error(zck));
+        dprintf(STDERR_FILENO, "%s", zck_get_error(zck));
     zck_free(&zck);
 error1:
     if(!good_exit)

diff --git a/src/zck.c b/src/zck.c
index 26487196aeee2f4afea643991f3a794c295c13ea..5e7ffdb39afcea9681c750fd9e8bf4ad511db89b 100644 (file)
--- a/src/zck.c
+++ b/src/zck.c
@@ -145,7 +145,8 @@ int main (int argc, char *argv[]) {
     if(arguments.dict != NULL) {
         int dict_fd = open(arguments.dict, O_RDONLY);
         if(dict_fd < 0) {
-            printf("Unable to open dictionary %s for reading", arguments.dict);
+            dprintf(STDERR_FILENO, "Unable to open dictionary %s for reading",
+                    arguments.dict);
             perror("");
             exit(1);
         }
@@ -169,7 +170,7 @@ int main (int argc, char *argv[]) {
 
     int dst_fd = open(out_name, O_TRUNC | O_WRONLY | O_CREAT, 0644);
     if(dst_fd < 0) {
-        printf("Unable to open %s", out_name);
+        dprintf(STDERR_FILENO, "Unable to open %s", out_name);
         perror("");
         if(dict) {
             free(dict);
@@ -181,11 +182,13 @@ int main (int argc, char *argv[]) {
 
     zckCtx *zck = zck_create();
     if(zck == NULL) {
-        printf("Unable to allocate zchunk context\n");
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_write(zck, dst_fd)) {
-        printf("Unable to write to %s: %s", out_name, zck_get_error(zck));
+        dprintf(STDERR_FILENO, "Unable to write to %s: %s", out_name,
+                zck_get_error(zck));
         exit(1);
     }
     free(out_name);
@@ -196,14 +199,14 @@ int main (int argc, char *argv[]) {
     }*/
     if(dict_size > 0) {
         if(!zck_set_soption(zck, ZCK_COMP_DICT, dict, dict_size)) {
-            printf("%s\n", zck_get_error(zck));
+            dprintf(STDERR_FILENO, "%s\n", zck_get_error(zck));
             exit(1);
         }
     }
     free(dict);
     if(arguments.manual_chunk) {
         if(!zck_set_ioption(zck, ZCK_MANUAL_CHUNK, 1)) {
-            printf("%s\n", zck_get_error(zck));
+            dprintf(STDERR_FILENO, "%s\n", zck_get_error(zck));
             exit(1);
         }
     }
@@ -212,13 +215,14 @@ int main (int argc, char *argv[]) {
     int in_fd = open(arguments.args[0], O_RDONLY);
     off_t in_size = 0;
     if(in_fd < 0) {
-        printf("Unable to open %s for reading", arguments.args[0]);
+        dprintf(STDERR_FILENO, "Unable to open %s for reading",
+                arguments.args[0]);
         perror("");
         exit(1);
     }
     in_size = lseek(in_fd, 0, SEEK_END);
     if(in_size < 0) {
-        perror("Unable to seek to end of input file");
+        dprintf(STDERR_FILENO, "Unable to seek to end of input file");
         exit(1);
     }
     if(lseek(in_fd, 0, SEEK_SET) < 0) {
@@ -228,7 +232,7 @@ int main (int argc, char *argv[]) {
     if(in_size > 0) {
         data = malloc(in_size);
         if(read(in_fd, data, in_size) < in_size) {
-            printf("Unable to read from input file\n");
+            dprintf(STDERR_FILENO, "Unable to read from input file\n");
             exit(1);
         }
         close(in_fd);
@@ -286,7 +290,7 @@ int main (int argc, char *argv[]) {
         /* Buzhash rolling window */
         } else {
             if(zck_write(zck, data, in_size) < 0) {
-                printf("%s", zck_get_error(zck));
+                dprintf(STDERR_FILENO, "%s", zck_get_error(zck));
                 exit(1);
             }
         }
@@ -297,10 +301,10 @@ int main (int argc, char *argv[]) {
         exit(1);
     }
     if(arguments.log_level <= ZCK_LOG_INFO) {
-        printf("Wrote %lu bytes in %lu chunks\n",
-               (unsigned long)(zck_get_data_length(zck) +
-                               zck_get_header_length(zck)),
-               (long)zck_get_chunk_count(zck));
+        dprintf(STDERR_FILENO, "Wrote %lu bytes in %lu chunks\n",
+                (unsigned long)(zck_get_data_length(zck) +
+                                zck_get_header_length(zck)),
+                (long)zck_get_chunk_count(zck));
     }
 
     zck_free(&zck);

diff --git a/src/zck_delta_size.c b/src/zck_delta_size.c
index ce82222a77ed72ecb1ef1b9aea79ef502e89e820..c6ae3e6a95f4bef32c01c4cd10d6ff21028c4ec0 100644 (file)
--- a/src/zck_delta_size.c
+++ b/src/zck_delta_size.c
@@ -104,18 +104,19 @@ int main (int argc, char *argv[]) {
 
     int src_fd = open(arguments.args[0], O_RDONLY);
     if(src_fd < 0) {
-        printf("Unable to open %s\n", arguments.args[0]);
+        dprintf(STDERR_FILENO, "Unable to open %s\n", arguments.args[0]);
         perror("");
         exit(1);
     }
     zckCtx *zck_src = zck_create();
     if(zck_src == NULL) {
-        printf("Unable to create zchunk context\n");
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_read(zck_src, src_fd)) {
-        printf("Error reading %s: %s", arguments.args[0],
-               zck_get_error(zck_src));
+        dprintf(STDERR_FILENO, "Error reading %s: %s", arguments.args[0],
+                zck_get_error(zck_src));
         zck_free(&zck_src);
         exit(1);
     }
@@ -123,20 +124,21 @@ int main (int argc, char *argv[]) {
 
     int tgt_fd = open(arguments.args[1], O_RDONLY);
     if(tgt_fd < 0) {
-        printf("Unable to open %s\n", arguments.args[1]);
+        dprintf(STDERR_FILENO, "Unable to open %s\n", arguments.args[1]);
         perror("");
         zck_free(&zck_src);
         exit(1);
     }
     zckCtx *zck_tgt = zck_create();
     if(zck_tgt == NULL) {
-        printf("Unable to create zchunk context\n");
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         zck_free(&zck_src);
         exit(1);
     }
     if(!zck_init_read(zck_tgt, tgt_fd)) {
-        printf("Error reading %s: %s", arguments.args[1],
-               zck_get_error(zck_tgt));
+        dprintf(STDERR_FILENO, "Error reading %s: %s", arguments.args[1],
+                zck_get_error(zck_tgt));
         zck_free(&zck_src);
         zck_free(&zck_tgt);
         exit(1);
@@ -144,9 +146,11 @@ int main (int argc, char *argv[]) {
     close(tgt_fd);
 
     if(zck_get_chunk_hash_type(zck_tgt) != zck_get_chunk_hash_type(zck_src)) {
-        printf("ERROR: Chunk hash types don't match:\n");
-        printf("   %s: %s\n", arguments.args[0], zck_hash_name_from_type(zck_get_chunk_hash_type(zck_tgt)));
-        printf("   %s: %s\n", arguments.args[1], zck_hash_name_from_type(zck_get_chunk_hash_type(zck_src)));
+        dprintf(STDERR_FILENO, "ERROR: Chunk hash types don't match:\n");
+        dprintf(STDERR_FILENO, "   %s: %s\n", arguments.args[0],
+                zck_hash_name_from_type(zck_get_chunk_hash_type(zck_tgt)));
+        dprintf(STDERR_FILENO, "   %s: %s\n", arguments.args[1],
+                zck_hash_name_from_type(zck_get_chunk_hash_type(zck_src)));
         zck_free(&zck_src);
         zck_free(&zck_tgt);
         exit(1);
@@ -157,7 +161,7 @@ int main (int argc, char *argv[]) {
         exit(1);
 
     if(!zck_compare_chunk_digest(tgt_idx, src_idx))
-        printf("WARNING: Dicts don't match\n");
+        dprintf(STDERR_FILENO, "WARNING: Dicts don't match\n");
     ssize_t dl_size = zck_get_header_length(zck_tgt);
     if(dl_size < 0)
         exit(1);

diff --git a/src/zck_dl.c b/src/zck_dl.c
index b609b079831c5dd1a3b6b5781e52b10fc0a6e1d2..a9e7e360d298535d6f0b36fa446389185aa917f2 100644 (file)
--- a/src/zck_dl.c
+++ b/src/zck_dl.c
@@ -150,7 +150,7 @@ size_t dl_header_cb(char *b, size_t l, size_t c, void *dl_v) {
 int dl_range(dlCtx *dl_ctx, char *url, char *range, int is_chunk) {
     if(dl_ctx == NULL || dl_ctx->dl == NULL) {
         free(range);
-        printf("Struct not defined\n");
+        dprintf(STDERR_FILENO, "Struct not defined\n");
         return 0;
     }
 
@@ -174,13 +174,14 @@ int dl_range(dlCtx *dl_ctx, char *url, char *range, int is_chunk) {
         return -1;
 
     if(res != CURLE_OK) {
-        printf("Download failed: %s\n", curl_easy_strerror(res));
+        dprintf(STDERR_FILENO, "Download failed: %s\n",
+                curl_easy_strerror(res));
         return 0;
     }
     long code;
     curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &code);
     if (code != 206 && code != 200) {
-        printf("HTTP Error: %li when downloading %s\n", code,
+        dprintf(STDERR_FILENO, "HTTP Error: %li when downloading %s\n", code,
                 url);
         return 0;
     }
@@ -206,8 +207,8 @@ int dl_bytes(dlCtx *dl_ctx, char *url, size_t bytes, size_t start,
         int fd = zck_get_fd(zck_dl_get_zck(dl));
 
         if(lseek(fd, *buffer_len, SEEK_SET) == -1) {
-            printf("Seek to download location failed: %s\n",
-                   strerror(errno));
+            dprintf(STDERR_FILENO, "Seek to download location failed: %s\n",
+                    strerror(errno));
             return 0;
         }
         if(*buffer_len >= start + bytes)
@@ -219,13 +220,14 @@ int dl_bytes(dlCtx *dl_ctx, char *url, size_t bytes, size_t start,
             return retval;
 
         if(log_level <= ZCK_LOG_DEBUG)
-            printf("Downloading %lu bytes at position %lu\n",
-                   (unsigned long)start+bytes-*buffer_len,
-                   (unsigned long)*buffer_len);
+            dprintf(STDERR_FILENO, "Downloading %lu bytes at position %lu\n",
+                    (unsigned long)start+bytes-*buffer_len,
+                    (unsigned long)*buffer_len);
         *buffer_len += start + bytes - *buffer_len;
         if(lseek(fd, start, SEEK_SET) == -1) {
-            printf("Seek to byte %lu of temporary file failed: %s\n",
-                   (unsigned long)start, strerror(errno));
+            dprintf(STDERR_FILENO,
+                    "Seek to byte %lu of temporary file failed: %s\n",
+                    (unsigned long)start, strerror(errno));
             return 0;
         }
     }
@@ -280,24 +282,26 @@ int main (int argc, char *argv[]) {
     if(arguments.source) {
         int src_fd = open(arguments.source, O_RDONLY);
         if(src_fd < 0) {
-            printf("Unable to open %s\n", arguments.source);
+            dprintf(STDERR_FILENO, "Unable to open %s\n", arguments.source);
             perror("");
             exit(10);
         }
         zck_src = zck_create();
         if(zck_src == NULL) {
-            printf("Unable to create zchunk context\n");
+            dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+            zck_clear_error(NULL);
             exit(10);
         }
         if(!zck_init_read(zck_src, src_fd)) {
-            printf("Unable to open %s\n", arguments.source);
+            dprintf(STDERR_FILENO, "Unable to open %s: %s", arguments.source,
+                    zck_get_error(zck_src));
             exit(10);
         }
     }
 
     CURL *curl_ctx = curl_easy_init();
     if(!curl_ctx) {
-        printf("Unable to allocate %lu bytes for curl context\n",
+        dprintf(STDERR_FILENO, "Unable to allocate %lu bytes for curl context\n",
                 (unsigned long)sizeof(CURL));
         exit(10);
     }
@@ -305,22 +309,27 @@ int main (int argc, char *argv[]) {
     char *outname = basename(arguments.args[0]);
     int dst_fd = open(outname, O_RDWR | O_CREAT, 0644);
     if(dst_fd < 0) {
-        printf("Unable to open %s: %s\n", outname, strerror(errno));
+        dprintf(STDERR_FILENO, "Unable to open %s: %s\n", outname,
+                strerror(errno));
         exit(10);
     }
     zckCtx *zck_tgt = zck_create();
     if(zck_tgt == NULL) {
-        printf("Unable to create zchunk context\n");
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         exit(10);
     }
     if(!zck_init_adv_read(zck_tgt, dst_fd)) {
-        printf("%s", zck_get_error(zck_tgt));
+        dprintf(STDERR_FILENO, "%s", zck_get_error(zck_tgt));
         exit(10);
     }
 
     zckDL *dl = zck_dl_init(zck_tgt);
-    if(dl == NULL)
+    if(dl == NULL) {
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         exit(10);
+    }
 
     int exit_val = 0;
 
@@ -334,8 +343,9 @@ int main (int argc, char *argv[]) {
     /* The server doesn't support ranges */
     if(retval == -1) {
         if(arguments.fail_no_ranges) {
-            printf("Server doesn't support ranges and --fail-no-ranges was "
-                   "set\n");
+            dprintf(STDERR_FILENO,
+                    "Server doesn't support ranges and --fail-no-ranges was "
+                    "set\n");
             exit_val = 2;
             goto out;
         }
@@ -356,7 +366,6 @@ int main (int argc, char *argv[]) {
         }
         lseek(dst_fd, 0, SEEK_SET);
         if(!zck_read_lead(zck_tgt) || !zck_read_header(zck_tgt)) {
-            printf("Error reading zchunk file\n");
             exit_val = 10;
             goto out;
         }
@@ -404,7 +413,6 @@ int main (int argc, char *argv[]) {
                 ra_index++;
             char *range_string = zck_get_range_char(zck_src, range);
             if(range_string == NULL) {
-                printf("%s", zck_get_error(zck_src));
                 exit_val = 10;
                 goto out;
             }
@@ -414,7 +422,9 @@ int main (int argc, char *argv[]) {
                     ra_index += 1;
                     dl_ctx.max_ranges = range_attempt[ra_index];
                 }
-                printf("Tried downloading too many ranges, reducing to %i\n", dl_ctx.max_ranges);
+                dprintf(STDERR_FILENO,
+                        "Tried downloading too many ranges, reducing to %i\n",
+                        dl_ctx.max_ranges);
             }
             if(!zck_dl_set_range(dl, NULL)) {
                 exit_val = 10;
@@ -446,6 +456,16 @@ int main (int argc, char *argv[]) {
             break;
     }
 out:
+    if(exit_val > 0) {
+        if(zck_is_error(NULL)) {
+            dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+            zck_clear_error(NULL);
+        }
+        if(zck_is_error(zck_src))
+            dprintf(STDERR_FILENO, "%s", zck_get_error(zck_src));
+        if(zck_is_error(zck_tgt))
+            dprintf(STDERR_FILENO, "%s", zck_get_error(zck_tgt));
+    }
     zck_dl_free(&dl);
     zck_free(&zck_tgt);
     zck_free(&zck_src);

diff --git a/src/zck_read_header.c b/src/zck_read_header.c
index b97cc5c37760a5260bd1a081e0c7cda3e08311a2..7b96a96202784b39c339726bd718654413281042 100644 (file)
--- a/src/zck_read_header.c
+++ b/src/zck_read_header.c
@@ -124,11 +124,13 @@ int main (int argc, char *argv[]) {
 
     zckCtx *zck = zck_create();
     if(zck == NULL) {
-        printf("Unable to create zchunk context\n");
+        dprintf(STDERR_FILENO, "%s", zck_get_error(NULL));
+        zck_clear_error(NULL);
         exit(1);
     }
     if(!zck_init_read(zck, src_fd)) {
-        printf("Error reading zchunk header: %s", zck_get_error(zck));
+        dprintf(STDERR_FILENO, "Error reading zchunk header: %s",
+                zck_get_error(zck));
         zck_free(&zck);
         exit(1);
     }
@@ -164,8 +166,10 @@ int main (int argc, char *argv[]) {
         for(zckChunk *chk = zck_get_first_chunk(zck); chk;
             chk=zck_get_next_chunk(chk), count++) {
             char *digest = zck_get_chunk_digest(chk);
-            if(digest == NULL)
+            if(digest == NULL) {
+                dprintf(STDERR_FILENO, "%s", zck_get_error(zck));
                 exit(1);
+            }
             printf("%12lu %s %12lu %12lu %12lu", count, digest,
                    (long unsigned)zck_get_chunk_start(chk),
                    (long unsigned)zck_get_chunk_comp_size(chk),