From 20f1d2ee7102955f8c906937fd0cdb4a184803df Mon Sep 17 00:00:00 2001 From: Wolf Vollprecht Date: Sat, 8 Jan 2022 15:25:40 +0100 Subject: [PATCH] unify order of ZCK_PUBLIC_API --- include/zck.h.in | 164 ++++++++++++++++++------------------- src/lib/dl/dl.c | 36 ++++---- src/lib/hash/hash.c | 24 +++--- src/lib/index/index_read.c | 30 +++---- src/lib/zck.c | 22 ++--- 5 files changed, 138 insertions(+), 138 deletions(-) diff --git a/include/zck.h.in b/include/zck.h.in index 0ca5c5f..0f9d03c 100644 --- a/include/zck.h.in +++ b/include/zck.h.in @@ -79,13 +79,13 @@ typedef size_t (*zck_wcb)(void *ptr, size_t l, size_t c, void *dl_v); * Reading a zchunk file *******************************************************************/ /* Initialize zchunk context */ -ZCK_PUBLIC_API zckCtx *zck_create(void) +zckCtx ZCK_PUBLIC_API *zck_create(void) ZCK_WARN_UNUSED; /* Initialize zchunk for reading */ -ZCK_PUBLIC_API bool zck_init_read (zckCtx *zck, int src_fd) +bool ZCK_PUBLIC_API zck_init_read (zckCtx *zck, int src_fd) ZCK_WARN_UNUSED; /* Decompress dst_size bytes from zchunk file to dst, while verifying hashes */ -ZCK_PUBLIC_API ssize_t zck_read(zckCtx *zck, char *dst, size_t dst_size) +ssize_t ZCK_PUBLIC_API zck_read(zckCtx *zck, char *dst, size_t dst_size) ZCK_WARN_UNUSED; @@ -93,40 +93,40 @@ ZCK_PUBLIC_API ssize_t zck_read(zckCtx *zck, char *dst, size_t dst_size) * Writing a zchunk file *******************************************************************/ /* Initialize zchunk for writing */ -ZCK_PUBLIC_API bool zck_init_write (zckCtx *zck, int dst_fd) +bool ZCK_PUBLIC_API zck_init_write (zckCtx *zck, int dst_fd) ZCK_WARN_UNUSED; /* Compress data src of size src_size, and write to zchunk file * Due to the nature of zchunk files and how they are built, no data will * actually appear in the zchunk file until zck_close() is called */ -ZCK_PUBLIC_API ssize_t zck_write(zckCtx *zck, const char *src, const size_t src_size) +ssize_t ZCK_PUBLIC_API zck_write(zckCtx *zck, const char *src, const size_t src_size) ZCK_WARN_UNUSED; /* Create a chunk boundary */ -ZCK_PUBLIC_API ssize_t zck_end_chunk(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_end_chunk(zckCtx *zck) ZCK_WARN_UNUSED; /* Create the database for uthash if not present (done automatically by read */ -ZCK_PUBLIC_API bool zck_generate_hashdb(zckCtx *zck); +bool ZCK_PUBLIC_API zck_generate_hashdb(zckCtx *zck); /******************************************************************* * Common functions for finishing a zchunk file *******************************************************************/ /* Close a zchunk file so it may no longer be read from or written to. The * context still contains information about the file */ -ZCK_PUBLIC_API bool zck_close(zckCtx *zck) +bool ZCK_PUBLIC_API zck_close(zckCtx *zck) ZCK_WARN_UNUSED; /* Free a zchunk context. You must pass the address of the context, and the * context will automatically be set to NULL after it is freed */ -ZCK_PUBLIC_API void zck_free(zckCtx **zck); +void ZCK_PUBLIC_API zck_free(zckCtx **zck); /******************************************************************* * Options *******************************************************************/ /* Set string option */ -ZCK_PUBLIC_API bool zck_set_soption(zckCtx *zck, zck_soption option, const char *value, +bool ZCK_PUBLIC_API zck_set_soption(zckCtx *zck, zck_soption option, const char *value, size_t length) ZCK_WARN_UNUSED; /* Set integer option */ -ZCK_PUBLIC_API bool zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) +bool ZCK_PUBLIC_API zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) ZCK_WARN_UNUSED; @@ -134,66 +134,66 @@ ZCK_PUBLIC_API bool zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t val * Error handling *******************************************************************/ /* Set logging level */ -ZCK_PUBLIC_API void zck_set_log_level(zck_log_type ll); +void ZCK_PUBLIC_API zck_set_log_level(zck_log_type ll); /* Set logging fd */ -ZCK_PUBLIC_API void zck_set_log_fd(int fd); +void ZCK_PUBLIC_API zck_set_log_fd(int fd); /* Check whether zck is in error state * Returns 0 if not, 1 if recoverable error, 2 if fatal error */ -ZCK_PUBLIC_API int zck_is_error(zckCtx *zck) +int ZCK_PUBLIC_API zck_is_error(zckCtx *zck) ZCK_WARN_UNUSED; /* Get error message * Returns char* containing error message. char* will contain empty string if * there is no error message */ -ZCK_PUBLIC_API const char *zck_get_error(zckCtx *zck); +const ZCK_PUBLIC_API char *zck_get_error(zckCtx *zck); /* Clear error message * Returns 1 if message was cleared, 0 if error is fatal and can't be cleared */ -ZCK_PUBLIC_API bool zck_clear_error(zckCtx *zck); +bool ZCK_PUBLIC_API zck_clear_error(zckCtx *zck); /* Set a callback for logs instead to write into a fd */ typedef void (*logcallback)(const char *function, zck_log_type lt, const char *format, va_list args); -ZCK_PUBLIC_API void zck_set_log_callback(logcallback function); +void ZCK_PUBLIC_API zck_set_log_callback(logcallback function); /******************************************************************* * Miscellaneous utilities *******************************************************************/ /* Validate the chunk and data checksums for the current file. * Returns 0 for error, -1 for invalid checksum and 1 for valid checksum */ -ZCK_PUBLIC_API int zck_validate_checksums(zckCtx *zck) +int ZCK_PUBLIC_API zck_validate_checksums(zckCtx *zck) ZCK_WARN_UNUSED; /* Validate just the data checksum for the current file * Returns 0 for error, -1 for invalid checksum and 1 for valid checksum */ -ZCK_PUBLIC_API int zck_validate_data_checksum(zckCtx *zck) +int ZCK_PUBLIC_API zck_validate_data_checksum(zckCtx *zck) ZCK_WARN_UNUSED; /* Go through file and mark valid chunks as valid * Returns 0 for error, -1 for invalid checksum and 1 for valid checksum */ -ZCK_PUBLIC_API int zck_find_valid_chunks(zckCtx *zck) +int ZCK_PUBLIC_API zck_find_valid_chunks(zckCtx *zck) ZCK_WARN_UNUSED; /* Get a zckRange of ranges that need to still be downloaded. * max_ranges is the maximum number of ranges supported in a single request * by the server. If the server supports unlimited ranges, set this to -1 * Returns NULL if there's an error */ -ZCK_PUBLIC_API zckRange *zck_get_missing_range(zckCtx *zck, int max_ranges) +zckRange ZCK_PUBLIC_API *zck_get_missing_range(zckCtx *zck, int max_ranges) ZCK_WARN_UNUSED; /* Get a string representation of a zckRange */ -ZCK_PUBLIC_API char *zck_get_range_char(zckCtx *zck, zckRange *range) +char ZCK_PUBLIC_API *zck_get_range_char(zckCtx *zck, zckRange *range) ZCK_WARN_UNUSED; /* Get file descriptor attached to zchunk context */ -ZCK_PUBLIC_API int zck_get_fd(zckCtx *zck) +int ZCK_PUBLIC_API zck_get_fd(zckCtx *zck) ZCK_WARN_UNUSED; /* Set file descriptor attached to zchunk context */ -ZCK_PUBLIC_API bool zck_set_fd(zckCtx *zck, int fd) +bool ZCK_PUBLIC_API zck_set_fd(zckCtx *zck, int fd) ZCK_WARN_UNUSED; /* Return number of missing chunks (-1 if error) */ -ZCK_PUBLIC_API int zck_missing_chunks(zckCtx *zck) +int ZCK_PUBLIC_API zck_missing_chunks(zckCtx *zck) ZCK_WARN_UNUSED; /* Return number of failed chunks (-1 if error) */ -ZCK_PUBLIC_API int zck_failed_chunks(zckCtx *zck) +int ZCK_PUBLIC_API zck_failed_chunks(zckCtx *zck) ZCK_WARN_UNUSED; /* Reset failed chunks to become missing */ -ZCK_PUBLIC_API void zck_reset_failed_chunks(zckCtx *zck); +void ZCK_PUBLIC_API zck_reset_failed_chunks(zckCtx *zck); /* Find chunks from a source */ -ZCK_PUBLIC_API bool zck_find_matching_chunks(zckCtx *src, zckCtx *tgt); +bool ZCK_PUBLIC_API zck_find_matching_chunks(zckCtx *src, zckCtx *tgt); /******************************************************************* * The functions should be all you need to read and write a zchunk @@ -206,22 +206,22 @@ ZCK_PUBLIC_API bool zck_find_matching_chunks(zckCtx *src, zckCtx *tgt); * Advanced miscellaneous zchunk functions *******************************************************************/ /* Get lead length */ -ZCK_PUBLIC_API ssize_t zck_get_lead_length(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_lead_length(zckCtx *zck) ZCK_WARN_UNUSED; /* Get header length (lead + preface + index + sigs) */ -ZCK_PUBLIC_API ssize_t zck_get_header_length(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_header_length(zckCtx *zck) ZCK_WARN_UNUSED; /* Get data length */ -ZCK_PUBLIC_API ssize_t zck_get_data_length(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_data_length(zckCtx *zck) ZCK_WARN_UNUSED; /* Get file length */ -ZCK_PUBLIC_API ssize_t zck_get_length(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_length(zckCtx *zck) ZCK_WARN_UNUSED; /* Get index digest */ -ZCK_PUBLIC_API char *zck_get_header_digest(zckCtx *zck) +char ZCK_PUBLIC_API *zck_get_header_digest(zckCtx *zck) ZCK_WARN_UNUSED; /* Get data digest */ -ZCK_PUBLIC_API char *zck_get_data_digest(zckCtx *zck) +char ZCK_PUBLIC_API *zck_get_data_digest(zckCtx *zck) ZCK_WARN_UNUSED; @@ -229,7 +229,7 @@ ZCK_PUBLIC_API char *zck_get_data_digest(zckCtx *zck) * Advanced compression functions *******************************************************************/ /* Get name of compression type */ -ZCK_PUBLIC_API const char *zck_comp_name_from_type(int comp_type) +const ZCK_PUBLIC_API char *zck_comp_name_from_type(int comp_type) ZCK_WARN_UNUSED; /* Initialize compression. Compression type and parameters *must* be done * before this is called */ @@ -239,84 +239,84 @@ ZCK_PUBLIC_API const char *zck_comp_name_from_type(int comp_type) * Advanced zchunk reading functions *******************************************************************/ /* Initialize zchunk for reading using advanced options */ -ZCK_PUBLIC_API bool zck_init_adv_read (zckCtx *zck, int src_fd) +bool ZCK_PUBLIC_API zck_init_adv_read (zckCtx *zck, int src_fd) ZCK_WARN_UNUSED; /* Read zchunk lead */ -ZCK_PUBLIC_API bool zck_read_lead(zckCtx *zck) +bool ZCK_PUBLIC_API zck_read_lead(zckCtx *zck) ZCK_WARN_UNUSED; /* Read zchunk header */ -ZCK_PUBLIC_API bool zck_read_header(zckCtx *zck) +bool ZCK_PUBLIC_API zck_read_header(zckCtx *zck) ZCK_WARN_UNUSED; /* Validate lead */ -ZCK_PUBLIC_API bool zck_validate_lead(zckCtx *zck) +bool ZCK_PUBLIC_API zck_validate_lead(zckCtx *zck) ZCK_WARN_UNUSED; /******************************************************************* * Indexes *******************************************************************/ /* Get chunk count */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_count(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_chunk_count(zckCtx *zck) ZCK_WARN_UNUSED; /* Get chunk by number */ -ZCK_PUBLIC_API zckChunk *zck_get_chunk(zckCtx *zck, size_t number) +zckChunk ZCK_PUBLIC_API *zck_get_chunk(zckCtx *zck, size_t number) ZCK_WARN_UNUSED; /* Get first chunk */ -ZCK_PUBLIC_API zckChunk *zck_get_first_chunk(zckCtx *zck) +zckChunk ZCK_PUBLIC_API *zck_get_first_chunk(zckCtx *zck) ZCK_WARN_UNUSED; /* Get next chunk */ -ZCK_PUBLIC_API zckChunk *zck_get_next_chunk(zckChunk *idx) +zckChunk ZCK_PUBLIC_API *zck_get_next_chunk(zckChunk *idx) ZCK_WARN_UNUSED; /* Get chunk starting location */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_start(zckChunk *idx) +ssize_t ZCK_PUBLIC_API zck_get_chunk_start(zckChunk *idx) ZCK_WARN_UNUSED; /* Get uncompressed chunk size */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_size(zckChunk *idx) +ssize_t ZCK_PUBLIC_API zck_get_chunk_size(zckChunk *idx) ZCK_WARN_UNUSED; /* Get compressed chunk size */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_comp_size(zckChunk *idx) +ssize_t ZCK_PUBLIC_API zck_get_chunk_comp_size(zckChunk *idx) ZCK_WARN_UNUSED; /* Get chunk number */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_number(zckChunk *idx) +ssize_t ZCK_PUBLIC_API zck_get_chunk_number(zckChunk *idx) ZCK_WARN_UNUSED; /* Get validity of current chunk - 1 = valid, 0 = missing, -1 = invalid */ -ZCK_PUBLIC_API int zck_get_chunk_valid(zckChunk *idx) +int ZCK_PUBLIC_API zck_get_chunk_valid(zckChunk *idx) ZCK_WARN_UNUSED; /* Get chunk digest */ -ZCK_PUBLIC_API char *zck_get_chunk_digest(zckChunk *item) +char ZCK_PUBLIC_API *zck_get_chunk_digest(zckChunk *item) ZCK_WARN_UNUSED; /* Get digest size of chunk hash type */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_digest_size(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_chunk_digest_size(zckCtx *zck) ZCK_WARN_UNUSED; /* Get uncompressed chunk digest */ -ZCK_PUBLIC_API char *zck_get_chunk_digest_uncompressed(zckChunk *item) +char ZCK_PUBLIC_API *zck_get_chunk_digest_uncompressed(zckChunk *item) ZCK_WARN_UNUSED; /* Get chunk data */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_data(zckChunk *idx, char *dst, size_t dst_size) +ssize_t ZCK_PUBLIC_API zck_get_chunk_data(zckChunk *idx, char *dst, size_t dst_size) ZCK_WARN_UNUSED; /* Get compressed chunk data */ -ZCK_PUBLIC_API ssize_t zck_get_chunk_comp_data(zckChunk *idx, char *dst, size_t dst_size) +ssize_t ZCK_PUBLIC_API zck_get_chunk_comp_data(zckChunk *idx, char *dst, size_t dst_size) ZCK_WARN_UNUSED; /* Find out if two chunk digests are the same */ -ZCK_PUBLIC_API bool zck_compare_chunk_digest(zckChunk *a, zckChunk *b) +bool ZCK_PUBLIC_API zck_compare_chunk_digest(zckChunk *a, zckChunk *b) ZCK_WARN_UNUSED; /* Get associate src chunk if any */ -ZCK_PUBLIC_API zckChunk *zck_get_src_chunk(zckChunk *idx) +zckChunk ZCK_PUBLIC_API *zck_get_src_chunk(zckChunk *idx) ZCK_WARN_UNUSED; /******************************************************************* * Advanced hash functions *******************************************************************/ /* Get overall hash type */ -ZCK_PUBLIC_API int zck_get_full_hash_type(zckCtx *zck) +int ZCK_PUBLIC_API zck_get_full_hash_type(zckCtx *zck) ZCK_WARN_UNUSED; /* Get digest size of overall hash type */ -ZCK_PUBLIC_API ssize_t zck_get_full_digest_size(zckCtx *zck) +ssize_t ZCK_PUBLIC_API zck_get_full_digest_size(zckCtx *zck) ZCK_WARN_UNUSED; /* Get chunk hash type */ -ZCK_PUBLIC_API int zck_get_chunk_hash_type(zckCtx *zck) +int ZCK_PUBLIC_API zck_get_chunk_hash_type(zckCtx *zck) ZCK_WARN_UNUSED; /* Get name of hash type */ -ZCK_PUBLIC_API const char *zck_hash_name_from_type(int hash_type) +const ZCK_PUBLIC_API char *zck_hash_name_from_type(int hash_type) ZCK_WARN_UNUSED; @@ -329,74 +329,74 @@ ZCK_PUBLIC_API const char *zck_hash_name_from_type(int hash_type) * Ranges *******************************************************************/ /* Get any matching chunks from src and put them in the right place in tgt */ -ZCK_PUBLIC_API bool zck_copy_chunks(zckCtx *src, zckCtx *tgt) +bool ZCK_PUBLIC_API zck_copy_chunks(zckCtx *src, zckCtx *tgt) ZCK_WARN_UNUSED; /* Free zckRange */ -ZCK_PUBLIC_API void zck_range_free(zckRange **info); +void ZCK_PUBLIC_API zck_range_free(zckRange **info); /* Get range string from start and end location */ -ZCK_PUBLIC_API char *zck_get_range(size_t start, size_t end) +char ZCK_PUBLIC_API *zck_get_range(size_t start, size_t end) ZCK_WARN_UNUSED; /* Get the minimum size needed to download in order to know how large the header * is */ -ZCK_PUBLIC_API int zck_get_min_download_size(void) +int ZCK_PUBLIC_API zck_get_min_download_size(void) ZCK_WARN_UNUSED; /* Get the number of separate range items in the range */ -ZCK_PUBLIC_API int zck_get_range_count(zckRange *range) +int ZCK_PUBLIC_API zck_get_range_count(zckRange *range) ZCK_WARN_UNUSED; /******************************************************************* * Downloading *******************************************************************/ /* Initialize zchunk download context */ -ZCK_PUBLIC_API zckDL *zck_dl_init(zckCtx *zck) +zckDL ZCK_PUBLIC_API *zck_dl_init(zckCtx *zck) ZCK_WARN_UNUSED; /* Reset zchunk download context for reuse */ -ZCK_PUBLIC_API void zck_dl_reset(zckDL *dl); +void ZCK_PUBLIC_API zck_dl_reset(zckDL *dl); /* Free zchunk download context */ -ZCK_PUBLIC_API void zck_dl_free(zckDL **dl); +void ZCK_PUBLIC_API zck_dl_free(zckDL **dl); /* Get zchunk context from download context */ -ZCK_PUBLIC_API zckCtx *zck_dl_get_zck(zckDL *dl) +zckCtx ZCK_PUBLIC_API *zck_dl_get_zck(zckDL *dl) ZCK_WARN_UNUSED; /* Set zchunk context in download context */ -ZCK_PUBLIC_API bool zck_dl_set_zck(zckDL *dl, zckCtx *zck) +bool ZCK_PUBLIC_API zck_dl_set_zck(zckDL *dl, zckCtx *zck) ZCK_WARN_UNUSED; /* Clear regex used for extracting download ranges from multipart download */ -ZCK_PUBLIC_API void zck_dl_clear_regex(zckDL *dl); +void ZCK_PUBLIC_API zck_dl_clear_regex(zckDL *dl); /* Download and process the header from url */ -ZCK_PUBLIC_API bool zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) +bool ZCK_PUBLIC_API zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) ZCK_WARN_UNUSED; /* Get number of bytes downloaded using download context */ -ZCK_PUBLIC_API ssize_t zck_dl_get_bytes_downloaded(zckDL *dl) +ssize_t ZCK_PUBLIC_API zck_dl_get_bytes_downloaded(zckDL *dl) ZCK_WARN_UNUSED; /* Get number of bytes uploaded using download context */ -ZCK_PUBLIC_API ssize_t zck_dl_get_bytes_uploaded(zckDL *dl) +ssize_t ZCK_PUBLIC_API zck_dl_get_bytes_uploaded(zckDL *dl) ZCK_WARN_UNUSED; /* Set download ranges for zchunk download context */ -ZCK_PUBLIC_API bool zck_dl_set_range(zckDL *dl, zckRange *range) +bool ZCK_PUBLIC_API zck_dl_set_range(zckDL *dl, zckRange *range) ZCK_WARN_UNUSED; /* Get download ranges from zchunk download context */ -ZCK_PUBLIC_API zckRange *zck_dl_get_range(zckDL *dl) +zckRange ZCK_PUBLIC_API *zck_dl_get_range(zckDL *dl) ZCK_WARN_UNUSED; /* Set header callback function */ -ZCK_PUBLIC_API bool zck_dl_set_header_cb(zckDL *dl, zck_wcb func) +bool ZCK_PUBLIC_API zck_dl_set_header_cb(zckDL *dl, zck_wcb func) ZCK_WARN_UNUSED; /* Set header userdata */ -ZCK_PUBLIC_API bool zck_dl_set_header_data(zckDL *dl, void *data) +bool ZCK_PUBLIC_API zck_dl_set_header_data(zckDL *dl, void *data) ZCK_WARN_UNUSED; /* Set write callback function */ -ZCK_PUBLIC_API bool zck_dl_set_write_cb(zckDL *dl, zck_wcb func) +bool ZCK_PUBLIC_API zck_dl_set_write_cb(zckDL *dl, zck_wcb func) ZCK_WARN_UNUSED; /* Set write userdata */ -ZCK_PUBLIC_API bool zck_dl_set_write_data(zckDL *dl, void *data) +bool ZCK_PUBLIC_API zck_dl_set_write_data(zckDL *dl, void *data) ZCK_WARN_UNUSED; /* Write callback. You *must* pass this and your initialized zchunk download * context to the downloader when downloading a zchunk file. If you have your * own callback, set dl->write_cb to your callback and dl->wdata to your * callback data. */ -ZCK_PUBLIC_API size_t zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v); -ZCK_PUBLIC_API size_t zck_write_zck_header_cb(void *ptr, size_t l, size_t c, void *dl_v); -ZCK_PUBLIC_API size_t zck_header_cb(char *b, size_t l, size_t c, void *dl_v); +size_t ZCK_PUBLIC_API zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v); +size_t ZCK_PUBLIC_API zck_write_zck_header_cb(void *ptr, size_t l, size_t c, void *dl_v); +size_t ZCK_PUBLIC_API zck_header_cb(char *b, size_t l, size_t c, void *dl_v); #endif diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c index db8d0d3..b27960f 100644 --- a/src/lib/dl/dl.c +++ b/src/lib/dl/dl.c @@ -232,7 +232,7 @@ int dl_write_range(zckDL *dl, const char *at, size_t length) { return wb + wb2; } -ZCK_PUBLIC_API bool zck_copy_chunks(zckCtx *src, zckCtx *tgt) { +bool ZCK_PUBLIC_API zck_copy_chunks(zckCtx *src, zckCtx *tgt) { VALIDATE_READ_BOOL(src); VALIDATE_READ_BOOL(tgt); @@ -256,7 +256,7 @@ ZCK_PUBLIC_API bool zck_copy_chunks(zckCtx *src, zckCtx *tgt) { return true; } -ZCK_PUBLIC_API bool zck_find_matching_chunks(zckCtx *src, zckCtx *tgt) { +bool ZCK_PUBLIC_API zck_find_matching_chunks(zckCtx *src, zckCtx *tgt) { if (!src || !tgt) return false; @@ -297,20 +297,20 @@ ZCK_PUBLIC_API bool zck_find_matching_chunks(zckCtx *src, zckCtx *tgt) { return true; } -ZCK_PUBLIC_API ssize_t zck_dl_get_bytes_downloaded(zckDL *dl) { +ssize_t ZCK_PUBLIC_API zck_dl_get_bytes_downloaded(zckDL *dl) { ALLOCD_INT(NULL, dl); return dl->dl; } -ZCK_PUBLIC_API ssize_t zck_dl_get_bytes_uploaded(zckDL *dl) { +ssize_t ZCK_PUBLIC_API zck_dl_get_bytes_uploaded(zckDL *dl) { ALLOCD_INT(NULL, dl); return dl->ul; } /* Initialize zckDL. When finished, zckDL *must* be freed by zck_dl_free() */ -ZCK_PUBLIC_API zckDL *zck_dl_init(zckCtx *zck) { +zckDL ZCK_PUBLIC_API *zck_dl_init(zckCtx *zck) { zckDL *dl = zmalloc(sizeof(zckDL)); if (!dl) { zck_log(ZCK_LOG_ERROR, "OOM in %s", __func__); @@ -322,7 +322,7 @@ ZCK_PUBLIC_API zckDL *zck_dl_init(zckCtx *zck) { } /* Reset dl while maintaining download statistics and private information */ -ZCK_PUBLIC_API void zck_dl_reset(zckDL *dl) { +void ZCK_PUBLIC_API zck_dl_reset(zckDL *dl) { if(!dl) return; @@ -345,7 +345,7 @@ ZCK_PUBLIC_API void zck_dl_reset(zckDL *dl) { } /* Free zckDL and set pointer to NULL */ -ZCK_PUBLIC_API void zck_dl_free(zckDL **dl) { +void ZCK_PUBLIC_API zck_dl_free(zckDL **dl) { zck_dl_reset(*dl); if((*dl)->mp) free((*dl)->mp); @@ -353,53 +353,53 @@ ZCK_PUBLIC_API void zck_dl_free(zckDL **dl) { *dl = NULL; } -ZCK_PUBLIC_API zckCtx *zck_dl_get_zck(zckDL *dl) { +zckCtx ZCK_PUBLIC_API *zck_dl_get_zck(zckDL *dl) { ALLOCD_PTR(NULL, dl); return dl->zck; } -ZCK_PUBLIC_API bool zck_dl_set_zck(zckDL *dl, zckCtx *zck) { +bool ZCK_PUBLIC_API zck_dl_set_zck(zckDL *dl, zckCtx *zck) { ALLOCD_BOOL(NULL, dl); dl->zck = zck; return true; } -ZCK_PUBLIC_API bool zck_dl_set_range(zckDL *dl, zckRange *range) { +bool ZCK_PUBLIC_API zck_dl_set_range(zckDL *dl, zckRange *range) { ALLOCD_BOOL(NULL, dl); dl->range = range; return true; } -ZCK_PUBLIC_API zckRange *zck_dl_get_range(zckDL *dl) { +zckRange ZCK_PUBLIC_API *zck_dl_get_range(zckDL *dl) { ALLOCD_PTR(NULL, dl); return dl->range; } -ZCK_PUBLIC_API bool zck_dl_set_header_cb(zckDL *dl, zck_wcb func) { +bool ZCK_PUBLIC_API zck_dl_set_header_cb(zckDL *dl, zck_wcb func) { ALLOCD_BOOL(NULL, dl); dl->header_cb = func; return true; } -ZCK_PUBLIC_API bool zck_dl_set_header_data(zckDL *dl, void *data) { +bool ZCK_PUBLIC_API zck_dl_set_header_data(zckDL *dl, void *data) { ALLOCD_BOOL(NULL, dl); dl->header_data = data; return true; } -ZCK_PUBLIC_API bool zck_dl_set_write_cb(zckDL *dl, zck_wcb func) { +bool ZCK_PUBLIC_API zck_dl_set_write_cb(zckDL *dl, zck_wcb func) { ALLOCD_BOOL(NULL, dl); dl->write_cb = func; return true; } -ZCK_PUBLIC_API bool zck_dl_set_write_data(zckDL *dl, void *data) { +bool ZCK_PUBLIC_API zck_dl_set_write_data(zckDL *dl, void *data) { ALLOCD_BOOL(NULL, dl); dl->write_data = data; @@ -410,7 +410,7 @@ ZCK_PUBLIC_API bool zck_dl_set_write_data(zckDL *dl, void *data) { * Callbacks *******************************************************************/ -ZCK_PUBLIC_API size_t zck_header_cb(char *b, size_t l, size_t c, void *dl_v) { +size_t ZCK_PUBLIC_API zck_header_cb(char *b, size_t l, size_t c, void *dl_v) { ALLOCD_BOOL(NULL, dl_v); zckDL *dl = (zckDL*)dl_v; @@ -422,7 +422,7 @@ ZCK_PUBLIC_API size_t zck_header_cb(char *b, size_t l, size_t c, void *dl_v) { return c*l; } -ZCK_PUBLIC_API size_t zck_write_zck_header_cb(void *ptr, size_t l, size_t c, +size_t ZCK_PUBLIC_API zck_write_zck_header_cb(void *ptr, size_t l, size_t c, void *dl_v) { ALLOCD_BOOL(NULL, dl_v); zckDL *dl = (zckDL*)dl_v; @@ -437,7 +437,7 @@ ZCK_PUBLIC_API size_t zck_write_zck_header_cb(void *ptr, size_t l, size_t c, return wb; } -ZCK_PUBLIC_API size_t zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v) { +size_t ZCK_PUBLIC_API zck_write_chunk_cb(void *ptr, size_t l, size_t c, void *dl_v) { ALLOCD_BOOL(NULL, dl_v); zckDL *dl = (zckDL*)dl_v; diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c index 699c2bb..01a1059 100644 --- a/src/lib/hash/hash.c +++ b/src/lib/hash/hash.c @@ -463,7 +463,7 @@ int validate_header(zckCtx *zck) { } /* Returns 1 if data hash matches, -1 if it doesn't and 0 if error */ -ZCK_PUBLIC_API int zck_validate_data_checksum(zckCtx *zck) { +int ZCK_PUBLIC_API zck_validate_data_checksum(zckCtx *zck) { VALIDATE_READ_BOOL(zck); if(!seek_data(zck, zck->data_offset, SEEK_SET)) @@ -495,7 +495,7 @@ ZCK_PUBLIC_API int zck_validate_data_checksum(zckCtx *zck) { return ret; } -ZCK_PUBLIC_API const char *zck_hash_name_from_type(int hash_type) { +const ZCK_PUBLIC_API char *zck_hash_name_from_type(int hash_type) { if(hash_type >= ZCK_HASH_UNKNOWN || hash_type < 0) { snprintf(unknown+8, 21, "%i)", hash_type); return unknown; @@ -503,49 +503,49 @@ ZCK_PUBLIC_API const char *zck_hash_name_from_type(int hash_type) { return HASH_NAME[hash_type]; } -ZCK_PUBLIC_API int zck_get_full_hash_type(zckCtx *zck) { +int ZCK_PUBLIC_API zck_get_full_hash_type(zckCtx *zck) { VALIDATE_INT(zck); return zck->hash_type.type; } -ZCK_PUBLIC_API ssize_t zck_get_full_digest_size(zckCtx *zck) { +ssize_t ZCK_PUBLIC_API zck_get_full_digest_size(zckCtx *zck) { VALIDATE_INT(zck); return zck->hash_type.digest_size; } -ZCK_PUBLIC_API int zck_get_chunk_hash_type(zckCtx *zck) { +int ZCK_PUBLIC_API zck_get_chunk_hash_type(zckCtx *zck) { VALIDATE_INT(zck); return zck->index.hash_type; } -ZCK_PUBLIC_API ssize_t zck_get_chunk_digest_size(zckCtx *zck) { +ssize_t ZCK_PUBLIC_API zck_get_chunk_digest_size(zckCtx *zck) { VALIDATE_INT(zck); return zck->index.digest_size; } -ZCK_PUBLIC_API char *zck_get_header_digest(zckCtx *zck) { +char ZCK_PUBLIC_API *zck_get_header_digest(zckCtx *zck) { VALIDATE_PTR(zck); return get_digest_string(zck->header_digest, zck->hash_type.digest_size); } -ZCK_PUBLIC_API char *zck_get_data_digest(zckCtx *zck) { +char ZCK_PUBLIC_API *zck_get_data_digest(zckCtx *zck) { VALIDATE_PTR(zck); return get_digest_string(zck->full_hash_digest, zck->hash_type.digest_size); } -ZCK_PUBLIC_API char *zck_get_chunk_digest(zckChunk *item) { +char ZCK_PUBLIC_API *zck_get_chunk_digest(zckChunk *item) { if(item == NULL) return NULL; return get_digest_string(item->digest, item->digest_size); } -ZCK_PUBLIC_API char *zck_get_chunk_digest_uncompressed(zckChunk *item) { +char ZCK_PUBLIC_API *zck_get_chunk_digest_uncompressed(zckChunk *item) { if(item == NULL || !item->zck->has_uncompressed_source) return NULL; return get_digest_string(item->digest_uncompressed, item->digest_size); @@ -553,14 +553,14 @@ ZCK_PUBLIC_API char *zck_get_chunk_digest_uncompressed(zckChunk *item) { /* Returns 1 if all chunks are valid, -1 if even one isn't and 0 if error */ -ZCK_PUBLIC_API int zck_find_valid_chunks(zckCtx *zck) { +int ZCK_PUBLIC_API 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 */ -ZCK_PUBLIC_API int zck_validate_checksums(zckCtx *zck) { +int ZCK_PUBLIC_API zck_validate_checksums(zckCtx *zck) { VALIDATE_READ_BOOL(zck); return validate_checksums(zck, ZCK_LOG_WARNING); diff --git a/src/lib/index/index_read.c b/src/lib/index/index_read.c index ce2ad08..22593b0 100644 --- a/src/lib/index/index_read.c +++ b/src/lib/index/index_read.c @@ -151,13 +151,13 @@ bool index_read(zckCtx *zck, char *data, size_t size, size_t max_length) { return true; } -ZCK_PUBLIC_API ssize_t zck_get_chunk_count(zckCtx *zck) { +ssize_t ZCK_PUBLIC_API zck_get_chunk_count(zckCtx *zck) { VALIDATE_INT(zck); return zck->index.count; } -ZCK_PUBLIC_API zckChunk *zck_get_chunk(zckCtx *zck, size_t number) { +zckChunk ZCK_PUBLIC_API *zck_get_chunk(zckCtx *zck, size_t number) { VALIDATE_PTR(zck); for(zckChunk *idx=zck->index.first; idx!=NULL; idx=idx->next) { @@ -168,13 +168,13 @@ ZCK_PUBLIC_API zckChunk *zck_get_chunk(zckCtx *zck, size_t number) { return NULL; } -ZCK_PUBLIC_API zckChunk *zck_get_first_chunk(zckCtx *zck) { +zckChunk ZCK_PUBLIC_API *zck_get_first_chunk(zckCtx *zck) { VALIDATE_PTR(zck); return zck->index.first; } -ZCK_PUBLIC_API zckChunk *zck_get_next_chunk(zckChunk *idx) { +zckChunk ZCK_PUBLIC_API *zck_get_next_chunk(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_PTR(idx->zck); ALLOCD_PTR(idx->zck, idx); @@ -185,7 +185,7 @@ ZCK_PUBLIC_API zckChunk *zck_get_next_chunk(zckChunk *idx) { return idx->next; } -ZCK_PUBLIC_API zckChunk *zck_get_src_chunk(zckChunk *idx) { +zckChunk ZCK_PUBLIC_API *zck_get_src_chunk(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_PTR(idx->zck); ALLOCD_PTR(idx->zck, idx); @@ -196,7 +196,7 @@ ZCK_PUBLIC_API zckChunk *zck_get_src_chunk(zckChunk *idx) { return idx->src; } -ZCK_PUBLIC_API ssize_t zck_get_chunk_start(zckChunk *idx) { +ssize_t ZCK_PUBLIC_API zck_get_chunk_start(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_INT(idx->zck); ALLOCD_INT(idx->zck, idx); @@ -210,7 +210,7 @@ ZCK_PUBLIC_API ssize_t zck_get_chunk_start(zckChunk *idx) { return idx->start; } -ZCK_PUBLIC_API ssize_t zck_get_chunk_size(zckChunk *idx) { +ssize_t ZCK_PUBLIC_API zck_get_chunk_size(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_INT(idx->zck); ALLOCD_INT(idx->zck, idx); @@ -221,7 +221,7 @@ ZCK_PUBLIC_API ssize_t zck_get_chunk_size(zckChunk *idx) { return idx->length; } -ZCK_PUBLIC_API ssize_t zck_get_chunk_comp_size(zckChunk *idx) { +ssize_t ZCK_PUBLIC_API zck_get_chunk_comp_size(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_INT(idx->zck); ALLOCD_INT(idx->zck, idx); @@ -232,7 +232,7 @@ ZCK_PUBLIC_API ssize_t zck_get_chunk_comp_size(zckChunk *idx) { return idx->comp_length; } -ZCK_PUBLIC_API ssize_t zck_get_chunk_number(zckChunk *idx) { +ssize_t ZCK_PUBLIC_API zck_get_chunk_number(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_INT(idx->zck); ALLOCD_INT(idx->zck, idx); @@ -243,7 +243,7 @@ ZCK_PUBLIC_API ssize_t zck_get_chunk_number(zckChunk *idx) { return idx->number; } -ZCK_PUBLIC_API int zck_get_chunk_valid(zckChunk *idx) { +int ZCK_PUBLIC_API zck_get_chunk_valid(zckChunk *idx) { if(idx && idx->zck) { VALIDATE_INT(idx->zck); ALLOCD_INT(idx->zck, idx); @@ -254,7 +254,7 @@ ZCK_PUBLIC_API int zck_get_chunk_valid(zckChunk *idx) { return idx->valid; } -ZCK_PUBLIC_API bool zck_compare_chunk_digest(zckChunk *a, zckChunk *b) { +bool ZCK_PUBLIC_API zck_compare_chunk_digest(zckChunk *a, zckChunk *b) { if(a && a->zck) { VALIDATE_BOOL(a->zck); ALLOCD_BOOL(a->zck, a); @@ -275,7 +275,7 @@ ZCK_PUBLIC_API bool zck_compare_chunk_digest(zckChunk *a, zckChunk *b) { return true; } -ZCK_PUBLIC_API int zck_missing_chunks(zckCtx *zck) { +int ZCK_PUBLIC_API zck_missing_chunks(zckCtx *zck) { VALIDATE_READ_INT(zck); int missing = 0; @@ -285,7 +285,7 @@ ZCK_PUBLIC_API int zck_missing_chunks(zckCtx *zck) { return missing; } -ZCK_PUBLIC_API int zck_failed_chunks(zckCtx *zck) { +int ZCK_PUBLIC_API zck_failed_chunks(zckCtx *zck) { VALIDATE_READ_INT(zck); int failed = 0; @@ -295,7 +295,7 @@ ZCK_PUBLIC_API int zck_failed_chunks(zckCtx *zck) { return failed; } -ZCK_PUBLIC_API void zck_reset_failed_chunks(zckCtx *zck) { +void ZCK_PUBLIC_API zck_reset_failed_chunks(zckCtx *zck) { if(!zck) return; @@ -305,7 +305,7 @@ ZCK_PUBLIC_API void zck_reset_failed_chunks(zckCtx *zck) { return; } -ZCK_PUBLIC_API bool zck_generate_hashdb(zckCtx *zck) { +bool ZCK_PUBLIC_API zck_generate_hashdb(zckCtx *zck) { if (zck->index.ht || zck->index.htuncomp) { zck_log(ZCK_LOG_ERROR, "Hash DB already present, it could not be created"); return false; diff --git a/src/lib/zck.c b/src/lib/zck.c index 03777fd..f9c9516 100644 --- a/src/lib/zck.c +++ b/src/lib/zck.c @@ -44,7 +44,7 @@ /* If lead format changes, this needs to be changed */ -ZCK_PUBLIC_API int zck_get_min_download_size() { +int ZCK_PUBLIC_API zck_get_min_download_size() { /* Magic + hash type + hash digest + header size */ return 5 + MAX_COMP_SIZE*2 + get_max_hash_size(); } @@ -246,7 +246,7 @@ bool import_dict(zckCtx *zck) { return true; } -ZCK_PUBLIC_API bool zck_set_soption(zckCtx *zck, zck_soption option, const char *value, +bool ZCK_PUBLIC_API zck_set_soption(zckCtx *zck, zck_soption option, const char *value, size_t length) { VALIDATE_BOOL(zck); char *data = zmalloc(length); @@ -301,7 +301,7 @@ ZCK_PUBLIC_API bool zck_set_soption(zckCtx *zck, zck_soption option, const char return true; } -ZCK_PUBLIC_API bool zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) { +bool ZCK_PUBLIC_API zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) { VALIDATE_BOOL(zck); /* Set hash type */ @@ -359,7 +359,7 @@ ZCK_PUBLIC_API bool zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t val return true; } -ZCK_PUBLIC_API bool zck_close(zckCtx *zck) { +bool ZCK_PUBLIC_API zck_close(zckCtx *zck) { VALIDATE_BOOL(zck); if(zck->mode == ZCK_MODE_WRITE) { @@ -387,7 +387,7 @@ ZCK_PUBLIC_API bool zck_close(zckCtx *zck) { return true; } -ZCK_PUBLIC_API void zck_free(zckCtx **zck) { +void ZCK_PUBLIC_API zck_free(zckCtx **zck) { if(zck == NULL || *zck == NULL) return; zck_clear(*zck); @@ -395,7 +395,7 @@ ZCK_PUBLIC_API void zck_free(zckCtx **zck) { *zck = NULL; } -ZCK_PUBLIC_API zckCtx *zck_create() { +zckCtx ZCK_PUBLIC_API *zck_create() { zckCtx *zck = zmalloc(sizeof(zckCtx)); if (!zck) { zck_log(ZCK_LOG_ERROR, "OOM in %s", __func__); @@ -407,7 +407,7 @@ ZCK_PUBLIC_API zckCtx *zck_create() { return zck; } -ZCK_PUBLIC_API bool zck_init_adv_read (zckCtx *zck, int src_fd) { +bool ZCK_PUBLIC_API zck_init_adv_read (zckCtx *zck, int src_fd) { VALIDATE_BOOL(zck); zck->mode = ZCK_MODE_READ; @@ -415,7 +415,7 @@ ZCK_PUBLIC_API bool zck_init_adv_read (zckCtx *zck, int src_fd) { return true; } -ZCK_PUBLIC_API bool zck_init_read (zckCtx *zck, int src_fd) { +bool ZCK_PUBLIC_API zck_init_read (zckCtx *zck, int src_fd) { VALIDATE_BOOL(zck); if(!zck_init_adv_read(zck, src_fd)) { @@ -436,7 +436,7 @@ ZCK_PUBLIC_API bool zck_init_read (zckCtx *zck, int src_fd) { return true; } -ZCK_PUBLIC_API bool zck_init_write (zckCtx *zck, int dst_fd) { +bool ZCK_PUBLIC_API zck_init_write (zckCtx *zck, int dst_fd) { VALIDATE_BOOL(zck); zck->mode = ZCK_MODE_WRITE; @@ -461,12 +461,12 @@ ZCK_PUBLIC_API bool zck_init_write (zckCtx *zck, int dst_fd) { return true; } -ZCK_PUBLIC_API int zck_get_fd(zckCtx *zck) { +int ZCK_PUBLIC_API zck_get_fd(zckCtx *zck) { VALIDATE_BOOL(zck); return zck->fd; } -ZCK_PUBLIC_API bool zck_set_fd(zckCtx *zck, int fd) { +bool ZCK_PUBLIC_API zck_set_fd(zckCtx *zck, int fd) { VALIDATE_BOOL(zck); zck->fd = fd; return true; -- 2.30.2