Only make API functions public using -fvisibility

Signed-off-by: Jonathan Dieter <jdieter@gmail.com>

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index 9d63973234b0984227e39980c1dfc1b599797d83..3191671e1086da8ca81281029b93415326e7e27f 100644 (file)
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -169,7 +169,7 @@ int zck_comp_close(zckCtx *zck) {
     return zck_comp_reset(zck);
 }
 
-int zck_set_compression_type(zckCtx *zck, int type) {
+int PUBLIC zck_set_compression_type(zckCtx *zck, int type) {
     VALIDATE(zck);
 
     zckComp *comp = &(zck->comp);
@@ -199,7 +199,7 @@ int zck_set_compression_type(zckCtx *zck, int type) {
     return True;
 }
 
-int zck_set_comp_parameter(zckCtx *zck, int option, void *value) {
+int PUBLIC zck_set_comp_parameter(zckCtx *zck, int option, void *value) {
     VALIDATE(zck);
 
     /* Cannot change compression parameters after compression has started */
@@ -235,7 +235,7 @@ int zck_set_comp_parameter(zckCtx *zck, int option, void *value) {
     return True;
 }
 
-const char *zck_comp_name_from_type(int comp_type) {
+const char PUBLIC *zck_comp_name_from_type(int comp_type) {
     if(comp_type > 2) {
         snprintf(unknown+8, 21, "%i)", comp_type);
         return unknown;
@@ -304,7 +304,7 @@ int zck_comp_add_to_data(zckComp *comp, const char *src, size_t src_size) {
     return True;
 }
 
-ssize_t zck_write(zckCtx *zck, const char *src, const size_t src_size) {
+ssize_t PUBLIC zck_write(zckCtx *zck, const char *src, const size_t src_size) {
     VALIDATE_WRITE_SIZE(zck);
 
     if(!zck->comp.started && !zck_comp_init(zck))
@@ -329,7 +329,7 @@ ssize_t zck_write(zckCtx *zck, const char *src, const size_t src_size) {
     return src_size;
 }
 
-ssize_t zck_end_chunk(zckCtx *zck) {
+ssize_t PUBLIC zck_end_chunk(zckCtx *zck) {
     VALIDATE_WRITE_SIZE(zck);
 
     if(!zck->comp.started && !zck_comp_init(zck))
@@ -467,7 +467,7 @@ zck_hash_error:
     return -2;
 }
 
-ssize_t zck_read(zckCtx *zck, char *dst, size_t dst_size) {
+ssize_t PUBLIC zck_read(zckCtx *zck, char *dst, size_t dst_size) {
     VALIDATE_READ_SIZE(zck);
 
     return comp_read(zck, dst, dst_size, 1);

diff --git a/src/lib/dl/dl.c b/src/lib/dl/dl.c
index 33edf510ac23ff1bc7fc9e7f81a6802d73fe9bf1..3181ad9dec06b6acb7cff731e753bbae6313a2fc 100644 (file)
--- a/src/lib/dl/dl.c
+++ b/src/lib/dl/dl.c
@@ -263,7 +263,7 @@ int zck_dl_write_and_verify(zckRange *info, zckCtx *src, zckCtx *tgt,
     return True;
 }
 
-int zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt) {
+int PUBLIC zck_dl_copy_src_chunks(zckRange *info, zckCtx *src, zckCtx *tgt) {
     zckIndex *tgt_info = zck_get_index(tgt);
     zckIndex *src_info = zck_get_index(src);
     zckIndexItem *tgt_idx = tgt_info->first;
@@ -358,7 +358,7 @@ int zck_dl_range_chk_chunk(zckDL *dl, char *url, int is_chunk) {
     return True;
 }
 
-int zck_dl_range(zckDL *dl, char *url) {
+int PUBLIC zck_dl_range(zckDL *dl, char *url) {
     return zck_dl_range_chk_chunk(dl, url, 1);
 }
 
@@ -429,7 +429,7 @@ int zck_zero_bytes(zckDL *dl, size_t bytes, size_t start, size_t *buffer_len) {
 }
 
 /* Download header */
-int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
+int PUBLIC zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
     if(zck == NULL) {
         zck_log(ZCK_LOG_ERROR, "zckCtx not initialized\n");
         return False;
@@ -487,21 +487,21 @@ int zck_dl_get_header(zckCtx *zck, zckDL *dl, char *url) {
     return True;
 }
 
-size_t zck_dl_get_bytes_downloaded(zckDL *dl) {
+size_t PUBLIC zck_dl_get_bytes_downloaded(zckDL *dl) {
     VALIDATE(dl);
     return dl->dl;
 }
 
-size_t zck_dl_get_bytes_uploaded(zckDL *dl) {
+size_t PUBLIC zck_dl_get_bytes_uploaded(zckDL *dl) {
     VALIDATE(dl);
     return dl->ul;
 }
 
-void zck_dl_global_init() {
+void PUBLIC zck_dl_global_init() {
     curl_global_init(CURL_GLOBAL_ALL);
 }
 
-void zck_dl_global_cleanup() {
+void PUBLIC zck_dl_global_cleanup() {
     curl_global_cleanup();
 }
 
@@ -519,7 +519,7 @@ void zck_dl_clear_regex(zckDL *dl) {
 }
 
 /* Initialize zckDL.  When finished, zckDL *must* be freed by zck_dl_free() */
-zckDL *zck_dl_init() {
+zckDL PUBLIC *zck_dl_init() {
     zckDL *dl = zmalloc(sizeof(zckDL));
     if(!dl) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes for zckDL\n",
@@ -549,7 +549,7 @@ zckDL *zck_dl_init() {
 }
 
 /* Free zckDL and set pointer to NULL */
-void zck_dl_free(zckDL **dl) {
+void PUBLIC zck_dl_free(zckDL **dl) {
     if(!*dl)
         return;
     if((*dl)->priv) {

diff --git a/src/lib/dl/range.c b/src/lib/dl/range.c
index 718c3977c891fb696b8e6b2f9cd0c8a3022cb5ad..d11103718cdec925dc7dfd6d37411fd387c88470 100644 (file)
--- a/src/lib/dl/range.c
+++ b/src/lib/dl/range.c
@@ -42,7 +42,7 @@ void zck_range_remove(zckRangeItem *range) {
     free(range);
 }
 
-void zck_range_close(zckRange *info) {
+void PUBLIC zck_range_close(zckRange *info) {
     zckRangeItem *next = info->first;
     while(next) {
         zckRangeItem *tmp = next;
@@ -147,7 +147,7 @@ int zck_range_add(zckRange *info, zckIndexItem *idx, zckCtx *zck) {
     return True;
 }
 
-int zck_range_calc_segments(zckRange *info, unsigned int max_ranges) {
+int PUBLIC zck_range_calc_segments(zckRange *info, unsigned int max_ranges) {
     if(max_ranges == 0)
         return False;
     info->segments = (info->count + max_ranges - 1) / max_ranges;

diff --git a/src/lib/hash/hash.c b/src/lib/hash/hash.c
index 678c90a2827533ae30f32b3ff7a549992457ccaf..03fc0532b865b579a71698153a36143efcf78b28 100644 (file)
--- a/src/lib/hash/hash.c
+++ b/src/lib/hash/hash.c
@@ -130,7 +130,7 @@ void zck_hash_close(zckHash *hash) {
 }
 
 /* Returns 1 if data hash matches, 0 if it doesn't and -1 if failure */
-int zck_hash_check_data(zckCtx *zck, int dst_fd) {
+int PUBLIC zck_hash_check_data(zckCtx *zck, int dst_fd) {
     if(!seek_data(dst_fd, zck->header_size + zck->index_size, SEEK_SET))
         return -1;
     if(!zck_hash_init(&(zck->check_full_hash), &(zck->hash_type)))
@@ -175,7 +175,7 @@ char *zck_hash_finalize(zckHash *hash) {
     return NULL;
 }
 
-const char *zck_hash_name_from_type(int hash_type) {
+const char PUBLIC *zck_hash_name_from_type(int hash_type) {
     if(hash_type > 1) {
         snprintf(unknown+8, 21, "%i)", hash_type);
         return unknown;

diff --git a/src/lib/log.c b/src/lib/log.c
index 8da799837e152f055723c59c018c3c7d3bb6263d..8572ad6a1e498afb9e76c83ecc37f25804016604 100644 (file)
--- a/src/lib/log.c
+++ b/src/lib/log.c
@@ -33,11 +33,11 @@
 
 static log_type log_level = ZCK_LOG_ERROR;
 
-void zck_set_log_level(log_type ll) {
+void PUBLIC zck_set_log_level(log_type ll) {
     log_level = ll;
 }
 
-void zck_log(log_type lt, const char *format, ...) {
+void PUBLIC zck_log(log_type lt, const char *format, ...) {
     if(lt >= log_level) {
         va_list args;
         va_start(args, format);

diff --git a/src/lib/meson.build b/src/lib/meson.build
index 86876dbf4574e97e7554df34a9d2ec923039d16c..ae053066c0ae40d744d1a61cb327853c45d0b77f 100644 (file)
--- a/src/lib/meson.build
+++ b/src/lib/meson.build
@@ -1,4 +1,5 @@
 sources = []
+add_global_arguments('-fvisibility=hidden', language : 'c')
 subdir('comp')
 subdir('hash')
 subdir('index')

diff --git a/src/lib/zck.c b/src/lib/zck.c
index c25049d26196bc5eac17fc91893422f12ad9ef74..60c014ed147f1b1d8bb32180ecc316b9584f4dd8 100644 (file)
--- a/src/lib/zck.c
+++ b/src/lib/zck.c
@@ -39,7 +39,7 @@
                             return False; \
                         }
 
-int zck_close(zckCtx *zck) {
+int PUBLIC zck_close(zckCtx *zck) {
     VALIDATE(zck);
 
     if(zck->mode == ZCK_MODE_WRITE) {
@@ -96,7 +96,7 @@ void zck_clear(zckCtx *zck) {
     }
 }
 
-void zck_free(zckCtx **zck) {
+void PUBLIC zck_free(zckCtx **zck) {
     if(*zck == NULL)
         return;
     zck_clear(*zck);
@@ -104,7 +104,7 @@ void zck_free(zckCtx **zck) {
     *zck = NULL;
 }
 
-zckCtx *zck_create() {
+zckCtx PUBLIC *zck_create() {
     zckCtx *zck = zmalloc(sizeof(zckCtx));
     if(zck == NULL) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
@@ -114,7 +114,7 @@ zckCtx *zck_create() {
     return zck;
 }
 
-zckCtx *zck_init_adv_read (int src_fd) {
+zckCtx PUBLIC *zck_init_adv_read (int src_fd) {
     zckCtx *zck = zck_create();
     if(zck == NULL)
         return NULL;
@@ -124,7 +124,7 @@ zckCtx *zck_init_adv_read (int src_fd) {
     return zck;
 }
 
-zckCtx *zck_init_read (int src_fd) {
+zckCtx PUBLIC *zck_init_read (int src_fd) {
     zckCtx *zck = zck_init_adv_read(src_fd);
     if(zck == NULL)
         return NULL;
@@ -135,7 +135,7 @@ zckCtx *zck_init_read (int src_fd) {
     return zck;
 }
 
-zckCtx *zck_init_write (int dst_fd) {
+zckCtx PUBLIC *zck_init_write (int dst_fd) {
     zckCtx *zck = zck_create();
     if(zck == NULL)
         return NULL;
@@ -165,7 +165,7 @@ iw_error:
     return NULL;
 }
 
-int zck_set_full_hash_type(zckCtx *zck, int hash_type) {
+int PUBLIC zck_set_full_hash_type(zckCtx *zck, int hash_type) {
     VALIDATE(zck);
     zck_log(ZCK_LOG_INFO, "Setting full hash to %s\n",
             zck_hash_name_from_type(hash_type));
@@ -182,7 +182,7 @@ int zck_set_full_hash_type(zckCtx *zck, int hash_type) {
     return True;
 }
 
-int zck_set_chunk_hash_type(zckCtx *zck, int hash_type) {
+int PUBLIC zck_set_chunk_hash_type(zckCtx *zck, int hash_type) {
     VALIDATE(zck);
     memset(&(zck->chunk_hash_type), 0, sizeof(zckHashType));
     zck_log(ZCK_LOG_INFO, "Setting chunk hash to %s\n",
@@ -197,55 +197,55 @@ int zck_set_chunk_hash_type(zckCtx *zck, int hash_type) {
     return True;
 }
 
-int zck_get_full_digest_size(zckCtx *zck) {
+int PUBLIC zck_get_full_digest_size(zckCtx *zck) {
     if(zck == NULL)
         return -1;
     return zck->hash_type.digest_size;
 }
 
-int zck_get_chunk_digest_size(zckCtx *zck) {
+int PUBLIC zck_get_chunk_digest_size(zckCtx *zck) {
     if(zck == NULL || zck->index.digest_size == 0)
         return -1;
     return zck->index.digest_size;
 }
 
-int zck_get_full_hash_type(zckCtx *zck) {
+int PUBLIC zck_get_full_hash_type(zckCtx *zck) {
     if(zck == NULL)
         return -1;
     return zck->hash_type.type;
 }
 
-int zck_get_chunk_hash_type(zckCtx *zck) {
+int PUBLIC zck_get_chunk_hash_type(zckCtx *zck) {
     if(zck == NULL)
         return -1;
     return zck->index.hash_type;
 }
 
-ssize_t zck_get_index_count(zckCtx *zck) {
+ssize_t PUBLIC zck_get_index_count(zckCtx *zck) {
     if(zck == NULL)
         return -1;
     return zck->index.count;
 }
 
-zckIndex *zck_get_index(zckCtx *zck) {
+zckIndex PUBLIC *zck_get_index(zckCtx *zck) {
     if(zck == NULL)
         return NULL;
     return &(zck->index);
 }
 
-char *zck_get_index_digest(zckCtx *zck) {
+char PUBLIC *zck_get_index_digest(zckCtx *zck) {
     if(zck == NULL)
         return NULL;
     return zck->index_digest;
 }
 
-char *zck_get_data_digest(zckCtx *zck) {
+char PUBLIC *zck_get_data_digest(zckCtx *zck) {
     if(zck == NULL)
         return NULL;
     return zck->full_hash_digest;
 }
 
-ssize_t zck_get_header_length(zckCtx *zck) {
+ssize_t PUBLIC zck_get_header_length(zckCtx *zck) {
     if(zck == NULL)
         return -1;
     return zck->header_size + zck->index_size;

diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index de365ce3baf41a7ff2b2306ea9410883a1f3c3d3..169b4bcac5503f11c0704f40ab7f7b6b69080dd4 100644 (file)
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -14,6 +14,8 @@
 
 #define zmalloc(x) calloc(1, x)
 
+#define PUBLIC __attribute__((visibility("default")))
+
 struct zckComp;
 
 typedef int (*finit)(struct zckComp *comp);