#endif
#define BLK_SIZE 32768
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not initialized\n"); \
- return False; \
- }
-
-#define VALIDATE_READ(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_READ) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for reading\n"); \
- return False; \
- }
-
-#define VALIDATE_WRITE(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_WRITE) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for writing\n"); \
- return False; \
- }
-
-#define VALIDATE_SIZE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckComp not initialized\n"); \
- return -1; \
- }
-
-#define VALIDATE_READ_SIZE(f) VALIDATE_SIZE(f); \
- if(f->mode != ZCK_MODE_READ) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckComp not opened for reading\n"); \
- return -1; \
- }
-
-#define VALIDATE_WRITE_SIZE(f) VALIDATE_SIZE(f); \
- if(f->mode != ZCK_MODE_WRITE) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckComp not opened for writing\n"); \
- return -1; \
- }
static char unknown[] = "Unknown(\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
};
static int set_comp_type(zckCtx *zck, ssize_t type) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
zckComp *comp = &(zck->comp);
/* Cannot change compression type after compression has started */
if(comp->started) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to set compression type after initialization\n");
+ set_error(zck, "Unable to set compression type after initialization");
return False;
}
comp->dc_data_loc = dc_data_loc;
comp->dc_data_size = dc_data_size;
- zck_log(ZCK_LOG_DEBUG, "Setting compression to %s\n",
+ zck_log(ZCK_LOG_DEBUG, "Setting compression to %s",
zck_comp_name_from_type(type));
if(type == ZCK_COMP_NONE) {
- return nocomp_setup(comp);
+ return nocomp_setup(zck, comp);
#ifdef ZCHUNK_ZSTD
} else if(type == ZCK_COMP_ZSTD) {
- return zstd_setup(comp);
+ return zstd_setup(zck, comp);
#endif
} else {
- zck_log(ZCK_LOG_ERROR, "Unsupported compression type: %s\n",
- zck_comp_name_from_type(type));
+ set_error(zck, "Unsupported compression type: %s",
+ zck_comp_name_from_type(type));
return False;
}
return True;
}
-static size_t comp_read_from_dc(zckComp *comp, char *dst, size_t dst_size) {
- VALIDATE_SIZE(comp);
- VALIDATE_SIZE(dst);
+static size_t comp_read_from_dc(zckCtx *zck, zckComp *comp, char *dst,
+ size_t dst_size) {
+ VALIDATE_TRI(zck);
+ _VALIDATE_TRI(comp);
+ _VALIDATE_TRI(dst);
size_t dl_size = dst_size;
if(dl_size > comp->dc_data_size - comp->dc_data_loc)
memcpy(dst, comp->dc_data+comp->dc_data_loc, dl_size);
comp->dc_data_loc += dl_size;
if(dl_size > 0)
- zck_log(ZCK_LOG_DEBUG, "Reading %lu bytes from decompressed buffer\n",
+ zck_log(ZCK_LOG_DEBUG, "Reading %lu bytes from decompressed buffer",
dl_size);
return dl_size;
}
-static int comp_add_to_data(zckComp *comp, const char *src, size_t src_size) {
- VALIDATE(comp);
- VALIDATE(src);
+static int comp_add_to_data(zckCtx *zck, zckComp *comp, const char *src,
+ size_t src_size) {
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(comp);
+ _VALIDATE_BOOL(src);
+
comp->data = realloc(comp->data, comp->data_size + src_size);
if(comp->data == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n",
- comp->data_size + src_size);
+ set_fatal_error(zck, "Unable to reallocate %lu bytes",
+ comp->data_size + src_size);
return False;
}
- zck_log(ZCK_LOG_DEBUG, "Adding %lu bytes to compressed buffer\n",
+ zck_log(ZCK_LOG_DEBUG, "Adding %lu bytes to compressed buffer",
src_size);
memcpy(comp->data + comp->data_size, src, src_size);
comp->data_size += src_size;
}
static ssize_t comp_end_dchunk(zckCtx *zck, int use_dict, size_t fd_size) {
- ssize_t rb = zck->comp.end_dchunk(&(zck->comp), use_dict, fd_size);
+ VALIDATE_READ_TRI(zck);
+
+ ssize_t rb = zck->comp.end_dchunk(zck, &(zck->comp), use_dict, fd_size);
if(validate_current_chunk(zck) < 1)
return -1;
zck->comp.data_loc = 0;
zck->comp.data_idx = zck->comp.data_idx->next;
- if(!hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
+ if(!hash_init(zck, &(zck->check_chunk_hash), &(zck->chunk_hash_type)))
return -1;
return rb;
}
static ssize_t comp_write(zckCtx *zck, const char *src, const size_t src_size) {
- VALIDATE_WRITE_SIZE(zck);
+ VALIDATE_WRITE_TRI(zck);
if(!zck->comp.started && !comp_init(zck))
return -1;
char *dst = NULL;
size_t dst_size = 0;
- if(zck->comp.compress(&(zck->comp), src, src_size, &dst, &dst_size, 1) < 0)
+ if(zck->comp.compress(zck, &(zck->comp), src, src_size, &dst,
+ &dst_size, 1) < 0)
return -1;
- if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
+ if(dst_size > 0 && !write_data(zck, zck->temp_fd, dst, dst_size)) {
free(dst);
return -1;
}
}
int comp_init(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
zckComp *comp = &(zck->comp);
if(zck->comp.started) {
- zck_log(ZCK_LOG_ERROR, "Compression already initialized\n");
+ set_error(zck, "Compression already initialized");
return False;
}
if((zck->comp.dict && zck->comp.dict_size == 0) ||
(zck->comp.dict == NULL && zck->comp.dict_size > 0)) {
- zck_log(ZCK_LOG_ERROR, "Invalid dictionary configuration\n");
+ set_error(zck, "Invalid dictionary configuration");
return False;
}
- zck_log(ZCK_LOG_DEBUG, "Initializing %s compression\n",
+ zck_log(ZCK_LOG_DEBUG, "Initializing %s compression",
zck_comp_name_from_type(comp->type));
- if(!zck->comp.init(&(zck->comp)))
+ if(!zck->comp.init(zck, &(zck->comp)))
return False;
if(zck->temp_fd) {
if(zck->comp.dict) {
char *dst = NULL;
size_t dst_size = 0;
- if(zck->comp.compress(comp, zck->comp.dict, zck->comp.dict_size,
- &dst, &dst_size, 0) < 0)
+ if(zck->comp.compress(zck, comp, zck->comp.dict,
+ zck->comp.dict_size, &dst, &dst_size, 0) < 0)
return False;
- if(!write_data(zck->temp_fd, dst, dst_size)) {
+ if(!write_data(zck, zck->temp_fd, dst, dst_size)) {
free(dst);
return False;
}
dst = NULL;
dst_size = 0;
- if(!zck->comp.end_cchunk(comp, &dst, &dst_size, 0))
+ if(!zck->comp.end_cchunk(zck, comp, &dst, &dst_size, 0))
return False;
- if(!write_data(zck->temp_fd, dst, dst_size)) {
+ if(!write_data(zck, zck->temp_fd, dst, dst_size)) {
free(dst);
return False;
}
}
int comp_reset(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
zck->comp.started = 0;
if(zck->comp.dc_data) {
}
if(zck->comp.close == NULL)
return True;
- return zck->comp.close(&(zck->comp));
+ return zck->comp.close(zck, &(zck->comp));
}
int comp_close(zckCtx *zck) {
- VALIDATE(zck);
- zck_log(ZCK_LOG_DEBUG, "Closing compression\n");
+ VALIDATE_BOOL(zck);
+
+ zck_log(ZCK_LOG_DEBUG, "Closing compression");
if(zck->comp.data) {
free(zck->comp.data);
zck->comp.data = NULL;
}
int comp_ioption(zckCtx *zck, zck_ioption option, ssize_t value) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
/* Cannot change compression parameters after compression has started */
if(zck && zck->comp.started) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to set compression parameters after initialization\n");
+ set_error(zck,
+ "Unable to set compression parameters after initialization");
return False;
}
if(option == ZCK_COMP_TYPE) {
return set_comp_type(zck, value);
} else {
if(zck && zck->comp.set_parameter)
- return zck->comp.set_parameter(&(zck->comp), option, &value);
+ return zck->comp.set_parameter(zck, &(zck->comp), option, &value);
- zck_log(ZCK_LOG_ERROR, "Unsupported compression parameter: %i\n",
- option);
+ set_error(zck, "Unsupported compression parameter: %i",
+ option);
return False;
}
return True;
int comp_soption(zckCtx *zck, zck_soption option, const void *value,
size_t length) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
/* Cannot change compression parameters after compression has started */
if(zck && zck->comp.started) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to set compression parameters after initialization\n");
+ set_error(zck,
+ "Unable to set compression parameters after initialization");
return False;
}
if(option == ZCK_COMP_DICT) {
zck->comp.dict_size = length;
} else {
if(zck && zck->comp.set_parameter)
- return zck->comp.set_parameter(&(zck->comp), option, value);
+ return zck->comp.set_parameter(zck, &(zck->comp), option, value);
- zck_log(ZCK_LOG_ERROR, "Unsupported compression parameter: %i\n",
- option);
+ set_error(zck, "Unsupported compression parameter: %i", option);
return False;
}
return True;
}
-int comp_add_to_dc(zckComp *comp, const char *src, size_t src_size) {
- VALIDATE(comp);
- VALIDATE(src);
+int comp_add_to_dc(zckCtx *zck, zckComp *comp, const char *src,
+ size_t src_size) {
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(comp);
+ _VALIDATE_BOOL(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);
if(temp == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- comp->dc_data_size - comp->dc_data_loc + src_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ comp->dc_data_size - comp->dc_data_loc + src_size);
return False;
}
if(comp->dc_data_loc != 0)
- zck_log(ZCK_LOG_DEBUG, "Freeing %lu bytes from decompressed buffer\n",
+ zck_log(ZCK_LOG_DEBUG, "Freeing %lu bytes from decompressed buffer",
comp->dc_data_loc);
- zck_log(ZCK_LOG_DEBUG, "Adding %lu bytes to decompressed buffer\n",
+ zck_log(ZCK_LOG_DEBUG, "Adding %lu bytes to decompressed buffer",
src_size);
memcpy(temp, comp->dc_data + comp->dc_data_loc,
comp->dc_data_size - comp->dc_data_loc);
}
ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict) {
- VALIDATE_READ_SIZE(zck);
+ VALIDATE_READ_TRI(zck);
if(!zck->comp.started) {
- zck_log(ZCK_LOG_ERROR, "Compression hasn't been initialized yet\n");
+ set_error(zck, "Compression hasn't been initialized yet");
return -1;
}
size_t dc = 0;
char *src = zmalloc(dst_size - dc);
if(src == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", dst_size-dc);
+ set_fatal_error(zck, "Unable to allocate %lu bytes", dst_size-dc);
return False;
}
int finished_rd = False;
int finished_dc = False;
- zck_log(ZCK_LOG_DEBUG, "Trying to read %lu bytes\n", dst_size);
+ zck_log(ZCK_LOG_DEBUG, "Trying to read %lu bytes", dst_size);
while(dc < dst_size) {
/* Get bytes from decompressed buffer */
- ssize_t rb = comp_read_from_dc(&(zck->comp), dst+dc, dst_size-dc);
+ ssize_t rb = comp_read_from_dc(zck, &(zck->comp), dst+dc, dst_size-dc);
if(rb < 0)
goto read_error;
dc += rb;
/* Decompress compressed buffer into decompressed buffer */
size_t dc_data_size = zck->comp.dc_data_size;
size_t dc_data_loc = zck->comp.dc_data_loc;
- if(!zck->comp.decompress(&(zck->comp), use_dict))
+ if(!zck->comp.decompress(zck, &(zck->comp), use_dict))
goto read_error;
/* Check whether we decompressed more data */
/* Skip first chunk if it's an empty dict */
if(zck->comp.data_idx->comp_length == 0)
zck->comp.data_idx = zck->comp.data_idx->next;
- if(!hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
+ if(!hash_init(zck, &(zck->check_chunk_hash),
+ &(zck->chunk_hash_type)))
goto hash_error;
if(zck->comp.data_loc > 0) {
- if(!hash_update(&(zck->check_full_hash), zck->comp.data,
- zck->comp.data_loc))
+ if(!hash_update(zck, &(zck->check_full_hash), zck->comp.data,
+ zck->comp.data_loc))
goto hash_error;
- if(!hash_update(&(zck->check_chunk_hash), zck->comp.data,
- zck->comp.data_loc))
+ if(!hash_update(zck, &(zck->check_chunk_hash), zck->comp.data,
+ zck->comp.data_loc))
goto hash_error;
}
if(zck->comp.data_idx == NULL) {
/* Decompressed buffer is empty, so read data from file and fill
* compressed buffer */
- rb = read_data(zck->fd, src, rs);
+ rb = read_data(zck, src, rs);
if(rb < 0)
goto read_error;
if(rb < rs) {
- zck_log(ZCK_LOG_DEBUG, "EOF\n");
+ zck_log(ZCK_LOG_DEBUG, "EOF");
finished_rd = True;
}
- if(!hash_update(&(zck->check_full_hash), src, rb) ||
- !hash_update(&(zck->check_chunk_hash), src, rb) ||
- !comp_add_to_data(&(zck->comp), src, rb))
+ if(!hash_update(zck, &(zck->check_full_hash), src, rb) ||
+ !hash_update(zck, &(zck->check_chunk_hash), src, rb) ||
+ !comp_add_to_data(zck, &(zck->comp), src, rb))
goto read_error;
}
free(src);
zck->buzhash_bitmask) == 0) {
if(comp_write(zck, loc, i) != i)
return -1;
- zck_log(ZCK_LOG_DEBUG, "Automatically ending chunk\n");
+ zck_log(ZCK_LOG_DEBUG, "Automatically ending chunk");
if(zck_end_chunk(zck) < 0)
return -1;
loc += i;
}
ssize_t PUBLIC zck_end_chunk(zckCtx *zck) {
- VALIDATE_WRITE_SIZE(zck);
+ VALIDATE_WRITE_TRI(zck);
if(!zck->comp.started && !comp_init(zck))
return -1;
size_t data_size = zck->comp.dc_data_size;
char *dst = NULL;
size_t dst_size = 0;
- if(!zck->comp.end_cchunk(&(zck->comp), &dst, &dst_size, 1))
+ if(!zck->comp.end_cchunk(zck, &(zck->comp), &dst, &dst_size, 1))
return -1;
- if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
+ if(dst_size > 0 && !write_data(zck, zck->temp_fd, dst, dst_size)) {
free(dst);
return -1;
}
free(dst);
return -1;
}
- zck_log(ZCK_LOG_DEBUG, "Finished chunk size: %lu\n", data_size);
+ zck_log(ZCK_LOG_DEBUG, "Finished chunk size: %lu", data_size);
free(dst);
return data_size;
}
ssize_t PUBLIC zck_read(zckCtx *zck, char *dst, size_t dst_size) {
- VALIDATE_READ_SIZE(zck);
+ VALIDATE_READ_TRI(zck);
return comp_read(zck, dst, dst_size, 1);
}
#include "zck_private.h"
-static int init(zckComp *comp) {
+static int init(zckCtx *zck, zckComp *comp) {
return True;
}
-static int end_cchunk(zckComp *comp, char **dst, size_t *dst_size,
+static int end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
int use_dict) {
*dst = NULL;
*dst_size = 0;
return True;
}
-static ssize_t compress(zckComp *comp, const char *src, const size_t src_size,
- char **dst, size_t *dst_size, int use_dict) {
+static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
+ const size_t src_size, char **dst, size_t *dst_size,
+ int use_dict) {
*dst = zmalloc(src_size);
if(dst == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", src_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes", src_size);
return -1;
}
}
-static int decompress(zckComp *comp, const int use_dict) {
+static int decompress(zckCtx *zck, zckComp *comp, const int use_dict) {
char *src = comp->data;
char src_size = comp->data_size;
comp->data = NULL;
comp->data_size = 0;
- if(!comp_add_to_dc(comp, src, src_size)) {
+ if(!comp_add_to_dc(zck, comp, src, src_size)) {
free(src);
return False;
}
return True;
}
-static int end_dchunk(zckComp *comp, const int use_dict, const size_t fd_size) {
+static int end_dchunk(zckCtx *zck, zckComp *comp, const int use_dict,
+ const size_t fd_size) {
return True;
}
-static int close(zckComp *comp) {
+static int close(zckCtx *zck, zckComp *comp) {
return True;
}
/* Nocomp doesn't support any parameters, so return error if setting a parameter
* was attempted */
-static int set_parameter(zckComp *comp, int option, const void *value) {
- zck_log(ZCK_LOG_ERROR, "Invalid compression parameter for ZCK_COMP_NONE\n");
+static int set_parameter(zckCtx *zck, zckComp *comp, int option,
+ const void *value) {
+ set_error(zck, "Invalid compression parameter for ZCK_COMP_NONE");
return False;
}
/* No default parameters to set when there's no compression */
-static int set_default_parameters(zckComp *comp) {
+static int set_default_parameters(zckCtx *zck, zckComp *comp) {
return True;
}
-int nocomp_setup(zckComp *comp) {
+int nocomp_setup(zckCtx *zck, zckComp *comp) {
comp->init = init;
comp->set_parameter = set_parameter;
comp->compress = compress;
comp->end_dchunk = end_dchunk;
comp->close = close;
comp->type = ZCK_COMP_NONE;
- return set_default_parameters(comp);
+ return set_default_parameters(zck, comp);
}
#ifndef ZCHUNK_COMPRESSION_NOCOMP_H
#define ZCHUNK_COMPRESSION_NOCOMP_H
-int nocomp_setup(zckComp *comp);
+int nocomp_setup(zckCtx *zck, zckComp *comp);
#endif
#include "zck_private.h"
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckComp not initialized\n"); \
- return False; \
- }
+static int init(zckCtx *zck, zckComp *comp) {
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(comp);
-static int init(zckComp *comp) {
comp->cctx = ZSTD_createCCtx();
comp->dctx = ZSTD_createDCtx();
if(comp->dict && comp->dict_size > 0) {
comp->cdict_ctx = ZSTD_createCDict(comp->dict, comp->dict_size,
comp->level);
if(comp->cdict_ctx == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to create zstd compression dict context\n");
+ set_fatal_error(zck,
+ "Unable to create zstd compression dict context");
return False;
}
comp->ddict_ctx = ZSTD_createDDict(comp->dict, comp->dict_size);
if(comp->ddict_ctx == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to create zstd decompression dict context\n");
+ set_fatal_error(zck,
+ "Unable to create zstd decompression dict context");
return False;
}
}
/* The zstd compression format doesn't allow streaming compression with a dict
* unless you statically link to it. If we have a dict, we do pseudo-streaming
* compression where we buffer the data until the chunk ends. */
-static ssize_t compress(zckComp *comp, const char *src, const size_t src_size,
- char **dst, size_t *dst_size, int use_dict) {
+static ssize_t compress(zckCtx *zck, zckComp *comp, const char *src,
+ const size_t src_size, char **dst, size_t *dst_size,
+ int use_dict) {
+ VALIDATE_TRI(zck);
+ _VALIDATE_TRI(comp);
+
comp->dc_data = realloc(comp->dc_data, comp->dc_data_size + src_size);
if(comp->dc_data == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- comp->dc_data_size + src_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ comp->dc_data_size + src_size);
return -1;
}
memcpy(comp->dc_data + comp->dc_data_size, src, src_size);
return 0;
}
-static int end_cchunk(zckComp *comp, char **dst, size_t *dst_size,
+static int end_cchunk(zckCtx *zck, zckComp *comp, char **dst, size_t *dst_size,
int use_dict) {
- VALIDATE(comp);
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(comp);
+
size_t max_size = ZSTD_compressBound(comp->dc_data_size);
if(ZSTD_isError(max_size)) {
- zck_log(ZCK_LOG_ERROR, "zstd compression error: %s\n",
- ZSTD_getErrorName(max_size));
+ set_fatal_error(zck, "zstd compression error: %s",
+ ZSTD_getErrorName(max_size));
return False;
}
*dst = zmalloc(max_size);
if(dst == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", max_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes", max_size);
return False;
}
comp->dc_data_size = 0;
comp->dc_data_loc = 0;
if(ZSTD_isError(*dst_size)) {
- zck_log(ZCK_LOG_ERROR, "zstd compression error: %s\n",
- ZSTD_getErrorName(*dst_size));
+ set_fatal_error(zck, "zstd compression error: %s",
+ ZSTD_getErrorName(*dst_size));
return False;
}
return True;
}
-static int decompress(zckComp *comp, const int use_dict) {
- VALIDATE(comp);
+static int decompress(zckCtx *zck, zckComp *comp, const int use_dict) {
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(comp);
return True;
}
-static int end_dchunk(zckComp *comp, const int use_dict, const size_t fd_size) {
+static int end_dchunk(zckCtx *zck, zckComp *comp, const int use_dict,
+ const size_t fd_size) {
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(comp);
+
char *src = comp->data;
size_t src_size = comp->data_size;
comp->data = NULL;
comp->data_size = 0;
char *dst = zmalloc(fd_size);
- if(dst == NULL)
+ if(dst == NULL) {
+ set_fatal_error(zck, "Unable to allocate %lu bytes", fd_size);
goto decomp_error_1;
+ }
size_t retval;
- zck_log(ZCK_LOG_DEBUG, "Decompressing %lu bytes to %lu bytes\n", src_size,
+ zck_log(ZCK_LOG_DEBUG, "Decompressing %lu bytes to %lu bytes", src_size,
fd_size);
if(use_dict && comp->ddict_ctx) {
- zck_log(ZCK_LOG_DEBUG, "Running decompression using dict\n");
+ zck_log(ZCK_LOG_DEBUG, "Running decompression using dict");
retval = ZSTD_decompress_usingDDict(comp->dctx, dst, fd_size, src,
src_size, comp->ddict_ctx);
} else {
- zck_log(ZCK_LOG_DEBUG, "Running decompression\n");
+ zck_log(ZCK_LOG_DEBUG, "Running decompression");
retval = ZSTD_decompressDCtx(comp->dctx, dst, fd_size, src, src_size);
}
if(ZSTD_isError(retval)) {
- zck_log(ZCK_LOG_ERROR, "zstd decompression error: %s\n",
- ZSTD_getErrorName(retval));
+ set_fatal_error(zck, "zstd decompression error: %s",
+ ZSTD_getErrorName(retval));
goto decomp_error_2;
}
- if(!comp_add_to_dc(comp, dst, fd_size))
+ if(!comp_add_to_dc(zck, comp, dst, fd_size))
goto decomp_error_2;
free(dst);
free(src);
return False;
}
-static int close(zckComp *comp) {
+static int close(zckCtx *zck, zckComp *comp) {
if(comp->cdict_ctx) {
ZSTD_freeCDict(comp->cdict_ctx);
comp->cdict_ctx = NULL;
return True;
}
-static int set_parameter(zckComp *comp, int option, const void *value) {
+static int set_parameter(zckCtx *zck, zckComp *comp, int option,
+ const void *value) {
if(option == ZCK_ZSTD_COMP_LEVEL) {
if(*(int*)value >= 0 && *(int*)value <= ZSTD_maxCLevel()) {
comp->level = *(int*)value;
return True;
}
}
- zck_log(ZCK_LOG_ERROR, "Invalid compression parameter for ZCK_COMP_ZSTD\n");
+ set_error(zck, "Invalid compression parameter for ZCK_COMP_ZSTD");
return False;
}
-static int set_default_parameters(zckComp *comp) {
+static int set_default_parameters(zckCtx *zck, zckComp *comp) {
/* Set default compression level to 16 */
int level=16;
- return set_parameter(comp, ZCK_ZSTD_COMP_LEVEL, &level);
+ return set_parameter(zck, comp, ZCK_ZSTD_COMP_LEVEL, &level);
}
-int zstd_setup(zckComp *comp) {
+int zstd_setup(zckCtx *zck, zckComp *comp) {
comp->init = init;
comp->set_parameter = set_parameter;
comp->compress = compress;
comp->end_dchunk = end_dchunk;
comp->close = close;
comp->type = ZCK_COMP_ZSTD;
- return set_default_parameters(comp);
+ return set_default_parameters(zck, comp);
}
#ifndef ZCHUNK_COMPRESSION_ZSTD_H
#define ZCHUNK_COMPRESSION_ZSTD_H
-int zstd_setup(zckComp *comp);
+int zstd_setup(zckCtx *zck, zckComp *comp);
#endif
return;
}
-int compint_to_size(size_t *val, const char *compint, size_t *length,
- size_t max_length) {
+int compint_to_size(zckCtx *zck, size_t *val, const char *compint,
+ size_t *length, size_t max_length) {
+ VALIDATE_BOOL(zck);
+
*val = 0;
size_t old_val = 0;
const unsigned char *i = (unsigned char *)compint;
/* Make sure we're not overflowing and fail if we do */
if(count > MAX_COMP_SIZE || count > max_length || *val < old_val) {
if(count > max_length)
- zck_log(ZCK_LOG_ERROR, "Read past end of header\n");
+ set_fatal_error(zck, "Read past end of header");
else
- zck_log(ZCK_LOG_ERROR, "Number too large\n");
+ set_fatal_error(zck, "Number too large");
*length -= count;
*val = 0;
return False;
return True;
}
-int compint_from_int(char *compint, int val, size_t *length) {
+int compint_from_int(zckCtx *zck, char *compint, int val, size_t *length) {
+ VALIDATE_BOOL(zck);
+
if(val < 0) {
- zck_log(ZCK_LOG_ERROR, "Unable to compress negative integers\n");
+ set_error(zck, "Unable to compress negative integers");
return False;
}
return True;
}
-int compint_to_int(int *val, const char *compint, size_t *length,
+int compint_to_int(zckCtx *zck, int *val, const char *compint, size_t *length,
size_t max_length) {
+ VALIDATE_BOOL(zck);
+
size_t new = (size_t)*val;
- if(!compint_to_size(&new, compint, length, max_length))
+ if(!compint_to_size(zck, &new, compint, length, max_length))
return False;
*val = (int)new;
if(*val < 0) {
- zck_log(ZCK_LOG_ERROR, "Overflow error: compressed int is negative\n");
+ set_fatal_error(zck, "Overflow error: compressed int is negative");
return False;
}
return True;
#include "zck_private.h"
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckDL not allocated\n"); \
- return False; \
- }
-
/* Free zckDL header regex used for downloading ranges */
static void clear_dl_regex(zckDL *dl) {
- if(dl == NULL || dl == NULL)
+ if(dl == NULL)
return;
if(dl->hdr_regex) {
static int zero_chunk(zckCtx *tgt, zckChunk *tgt_idx) {
char buf[BUF_SIZE] = {0};
size_t to_read = tgt_idx->comp_length;
- if(!seek_data(tgt->fd, tgt->data_offset + tgt_idx->start, SEEK_SET))
+ if(!seek_data(tgt, 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(!write_data(tgt->fd, buf, rb))
+ if(!write_data(tgt, tgt->fd, buf, rb))
return False;
to_read -= rb;
}
/* Check whether last downloaded chunk is valid and zero it out if it isn't */
static int set_chunk_valid(zckDL *dl) {
- VALIDATE(dl);
- VALIDATE(dl);
+ _VALIDATE_BOOL(dl);
+ VALIDATE_BOOL(dl->zck);
int retval = validate_chunk(dl->zck, dl->tgt_check, ZCK_LOG_WARNING,
dl->tgt_number);
/* Write length or to end of current chunk, whichever comes first */
static int dl_write(zckDL *dl, const char *at, size_t length) {
- VALIDATE(dl);
- VALIDATE(dl);
+ _VALIDATE_TRI(dl);
+ VALIDATE_TRI(dl->zck);
+
int wb = 0;
if(dl->write_in_chunk > 0) {
if(dl->write_in_chunk < length)
wb = dl->write_in_chunk;
else
wb = length;
- if(!write_data(dl->zck->fd, at, wb))
+ if(!write_data(dl->zck, dl->zck->fd, at, wb))
return -1;
dl->write_in_chunk -= wb;
- if(!hash_update(&(dl->zck->check_chunk_hash), at, wb))
+ if(!hash_update(dl->zck, &(dl->zck->check_chunk_hash), at, wb))
return -1;
- zck_log(ZCK_LOG_DEBUG, "Writing %lu bytes\n", wb);
+ zck_log(ZCK_LOG_DEBUG, "Writing %lu bytes", wb);
dl->dl_chunk_data += wb;
}
return wb;
static int write_and_verify_chunk(zckCtx *src, zckCtx *tgt,
zckChunk *src_idx,
zckChunk *tgt_idx) {
+ VALIDATE_READ_BOOL(src);
+ VALIDATE_WRITE_BOOL(tgt);
+
static char buf[BUF_SIZE] = {0};
size_t to_read = src_idx->comp_length;
- if(!seek_data(src->fd, src->data_offset + src_idx->start, SEEK_SET))
+ if(!seek_data(src, src->data_offset + src_idx->start, SEEK_SET))
return False;
- if(!seek_data(tgt->fd, tgt->data_offset + tgt_idx->start, SEEK_SET))
+ if(!seek_data(tgt, tgt->data_offset + tgt_idx->start, SEEK_SET))
return False;
zckHash check_hash = {0};
- if(!hash_init(&check_hash, &(src->chunk_hash_type)))
+ if(!hash_init(tgt, &check_hash, &(src->chunk_hash_type)))
return False;
while(to_read > 0) {
int rb = BUF_SIZE;
if(rb > to_read)
rb = to_read;
- if(!read_data(src->fd, buf, rb))
+ if(!read_data(src, buf, rb))
return False;
- if(!hash_update(&check_hash, buf, rb))
+ if(!hash_update(tgt, &check_hash, buf, rb))
return False;
- if(!write_data(tgt->fd, buf, rb))
+ if(!write_data(tgt, tgt->fd, buf, rb))
return False;
to_read -= rb;
}
- char *digest = hash_finalize(&check_hash);
+ char *digest = hash_finalize(tgt, &check_hash);
/* If chunk is invalid, overwrite with zeros and add to download range */
if(memcmp(digest, src_idx->digest, src_idx->digest_size) != 0) {
char *pdigest = zck_get_chunk_digest(src_idx);
- zck_log(ZCK_LOG_WARNING, "Source hash: %s\n", pdigest);
+ zck_log(ZCK_LOG_WARNING, "Source hash: %s", pdigest);
free(pdigest);
pdigest = get_digest_string(digest, src_idx->digest_size);
- zck_log(ZCK_LOG_WARNING, "Target hash: %s\n", pdigest);
+ zck_log(ZCK_LOG_WARNING, "Target hash: %s", pdigest);
free(pdigest);
if(!zero_chunk(tgt, tgt_idx))
return False;
tgt_idx->valid = -1;
} else {
tgt_idx->valid = 1;
- zck_log(ZCK_LOG_DEBUG, "Wrote %lu bytes at %lu\n",
+ zck_log(ZCK_LOG_DEBUG, "Wrote %lu bytes at %lu",
tgt_idx->comp_length, tgt_idx->start);
}
free(digest);
/* Split current read into the appropriate chunks and write appropriately */
int dl_write_range(zckDL *dl, const char *at, size_t length) {
- VALIDATE(dl);
- VALIDATE(dl);
+ _VALIDATE_BOOL(dl);
+ VALIDATE_BOOL(dl->zck);
+
if(dl->range == NULL) {
- zck_log(ZCK_LOG_ERROR, "zckDL range not initialized\n");
+ set_error(dl->zck, "zckDL range not initialized");
return 0;
}
if(dl->range->index.first == NULL) {
- zck_log(ZCK_LOG_ERROR, "zckDL index not initialized\n");
+ set_error(dl->zck, "zckDL index not initialized");
return 0;
}
- if(dl->zck == NULL || dl->zck->index.first == NULL) {
- zck_log(ZCK_LOG_ERROR, "zckCtx index not initialized\n");
+ if(dl->zck->index.first == NULL) {
+ set_error(dl->zck, "zckCtx index not initialized");
return 0;
}
int wb = dl_write(dl, at, length);
chk->digest_size) == 0) {
dl->tgt_check = tgt_chk;
dl->tgt_number = count;
- if(!hash_init(&(dl->zck->check_chunk_hash),
- &(dl->zck->chunk_hash_type)))
+ if(!hash_init(dl->zck, &(dl->zck->check_chunk_hash),
+ &(dl->zck->chunk_hash_type)))
return 0;
dl->write_in_chunk = chk->comp_length;
- if(!seek_data(dl->zck->fd,
+ if(!seek_data(dl->zck,
dl->zck->data_offset + tgt_chk->start,
SEEK_SET))
return 0;
return True;
}
-size_t PUBLIC zck_dl_get_bytes_downloaded(zckDL *dl) {
- VALIDATE(dl);
+ssize_t PUBLIC zck_dl_get_bytes_downloaded(zckDL *dl) {
+ _VALIDATE_TRI(dl);
+
return dl->dl;
}
-size_t PUBLIC zck_dl_get_bytes_uploaded(zckDL *dl) {
- VALIDATE(dl);
+ssize_t PUBLIC zck_dl_get_bytes_uploaded(zckDL *dl) {
+ _VALIDATE_TRI(dl);
+
return dl->ul;
}
zckDL PUBLIC *zck_dl_init(zckCtx *zck) {
zckDL *dl = zmalloc(sizeof(zckDL));
if(!dl) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes for zckDL\n",
- sizeof(zckDL));
+ set_fatal_error(zck, "Unable to allocate %lu bytes for zckDL",
+ sizeof(zckDL));
return NULL;
}
dl->mp = zmalloc(sizeof(zckMP));
if(!dl->mp) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to allocate %lu bytes for dl->mp\n",
- sizeof(zckMP));
+ set_fatal_error(zck, "Unable to allocate %lu bytes for dl->mp",
+ sizeof(zckMP));
return NULL;
}
dl->zck = zck;
}
zckCtx PUBLIC *zck_dl_get_zck(zckDL *dl) {
- if(dl == NULL)
- return NULL;
+ _VALIDATE_CHAR(dl);
+
return dl->zck;
}
int PUBLIC zck_dl_set_zck(zckDL *dl, zckCtx *zck) {
- if(dl == NULL)
- return False;
+ _VALIDATE_BOOL(dl);
+
dl->zck = zck;
return True;
}
int PUBLIC zck_dl_set_range(zckDL *dl, zckRange *range) {
- if(dl == NULL)
- return False;
+ _VALIDATE_BOOL(dl);
+
dl->range = range;
return True;
}
zckRange PUBLIC *zck_dl_get_range(zckDL *dl) {
- if(dl == NULL)
- return NULL;
+ _VALIDATE_CHAR(dl);
+
return dl->range;
}
int PUBLIC zck_dl_set_header_cb(zckDL *dl, zck_wcb func) {
- if(dl == NULL)
- return False;
+ _VALIDATE_BOOL(dl);
+
dl->header_cb = func;
return True;
}
int PUBLIC zck_dl_set_header_data(zckDL *dl, void *data) {
- if(dl == NULL)
- return False;
+ _VALIDATE_BOOL(dl);
+
dl->header_data = data;
return True;
}
int PUBLIC zck_dl_set_write_cb(zckDL *dl, zck_wcb func) {
- if(dl == NULL)
- return False;
+ _VALIDATE_BOOL(dl);
+
dl->write_cb = func;
return True;
}
int PUBLIC zck_dl_set_write_data(zckDL *dl, void *data) {
- if(dl == NULL)
- return False;
+ _VALIDATE_BOOL(dl);
+
dl->write_data = data;
return True;
}
*******************************************************************/
size_t PUBLIC zck_header_cb(char *b, size_t l, size_t c, void *dl_v) {
- if(dl_v == NULL)
- return 0;
+ _VALIDATE_BOOL(dl_v);
zckDL *dl = (zckDL*)dl_v;
if(multipart_get_boundary(dl, b, c*l) == 0)
}
size_t PUBLIC zck_write_zck_header_cb(void *ptr, size_t l, size_t c, void *dl_v) {
- if(dl_v == NULL)
- return 0;
+ _VALIDATE_BOOL(dl_v);
zckDL *dl = (zckDL*)dl_v;
+
size_t wb = 0;
dl->dl += l*c;
- size_t loc = tell_data(dl->zck->fd);
- zck_log(ZCK_LOG_DEBUG, "Downloading %lu bytes to position %lu\n", l*c, loc);
+ size_t loc = tell_data(dl->zck);
+ zck_log(ZCK_LOG_DEBUG, "Downloading %lu bytes to position %lu", l*c, loc);
wb = write(dl->zck->fd, ptr, l*c);
if(dl->write_cb)
return dl->write_cb(ptr, l, c, dl->write_data);
}
size_t PUBLIC zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v) {
- if(dl_v == NULL)
- return 0;
+ _VALIDATE_BOOL(dl_v);
zckDL *dl = (zckDL*)dl_v;
+
size_t wb = 0;
dl->dl += l*c;
if(dl->boundary != NULL) {
#include "zck_private.h"
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckDL not allocated\n"); \
- return False; \
- }
+static char *add_boundary_to_regex(zckCtx *zck, const char *regex,
+ const char *boundary) {
+ VALIDATE_CHAR(zck);
-static char *add_boundary_to_regex(const char *regex, const char *boundary) {
if(regex == NULL || boundary == NULL)
return NULL;
char *regex_b = zmalloc(strlen(regex) + strlen(boundary) + 1);
if(regex_b == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to reallocate %lu bytes for regular expression\n",
- strlen(regex) + strlen(boundary) - 2);
+ set_fatal_error(zck,
+ "Unable to reallocate %lu bytes for regular expression",
+ strlen(regex) + strlen(boundary) - 2);
return NULL;
}
if(snprintf(regex_b, strlen(regex) + strlen(boundary), regex,
boundary) != strlen(regex) + strlen(boundary) - 2) {
free(regex_b);
- zck_log(ZCK_LOG_ERROR, "Unable to build regular expression\n");
+ set_error(zck, "Unable to build regular expression");
return NULL;
}
return regex_b;
}
-static int create_regex(regex_t *reg, const char *regex) {
+static int create_regex(zckCtx *zck, regex_t *reg, const char *regex) {
+ VALIDATE_BOOL(zck);
+
if(reg == NULL || regex == NULL) {
- zck_log(ZCK_LOG_ERROR, "Regular expression not initialized\n");
+ set_error(zck, "Regular expression not initialized");
return False;
}
if(regcomp(reg, regex, REG_ICASE | REG_EXTENDED) != 0) {
- zck_log(ZCK_LOG_ERROR, "Unable to compile regular expression\n");
+ set_error(zck, "Unable to compile regular expression");
return False;
}
return True;
}
static int gen_regex(zckDL *dl) {
+ _VALIDATE_BOOL(dl);
+ VALIDATE_BOOL(dl->zck);
+
char *next = "\r\n--%s\r\ncontent-type:.*\r\n" \
"content-range: *bytes *([0-9]+) *- *([0-9]+) */.*\r\n\r";
char *end = "\r\n--%s--\r\n\r";
- char *regex_n = add_boundary_to_regex(next, dl->boundary);
+ char *regex_n = add_boundary_to_regex(dl->zck, next, dl->boundary);
if(regex_n == NULL)
return False;
- char *regex_e = add_boundary_to_regex(end, dl->boundary);
+ char *regex_e = add_boundary_to_regex(dl->zck, end, dl->boundary);
if(regex_n == NULL)
return False;
dl->dl_regex = zmalloc(sizeof(regex_t));
- if(!create_regex(dl->dl_regex, regex_n)) {
+ if(!create_regex(dl->zck, dl->dl_regex, regex_n)) {
free(regex_n);
return False;
}
free(regex_n);
dl->end_regex = zmalloc(sizeof(regex_t));
- if(!create_regex(dl->end_regex, regex_e)) {
+ if(!create_regex(dl->zck, dl->end_regex, regex_e)) {
free(regex_e);
return False;
}
}
size_t multipart_extract(zckDL *dl, char *b, size_t l) {
- VALIDATE(dl);
+ _VALIDATE_BOOL(dl);
+ VALIDATE_BOOL(dl->zck);
+
if(dl == NULL || dl->mp == NULL)
return 0;
zckMP *mp = dl->mp;
if(mp->buffer) {
buf = realloc(mp->buffer, mp->buffer_len + l);
if(buf == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes for zckDL\n",
- mp->buffer_len + l);
+ set_fatal_error(dl->zck, "Unable to reallocate %lu bytes for zckDL",
+ mp->buffer_len + l);
return 0;
}
memcpy(buf + mp->buffer_len, b, l);
regmatch_t match[4] = {{0}};
if(regexec(dl->dl_regex, i, 3, match, 0) != 0) {
if(regexec(dl->end_regex, i, 3, match, 0) != 0)
- zck_log(ZCK_LOG_ERROR, "Unable to find multipart download range\n");
+ set_error(dl->zck, "Unable to find multipart download range");
goto end;
}
rend = rend*10 + (size_t)(c[0] - 48);
i += match[0].rm_eo + 1;
- zck_log(ZCK_LOG_DEBUG, "Download range: %lu-%lu\n", rstart, rend);
+ zck_log(ZCK_LOG_DEBUG, "Download range: %lu-%lu", rstart, rend);
mp->length = rend-rstart+1;
mp->state = 1;
}
}
size_t multipart_get_boundary(zckDL *dl, char *b, size_t size) {
- VALIDATE(dl);
+ _VALIDATE_BOOL(dl);
+ VALIDATE_BOOL(dl->zck);
+
if(dl == NULL)
return 0;
if(dl->hdr_regex == NULL) {
char *regex = "boundary *= *([0-9a-fA-F]+)";
dl->hdr_regex = zmalloc(sizeof(regex_t));
- if(!create_regex(dl->hdr_regex, regex))
+ if(!create_regex(dl->zck, dl->hdr_regex, regex))
return 0;
}
* terminated string */
char *buf = zmalloc(size+1);
if(buf == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes for header\n",
- size+1);
+ set_fatal_error(dl->zck, "Unable to allocate %lu bytes for header",
+ size+1);
return 0;
}
buf[size] = '\0';
reset_mp(dl->mp);
char *boundary = zmalloc(match[1].rm_eo - match[1].rm_so + 1);
memcpy(boundary, buf + match[1].rm_so, match[1].rm_eo - match[1].rm_so);
- zck_log(ZCK_LOG_DEBUG, "Multipart boundary: %s\n", boundary);
+ zck_log(ZCK_LOG_DEBUG, "Multipart boundary: %s", boundary);
dl->boundary = boundary;
}
if(buf)
#include "zck_private.h"
-static zckRangeItem *range_insert_new(zckRangeItem *prev, zckRangeItem *next,
- uint64_t start, uint64_t end,
- zckRange *info, zckChunk *idx,
- int add_index) {
+static zckRangeItem *range_insert_new(zckCtx *zck, zckRangeItem *prev,
+ zckRangeItem *next, uint64_t start,
+ uint64_t end, zckRange *info,
+ zckChunk *idx, int add_index) {
+ VALIDATE_CHAR(zck);
+
zckRangeItem *new = zmalloc(sizeof(zckRangeItem));
if(!new) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- sizeof(zckRangeItem));
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ sizeof(zckRangeItem));
return NULL;
}
new->start = start;
return new;
}
-static void range_remove(zckRangeItem *range) {
+static void range_remove(zckCtx *zck, zckRangeItem *range) {
if(range->prev)
range->prev->next = range->next;
if(range->next)
free(range);
}
-static void range_merge_combined(zckRange *info) {
+static void range_merge_combined(zckCtx *zck, zckRange *info) {
if(!info) {
- zck_log(ZCK_LOG_ERROR, "zckRange not allocated\n");
+ set_error(zck, "zckRange not allocated");
return;
}
for(zckRangeItem *ptr=info->first; ptr;) {
if(ptr->next && ptr->end >= ptr->next->start-1) {
if(ptr->end < ptr->next->end)
ptr->end = ptr->next->end;
- range_remove(ptr->next);
+ range_remove(zck, ptr->next);
info->count -= 1;
} else {
ptr = ptr->next;
static int range_add(zckRange *info, zckChunk *chk, zckCtx *zck) {
if(info == NULL || chk == NULL) {
- zck_log(ZCK_LOG_ERROR, "zckRange or zckChunk not allocated\n");
+ set_error(zck, "zckRange or zckChunk not allocated");
return False;
}
size_t header_len = 0;
ptr = ptr->next;
continue;
} else if(start < ptr->start) {
- if(range_insert_new(ptr->prev, ptr, start, end, info, chk,
+ if(range_insert_new(zck, ptr->prev, ptr, start, end, info, chk,
add_index) == NULL)
return False;
if(info->first == ptr) {
info->first = ptr->prev;
}
info->count += 1;
- range_merge_combined(info);
+ range_merge_combined(zck, info);
return True;
} else { // start == ptr->start
if(end > ptr->end)
ptr->end = end;
info->count += 1;
- range_merge_combined(info);
+ range_merge_combined(zck, info);
return True;
}
}
/* We've only reached here if we should be last item */
- zckRangeItem *new = range_insert_new(prev, NULL, start, end, info, chk,
+ zckRangeItem *new = range_insert_new(zck, prev, NULL, start, end, info, chk,
add_index);
if(new == NULL)
return False;
if(info->first == NULL)
info->first = new;
info->count += 1;
- range_merge_combined(info);
+ range_merge_combined(zck, info);
return True;
}
*info = NULL;
}
-char PUBLIC *zck_get_range_char(zckRange *range) {
+char PUBLIC *zck_get_range_char(zckCtx *zck, zckRange *range) {
int buf_size=BUF_SIZE;
char *output=malloc(buf_size);
if(!output) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", buf_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes", buf_size);
return NULL;
}
(long unsigned)ri->start,
(long unsigned)ri->end);
if(length < 0) {
- zck_log(ZCK_LOG_ERROR, "Unable to get range: %s\n",
- strerror(errno));
+ set_fatal_error(zck, "Unable to get range: %s", strerror(errno));
free(output);
return NULL;
}
buf_size = (int)(buf_size * 1.5);
output = realloc(output, buf_size);
if(output == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- buf_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes", buf_size);
return NULL;
}
continue;
output[loc-1]='\0'; // Remove final comma
output = realloc(output, loc);
if(output == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to shrink range to %lu bytes\n",
- loc);
+ set_fatal_error(zck, "Unable to shrink range to %lu bytes", loc);
free(output);
return NULL;
}
}
zckRange PUBLIC *zck_get_missing_range(zckCtx *zck, int max_ranges) {
+ VALIDATE_CHAR(zck);
+
zckRange *range = zmalloc(sizeof(zckRange));
if(range == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- sizeof(zckRange));
+ set_fatal_error(zck, "Unable to allocate %lu bytes", sizeof(zckRange));
return NULL;
}
for(zckChunk *chk = zck->index.first; chk; chk = chk->next) {
char PUBLIC *zck_get_range(size_t start, size_t end) {
zckRange range = {0};
zckRangeItem ri = {0};
+ zckCtx *zck = zck_create();
range.first = &ri;
ri.start = start;
ri.end = end;
- return zck_get_range_char(&range);
+ char *ret = zck_get_range_char(zck, &range);
+ zck_free(&zck);
+ return ret;
}
int PUBLIC zck_get_range_count(zckRange *range) {
- if(range == NULL)
- return -1;
+ _VALIDATE_TRI(range);
+
return range->count;
}
#define sha1_byte void
#endif
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n"); \
- return False; \
- }
-
-#define VALIDATE_READ(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_READ) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for reading\n"); \
- return False; \
- }
-
-#define VALIDATE_WRITE(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_WRITE) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for writing\n"); \
- return False; \
- }
/* This needs to be updated to the largest hash size every time a new hash type
* is added */
int get_max_hash_size() {
return SHA512_DIGEST_SIZE;
}
-
-
static char unknown[] = "Unknown(\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
const static char *HASH_NAME[] = {
};
static int validate_checksums(zckCtx *zck, zck_log_type bad_checksums) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
char buf[BUF_SIZE] = {0};
if(zck->data_offset == 0) {
- zck_log(ZCK_LOG_ERROR, "Header hasn't been read yet\n");
+ set_error(zck, "Header hasn't been read yet");
return 0;
}
- if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
+ if(!hash_init(zck, &(zck->check_full_hash), &(zck->hash_type)))
return 0;
- if(!seek_data(zck->fd, zck->data_offset, SEEK_SET))
+ if(!seek_data(zck, zck->data_offset, SEEK_SET))
return 0;
/* Check each chunk checksum */
continue;
}
- if(!hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
+ if(!hash_init(zck, &(zck->check_chunk_hash), &(zck->chunk_hash_type)))
return 0;
size_t rlen = 0;
size_t rsize = BUF_SIZE;
if(BUF_SIZE > idx->comp_length - rlen)
rsize = idx->comp_length - rlen;
- if(read_data(zck->fd, buf, rsize) != rsize)
- zck_log(ZCK_LOG_DEBUG, "No more data\n");
- if(!hash_update(&(zck->check_chunk_hash), buf, rsize))
+ if(read_data(zck, buf, rsize) != rsize)
+ zck_log(ZCK_LOG_DEBUG, "No more data");
+ if(!hash_update(zck, &(zck->check_chunk_hash), buf, rsize))
return 0;
- if(!hash_update(&(zck->check_full_hash), buf, rsize))
+ if(!hash_update(zck, &(zck->check_full_hash), buf, rsize))
return 0;
rlen += rsize;
}
}
/* Go back to beginning of data section */
- if(!seek_data(zck->fd, zck->data_offset, SEEK_SET))
+ if(!seek_data(zck, zck->data_offset, SEEK_SET))
return 0;
/* Reinitialize data checksum */
- if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
+ if(!hash_init(zck, &(zck->check_full_hash), &(zck->hash_type)))
return 0;
return valid_file;
return str;
}
-int hash_setup(zckHashType *ht, int h) {
- if(ht) {
- if(h == ZCK_HASH_SHA1) {
- memset(ht, 0, sizeof(zckHashType));
- ht->type = ZCK_HASH_SHA1;
- ht->digest_size = SHA1_DIGEST_LENGTH;
- zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s\n",
- zck_hash_name_from_type(ht->type));
- return True;
- } else if(h == ZCK_HASH_SHA256) {
- memset(ht, 0, sizeof(zckHashType));
- ht->type = ZCK_HASH_SHA256;
- ht->digest_size = SHA256_DIGEST_SIZE;
- zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s\n",
- zck_hash_name_from_type(ht->type));
- return True;
- } else if(h >= ZCK_HASH_SHA512 &&
- h <= ZCK_HASH_SHA512_128) {
- memset(ht, 0, sizeof(zckHashType));
- ht->type = h;
- if(h == ZCK_HASH_SHA512)
- ht->digest_size = SHA512_DIGEST_SIZE;
- else if(h == ZCK_HASH_SHA512_128)
- ht->digest_size = 16;
- zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s\n",
- zck_hash_name_from_type(ht->type));
- return True;
- }
- zck_log(ZCK_LOG_ERROR, "Unsupported hash type: %s\n",
- zck_hash_name_from_type(h));
+int hash_setup(zckCtx *zck, zckHashType *ht, int h) {
+ if(!ht) {
+ set_error(zck, "zckHashType is null");
return False;
}
- zck_log(ZCK_LOG_ERROR, "zckHashType is null\n");
+ if(h == ZCK_HASH_SHA1) {
+ memset(ht, 0, sizeof(zckHashType));
+ ht->type = ZCK_HASH_SHA1;
+ ht->digest_size = SHA1_DIGEST_LENGTH;
+ zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s",
+ zck_hash_name_from_type(ht->type));
+ return True;
+ } else if(h == ZCK_HASH_SHA256) {
+ memset(ht, 0, sizeof(zckHashType));
+ ht->type = ZCK_HASH_SHA256;
+ ht->digest_size = SHA256_DIGEST_SIZE;
+ zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s",
+ zck_hash_name_from_type(ht->type));
+ return True;
+ } else if(h >= ZCK_HASH_SHA512 &&
+ h <= ZCK_HASH_SHA512_128) {
+ memset(ht, 0, sizeof(zckHashType));
+ ht->type = h;
+ if(h == ZCK_HASH_SHA512)
+ ht->digest_size = SHA512_DIGEST_SIZE;
+ else if(h == ZCK_HASH_SHA512_128)
+ ht->digest_size = 16;
+ zck_log(ZCK_LOG_DEBUG, "Setting up hash type %s",
+ zck_hash_name_from_type(ht->type));
+ return True;
+ }
+ set_error(zck, "Unsupported hash type: %s", zck_hash_name_from_type(h));
return False;
}
return;
}
-int hash_init(zckHash *hash, zckHashType *hash_type) {
+int hash_init(zckCtx *zck, zckHash *hash, zckHashType *hash_type) {
hash_close(hash);
- if(hash && hash_type) {
- if(hash_type->type == ZCK_HASH_SHA1) {
- zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-1 hash\n");
- hash->ctx = zmalloc(sizeof(SHA_CTX));
- hash->type = hash_type;
- if(hash->ctx == NULL)
- return False;
- SHA1_Init((SHA_CTX *) hash->ctx);
- return True;
- } else if(hash_type->type == ZCK_HASH_SHA256) {
- zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-256 hash\n");
- hash->ctx = zmalloc(sizeof(SHA256_CTX));
- hash->type = hash_type;
- if(hash->ctx == NULL)
- return False;
- SHA256_Init((SHA256_CTX *) hash->ctx);
- return True;
- } else if(hash_type->type >= ZCK_HASH_SHA512 &&
- hash_type->type <= ZCK_HASH_SHA512_128) {
- zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-512 hash\n");
- hash->ctx = zmalloc(sizeof(SHA512_CTX));
- hash->type = hash_type;
- if(hash->ctx == NULL)
- return False;
- SHA512_Init((SHA512_CTX *) hash->ctx);
- return True;
- }
- zck_log(ZCK_LOG_ERROR, "Unsupported hash type: %i\n", hash_type->type);
+ if(hash == NULL || hash_type == NULL) {
+ set_error(zck, "Either zckHash or zckHashType struct is null");
return False;
}
- zck_log(ZCK_LOG_ERROR, "Either zckHash or zckHashType struct is null\n");
+ if(hash_type->type == ZCK_HASH_SHA1) {
+ zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-1 hash");
+ hash->ctx = zmalloc(sizeof(SHA_CTX));
+ hash->type = hash_type;
+ if(hash->ctx == NULL)
+ return False;
+ SHA1_Init((SHA_CTX *) hash->ctx);
+ return True;
+ } else if(hash_type->type == ZCK_HASH_SHA256) {
+ zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-256 hash");
+ hash->ctx = zmalloc(sizeof(SHA256_CTX));
+ hash->type = hash_type;
+ if(hash->ctx == NULL)
+ return False;
+ SHA256_Init((SHA256_CTX *) hash->ctx);
+ return True;
+ } else if(hash_type->type >= ZCK_HASH_SHA512 &&
+ hash_type->type <= ZCK_HASH_SHA512_128) {
+ zck_log(ZCK_LOG_DDEBUG, "Initializing SHA-512 hash");
+ hash->ctx = zmalloc(sizeof(SHA512_CTX));
+ hash->type = hash_type;
+ if(hash->ctx == NULL)
+ return False;
+ SHA512_Init((SHA512_CTX *) hash->ctx);
+ return True;
+ }
+ set_error(zck, "Unsupported hash type: %s",
+ zck_hash_name_from_type(hash_type->type));
return False;
}
-int hash_update(zckHash *hash, const char *message, const size_t size) {
+int hash_update(zckCtx *zck, zckHash *hash, const char *message,
+ const size_t size) {
if(message == NULL && size == 0)
return True;
if(message == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Hash data is supposed to have %lu bytes, but is NULL\n", size);
+ set_error(zck,
+ "Hash data is supposed to have %lu bytes, but is NULL", size);
return False;
}
if(size == 0) {
- zck_log(ZCK_LOG_ERROR,
- "Hash data is supposed to be 0-length, but is not NULL\n");
+ set_error(zck,
+ "Hash data is supposed to be 0-length, but is not NULL");
return False;
}
if(hash && hash->ctx && hash->type) {
SHA1_Update((SHA_CTX *)hash->ctx, (const sha1_byte *)message, size);
return True;
} else if(hash->type->type == ZCK_HASH_SHA256) {
- SHA256_Update((SHA256_CTX *)hash->ctx, (const unsigned char *)message, size);
+ SHA256_Update((SHA256_CTX *)hash->ctx,
+ (const unsigned char *)message, size);
return True;
} else if(hash->type->type >= ZCK_HASH_SHA512 &&
hash->type->type <= ZCK_HASH_SHA512_128) {
- SHA512_Update((SHA512_CTX *)hash->ctx, (const unsigned char *)message, size);
+ SHA512_Update((SHA512_CTX *)hash->ctx,
+ (const unsigned char *)message, size);
return True;
}
- zck_log(ZCK_LOG_ERROR, "Unsupported hash type: %i\n", hash->type);
+ set_error(zck, "Unsupported hash type: %s",
+ zck_hash_name_from_type(hash->type->type));
+
return False;
}
- zck_log(ZCK_LOG_ERROR, "Hash hasn't been initialized\n");
+ set_error(zck, "Hash hasn't been initialized");
return False;
}
-char *hash_finalize(zckHash *hash) {
- if(hash && hash->ctx && hash->type) {
- if(hash->type->type == ZCK_HASH_SHA1) {
- unsigned char *digest = zmalloc(SHA1_DIGEST_LENGTH);
- SHA1_Final((sha1_byte*)digest, (SHA_CTX *)hash->ctx);
- hash_close(hash);
- return (char *)digest;
- } else if(hash->type->type == ZCK_HASH_SHA256) {
- unsigned char *digest = zmalloc(SHA256_DIGEST_SIZE);
- SHA256_Final(digest, (SHA256_CTX *)hash->ctx);
- hash_close(hash);
- return (char *)digest;
- } else if(hash->type->type >= ZCK_HASH_SHA512 &&
- hash->type->type <= ZCK_HASH_SHA512_128) {
- unsigned char *digest = zmalloc(SHA512_DIGEST_SIZE);
- SHA512_Final(digest, (SHA512_CTX *)hash->ctx);
- hash_close(hash);
- return (char *)digest;
- }
- zck_log(ZCK_LOG_ERROR, "Unsupported hash type: %i\n", hash->type);
+char *hash_finalize(zckCtx *zck, zckHash *hash) {
+ if(!hash || !hash->ctx || !hash->type) {
+ set_error(zck, "Hash hasn't been initialized");
hash_close(hash);
return NULL;
}
- zck_log(ZCK_LOG_ERROR, "Hash hasn't been initialized\n");
+ if(hash->type->type == ZCK_HASH_SHA1) {
+ unsigned char *digest = zmalloc(SHA1_DIGEST_LENGTH);
+ SHA1_Final((sha1_byte*)digest, (SHA_CTX *)hash->ctx);
+ hash_close(hash);
+ return (char *)digest;
+ } else if(hash->type->type == ZCK_HASH_SHA256) {
+ unsigned char *digest = zmalloc(SHA256_DIGEST_SIZE);
+ SHA256_Final(digest, (SHA256_CTX *)hash->ctx);
+ hash_close(hash);
+ return (char *)digest;
+ } else if(hash->type->type >= ZCK_HASH_SHA512 &&
+ hash->type->type <= ZCK_HASH_SHA512_128) {
+ unsigned char *digest = zmalloc(SHA512_DIGEST_SIZE);
+ SHA512_Final(digest, (SHA512_CTX *)hash->ctx);
+ hash_close(hash);
+ return (char *)digest;
+ }
+ set_error(zck, "Unsupported hash type: %s",
+ zck_hash_name_from_type(hash->type->type));
hash_close(hash);
return NULL;
}
int set_full_hash_type(zckCtx *zck, int hash_type) {
- VALIDATE(zck);
- zck_log(ZCK_LOG_INFO, "Setting full hash to %s\n",
+ VALIDATE_BOOL(zck);
+
+ zck_log(ZCK_LOG_INFO, "Setting full hash to %s",
zck_hash_name_from_type(hash_type));
- if(!hash_setup(&(zck->hash_type), hash_type)) {
- zck_log(ZCK_LOG_ERROR, "Unable to set full hash to %s\n",
- zck_hash_name_from_type(hash_type));
+ if(!hash_setup(zck, &(zck->hash_type), hash_type)) {
+ set_error(zck, "Unable to set full hash");
return False;
}
- if(!hash_init(&(zck->full_hash), &(zck->hash_type))) {
- zck_log(ZCK_LOG_ERROR, "Unable initialize full hash\n");
+ if(!hash_init(zck, &(zck->full_hash), &(zck->hash_type))) {
+ set_error(zck, "Unable initialize full hash");
return False;
}
return True;
}
int set_chunk_hash_type(zckCtx *zck, int hash_type) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
+
memset(&(zck->chunk_hash_type), 0, sizeof(zckHashType));
- zck_log(ZCK_LOG_DEBUG, "Setting chunk hash to %s\n",
+ zck_log(ZCK_LOG_DEBUG, "Setting chunk hash to %s",
zck_hash_name_from_type(hash_type));
- if(!hash_setup(&(zck->chunk_hash_type), hash_type)) {
- zck_log(ZCK_LOG_ERROR, "Unable to set chunk hash to %s\n",
- zck_hash_name_from_type(hash_type));
+ if(!hash_setup(zck, &(zck->chunk_hash_type), hash_type)) {
+ set_error(zck, "Unable to set chunk hash");
return False;
}
zck->index.hash_type = zck->chunk_hash_type.type;
/* Validate chunk, returning -1 if checksum fails, 1 if good, 0 if error */
int validate_chunk(zckCtx *zck, zckChunk *idx,
zck_log_type bad_checksum, int chunk_number) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
if(idx == NULL) {
- zck_log(ZCK_LOG_ERROR, "Index not initialized\n");
+ set_error(zck, "Index not initialized");
return 0;
}
- char *digest = hash_finalize(&(zck->check_chunk_hash));
+ char *digest = hash_finalize(zck, &(zck->check_chunk_hash));
if(digest == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to calculate %s checksum for chunk\n");
+ set_error(zck, "Unable to calculate chunk checksum");
return 0;
}
if(idx->comp_length == 0)
memset(digest, 0, idx->digest_size);
char *pdigest = zck_get_chunk_digest(idx);
- zck_log(ZCK_LOG_DDEBUG, "Expected chunk checksum: %s\n", pdigest);
+ zck_log(ZCK_LOG_DDEBUG, "Expected chunk checksum: %s", pdigest);
free(pdigest);
pdigest = get_digest_string(digest, idx->digest_size);
- zck_log(ZCK_LOG_DDEBUG, "Calculated chunk checksum: %s\n", pdigest);
+ zck_log(ZCK_LOG_DDEBUG, "Calculated chunk checksum: %s", pdigest);
free(pdigest);
if(memcmp(digest, idx->digest, idx->digest_size) != 0) {
free(digest);
if(chunk_number == -1)
- zck_log(bad_checksum, "Chunk checksum: FAILED!\n");
+ zck_log(bad_checksum, "Chunk checksum: FAILED!");
else
- zck_log(bad_checksum, "Chunk %i's checksum: FAILED\n",
+ zck_log(bad_checksum, "Chunk %i's checksum: FAILED",
chunk_number);
return -1;
}
if(chunk_number == -1)
- zck_log(ZCK_LOG_DEBUG, "Chunk checksum: valid\n");
+ zck_log(ZCK_LOG_DEBUG, "Chunk checksum: valid");
else
- zck_log(ZCK_LOG_DEBUG, "Chunk %i's checksum: valid\n", chunk_number);
+ zck_log(ZCK_LOG_DEBUG, "Chunk %i's checksum: valid", chunk_number);
free(digest);
return 1;
}
int validate_current_chunk(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
return validate_chunk(zck, zck->comp.data_idx, ZCK_LOG_ERROR, -1);
}
int validate_file(zckCtx *zck, zck_log_type bad_checksums) {
- VALIDATE(zck);
- char *digest = hash_finalize(&(zck->check_full_hash));
+ VALIDATE_BOOL(zck);
+ char *digest = hash_finalize(zck, &(zck->check_full_hash));
if(digest == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to calculate %s checksum for full file\n");
+ set_error(zck, "Unable to calculate full file checksum");
return 0;
}
- zck_log(ZCK_LOG_DEBUG, "Checking data checksum\n");
+ zck_log(ZCK_LOG_DEBUG, "Checking data checksum");
char *cks = get_digest_string(zck->full_hash_digest,
zck->hash_type.digest_size);
- zck_log(ZCK_LOG_DEBUG, "Expected data checksum: %s\n", cks);
+ zck_log(ZCK_LOG_DEBUG, "Expected data checksum: %s", cks);
free(cks);
cks = get_digest_string(digest, zck->hash_type.digest_size);
- zck_log(ZCK_LOG_DEBUG, "Calculated data checksum: %s\n", cks);
+ zck_log(ZCK_LOG_DEBUG, "Calculated data checksum: %s", cks);
free(cks);
if(memcmp(digest, zck->full_hash_digest, zck->hash_type.digest_size) != 0) {
free(digest);
- zck_log(bad_checksums, "Data checksum failed!\n");
+ zck_log(bad_checksums, "Data checksum failed!");
return -1;
}
- zck_log(ZCK_LOG_DEBUG, "Data checksum valid\n");
+ zck_log(ZCK_LOG_DEBUG, "Data checksum valid");
free(digest);
return 1;
}
int validate_header(zckCtx *zck) {
- VALIDATE(zck);
- char *digest = hash_finalize(&(zck->check_full_hash));
+ VALIDATE_BOOL(zck);
+
+ char *digest = hash_finalize(zck, &(zck->check_full_hash));
if(digest == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to calculate %s checksum for header\n");
+ set_error(zck, "Unable to calculate header checksum");
return 0;
}
- zck_log(ZCK_LOG_DEBUG, "Checking header checksum\n");
+ zck_log(ZCK_LOG_DEBUG, "Checking header checksum");
char *cks = get_digest_string(zck->header_digest,
zck->hash_type.digest_size);
- zck_log(ZCK_LOG_DEBUG, "Expected header checksum: %s\n", cks);
+ zck_log(ZCK_LOG_DEBUG, "Expected header checksum: %s", cks);
free(cks);
cks = get_digest_string(digest, zck->hash_type.digest_size);
- zck_log(ZCK_LOG_DEBUG, "Calculated header checksum: %s\n", cks);
+ zck_log(ZCK_LOG_DEBUG, "Calculated header checksum: %s", cks);
free(cks);
if(memcmp(digest, zck->header_digest, zck->hash_type.digest_size) != 0) {
free(digest);
- zck_log(ZCK_LOG_ERROR, "Header checksum failed!\n");
+ zck_log(ZCK_LOG_INFO, "Header checksum failed!");
return -1;
}
- zck_log(ZCK_LOG_DEBUG, "Header checksum valid\n");
+ zck_log(ZCK_LOG_DEBUG, "Header checksum valid");
free(digest);
- if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
+ if(!hash_init(zck, &(zck->check_full_hash), &(zck->hash_type)))
return 0;
return 1;
/* Returns 1 if data hash matches, -1 if it doesn't and 0 if error */
int PUBLIC zck_validate_data_checksum(zckCtx *zck) {
- if(!seek_data(zck->fd, zck->data_offset, SEEK_SET))
+ VALIDATE_READ_BOOL(zck);
+
+ if(!seek_data(zck, zck->data_offset, SEEK_SET))
return 0;
- if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
+ if(!hash_init(zck, &(zck->check_full_hash), &(zck->hash_type)))
return 0;
char buf[BUF_SIZE] = {0};
zckChunk *idx = zck->index.first;
- zck_log(ZCK_LOG_DEBUG, "Checking full hash\n");
+ zck_log(ZCK_LOG_DEBUG, "Checking full hash");
while(idx) {
size_t to_read = idx->comp_length;
while(to_read > 0) {
size_t rb = BUF_SIZE;
if(rb > to_read)
rb = to_read;
- if(!read_data(zck->fd, buf, rb))
+ if(!read_data(zck, buf, rb))
return 0;
- if(!hash_update(&(zck->check_full_hash), buf, rb))
+ if(!hash_update(zck, &(zck->check_full_hash), buf, rb))
return 0;
to_read -= rb;
}
}
int PUBLIC zck_get_full_hash_type(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
+
return zck->hash_type.type;
}
ssize_t PUBLIC zck_get_full_digest_size(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
+
return zck->hash_type.digest_size;
}
int PUBLIC zck_get_chunk_hash_type(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
+
return zck->index.hash_type;
}
ssize_t PUBLIC zck_get_chunk_digest_size(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
+
return zck->index.digest_size;
}
char PUBLIC *zck_get_header_digest(zckCtx *zck) {
- if(zck == NULL)
- return NULL;
+ VALIDATE_CHAR(zck);
+
return get_digest_string(zck->header_digest, zck->hash_type.digest_size);
}
char PUBLIC *zck_get_data_digest(zckCtx *zck) {
- if(zck == NULL)
- return NULL;
+ VALIDATE_CHAR(zck);
+
return get_digest_string(zck->full_hash_digest, zck->hash_type.digest_size);
}
/* Returns 1 if all chunks are valid, -1 if even one isn't and 0 if error */
int PUBLIC zck_find_valid_chunks(zckCtx *zck) {
+ VALIDATE_READ_BOOL(zck);
+
return validate_checksums(zck, ZCK_LOG_DEBUG);
}
/* Returns 1 if all checksums matched, -1 if even one doesn't and 0 if error */
int PUBLIC zck_validate_checksums(zckCtx *zck) {
+ VALIDATE_READ_BOOL(zck);
+
return validate_checksums(zck, ZCK_LOG_WARNING);
}
#include "zck_private.h"
-#define MAX_HEADER_IN_MEM 10*1024*1024
-
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not initialized\n"); \
- return False; \
- }
-
-#define VALIDATE_READ(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_READ) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for reading\n"); \
- return False; \
- }
-
-#define VALIDATE_WRITE(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_WRITE) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for writing\n"); \
- return False; \
- }
-
static int check_flags(zckCtx *zck, size_t flags) {
zck->has_streams = flags & 1;
if(zck->has_streams) {
- zck_log(ZCK_LOG_ERROR, "This version of zchunk doesn't support streams\n");
+ set_fatal_error(zck,
+ "This version of zchunk doesn't support streams");
return False;
}
flags = flags & (SIZE_MAX - 1);
if(flags != 0) {
- zck_log(ZCK_LOG_ERROR, "Unknown flags(s) set\n");
+ set_fatal_error(zck, "Unknown flags(s) set");
return False;
}
return True;
/* Allocate header and store any extra bytes at beginning of header */
zck->header = realloc(zck->header, zck->lead_size + zck->header_length);
if(zck->header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n",
- zck->lead_size + zck->header_length);
+ set_fatal_error(zck, "Unable to reallocate %lu bytes",
+ zck->lead_size + zck->header_length);
return False;
}
zck->lead_string = zck->header;
size_t loaded = 0;
if(zck->header_length < zck->header_size - zck->lead_size) {
- zck_log(ZCK_LOG_ERROR, "Header size is too small for actual data\n");
+ set_fatal_error(zck, "Header size is too small for actual data");
return False;
}
if(zck->lead_size < zck->header_size)
loaded = zck->header_size - zck->lead_size;
/* Read header from file */
- zck_log(ZCK_LOG_DEBUG, "Reading the rest of the header: %lu bytes\n",
+ zck_log(ZCK_LOG_DEBUG, "Reading the rest of the header: %lu bytes",
zck->header_length);
if(loaded < zck->header_length) {
- if(!read_data(zck->fd, header + loaded, zck->header_length - loaded))
+ if(!read_data(zck, header + loaded, zck->header_length - loaded))
return False;
zck->header_size = zck->lead_size + zck->header_length;
}
- if(!hash_init(&(zck->check_full_hash), &(zck->hash_type)))
+ if(!hash_init(zck, &(zck->check_full_hash), &(zck->hash_type)))
return False;
- if(!hash_update(&(zck->check_full_hash), zck->header,
- zck->hdr_digest_loc))
+ if(!hash_update(zck, &(zck->check_full_hash), zck->header,
+ zck->hdr_digest_loc))
return False;
- if(!hash_update(&(zck->check_full_hash), header, zck->header_length))
+ if(!hash_update(zck, &(zck->check_full_hash), header, zck->header_length))
return False;
if(validate_header(zck) < 1)
return False;
}
static int read_preface(zckCtx *zck) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
if(zck->header_digest == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Reading preface before lead is read\n");
+ set_error(zck, "Reading preface before lead is read");
return False;
}
size_t max_length = zck->header_length;
/* Read data digest */
- zck_log(ZCK_LOG_DEBUG, "Reading data digest\n");
+ zck_log(ZCK_LOG_DEBUG, "Reading data digest");
if(length + zck->hash_type.digest_size > max_length) {
- zck_log(ZCK_LOG_ERROR, "Read past end of header\n");
+ set_fatal_error(zck, "Read past end of header");
return False;
}
zck->full_hash_digest = zmalloc(zck->hash_type.digest_size);
if(!zck->full_hash_digest) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- zck->hash_type.digest_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ zck->hash_type.digest_size);
return False;
}
memcpy(zck->full_hash_digest, header+length, zck->hash_type.digest_size);
/* Read flags */
size_t flags = 0;
- if(!compint_to_size(&flags, header+length, &length, max_length))
+ if(!compint_to_size(zck, &flags, header+length, &length, max_length))
return False;
if(!check_flags(zck, flags))
return False;
/* Setup for reading compression type */
- zck_log(ZCK_LOG_DEBUG, "Reading compression type and index size\n");
+ zck_log(ZCK_LOG_DEBUG, "Reading compression type and index size");
int tmp = 0;
/* Read and initialize compression type */
- if(!compint_to_int(&tmp, header+length, &length, max_length))
+ if(!compint_to_int(zck, &tmp, header+length, &length, max_length))
return False;
if(!comp_ioption(zck, ZCK_COMP_TYPE, tmp))
return False;
return False;
/* Read and initialize index size */
- if(!compint_to_int(&tmp, header+length, &length, max_length))
+ if(!compint_to_int(zck, &tmp, header+length, &length, max_length))
return False;
zck->index_size = tmp;
}
static int read_index(zckCtx *zck) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
if(zck->preface_string == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Reading index before preface is read\n");
+ set_error(zck, "Reading index before preface is read");
return False;
}
char *header = NULL;
- zck_log(ZCK_LOG_DEBUG, "Reading index\n");
+ zck_log(ZCK_LOG_DEBUG, "Reading index");
if(zck->lead_size + zck->preface_size + zck->index_size >
zck->header_size) {
- zck_log(ZCK_LOG_ERROR, "Read past end of header\n");
+ set_fatal_error(zck, "Read past end of header");
return False;
}
header = zck->header + zck->lead_size + zck->preface_size;
}
static int read_sig(zckCtx *zck) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
if(zck->index_string == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Reading signatures before index is read\n");
+ set_error(zck, "Reading signatures before index is read");
return False;
}
zck->index_size);
size_t length = 0;
- if(!compint_to_int(&(zck->sigs.count), header, &length, max_length))
+ if(!compint_to_int(zck, &(zck->sigs.count), header, &length, max_length))
return False;
/* We don't actually support signatures yet, so bail if there is one */
- zck_log(ZCK_LOG_DEBUG, "Signature count: %i\n", zck->sigs.count);
+ zck_log(ZCK_LOG_DEBUG, "Signature count: %i", zck->sigs.count);
if(zck->sigs.count > 0) {
- zck_log(ZCK_LOG_ERROR, "Signatures aren't supported yet\n");
+ set_fatal_error(zck, "Signatures aren't supported yet");
return False;
}
if(zck->header_size >
zck->lead_size + zck->preface_size + zck->index_size + length)
- zck_log(ZCK_LOG_WARNING, "There are %lu unused bytes in the header\n");
+ zck_log(ZCK_LOG_WARNING, "There are %lu unused bytes in the header");
zck->sig_size = length;
zck->sig_string = header;
}
static int preface_create(zckCtx *zck) {
+ VALIDATE_WRITE_BOOL(zck);
+
int header_malloc = zck->hash_type.digest_size + 4 + 2*MAX_COMP_SIZE;
char *header = zmalloc(header_malloc);
if(header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", header_malloc);
+ set_error(zck, "Unable to allocate %lu bytes", header_malloc);
return False;
}
size_t length = 0;
compint_from_size(header+length, flags, &length);
/* Write out compression type and index size */
- if(!compint_from_int(header+length, zck->comp.type, &length)) {
+ if(!compint_from_int(zck, header+length, zck->comp.type, &length)) {
free(header);
return False;
}
/* Shrink header to actual size */
header = realloc(header, length);
if(header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n", length);
+ set_fatal_error(zck, "Unable to reallocate %lu bytes", length);
return False;
}
zck->preface_string = header;
zck->preface_size = length;
- zck_log(ZCK_LOG_DEBUG, "Generated preface: %lu bytes\n", zck->preface_size);
+ zck_log(ZCK_LOG_DEBUG, "Generated preface: %lu bytes", zck->preface_size);
return True;
}
static int sig_create(zckCtx *zck) {
char *header = zmalloc(MAX_COMP_SIZE);
if(header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", MAX_COMP_SIZE);
+ set_error(zck, "Unable to allocate %lu bytes", MAX_COMP_SIZE);
return False;
}
size_t length = 0;
- zck_log(ZCK_LOG_DEBUG, "Calculating %i signatures\n", zck->sigs.count);
+ zck_log(ZCK_LOG_DEBUG, "Calculating %i signatures", zck->sigs.count);
/* Write out signature count and signatures */
- if(!compint_from_int(header+length, zck->sigs.count, &length)) {
+ if(!compint_from_int(zck, header+length, zck->sigs.count, &length)) {
free(header);
return False;
}
}
zck->sig_string = header;
zck->sig_size = length;
- zck_log(ZCK_LOG_DEBUG, "Generated signatures: %lu bytes\n", zck->sig_size);
+ zck_log(ZCK_LOG_DEBUG, "Generated signatures: %lu bytes", zck->sig_size);
return True;
}
int phs = 5 + 2*MAX_COMP_SIZE + zck->hash_type.digest_size;
char *header = zmalloc(phs);
if(header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", phs);
+ set_error(zck, "Unable to allocate %lu bytes", phs);
return False;
}
size_t length = 0;
header = realloc(header, length);
if(header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n", length);
+ set_fatal_error(zck, "Unable to reallocate %lu bytes", length);
return False;
}
zck->lead_string = header;
zck->lead_size = length;
- zck_log(ZCK_LOG_DEBUG, "Generated lead: %lu bytes\n", zck->lead_size);
+ zck_log(ZCK_LOG_DEBUG, "Generated lead: %lu bytes", zck->lead_size);
return True;
}
int header_create(zckCtx *zck) {
+ VALIDATE_WRITE_BOOL(zck);
+
/* Rebuild header without header hash */
if(zck->header_digest) {
free(zck->header_digest);
zck->index_size + zck->sig_size;
/* Merge everything into one large string */
- zck_log(ZCK_LOG_DEBUG, "Merging into header: %lu bytes\n",
+ zck_log(ZCK_LOG_DEBUG, "Merging into header: %lu bytes",
zck->data_offset);
zck->header = zmalloc(zck->data_offset);
if(zck->header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- zck->data_offset);
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ zck->data_offset);
return False;
}
size_t offs = 0;
zckHash header_hash = {0};
/* Calculate hash of header */
- if(!hash_init(&header_hash, &(zck->hash_type)))
+ if(!hash_init(zck, &header_hash, &(zck->hash_type)))
return False;
- zck_log(ZCK_LOG_DEBUG, "Hashing lead\n");
+ zck_log(ZCK_LOG_DEBUG, "Hashing lead");
/* Hash lead up to header digest */
- if(!hash_update(&header_hash, zck->lead_string,
- zck->hdr_digest_loc))
+ if(!hash_update(zck, &header_hash, zck->lead_string,
+ zck->hdr_digest_loc))
return False;
- zck_log(ZCK_LOG_DEBUG, "Hashing the rest\n");
+ zck_log(ZCK_LOG_DEBUG, "Hashing the rest");
/* Hash rest of header */
- if(!hash_update(&header_hash, zck->preface_string, zck->header_length))
+ if(!hash_update(zck, &header_hash, zck->preface_string, zck->header_length))
return False;
- zck->header_digest = hash_finalize(&header_hash);
- if(zck->header_digest == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to calculate %s checksum for index\n",
- zck_hash_name_from_type(zck->hash_type.type));
+ zck->header_digest = hash_finalize(zck, &header_hash);
+ if(zck->header_digest == NULL)
return False;
- }
+
/* Write digest to header */
memcpy(zck->lead_string+zck->hdr_digest_loc, zck->header_digest,
zck->hash_type.digest_size);
}
int write_header(zckCtx *zck) {
- VALIDATE_WRITE(zck);
+ VALIDATE_WRITE_BOOL(zck);
- zck_log(ZCK_LOG_DEBUG, "Writing header: %lu bytes\n",
+ zck_log(ZCK_LOG_DEBUG, "Writing header: %lu bytes",
zck->lead_size);
- if(!write_data(zck->fd, zck->header, zck->header_size))
+ if(!write_data(zck, zck->fd, zck->header, zck->header_size))
return False;
return True;
}
-static int read_lead(zckCtx *zck, zck_log_type log_level) {
- VALIDATE_READ(zck);
+static int read_lead(zckCtx *zck) {
+ VALIDATE_READ_BOOL(zck);
int lead = 5 + 2*MAX_COMP_SIZE;
char *header = zmalloc(lead);
if(header == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", lead);
+ set_error(zck, "Unable to allocate %lu bytes", lead);
return False;
}
size_t length = 0;
- if(read_data(zck->fd, header, lead) < lead)
+ if(read_data(zck, header, lead) < lead)
return False;
if(memcmp(header, "\0ZCK1", 5) != 0) {
free(header);
- zck_log(log_level,
- "Invalid lead, perhaps this is not a zck file?\n");
+ set_error(zck, "Invalid lead, perhaps this is not a zck file?");
return False;
}
length += 5;
/* Read hash type for header and full digest and initialize check hash */
int hash_type = 0;
- if(!compint_to_int(&hash_type, header+length, &length, lead)) {
+ if(!compint_to_int(zck, &hash_type, header+length, &length, lead)) {
free(header);
return False;
}
if(zck->prep_hash_type > -1 && zck->prep_hash_type != hash_type) {
free(header);
- zck_log(log_level,
- "Hash type (%i) doesn't match requested hash type "
- "(%i)\n", hash_type, zck->prep_hash_type);
+ set_error(zck, "Hash type (%i) doesn't match requested hash type "
+ "(%i)", hash_type, zck->prep_hash_type);
return False;
}
- if(!hash_setup(&(zck->hash_type), hash_type)) {
+ if(!hash_setup(zck, &(zck->hash_type), hash_type)) {
free(header);
return False;
}
- zck_log(ZCK_LOG_DEBUG, "Setting header and full digest hash type to %s\n",
+ zck_log(ZCK_LOG_DEBUG, "Setting header and full digest hash type to %s",
zck_hash_name_from_type(hash_type));
/* Read header size */
size_t header_length = 0;
- if(!compint_to_size(&header_length, header+length, &length, lead)) {
+ if(!compint_to_size(zck, &header_length, header+length, &length, lead)) {
free(header);
hash_reset(&(zck->hash_type));
return False;
zck->hdr_digest_loc = length;
/* Read header digest */
- zck_log(ZCK_LOG_DEBUG, "Reading header digest\n");
+ zck_log(ZCK_LOG_DEBUG, "Reading header digest");
header = realloc(header, length + zck->hash_type.digest_size);
if(header == NULL) {
zck->header_length = 0;
zck->hdr_digest_loc = 0;
hash_reset(&(zck->hash_type));
- zck_log(ZCK_LOG_ERROR, "Unable to re-allocate %lu bytes\n",
- length + zck->hash_type.digest_size);
+ set_fatal_error(zck, "Unable to re-allocate %lu bytes",
+ length + zck->hash_type.digest_size);
return False;
}
size_t to_read = 0;
if(lead < length + zck->hash_type.digest_size)
to_read = length + zck->hash_type.digest_size - lead;
- if(read_data(zck->fd, header + lead, to_read) < to_read) {
+ if(read_data(zck, header + lead, to_read) < to_read) {
free(header);
zck->header_length = 0;
zck->hdr_digest_loc = 0;
zck->header_length = 0;
zck->hdr_digest_loc = 0;
hash_reset(&(zck->hash_type));
- zck_log(log_level,
- "Header digest doesn't match requested header digest\n"
- "Expected: %s\nActual: %s\n",
- get_digest_string(zck->prep_digest, zck->hash_type.digest_size),
- get_digest_string(header + length, zck->hash_type.digest_size));
+ set_error(zck,
+ "Header digest doesn't match requested header digest"
+ "Expected: %sActual: %s",
+ get_digest_string(zck->prep_digest,
+ zck->hash_type.digest_size),
+ get_digest_string(header + length,
+ zck->hash_type.digest_size));
return False;
}
zck->header_digest = zmalloc(zck->hash_type.digest_size);
zck->header_length = 0;
zck->hdr_digest_loc = 0;
hash_reset(&(zck->hash_type));
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- zck->hash_type.digest_size);
+ set_error(zck, "Unable to allocate %lu bytes",
+ zck->hash_type.digest_size);
return False;
}
memcpy(zck->header_digest, header + length, zck->hash_type.digest_size);
hash_reset(&(zck->hash_type));
free(zck->header_digest);
zck->header_digest = NULL;
- zck_log(log_level,
- "Header length (%lu) doesn't match requested header length "
- "(%lu)\n", zck->header_length + length,
- zck->prep_hdr_size);
+ set_error(zck,
+ "Header length (%lu) doesn't match requested header length "
+ "(%lu)", zck->header_length + length,
+ zck->prep_hdr_size);
return False;
}
/* Store pre-header */
zck->header_size = lead;
zck->lead_string = header;
zck->lead_size = length;
- zck_log(ZCK_LOG_DEBUG, "Parsed lead: %lu bytes\n", length);
+ zck_log(ZCK_LOG_DEBUG, "Parsed lead: %lu bytes", length);
return True;
}
int PUBLIC zck_read_lead(zckCtx *zck) {
- if(zck == NULL)
- return False;
- return read_lead(zck, ZCK_LOG_ERROR);
+ VALIDATE_BOOL(zck);
+
+ return read_lead(zck);
}
int PUBLIC zck_validate_lead(zckCtx *zck) {
- if(zck == NULL)
- return False;
- int retval = read_lead(zck, ZCK_LOG_DEBUG);
+ VALIDATE_BOOL(zck);
+
+ int retval = read_lead(zck);
+ zck_clear_error(zck);
free(zck->header);
free(zck->header_digest);
zck->header = NULL;
zck->header_digest = NULL;
zck->hdr_digest_loc = 0;
hash_reset(&(zck->hash_type));
- if(!seek_data(zck->fd, 0, SEEK_SET))
+ if(!seek_data(zck, 0, SEEK_SET))
return False;
return retval;
}
int PUBLIC zck_read_header(zckCtx *zck) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
if(!read_header_from_file(zck))
return False;
}
ssize_t PUBLIC zck_get_header_length(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
return zck->lead_size + zck->header_length;
}
ssize_t PUBLIC zck_get_lead_length(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
return zck->lead_size;
}
ssize_t PUBLIC zck_get_data_length(zckCtx *zck) {
+ VALIDATE_TRI(zck);
zckChunk *idx = zck->index.first;
while(idx->next != NULL)
idx = idx->next;
}
ssize_t PUBLIC zck_get_length(zckCtx *zck) {
+ VALIDATE_TRI(zck);
return zck_get_header_length(zck) + zck_get_data_length(zck);
}
#include "zck_private.h"
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n"); \
- return False; \
- }
-
static int create_chunk(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
clear_work_index(zck);
zck->work_index_item = zmalloc(sizeof(zckChunk));
if(zck->work_index_item == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- sizeof(zckChunk));
+ set_error(zck, "Unable to allocate %lu bytes",
+ sizeof(zckChunk));
return False;
}
- if(!hash_init(&(zck->work_index_hash), &(zck->chunk_hash_type)))
+ if(!hash_init(zck, &(zck->work_index_hash), &(zck->chunk_hash_type)))
return False;
return True;
}
static int finish_chunk(zckIndex *index, zckChunk *item, char *digest,
int valid, zckCtx *zck) {
- VALIDATE(index);
- VALIDATE(item);
+ VALIDATE_BOOL(zck);
+ _VALIDATE_BOOL(index);
+ _VALIDATE_BOOL(item);
item->digest = zmalloc(index->digest_size);
if(item->digest == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- index->digest_size);
+ set_error(zck, "Unable to allocate %lu bytes", index->digest_size);
return False;
}
if(digest) {
}
int index_create(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
char *index;
size_t index_malloc = 0;
size_t index_size = 0;
- zck->full_hash_digest = hash_finalize(&(zck->full_hash));
+ zck->full_hash_digest = hash_finalize(zck, &(zck->full_hash));
if(zck->full_hash_digest == NULL)
return False;
/* Shrink index to actual size */
index = realloc(index, index_size);
if(index == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n", index_size);
+ set_fatal_error(zck, "Unable to reallocate %lu bytes", index_size);
return False;
}
zck->index_string = index;
zck->index_size = index_size;
- zck_log(ZCK_LOG_DEBUG, "Generated index: %lu bytes\n", zck->index_size);
+ zck_log(ZCK_LOG_DEBUG, "Generated index: %lu bytes", zck->index_size);
return True;
}
int index_new_chunk(zckIndex *index, char *digest, int digest_size,
size_t comp_size, size_t orig_size, int finished,
zckCtx *zck) {
+ VALIDATE_BOOL(zck);
+
if(index == NULL) {
- zck_log(ZCK_LOG_ERROR, "Invalid index\n");
+ set_error(zck, "Invalid index");
return False;
}
if(digest_size == 0) {
- zck_log(ZCK_LOG_ERROR, "Digest size 0 too small\n");
+ set_error(zck, "Digest size 0 too small");
return False;
}
zckChunk *chk = zmalloc(sizeof(zckChunk));
if(chk == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- sizeof(zckChunk));
+ set_error(zck, "Unable to allocate %lu bytes", sizeof(zckChunk));
return False;
}
index->digest_size = digest_size;
int index_add_to_chunk(zckCtx *zck, char *data, size_t comp_size,
size_t orig_size) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
if(zck->work_index_item == NULL && !create_chunk(zck))
return False;
if(comp_size == 0)
return True;
- if(!hash_update(&(zck->full_hash), data, comp_size))
+ if(!hash_update(zck, &(zck->full_hash), data, comp_size))
return False;
- if(!hash_update(&(zck->work_index_hash), data, comp_size))
+ if(!hash_update(zck, &(zck->work_index_hash), data, comp_size))
return False;
zck->work_index_item->comp_length += comp_size;
}
int index_finish_chunk(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
if(zck->work_index_item == NULL && !create_chunk(zck))
return False;
char *digest = NULL;
if(zck->work_index_item->length > 0) {
/* Finalize chunk checksum */
- digest = hash_finalize(&(zck->work_index_hash));
+ digest = hash_finalize(zck, &(zck->work_index_hash));
if(digest == NULL) {
- zck_log(ZCK_LOG_ERROR,
- "Unable to calculate %s checksum for new chunk\n",
- zck_hash_name_from_type(zck->index.hash_type));
+ set_fatal_error(zck,
+ "Unable to calculate %s checksum for new chunk",
+ zck_hash_name_from_type(zck->index.hash_type));
return False;
}
} else {
digest = zmalloc(zck->chunk_hash_type.digest_size);
if(digest == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- zck->chunk_hash_type.digest_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ zck->chunk_hash_type.digest_size);
return False;
}
}
#include "zck_private.h"
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n"); \
- return False; \
- }
-
int index_read(zckCtx *zck, char *data, size_t size, size_t max_length) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
size_t length = 0;
/* Read and configure hash type */
int hash_type;
- if(!compint_to_int(&hash_type, data + length, &length, max_length))
+ if(!compint_to_int(zck, &hash_type, data + length, &length, max_length)) {
+ set_fatal_error(zck, "Unable to read hash type");
return False;
- if(!set_chunk_hash_type(zck, hash_type))
+ }
+ if(!set_chunk_hash_type(zck, hash_type)) {
+ set_fatal_error(zck, "Unable to set chunk hash type");
return False;
+ }
/* Read number of index entries */
size_t index_count;
- if(!compint_to_size(&index_count, data + length, &length, max_length))
+ if(!compint_to_size(zck, &index_count, data + length, &length,
+ max_length)) {
+ set_fatal_error(zck, "Unable to read index count");
return False;
+ }
zck->index.count = index_count;
zckChunk *prev = zck->index.first;
size_t idx_loc = 0;
+ int count = 0;
while(length < size) {
if(length + zck->index.digest_size > max_length) {
- zck_log(ZCK_LOG_ERROR, "Read past end of header\n");
+ set_fatal_error(zck, "Read past end of header");
return False;
}
zckChunk *new = zmalloc(sizeof(zckChunk));
if(!new) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- sizeof(zckChunk));
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ sizeof(zckChunk));
return False;
}
/* Read index entry digest */
new->digest = zmalloc(zck->index.digest_size);
if(!new->digest) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- zck->index.digest_size);
+ set_fatal_error(zck, "Unable to allocate %lu bytes",
+ zck->index.digest_size);
return False;
}
memcpy(new->digest, data+length, zck->index.digest_size);
/* Read and store entry length */
size_t chunk_length = 0;
- if(!compint_to_size(&chunk_length, data+length, &length, max_length))
+ if(!compint_to_size(zck, &chunk_length, data+length, &length,
+ max_length)) {
+ set_fatal_error(zck, "Unable to read chunk %i compressed size",
+ count);
return False;
+ }
new->start = idx_loc;
new->comp_length = chunk_length;
/* Read and store uncompressed entry length */
chunk_length = 0;
- if(!compint_to_size(&chunk_length, data+length, &length, max_length))
+ if(!compint_to_size(zck, &chunk_length, data+length, &length,
+ max_length)) {
+ set_fatal_error(zck, "Unable to read chunk %i uncompressed size",
+ count);
return False;
+ }
new->length = chunk_length;
new->zck = zck;
new->valid = 0;
idx_loc += new->comp_length;
+ count++;
zck->index.length = idx_loc;
if(prev)
}
ssize_t PUBLIC zck_get_chunk_count(zckCtx *zck) {
- if(zck == NULL)
- return -1;
+ VALIDATE_TRI(zck);
+
return zck->index.count;
}
zckChunk PUBLIC *zck_get_first_chunk(zckCtx *zck) {
- if(zck == NULL)
- return NULL;
+ VALIDATE_CHAR(zck);
+
return zck->index.first;
}
zckChunk PUBLIC *zck_get_next_chunk(zckChunk *idx) {
- if(idx == NULL)
- return NULL;
+ _VALIDATE_CHAR(idx);
+
return idx->next;
}
ssize_t PUBLIC zck_get_chunk_start(zckChunk *idx) {
- if(idx == NULL)
- return -1;
- if(idx->zck)
+ _VALIDATE_TRI(idx);
+
+ if(idx->zck) {
+ VALIDATE_TRI(idx->zck);
return idx->start + zck_get_header_length(idx->zck);
- else
+ } else {
return idx->start;
+ }
}
ssize_t PUBLIC zck_get_chunk_size(zckChunk *idx) {
- if(idx == NULL)
- return -1;
+ _VALIDATE_TRI(idx);
+
return idx->length;
}
ssize_t PUBLIC zck_get_chunk_comp_size(zckChunk *idx) {
- if(idx == NULL)
- return -1;
+ _VALIDATE_TRI(idx);
+
return idx->comp_length;
}
int PUBLIC zck_get_chunk_valid(zckChunk *idx) {
- if(idx == NULL)
- return -1;
+ _VALIDATE_TRI(idx);
+
return idx->valid;
}
int PUBLIC zck_compare_chunk_digest(zckChunk *a, zckChunk *b) {
- if(a == NULL || b == NULL)
- return False;
+ _VALIDATE_BOOL(a);
+ _VALIDATE_BOOL(b);
+
if(a->digest_size != b->digest_size)
return False;
if(memcmp(a->digest, b->digest, a->digest_size) != 0)
}
int PUBLIC zck_missing_chunks(zckCtx *zck) {
- if(zck == NULL) {
- zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n");
- return -1;
- }
+ VALIDATE_READ_TRI(zck);
+
int missing = 0;
for(zckChunk *idx = zck->index.first; idx; idx=idx->next)
if(idx->valid == 0)
}
int PUBLIC zck_failed_chunks(zckCtx *zck) {
- if(zck == NULL) {
- zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n");
- return -1;
- }
+ VALIDATE_READ_TRI(zck);
+
int failed = 0;
for(zckChunk *idx = zck->index.first; idx; idx=idx->next)
if(idx->valid == -1)
#include "zck_private.h"
-ssize_t read_data(int fd, char *data, size_t length) {
+ssize_t read_data(zckCtx *zck, char *data, size_t length) {
+ VALIDATE_READ_TRI(zck);
+
if(length == 0)
return 0;
if(data == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to read to NULL data pointer\n");
+ set_error(zck, "Unable to read to NULL data pointer");
return -1;
}
- ssize_t read_bytes = read(fd, data, length);
+ ssize_t read_bytes = read(zck->fd, data, length);
if(read_bytes == -1) {
- zck_log(ZCK_LOG_ERROR, "Error reading data: %s\n", strerror(errno));
+ set_error(zck, "Error reading data: %s", strerror(errno));
return -1;
}
return read_bytes;
}
-int write_data(int fd, const char *data, size_t length) {
+int write_data(zckCtx *zck, int fd, const char *data, size_t length) {
+ VALIDATE_WRITE_TRI(zck);
+
if(length == 0)
return True;
if(data == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to write from NULL data pointer\n");
+ set_error(zck, "Unable to write from NULL data pointer");
return False;
}
ssize_t write_bytes = write(fd, data, length);
if(write_bytes == -1) {
- zck_log(ZCK_LOG_ERROR, "Error write data: %s\n", strerror(errno));
+ set_error(zck, "Error write data: %s", strerror(errno));
return False;
} else if(write_bytes != length) {
- zck_log(ZCK_LOG_ERROR, "Short write\n");
+ set_fatal_error(zck, "Short write");
return False;
}
return True;
}
-int seek_data(int fd, off_t offset, int whence) {
- if(lseek(fd, offset, whence) == -1) {
+int seek_data(zckCtx *zck, off_t offset, int whence) {
+ VALIDATE_TRI(zck);
+
+ if(lseek(zck->fd, offset, whence) == -1) {
char *wh_str = NULL;
if(whence == SEEK_CUR) {
} else {
wh_str = "using unknown measurement";
}
- zck_log(ZCK_LOG_ERROR, "Unable to seek to %lu %s: %s\n", offset, wh_str,
- strerror(errno));
+ set_error(zck, "Unable to seek to %lu %s: %s", offset, wh_str,
+ strerror(errno));
return False;
}
return True;
}
-ssize_t tell_data(int fd) {
- ssize_t loc = lseek(fd, 0, SEEK_CUR);
+ssize_t tell_data(zckCtx *zck) {
+ ssize_t loc = lseek(zck->fd, 0, SEEK_CUR);
return loc;
}
return False;
while((read_count = read(zck->temp_fd, data, BUF_SIZE)) > 0) {
- if(read_count == -1 || !write_data(zck->fd, data, read_count)) {
+ if(read_count == -1 || !write_data(zck, zck->fd, data, read_count)) {
free(data);
return False;
}
#include "zck_private.h"
-#define VALIDATE(f) if(!f) { \
- zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n"); \
- return False; \
- }
-
-#define VALIDATE_READ(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_READ) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for reading\n"); \
- return False; \
- }
-
-#define VALIDATE_WRITE(f) VALIDATE(f); \
- if(f->mode != ZCK_MODE_WRITE) { \
- zck_log(ZCK_LOG_ERROR, \
- "zckCtx not opened for writing\n"); \
- return False; \
- }
+
/* If lead format changes, this needs to be changed */
int PUBLIC zck_get_min_download_size() {
return result;
}
-static char *ascii_checksum_to_bin (char *checksum) {
+static char *ascii_checksum_to_bin (zckCtx *zck, char *checksum) {
int cl = strlen(checksum);
char *raw_checksum = zmalloc(cl/2);
if(raw_checksum == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", cl/2);
+ set_error(zck, "Unable to allocate %lu bytes\n", cl/2);
return NULL;
}
char *rp = raw_checksum;
zck->buzhash_bitmask = s;
}
-int get_tmp_fd() {
+int get_tmp_fd(zckCtx *zck) {
+ VALIDATE_BOOL(zck);
+
int temp_fd;
char *fname = NULL;
char template[] = "zcktempXXXXXX";
}
fname = zmalloc(strlen(template) + strlen(tmpdir) + 2);
if(fname == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
- strlen(template) + strlen(tmpdir) + 2);
+ set_error(zck, "Unable to allocate %lu bytes\n",
+ strlen(template) + strlen(tmpdir) + 2);
return -1;
}
strncpy(fname, tmpdir, strlen(tmpdir));
temp_fd = mkstemp(fname);
if(temp_fd < 0) {
free(fname);
- zck_log(ZCK_LOG_ERROR, "Unable to create temporary file\n");
+ set_error(zck, "Unable to create temporary file\n");
return -1;
}
if(unlink(fname) < 0) {
free(fname);
- zck_log(ZCK_LOG_ERROR, "Unable to delete temporary file\n");
+ set_error(zck, "Unable to delete temporary file\n");
return -1;
}
free(fname);
}
int import_dict(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
size_t size = zck->index.first->length;
zck_log(ZCK_LOG_DEBUG, "Reading compression dict\n");
char *data = zmalloc(size);
if(data == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", size);
+ set_error(zck, "Unable to allocate %lu bytes\n", size);
return False;
}
if(comp_read(zck, data, size, 0) != size) {
- zck_log(ZCK_LOG_ERROR, "Error reading compressed dict\n");
+ set_error(zck, "Error reading compressed dict\n");
return False;
}
zck_log(ZCK_LOG_DEBUG, "Resetting compression\n");
int PUBLIC zck_set_soption(zckCtx *zck, zck_soption option, const char *value,
size_t length) {
+ VALIDATE_BOOL(zck);
char *data = zmalloc(length);
if(data == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", length);
+ set_error(zck, "Unable to allocate %lu bytes\n", length);
return False;
}
memcpy(data, value, length);
/* Validation options */
if(option == ZCK_VAL_HEADER_DIGEST) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
zckHashType chk_type = {0};
if(zck->prep_hash_type < 0) {
free(data);
- zck_log(ZCK_LOG_ERROR,
- "For validation, you must set the header hash type "
- "*before* the header digest itself\n");
+ set_error(zck, "For validation, you must set the header hash type "
+ "*before* the header digest itself\n");
return False;
}
- if(!hash_setup(&chk_type, zck->prep_hash_type)) {
+ if(!hash_setup(zck, &chk_type, zck->prep_hash_type)) {
free(data);
return False;
}
if(chk_type.digest_size*2 != length) {
free(data);
- zck_log(ZCK_LOG_ERROR, "Hash digest size mismatch for header "
- "validation\n"
- "Expected: %lu\nProvided: %lu\n", chk_type.digest_size*2,
- length);
+ set_fatal_error(zck, "Hash digest size mismatch for header "
+ "validation\n"
+ "Expected: %lu\nProvided: %lu\n",
+ chk_type.digest_size*2, length);
return False;
}
- zck_log(ZCK_LOG_DEBUG, "Setting expected hash to (%s)%s\n", zck_hash_name_from_type(zck->prep_hash_type), data);
- zck->prep_digest = ascii_checksum_to_bin(data);
+ zck_log(ZCK_LOG_DEBUG, "Setting expected hash to (%s)%s\n",
+ zck_hash_name_from_type(zck->prep_hash_type), data);
+ zck->prep_digest = ascii_checksum_to_bin(zck, data);
free(data);
/* Compression options */
} else if(option < 2000) {
- VALIDATE_WRITE(zck);
+ VALIDATE_WRITE_BOOL(zck);
return comp_soption(zck, option, data, length);
/* Unknown options */
} else {
free(data);
- zck_log(ZCK_LOG_ERROR, "Unknown string option %i\n", option);
+ set_error(zck, "Unknown string option %i\n", option);
return False;
}
return True;
}
int PUBLIC zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) {
+ VALIDATE_BOOL(zck);
+
/* Set hash type */
if(option == ZCK_HASH_FULL_TYPE) {
- VALIDATE_WRITE(zck);
+ VALIDATE_WRITE_BOOL(zck);
return set_full_hash_type(zck, value);
} else if(option == ZCK_HASH_CHUNK_TYPE) {
- VALIDATE_WRITE(zck);
+ VALIDATE_WRITE_BOOL(zck);
return set_chunk_hash_type(zck, value);
/* Validation options */
} else if(option == ZCK_VAL_HEADER_HASH_TYPE) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
if(value < 0) {
- zck_log(ZCK_LOG_ERROR,
- "Header hash type can't be less than zero: %li\n",
- value);
+ set_error(zck, "Header hash type can't be less than zero: %li\n",
+ value);
return False;
}
/* Make sure that header hash type is set before the header digest,
* otherwise we run the risk of a buffer overflow */
if(zck->prep_digest != NULL) {
- zck_log(ZCK_LOG_ERROR,
- "For validation, you must set the header hash type "
- "*before* the header digest itself\n");
+ set_error(zck, "For validation, you must set the header hash type "
+ "*before* the header digest itself\n");
return False;
}
zck->prep_hash_type = value;
} else if(option == ZCK_VAL_HEADER_LENGTH) {
- VALIDATE_READ(zck);
+ VALIDATE_READ_BOOL(zck);
if(value < 0) {
- zck_log(ZCK_LOG_ERROR,
- "Header size validation can't be less than zero: %li\n",
- value);
+ set_error(zck,
+ "Header size validation can't be less than zero: %li\n",
+ value);
return False;
}
zck->prep_hdr_size = value;
} else if(option == ZCK_MANUAL_CHUNK) {
- VALIDATE_WRITE(zck);
+ VALIDATE_WRITE_BOOL(zck);
if(value != 0) {
zck_log(ZCK_LOG_DEBUG, "Disabling automatic chunking\n");
zck->manual_chunk = 1;
/* Hash options */
} else if(option < 100) {
/* Currently no hash options other than setting hash type, so bail */
- zck_log(ZCK_LOG_ERROR, "Unknown option %lu\n", value);
+ set_error(zck, "Unknown option %lu\n", value);
return False;
/* Compression options */
} else if(option < 2000) {
- VALIDATE_WRITE(zck);
+ VALIDATE_WRITE_BOOL(zck);
return comp_ioption(zck, option, value);
/* Unknown options */
} else {
- zck_log(ZCK_LOG_ERROR, "Unknown integer option %i\n", option);
+ set_error(zck, "Unknown integer option %i\n", option);
return False;
}
return True;
}
int PUBLIC zck_close(zckCtx *zck) {
- VALIDATE(zck);
+ VALIDATE_BOOL(zck);
if(zck->mode == ZCK_MODE_WRITE) {
if(zck_end_chunk(zck) < 0)
}
void PUBLIC zck_free(zckCtx **zck) {
- if(*zck == NULL)
+ if(zck == NULL || *zck == NULL)
return;
zck_clear(*zck);
free(*zck);
zckCtx PUBLIC *zck_create() {
zckCtx *zck = zmalloc(sizeof(zckCtx));
if(zck == NULL) {
- zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
+ zck_log(ZCK_LOG_NONE, "Unable to allocate %lu bytes\n",
sizeof(zckCtx));
- return False;
+ return NULL;
}
zck->prep_hash_type = -1;
zck->prep_hdr_size = -1;
return zck;
}
-zckCtx PUBLIC *zck_init_adv_read (int src_fd) {
- zckCtx *zck = zck_create();
- if(zck == NULL)
- return NULL;
+int PUBLIC zck_init_adv_read (zckCtx *zck, int src_fd) {
+ VALIDATE_BOOL(zck);
zck->mode = ZCK_MODE_READ;
zck->fd = src_fd;
- return zck;
+ return True;
}
-zckCtx PUBLIC *zck_init_read (int src_fd) {
- zckCtx *zck = zck_init_adv_read(src_fd);
- if(zck == NULL)
- return NULL;
+int PUBLIC zck_init_read (zckCtx *zck, int src_fd) {
+ VALIDATE_BOOL(zck);
- if(!zck_read_lead(zck)) {
- zck_free(&zck);
- return NULL;
- }
- if(!zck_read_header(zck)) {
- zck_free(&zck);
- return NULL;
- }
+ if(!zck_init_adv_read(zck, src_fd))
+ return False;
- return zck;
+ if(!zck_read_lead(zck))
+ return False;
+
+ if(!zck_read_header(zck))
+ return False;
+
+ return True;
}
-zckCtx PUBLIC *zck_init_write (int dst_fd) {
- zckCtx *zck = zck_create();
- if(zck == NULL)
- return NULL;
+int PUBLIC zck_init_write (zckCtx *zck, int dst_fd) {
+ VALIDATE_BOOL(zck);
zck->mode = ZCK_MODE_WRITE;
- zck->temp_fd = get_tmp_fd();
+ zck->temp_fd = get_tmp_fd(zck);
if(zck->temp_fd < 0)
- goto iw_error;
+ return False;
/* Set defaults */
#ifdef ZCHUNK_ZSTD
if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_ZSTD))
- goto iw_error;
+ return False;
#else
if(!zck_set_ioption(zck, ZCK_COMP_TYPE, ZCK_COMP_NONE))
- goto iw_error;
+ return False;
#endif
if(!zck_set_ioption(zck, ZCK_HASH_FULL_TYPE, ZCK_HASH_SHA256))
- goto iw_error;
+ return False;
if(!zck_set_ioption(zck, ZCK_HASH_CHUNK_TYPE, ZCK_HASH_SHA512_128))
- goto iw_error;
+ return False;
zck->fd = dst_fd;
- return zck;
-iw_error:
- free(zck);
- return NULL;
+ return True;
}
int PUBLIC zck_get_fd(zckCtx *zck) {
+ VALIDATE_BOOL(zck);
return zck->fd;
}
-void PUBLIC zck_set_fd(zckCtx *zck, int fd) {
+int PUBLIC zck_set_fd(zckCtx *zck, int fd) {
+ VALIDATE_BOOL(zck);
zck->fd = fd;
- return;
+ return True;
}
#define zck_log(...) zck_log_wf(__func__, __VA_ARGS__)
-#define set_error(zck, ...) set_error_wf(zck, 0, __VA_ARGS__); \
- zck_log(__VA_ARGS__)
-#define set_fatal_error(zck, ...) set_error_wf(zck, 1, __VA_ARGS__); \
- zck_log(__VA_ARGS__)
-struct zckComp;
-
-typedef int (*finit)(struct zckComp *comp);
-typedef int (*fparam)(struct zckComp *comp, int option, const void *value);
-typedef int (*fccompend)(struct zckComp *comp, char **dst, size_t *dst_size,
- int use_dict);
-typedef ssize_t (*fcomp)(struct zckComp *comp, const char *src,
+#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 _VALIDATE_BOOL(f) if(!f) { \
+ zck_log(ZCK_LOG_NONE, \
+ "zckCtx not initialized\n"); \
+ return False; \
+ }
+#define _VALIDATE_TRI(f) if(!f) { \
+ zck_log(ZCK_LOG_NONE, \
+ "zckCtx not initialized\n"); \
+ return -1; \
+ }
+#define _VALIDATE_CHAR(f) if(!f) { \
+ zck_log(ZCK_LOG_NONE, \
+ "zckCtx not initialized\n"); \
+ return NULL; \
+ }
+#define VALIDATE_BOOL(f) _VALIDATE_BOOL(f) \
+ if((f)->error_state > 0) return False;
+#define VALIDATE_TRI(f) _VALIDATE_TRI(f) \
+ if((f)->error_state > 0) return -1;
+#define VALIDATE_CHAR(f) _VALIDATE_CHAR(f) \
+ if((f)->error_state > 0) return NULL;
+
+#define VALIDATE_READ_BOOL(f) VALIDATE_BOOL(f); \
+ if(f->mode != ZCK_MODE_READ) { \
+ set_error(f, \
+ "zckCtx not opened for reading\n"); \
+ return False; \
+ }
+#define VALIDATE_READ_TRI(f) VALIDATE_TRI(f); \
+ if(f->mode != ZCK_MODE_READ) { \
+ set_error(f, \
+ "zckCtx not opened for reading\n"); \
+ return -1; \
+ }
+#define VALIDATE_READ_CHAR(f) VALIDATE_CHAR(f); \
+ if(f->mode != ZCK_MODE_READ) { \
+ set_error(f, \
+ "zckCtx not opened for reading\n"); \
+ return NULL; \
+ }
+
+#define VALIDATE_WRITE_BOOL(f) VALIDATE_BOOL(f); \
+ if(f->mode != ZCK_MODE_WRITE) { \
+ set_error(f, \
+ "zckCtx not opened for writing\n"); \
+ return False; \
+ }
+#define VALIDATE_WRITE_TRI(f) VALIDATE_TRI(f); \
+ if(f->mode != ZCK_MODE_WRITE) { \
+ set_error(f, \
+ "zckCtx not opened for writing\n"); \
+ return -1; \
+ }
+#define VALIDATE_WRITE_CHAR(f) VALIDATE_CHAR(f); \
+ if(f->mode != ZCK_MODE_WRITE) { \
+ set_error(f, \
+ "zckCtx not opened for writing\n"); \
+ return NULL; \
+ }
+typedef struct zckComp zckComp;
+typedef zckCtx zckCtx;
+
+typedef int (*finit)(zckCtx *zck, zckComp *comp);
+typedef int (*fparam)(zckCtx *zck,zckComp *comp, int option, const void *value);
+typedef int (*fccompend)(zckCtx *zck, zckComp *comp, char **dst,
+ size_t *dst_size, int use_dict);
+typedef ssize_t (*fcomp)(zckCtx *zck, zckComp *comp, const char *src,
const size_t src_size, char **dst, size_t *dst_size,
int use_dict);
-typedef int (*fdecomp)(struct zckComp *comp, const int use_dict);
-typedef int (*fdcompend)(struct zckComp *comp, const int use_dict,
+typedef int (*fdecomp)(zckCtx *zck, zckComp *comp, const int use_dict);
+typedef int (*fdcompend)(zckCtx *zck, zckComp *comp, const int use_dict,
const size_t fd_size);
-typedef int (*fcclose)(struct zckComp *comp);
+typedef int (*fcclose)(zckCtx *zck, zckComp *comp);
typedef enum zck_log_type zck_log_type;
/* hash/hash.h */
-int hash_setup(zckHashType *ht, int h)
+int hash_setup(zckCtx *zck, zckHashType *ht, int h)
__attribute__ ((warn_unused_result));
-int hash_init(zckHash *hash, zckHashType *hash_type)
+int hash_init(zckCtx *zck, zckHash *hash, zckHashType *hash_type)
__attribute__ ((warn_unused_result));
-int hash_update(zckHash *hash, const char *message, const size_t size)
+int hash_update(zckCtx *zck, zckHash *hash, const char *message,
+ const size_t size)
__attribute__ ((warn_unused_result));
-char *hash_finalize(zckHash *hash)
+char *hash_finalize(zckCtx *zck, zckHash *hash)
__attribute__ ((warn_unused_result));
void hash_close(zckHash *hash);
void hash_reset(zckHashType *ht);
/* io.c */
-int seek_data(int fd, off_t offset, int whence)
+int seek_data(zckCtx *zck, off_t offset, int whence)
__attribute__ ((warn_unused_result));
-ssize_t tell_data(int fd)
+ssize_t tell_data(zckCtx *zck)
__attribute__ ((warn_unused_result));
-ssize_t read_data(int fd, char *data, size_t length)
+ssize_t read_data(zckCtx *zck, char *data, size_t length)
__attribute__ ((warn_unused_result));
-int write_data(int fd, const char *data, size_t length)
+int write_data(zckCtx *zck, int fd, const char *data, size_t length)
__attribute__ ((warn_unused_result));
int chunks_from_temp(zckCtx *zck)
__attribute__ ((warn_unused_result));
__attribute__ ((warn_unused_result));
int comp_reset(zckCtx *zck)
__attribute__ ((warn_unused_result));
-int comp_add_to_dc(zckComp *comp, const char *src, size_t src_size)
+int comp_add_to_dc(zckCtx *zck, zckComp *comp, const char *src, size_t src_size)
__attribute__ ((warn_unused_result));
ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict)
__attribute__ ((warn_unused_result));
__attribute__ ((warn_unused_result));
/* compint.c */
-int compint_from_int(char *compint, int val, size_t *length)
+int compint_from_int(zckCtx *zck, char *compint, int val, size_t *length)
__attribute__ ((warn_unused_result));
void compint_from_size(char *compint, size_t val, size_t *length);
-int compint_to_int(int *val, const char *compint, size_t *length,
+int compint_to_int(zckCtx *zck, int *val, const char *compint, size_t *length,
size_t max_length)
__attribute__ ((warn_unused_result));
-int compint_to_size(size_t *val, const char *compint, size_t *length,
- size_t max_length)
+int compint_to_size(zckCtx *zck, size_t *val, const char *compint,
+ size_t *length, size_t max_length)
__attribute__ ((warn_unused_result));
/* log.c */
+void zck_log_v(const char *function, zck_log_type lt, const char *format,
+ va_list args);
void zck_log_wf(const char *function, zck_log_type lt, const char *format, ...);
/* error.c */
-void set_error_wf(zckCtx *zck, int fatal, const char *format, ...);
+void set_error_wf(zckCtx *zck, int fatal, const char *function,
+ const char *format, ...);
#endif
int good_exit = False;
- zckCtx *zck = zck_init_read(src_fd);
+ zckCtx *zck = zck_create();
if(zck == NULL)
goto error1;
char *data = malloc(BUF_SIZE);
+ if(!zck_init_read(zck, src_fd))
+ goto error2;
+
size_t total = 0;
while(True) {
ssize_t read = zck_read(zck, data, BUF_SIZE);
good_exit = True;
error2:
free(data);
+ if(!good_exit)
+ printf(zck_get_error(zck));
zck_free(&zck);
error1:
if(!good_exit)
}
free(out_name);
- zckCtx *zck = zck_init_write(dst_fd);
+ zckCtx *zck = zck_create();
if(zck == NULL) {
+ printf("Unable to allocate zchunk context\n");
+ exit(1);
+ }
+ if(!zck_init_write(zck, dst_fd)) {
printf("Unable to write to %s\n", out_name);
exit(1);
}
exit(1);
}*/
if(dict_size > 0) {
- if(!zck_set_soption(zck, ZCK_COMP_DICT, dict, dict_size))
+ if(!zck_set_soption(zck, ZCK_COMP_DICT, dict, dict_size)) {
+ printf(zck_get_error(zck));
exit(1);
+ }
}
free(dict);
if(arguments.manual_chunk) {
- if(!zck_set_ioption(zck, ZCK_MANUAL_CHUNK, 1))
+ if(!zck_set_ioption(zck, ZCK_MANUAL_CHUNK, 1)) {
+ printf(zck_get_error(zck));
exit(1);
+ }
}
char *data;
}
/* Buzhash rolling window */
} else {
- if(zck_write(zck, data, in_size) < 0)
+ if(zck_write(zck, data, in_size) < 0) {
+ printf(zck_get_error(zck));
exit(1);
+ }
}
free(data);
}
- if(!zck_close(zck))
+ if(!zck_close(zck)) {
+ printf(zck_get_error(zck));
exit(1);
+ }
if(arguments.log_level <= ZCK_LOG_INFO) {
printf("Wrote %lu bytes in %lu chunks\n",
(unsigned long)(zck_get_data_length(zck) +
perror("");
exit(1);
}
- zckCtx *zck_src = zck_init_read(src_fd);
+ zckCtx *zck_src = zck_create();
if(zck_src == NULL) {
+ printf("Unable to create zchunk context\n");
+ exit(1);
+ }
+ if(!zck_init_read(zck_src, src_fd)) {
printf("Unable to read header from %s\n", arguments.args[0]);
exit(1);
}
perror("");
exit(1);
}
- zckCtx *zck_tgt = zck_init_read(tgt_fd);
+ zckCtx *zck_tgt = zck_create();
if(zck_tgt == NULL) {
+ printf("Unable to create zchunk context\n");
+ exit(1);
+ }
+ if(!zck_init_read(zck_tgt, tgt_fd)) {
printf("Unable to open %s\n", arguments.args[1]);
exit(1);
}
perror("");
exit(10);
}
- zck_src = zck_init_read(src_fd);
+ zck_src = zck_create();
if(zck_src == NULL) {
+ printf("Unable to create zchunk context\n");
+ exit(10);
+ }
+ if(!zck_init_read(zck_src, src_fd)) {
printf("Unable to open %s\n", arguments.source);
exit(10);
}
free(outname_full);
exit(10);
}
- zckCtx *zck_tgt = zck_init_adv_read(dst_fd);
- if(zck_tgt == NULL)
+ zckCtx *zck_tgt = zck_create();
+ if(zck_tgt == NULL) {
+ printf("Unable to create zchunk context\n");
exit(10);
+ }
+ if(!zck_init_adv_read(zck_tgt, dst_fd)) {
+ printf(zck_get_error(zck_tgt));
+ exit(10);
+ }
zckDL *dl = zck_dl_init(zck_tgt);
if(dl == NULL)
while(range_attempt[ra_index] > 1 &&
range_attempt[ra_index+1] > zck_get_range_count(range))
ra_index++;
- char *range_string = zck_get_range_char(range);
+ char *range_string = zck_get_range_char(zck_src, range);
if(range_string == NULL) {
+ printf(zck_get_error(zck_src));
exit_val = 10;
goto out;
}
perror("");
exit(1);
}
- zckCtx *zck = zck_init_read(src_fd);
+
+ zckCtx *zck = zck_create();
if(zck == NULL) {
+ printf("Unable to create zchunk context\n");
+ exit(1);
+ }
+ if(!zck_init_read(zck, src_fd)) {
+ printf(zck_get_error(zck));
printf("Unable to read zchunk header\n");
exit(1);
}
projects / zchunk.git / commitdiff