From 5f232ed616c0d97af470da71506ead3fa153bfc6 Mon Sep 17 00:00:00 2001 From: Jonathan Dieter Date: Wed, 1 Aug 2018 21:27:38 +0100 Subject: [PATCH] Error handling cleanup Signed-off-by: Jonathan Dieter --- src/lib/comp/comp.c | 16 ++++----- src/lib/comp/nocomp/nocomp.c | 8 ++--- src/lib/comp/zstd/zstd.c | 13 ++++--- src/lib/dl/dl.c | 32 ++++++++--------- src/lib/dl/multipart.c | 6 ++-- src/lib/dl/range.c | 2 +- src/lib/error.c | 15 +++++--- src/lib/index/index_create.c | 4 +-- src/lib/index/index_read.c | 55 ++++++++++++++++++++++++------ src/lib/zck.c | 4 +-- src/lib/zck_private.h | 18 +++++----- src/unzck.c | 17 ++++++---- src/zck.c | 32 +++++++++-------- src/zck_delta_size.c | 28 ++++++++------- src/zck_dl.c | 66 +++++++++++++++++++++++------------- src/zck_read_header.c | 10 ++++-- 16 files changed, 202 insertions(+), 124 deletions(-) diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c index 1a9d14f..5f54046 100644 --- 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 539b94b..f46fbaa 100644 --- 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 21188e3..b723f03 100644 --- 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 1bfc58c..44d3c5a 100644 --- 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 bd3c5ae..ce6a04e 100644 --- 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 18e9ec6..eb25b16 100644 --- 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 2bc572b..b04d61f 100644 --- 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 b6bb783..ec09192 100644 --- 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 29f109e..136c1bd 100644 --- 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 216a4c1..a3359ea 100644 --- 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 2502c13..0a3afad 100644 --- 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 dc15ba9..a848c5d 100644 --- 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 2648719..5e7ffdb 100644 --- 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 ce82222..c6ae3e6 100644 --- 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 b609b07..a9e7e36 100644 --- 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 b97cc5c..7b96a96 100644 --- 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), -- 2.30.2