* 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));
/*******************************************************************
*******************************************************************/
/* 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);
* 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));
/*******************************************************************
* 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));
/*******************************************************************
* 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);
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
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 */
+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)
projects / zchunk.git / commitdiff