unify order of ZCK_PUBLIC_API

diff --git a/include/zck.h.in b/include/zck.h.in
index 0ca5c5fb49c8376274671baabd19fe9c60afd3f9..0f9d03c2994fb11e9a8aeecdf67e01424eb5ba67 100644 (file)
--- 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 db8d0d3ee090d8646d5ba0ae6df868e453c3fdc2..b27960f56f2c4f5487d968525a6e807302513861 100644 (file)
--- 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 699c2bbd293065822363605d5770b2b901763b86..01a10596db8124db8b0062277eff317bf5f14af4 100644 (file)
--- 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 ce2ad083d7dc8e8b08b04ab1f6a6f10661db75f8..22593b0eb8f5446576c681abc90f43d473171e96 100644 (file)
--- 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 03777fda5a6835299f9c25b86d07ea5dc53af537..f9c95161126191dda5ff231ee51e90a737438593 100644 (file)
--- 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;