From: Jonathan Dieter Date: Tue, 17 Apr 2018 09:28:00 +0000 (+0300) Subject: Give all functions warn_unused_result and make sure warnings are turned on X-Git-Tag: archive/raspbian/1.1.9+ds1-1+rpi1~1^2~318 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=f2682b8d8159639368563769162d0bba511d6953;p=zchunk.git Give all functions warn_unused_result and make sure warnings are turned on Signed-off-by: Jonathan Dieter --- diff --git a/include/zck.h b/include/zck.h index d899c63..069c634 100644 --- a/include/zck.h +++ b/include/zck.h @@ -68,22 +68,27 @@ typedef struct zckIndex { * Reading a zchunk file *******************************************************************/ /* Initialize zchunk for reading */ -zckCtx *zck_init_read (int src_fd); +zckCtx *zck_init_read (int src_fd) + __attribute__ ((warn_unused_result)); /* Decompress dst_size bytes from zchunk file to dst, while verifying hashes */ -ssize_t zck_read(zckCtx *zck, char *dst, size_t dst_size); +ssize_t zck_read(zckCtx *zck, char *dst, size_t dst_size) + __attribute__ ((warn_unused_result)); /******************************************************************* * Writing a zchunk file *******************************************************************/ /* Initialize zchunk for writing */ -zckCtx *zck_init_write (int dst_fd); +zckCtx *zck_init_write (int dst_fd) + __attribute__ ((warn_unused_result)); /* 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 */ -ssize_t zck_write(zckCtx *zck, const char *src, const size_t src_size); +ssize_t zck_write(zckCtx *zck, const char *src, const size_t src_size) + __attribute__ ((warn_unused_result)); /* Create a chunk boundary */ -ssize_t zck_end_chunk(zckCtx *zck); +ssize_t zck_end_chunk(zckCtx *zck) + __attribute__ ((warn_unused_result)); /******************************************************************* @@ -91,7 +96,8 @@ ssize_t zck_end_chunk(zckCtx *zck); *******************************************************************/ /* Close a zchunk file so it may no longer be read from or written to. The * context still contains information about the file */ -int zck_close(zckCtx *zck); +int zck_close(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* 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 */ void zck_free(zckCtx **zck); @@ -101,9 +107,11 @@ void zck_free(zckCtx **zck); * Options *******************************************************************/ /* Set string option */ -int zck_set_soption(zckCtx *zck, zck_soption option, const void *value); +int zck_set_soption(zckCtx *zck, zck_soption option, const void *value) + __attribute__ ((warn_unused_result)); /* Set integer option */ -int zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value); +int zck_set_ioption(zckCtx *zck, zck_ioption option, ssize_t value) + __attribute__ ((warn_unused_result)); /******************************************************************* @@ -124,70 +132,91 @@ void zck_set_log_level(zck_log_type ll); * Advanced miscellaneous zchunk functions *******************************************************************/ /* Initialize zchunk context */ -zckCtx *zck_create(); +zckCtx *zck_create() + __attribute__ ((warn_unused_result)); /* Get header length (header + index) */ -ssize_t zck_get_header_length(zckCtx *zck); +ssize_t zck_get_header_length(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get data length */ -ssize_t zck_get_data_length(zckCtx *zck); +ssize_t zck_get_data_length(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get index digest */ -char *zck_get_header_digest(zckCtx *zck); +char *zck_get_header_digest(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get data digest */ -char *zck_get_data_digest(zckCtx *zck); +char *zck_get_data_digest(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get temporary fd that will disappear when fd is closed */ -int zck_get_tmp_fd(); +int zck_get_tmp_fd() + __attribute__ ((warn_unused_result)); /******************************************************************* * Advanced compression functions *******************************************************************/ /* Get name of compression type */ -const char *zck_comp_name_from_type(int comp_type); +const char *zck_comp_name_from_type(int comp_type) + __attribute__ ((warn_unused_result)); /* Initialize compression. Compression type and parameters *must* be done * before this is called */ -int zck_comp_init(zckCtx *zck); +int zck_comp_init(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Release compression resources. After this is run, you may change compression * type and parameters */ -int zck_comp_close(zckCtx *zck); +int zck_comp_close(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Reset compression configuration without losing buffered compressed data. * After this is run, you may change compression type and parameters */ -int zck_comp_reset(zckCtx *zck); +int zck_comp_reset(zckCtx *zck) + __attribute__ ((warn_unused_result)); /******************************************************************* * Advanced zchunk reading functions *******************************************************************/ /* Initialize zchunk for reading using advanced options */ -zckCtx *zck_init_adv_read (int src_fd); +zckCtx *zck_init_adv_read (int src_fd) + __attribute__ ((warn_unused_result)); /* Read zchunk header */ -int zck_read_header(zckCtx *zck); +int zck_read_header(zckCtx *zck) + __attribute__ ((warn_unused_result)); /******************************************************************* * Indexes *******************************************************************/ /* Get index count */ -ssize_t zck_get_index_count(zckCtx *zck); +ssize_t zck_get_index_count(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get index */ -zckIndex *zck_get_index(zckCtx *zck); +zckIndex *zck_get_index(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get chunk digest */ -char *zck_get_chunk_digest(zckIndexItem *item); +char *zck_get_chunk_digest(zckIndexItem *item) + __attribute__ ((warn_unused_result)); /******************************************************************* * Advanced hash functions *******************************************************************/ /* Get overall hash type */ -int zck_get_full_hash_type(zckCtx *zck); +int zck_get_full_hash_type(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get digest size of overall hash type */ -int zck_get_full_digest_size(zckCtx *zck); +int zck_get_full_digest_size(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get chunk hash type */ -int zck_get_chunk_hash_type(zckCtx *zck); +int zck_get_chunk_hash_type(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get digest size of chunk hash type */ -int zck_get_chunk_digest_size(zckCtx *zck); +int zck_get_chunk_digest_size(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* Get name of hash type */ -const char *zck_hash_name_from_type(int hash_type); +const char *zck_hash_name_from_type(int hash_type) + __attribute__ ((warn_unused_result)); /* Check data hash */ -int zck_hash_check_data(zckCtx *zck, int dst_fd); +int zck_hash_check_data(zckCtx *zck, int dst_fd) + __attribute__ ((warn_unused_result)); /******************************************************************* @@ -228,14 +257,18 @@ typedef struct zckDL { * Ranges *******************************************************************/ /* Update info with the maximum number of ranges in a single request */ -int zck_range_calc_segments(zckRange *info, unsigned int max_ranges); +int zck_range_calc_segments(zckRange *info, unsigned int max_ranges) + __attribute__ ((warn_unused_result)); /* Get any matching chunks from src and put them in the right place in tgt */ -int zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt); +int zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt) + __attribute__ ((warn_unused_result)); /* Get index of chunks not available in src, and put them in info */ -int zck_range_get_need_dl(zckRange *info, zckCtx *zck_src, zckCtx *zck_tgt); +int zck_range_get_need_dl(zckRange *info, zckCtx *zck_src, zckCtx *zck_tgt) + __attribute__ ((warn_unused_result)); /* Get array of range request strings. ra must be allocated to size * info->segments, and the strings must be freed by the caller after use */ -int zck_range_get_array(zckRange *info, char **ra); +int zck_range_get_array(zckRange *info, char **ra) + __attribute__ ((warn_unused_result)); /* Free any resources in zckRange */ void zck_range_close(zckRange *info); @@ -251,19 +284,25 @@ void zck_dl_global_init(); void zck_dl_global_cleanup(); /* Initialize zchunk download context */ -zckDL *zck_dl_init(); +zckDL *zck_dl_init() + __attribute__ ((warn_unused_result)); /* Free zchunk download context */ void zck_dl_free(zckDL **dl); /* Clear regex used for extracting download ranges from multipart download */ void zck_dl_clear_regex(zckDL *dl); /* Download and process the header from url */ -int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url); +int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) + __attribute__ ((warn_unused_result)); /* Get number of bytes downloaded using download context */ -size_t zck_dl_get_bytes_downloaded(zckDL *dl); +size_t zck_dl_get_bytes_downloaded(zckDL *dl) + __attribute__ ((warn_unused_result)); /* Get number of bytes uploaded using download context */ -size_t zck_dl_get_bytes_uploaded(zckDL *dl); +size_t zck_dl_get_bytes_uploaded(zckDL *dl) + __attribute__ ((warn_unused_result)); /* Download ranges specified in dl->info from url */ -int zck_dl_range(zckDL *dl, char *url); +int zck_dl_range(zckDL *dl, char *url) + __attribute__ ((warn_unused_result)); /* Return string with range request from start to end (inclusive) */ -char *zck_dl_get_range(unsigned int start, unsigned int end); +char *zck_dl_get_range(unsigned int start, unsigned int end) + __attribute__ ((warn_unused_result)); #endif diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h index 9a54083..415aad5 100644 --- a/src/lib/zck_private.h +++ b/src/lib/zck_private.h @@ -123,81 +123,130 @@ typedef struct zckCtx { size_t data_size; } zckCtx; -const char *zck_hash_name_from_type(int hash_type); -int zck_get_tmp_fd(); -int zck_import_dict(zckCtx *zck); -int zck_validate_file(zckCtx *zck); -int zck_validate_current_chunk(zckCtx *zck); +const char *zck_hash_name_from_type(int hash_type) + __attribute__ ((warn_unused_result)); +int zck_get_tmp_fd() + __attribute__ ((warn_unused_result)); +int zck_import_dict(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_validate_file(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_validate_current_chunk(zckCtx *zck) + __attribute__ ((warn_unused_result)); void zck_clear_work_index(zckCtx *zck); -char *get_digest_string(const char *digest, int size); +char *get_digest_string(const char *digest, int size) + __attribute__ ((warn_unused_result)); /* hash/hash.h */ -int zck_hash_setup(zckHashType *ht, int h); -int zck_hash_init(zckHash *hash, zckHashType *hash_type); -int zck_hash_update(zckHash *hash, const char *message, const size_t size); -char *zck_hash_finalize(zckHash *hash); +int zck_hash_setup(zckHashType *ht, int h) + __attribute__ ((warn_unused_result)); +int zck_hash_init(zckHash *hash, zckHashType *hash_type) + __attribute__ ((warn_unused_result)); +int zck_hash_update(zckHash *hash, const char *message, const size_t size) + __attribute__ ((warn_unused_result)); +char *zck_hash_finalize(zckHash *hash) + __attribute__ ((warn_unused_result)); void zck_hash_close(zckHash *hash); -const char *zck_hash_get_printable(const char *digest, zckHashType *type); -int set_full_hash_type(zckCtx *zck, int hash_type); -int set_chunk_hash_type(zckCtx *zck, int hash_type); +const char *zck_hash_get_printable(const char *digest, zckHashType *type) + __attribute__ ((warn_unused_result)); +int set_full_hash_type(zckCtx *zck, int hash_type) + __attribute__ ((warn_unused_result)); +int set_chunk_hash_type(zckCtx *zck, int hash_type) + __attribute__ ((warn_unused_result)); /* index/index.c */ -int zck_index_read(zckCtx *zck, char *data, size_t size); -int zck_index_finalize(zckCtx *zck); +int zck_index_read(zckCtx *zck, char *data, size_t size) + __attribute__ ((warn_unused_result)); +int zck_index_finalize(zckCtx *zck) + __attribute__ ((warn_unused_result)); int zck_index_new_chunk(zckIndex *index, char *digest, int digest_size, - size_t comp_size, size_t orig_size, int finished); + size_t comp_size, size_t orig_size, int finished) + __attribute__ ((warn_unused_result)); int zck_index_add_to_chunk(zckCtx *zck, char *data, size_t comp_size, - size_t orig_size); -int zck_index_finish_chunk(zckCtx *zck); + size_t orig_size) + __attribute__ ((warn_unused_result)); +int zck_index_finish_chunk(zckCtx *zck) + __attribute__ ((warn_unused_result)); void zck_index_clean(zckIndex *index); void zck_index_free(zckCtx *zck); void zck_index_free_item(zckIndexItem **item); -int zck_write_index(zckCtx *zck); -zckIndexItem *zck_get_index_of_loc(zckIndex *index, size_t loc); +int zck_write_index(zckCtx *zck) + __attribute__ ((warn_unused_result)); +zckIndexItem *zck_get_index_of_loc(zckIndex *index, size_t loc) + __attribute__ ((warn_unused_result)); /* io.c */ -int seek_data(int fd, off_t offset, int whence); -ssize_t tell_data(int fd); -ssize_t read_data(int fd, char *data, size_t length); -int write_data(int fd, const char *data, size_t length); -int write_comp_size(int fd, size_t val); -int read_comp_size(int fd, size_t *val, size_t *length); -int chunks_from_temp(zckCtx *zck); +int seek_data(int fd, off_t offset, int whence) + __attribute__ ((warn_unused_result)); +ssize_t tell_data(int fd) + __attribute__ ((warn_unused_result)); +ssize_t read_data(int fd, char *data, size_t length) + __attribute__ ((warn_unused_result)); +int write_data(int fd, const char *data, size_t length) + __attribute__ ((warn_unused_result)); +int write_comp_size(int fd, size_t val) + __attribute__ ((warn_unused_result)); +int read_comp_size(int fd, size_t *val, size_t *length) + __attribute__ ((warn_unused_result)); +int chunks_from_temp(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* header.c */ -int zck_read_initial(zckCtx *zck); -int zck_read_index_hash(zckCtx *zck); -int zck_read_ct_is(zckCtx *zck); -int zck_read_index(zckCtx *zck); -int zck_read_header(zckCtx *zck); -int zck_header_create(zckCtx *zck); -int zck_write_header(zckCtx *zck); +int zck_read_initial(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_read_index_hash(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_read_ct_is(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_read_index(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_read_header(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_header_create(zckCtx *zck) + __attribute__ ((warn_unused_result)); +int zck_write_header(zckCtx *zck) + __attribute__ ((warn_unused_result)); /* comp/comp.c */ -int zck_comp_add_to_dc(zckComp *comp, const char *src, size_t src_size); -int zck_comp_add_to_data(zckComp *comp, const char *src, size_t src_size); -size_t zck_comp_read_from_dc(zckComp *comp, char *dst, size_t dst_size); -ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict); -int comp_ioption(zckCtx *zck, zck_ioption option, ssize_t value); -int comp_soption(zckCtx *zck, zck_soption option, const void *value); +int zck_comp_add_to_dc(zckComp *comp, const char *src, size_t src_size) + __attribute__ ((warn_unused_result)); +int zck_comp_add_to_data(zckComp *comp, const char *src, size_t src_size) + __attribute__ ((warn_unused_result)); +size_t zck_comp_read_from_dc(zckComp *comp, char *dst, size_t dst_size) + __attribute__ ((warn_unused_result)); +ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict) + __attribute__ ((warn_unused_result)); +int comp_ioption(zckCtx *zck, zck_ioption option, ssize_t value) + __attribute__ ((warn_unused_result)); +int comp_soption(zckCtx *zck, zck_soption option, const void *value) + __attribute__ ((warn_unused_result)); /* dl/range.c */ -char *zck_range_get_char(zckRangeItem **range, int max_ranges); -int zck_range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck); +char *zck_range_get_char(zckRangeItem **range, int max_ranges) + __attribute__ ((warn_unused_result)); +int zck_range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck) + __attribute__ ((warn_unused_result)); /* dl/multipart.c */ -size_t zck_multipart_extract(zckDL *dl, char *b, size_t l); -size_t zck_multipart_get_boundary(zckDL *dl, char *b, size_t size); +size_t zck_multipart_extract(zckDL *dl, char *b, size_t l) + __attribute__ ((warn_unused_result)); +size_t zck_multipart_get_boundary(zckDL *dl, char *b, size_t size) + __attribute__ ((warn_unused_result)); /* dl/dl.c */ -int zck_dl_write_range(zckDL *dl, const char *at, size_t length); -int zck_dl_range_chk_chunk(zckDL *dl, char *url, int is_chunk); +int zck_dl_write_range(zckDL *dl, const char *at, size_t length) + __attribute__ ((warn_unused_result)); +int zck_dl_range_chk_chunk(zckDL *dl, char *url, int is_chunk) + __attribute__ ((warn_unused_result)); /* compint.c */ -int zck_compint_from_int(char *compint, int val, size_t *length); -int zck_compint_from_size(char *compint, size_t val, size_t *length); -int zck_compint_to_int(int *val, const char *compint, size_t *length); -int zck_compint_to_size(size_t *val, const char *compint, size_t *length); +int zck_compint_from_int(char *compint, int val, size_t *length) + __attribute__ ((warn_unused_result)); +void zck_compint_from_size(char *compint, size_t val, size_t *length); +int zck_compint_to_int(int *val, const char *compint, size_t *length) + __attribute__ ((warn_unused_result)); +int zck_compint_to_size(size_t *val, const char *compint, size_t *length) + __attribute__ ((warn_unused_result)); /* log.c */ diff --git a/src/meson.build b/src/meson.build index b609a65..16cde0b 100644 --- a/src/meson.build +++ b/src/meson.build @@ -1,3 +1,4 @@ +add_global_arguments('-Wunused-result', language : 'c') subdir('lib') executable('zck', ['zck.c'], include_directories: inc, link_with: zcklib, install: true) executable('unzck', ['unzck.c'], include_directories: inc, link_with: zcklib, install: true)