From: Jonathan Dieter <jdieter@gmail.com>
Date: Fri, 13 Apr 2018 11:05:32 +0000 (+0300)
Subject: Only make API functions public using -fvisibility
X-Git-Tag: archive/raspbian/1.1.9+ds1-1+rpi1~1^2~325
X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=59b76a67d3cb46ec071a6bbfaf528bbb26ef0d12;p=zchunk.git

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 9d63973..3191671 100644
--- 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 33edf51..3181ad9 100644
--- 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 718c397..d111037 100644
--- 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 678c90a..03fc053 100644
--- 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 8da7998..8572ad6 100644
--- 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 86876db..ae05306 100644
--- 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 c25049d..60c014e 100644
--- 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 de365ce..169b4bc 100644
--- 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);