From: Jonathan Dieter <jdieter@gmail.com>
Date: Wed, 6 Jun 2018 08:20:14 +0000 (+0300)
Subject: Make functions that aren't used outside the file static, and reorder
X-Git-Tag: archive/raspbian/1.1.9+ds1-1+rpi1~1^2~243
X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=040e4e6bb3f49b595c0869c675d22a03f8b508f0;p=zchunk.git

Make functions that aren't used outside the file static, and reorder
functions

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

diff --git a/src/lib/comp/comp.c b/src/lib/comp/comp.c
index 00fee99..1a3fe9e 100644
--- a/src/lib/comp/comp.c
+++ b/src/lib/comp/comp.c
@@ -85,6 +85,86 @@ const static char *COMP_NAME[] = {
     "zstd"
 };
 
+static int set_comp_type(zckCtx *zck, ssize_t type) {
+    VALIDATE(zck);
+
+    zckComp *comp = &(zck->comp);
+
+    /* Cannot change compression type after compression has started */
+    if(comp->started) {
+        zck_log(ZCK_LOG_ERROR,
+                "Unable to set compression type after initialization\n");
+        return False;
+    }
+
+    /* Set all values to 0 before setting compression type */
+    char *dc_data = comp->dc_data;
+    size_t dc_data_loc = comp->dc_data_loc;
+    size_t dc_data_size = comp->dc_data_size;
+    memset(comp, 0, sizeof(zckComp));
+    comp->dc_data = dc_data;
+    comp->dc_data_loc = dc_data_loc;
+    comp->dc_data_size = dc_data_size;
+
+    zck_log(ZCK_LOG_DEBUG, "Setting compression to %s\n",
+            zck_comp_name_from_type(type));
+    if(type == ZCK_COMP_NONE) {
+        return nocomp_setup(comp);
+#ifdef ZCHUNK_ZSTD
+    } else if(type == ZCK_COMP_ZSTD) {
+        return zstd_setup(comp);
+#endif
+    } else {
+        zck_log(ZCK_LOG_ERROR, "Unsupported compression type: %s\n",
+                zck_comp_name_from_type(type));
+        return False;
+    }
+    return True;
+}
+
+static size_t comp_read_from_dc(zckComp *comp, char *dst, size_t dst_size) {
+    VALIDATE_SIZE(comp);
+    VALIDATE_SIZE(dst);
+
+    size_t dl_size = dst_size;
+    if(dl_size > comp->dc_data_size - comp->dc_data_loc)
+        dl_size = comp->dc_data_size - comp->dc_data_loc;
+    memcpy(dst, comp->dc_data+comp->dc_data_loc, dl_size);
+    comp->dc_data_loc += dl_size;
+    if(dl_size > 0)
+        zck_log(ZCK_LOG_DEBUG, "Reading %lu bytes from decompressed buffer\n",
+                dl_size);
+    return dl_size;
+}
+
+static int comp_add_to_data(zckComp *comp, const char *src, size_t src_size) {
+    VALIDATE(comp);
+    VALIDATE(src);
+    comp->data = realloc(comp->data, comp->data_size + src_size);
+    if(comp->data == NULL) {
+        zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n",
+                comp->data_size + src_size);
+        return False;
+    }
+    zck_log(ZCK_LOG_DEBUG, "Adding %lu bytes to compressed buffer\n",
+        src_size);
+    memcpy(comp->data + comp->data_size, src, src_size);
+    comp->data_size += src_size;
+    comp->data_loc += src_size;
+    return True;
+}
+
+static ssize_t comp_end_dchunk(zckCtx *zck, int use_dict, size_t fd_size) {
+    ssize_t rb = zck->comp.end_dchunk(&(zck->comp), use_dict, fd_size);
+    if(validate_current_chunk(zck) < 1)
+        return -1;
+    zck->comp.data_loc = 0;
+    zck->comp.data_idx = zck->comp.data_idx->next;
+    if(!hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
+        return -1;
+    return rb;
+}
+
 int comp_init(zckCtx *zck) {
     VALIDATE(zck);
 
@@ -176,43 +256,6 @@ int comp_close(zckCtx *zck) {
     return comp_reset(zck);
 }
 
-static int set_comp_type(zckCtx *zck, ssize_t type) {
-    VALIDATE(zck);
-
-    zckComp *comp = &(zck->comp);
-
-    /* Cannot change compression type after compression has started */
-    if(comp->started) {
-        zck_log(ZCK_LOG_ERROR,
-                "Unable to set compression type after initialization\n");
-        return False;
-    }
-
-    /* Set all values to 0 before setting compression type */
-    char *dc_data = comp->dc_data;
-    size_t dc_data_loc = comp->dc_data_loc;
-    size_t dc_data_size = comp->dc_data_size;
-    memset(comp, 0, sizeof(zckComp));
-    comp->dc_data = dc_data;
-    comp->dc_data_loc = dc_data_loc;
-    comp->dc_data_size = dc_data_size;
-
-    zck_log(ZCK_LOG_DEBUG, "Setting compression to %s\n",
-            zck_comp_name_from_type(type));
-    if(type == ZCK_COMP_NONE) {
-        return nocomp_setup(comp);
-#ifdef ZCHUNK_ZSTD
-    } else if(type == ZCK_COMP_ZSTD) {
-        return zstd_setup(comp);
-#endif
-    } else {
-        zck_log(ZCK_LOG_ERROR, "Unsupported compression type: %s\n",
-                zck_comp_name_from_type(type));
-        return False;
-    }
-    return True;
-}
-
 int comp_ioption(zckCtx *zck, zck_ioption option, ssize_t value) {
     VALIDATE(zck);
 
@@ -266,29 +309,6 @@ int comp_soption(zckCtx *zck, zck_soption option, const void *value,
     return True;
 }
 
-const char PUBLIC *zck_comp_name_from_type(int comp_type) {
-    if(comp_type > 2) {
-        snprintf(unknown+8, 21, "%i)", comp_type);
-        return unknown;
-    }
-    return COMP_NAME[comp_type];
-}
-
-size_t comp_read_from_dc(zckComp *comp, char *dst, size_t dst_size) {
-    VALIDATE_SIZE(comp);
-    VALIDATE_SIZE(dst);
-
-    size_t dl_size = dst_size;
-    if(dl_size > comp->dc_data_size - comp->dc_data_loc)
-        dl_size = comp->dc_data_size - comp->dc_data_loc;
-    memcpy(dst, comp->dc_data+comp->dc_data_loc, dl_size);
-    comp->dc_data_loc += dl_size;
-    if(dl_size > 0)
-        zck_log(ZCK_LOG_DEBUG, "Reading %lu bytes from decompressed buffer\n",
-                dl_size);
-    return dl_size;
-}
-
 int comp_add_to_dc(zckComp *comp, const char *src, size_t src_size) {
     VALIDATE(comp);
     VALIDATE(src);
@@ -318,90 +338,6 @@ int comp_add_to_dc(zckComp *comp, const char *src, size_t src_size) {
     return True;
 }
 
-int comp_add_to_data(zckComp *comp, const char *src, size_t src_size) {
-    VALIDATE(comp);
-    VALIDATE(src);
-    comp->data = realloc(comp->data, comp->data_size + src_size);
-    if(comp->data == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Unable to reallocate %lu bytes\n",
-                comp->data_size + src_size);
-        return False;
-    }
-    zck_log(ZCK_LOG_DEBUG, "Adding %lu bytes to compressed buffer\n",
-        src_size);
-    memcpy(comp->data + comp->data_size, src, src_size);
-    comp->data_size += src_size;
-    comp->data_loc += src_size;
-    return True;
-}
-
-ssize_t PUBLIC zck_write(zckCtx *zck, const char *src, const size_t src_size) {
-    VALIDATE_WRITE_SIZE(zck);
-
-    if(!zck->comp.started && !comp_init(zck))
-        return -1;
-
-    if(src_size == 0)
-        return 0;
-
-    char *dst = NULL;
-    size_t dst_size = 0;
-    if(zck->comp.compress(&(zck->comp), src, src_size, &dst, &dst_size, 1) < 0)
-        return -1;
-    if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
-        free(dst);
-        return -1;
-    }
-    if(!index_add_to_chunk(zck, dst, dst_size, src_size)) {
-        free(dst);
-        return -1;
-    }
-    free(dst);
-    return src_size;
-}
-
-ssize_t PUBLIC zck_end_chunk(zckCtx *zck) {
-    VALIDATE_WRITE_SIZE(zck);
-
-    if(!zck->comp.started && !comp_init(zck))
-        return -1;
-
-    /* No point in compressing empty data */
-    if(zck->comp.dc_data_size == 0)
-        return 0;
-
-    size_t data_size = zck->comp.dc_data_size;
-    char *dst = NULL;
-    size_t dst_size = 0;
-    if(!zck->comp.end_cchunk(&(zck->comp), &dst, &dst_size, 1))
-        return -1;
-    if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
-        free(dst);
-        return -1;
-    }
-    if(!index_add_to_chunk(zck, dst, dst_size, 0)) {
-        free(dst);
-        return -1;
-    }
-    if(!index_finish_chunk(zck)) {
-        free(dst);
-        return -1;
-    }
-    free(dst);
-    return data_size;
-}
-
-ssize_t comp_end_dchunk(zckCtx *zck, int use_dict, size_t fd_size) {
-    ssize_t rb = zck->comp.end_dchunk(&(zck->comp), use_dict, fd_size);
-    if(validate_current_chunk(zck) < 1)
-        return -1;
-    zck->comp.data_loc = 0;
-    zck->comp.data_idx = zck->comp.data_idx->next;
-    if(!hash_init(&(zck->check_chunk_hash), &(zck->chunk_hash_type)))
-        return -1;
-    return rb;
-}
-
 ssize_t comp_read(zckCtx *zck, char *dst, size_t dst_size, int use_dict) {
     VALIDATE_READ_SIZE(zck);
 
@@ -516,6 +452,70 @@ hash_error:
     return -2;
 }
 
+const char PUBLIC *zck_comp_name_from_type(int comp_type) {
+    if(comp_type > 2) {
+        snprintf(unknown+8, 21, "%i)", comp_type);
+        return unknown;
+    }
+    return COMP_NAME[comp_type];
+}
+
+ssize_t PUBLIC zck_write(zckCtx *zck, const char *src, const size_t src_size) {
+    VALIDATE_WRITE_SIZE(zck);
+
+    if(!zck->comp.started && !comp_init(zck))
+        return -1;
+
+    if(src_size == 0)
+        return 0;
+
+    char *dst = NULL;
+    size_t dst_size = 0;
+    if(zck->comp.compress(&(zck->comp), src, src_size, &dst, &dst_size, 1) < 0)
+        return -1;
+    if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
+        free(dst);
+        return -1;
+    }
+    if(!index_add_to_chunk(zck, dst, dst_size, src_size)) {
+        free(dst);
+        return -1;
+    }
+    free(dst);
+    return src_size;
+}
+
+ssize_t PUBLIC zck_end_chunk(zckCtx *zck) {
+    VALIDATE_WRITE_SIZE(zck);
+
+    if(!zck->comp.started && !comp_init(zck))
+        return -1;
+
+    /* No point in compressing empty data */
+    if(zck->comp.dc_data_size == 0)
+        return 0;
+
+    size_t data_size = zck->comp.dc_data_size;
+    char *dst = NULL;
+    size_t dst_size = 0;
+    if(!zck->comp.end_cchunk(&(zck->comp), &dst, &dst_size, 1))
+        return -1;
+    if(dst_size > 0 && !write_data(zck->temp_fd, dst, dst_size)) {
+        free(dst);
+        return -1;
+    }
+    if(!index_add_to_chunk(zck, dst, dst_size, 0)) {
+        free(dst);
+        return -1;
+    }
+    if(!index_finish_chunk(zck)) {
+        free(dst);
+        return -1;
+    }
+    free(dst);
+    return data_size;
+}
+
 ssize_t PUBLIC zck_read(zckCtx *zck, char *dst, size_t dst_size) {
     VALIDATE_READ_SIZE(zck);
 
diff --git a/src/lib/header.c b/src/lib/header.c
index fe60e73..485c3b2 100644
--- a/src/lib/header.c
+++ b/src/lib/header.c
@@ -54,7 +54,7 @@
                                 return False; \
                             }
 
-int check_flags(zckCtx *zck, char *header, size_t *length, size_t max_length) {
+static int check_flags(zckCtx *zck, char *header, size_t *length, size_t max_length) {
     if(max_length < 4) {
         zck_log(ZCK_LOG_ERROR, "Read past end of header\n");
         return False;
@@ -71,105 +71,7 @@ int check_flags(zckCtx *zck, char *header, size_t *length, size_t max_length) {
     return True;
 }
 
-int PUBLIC zck_read_lead(zckCtx *zck) {
-    VALIDATE_READ(zck);
-
-    int lead = 5 + 2*MAX_COMP_SIZE;
-
-    char *header = zmalloc(lead);
-    if(header == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", lead);
-        return False;
-    }
-    size_t length = 0;
-
-    if(read_data(zck->fd, header, lead) < lead)
-        return False;
-
-    if(memcmp(header, "\0ZCK1", 5) != 0) {
-        free(header);
-        zck_log(ZCK_LOG_ERROR,
-                "Invalid lead, perhaps this is not a zck file?\n");
-        return False;
-    }
-    length += 5;
-
-    /* Read hash type for header and full digest and initialize check hash */
-    int hash_type = 0;
-    if(!compint_to_int(&hash_type, header+length, &length, lead))
-        return False;
-    if(zck->prep_hash_type > -1 && zck->prep_hash_type != hash_type) {
-        zck_log(ZCK_LOG_ERROR,
-                "Hash type (%i) doesn't match requested hash type "
-                "(%i)\n", hash_type, zck->prep_hash_type);
-        return False;
-    }
-    if(!hash_setup(&(zck->hash_type), hash_type))
-        return False;
-    zck_log(ZCK_LOG_DEBUG, "Setting header and full digest hash type to %s\n",
-            zck_hash_name_from_type(hash_type));
-
-    /* Read header size */
-    size_t header_length = 0;
-    if(!compint_to_size(&header_length, header+length, &length, lead))
-        return False;
-    zck->header_length = header_length;
-
-    /* Set header digest location */
-    zck->hdr_digest_loc = length;
-
-    /* Read header digest */
-    zck_log(ZCK_LOG_DEBUG, "Reading header digest\n");
-    header = realloc(header, length + zck->hash_type.digest_size);
-    if(header == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Unable to re-allocate %lu bytes\n",
-                length + zck->hash_type.digest_size);
-        return False;
-    }
-    size_t to_read = 0;
-    if(lead < length + zck->hash_type.digest_size)
-        to_read = length + zck->hash_type.digest_size - lead;
-    if(read_data(zck->fd, header + lead, to_read) < to_read)
-        return False;
-    lead += to_read;
-
-    if(zck->prep_digest &&
-       memcmp(zck->prep_digest, header + length, zck->hash_type.digest_size) != 0) {
-        zck_log(ZCK_LOG_ERROR,
-                "Header digest doesn't match requested header digest\n"
-                "Expected: %s\nActual: %s\n",
-                get_digest_string(zck->prep_digest, zck->hash_type.digest_size),
-                get_digest_string(header + length, zck->hash_type.digest_size));
-        return False;
-    }
-    zck->header_digest = zmalloc(zck->hash_type.digest_size);
-    if(zck->header_digest == NULL) {
-        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
-                zck->hash_type.digest_size);
-        return False;
-    }
-    memcpy(zck->header_digest, header + length, zck->hash_type.digest_size);
-    length += zck->hash_type.digest_size;
-
-    /* Check whether full header length matches specified header length */
-    if(zck->prep_hdr_size > -1 &&
-       (size_t)zck->prep_hdr_size != zck->header_length + length) {
-        zck_log(ZCK_LOG_ERROR,
-                "Header length (%lu) doesn't match requested header length "
-                "(%lu)\n", zck->header_length + length,
-                zck->prep_hdr_size);
-        return False;
-    }
-    /* Store pre-header */
-    zck->header = header;
-    zck->header_size = lead;
-    zck->lead_string = header;
-    zck->lead_size = length;
-    zck_log(ZCK_LOG_DEBUG, "Parsed lead: %lu bytes\n", length);
-    return True;
-}
-
-int read_header_from_file(zckCtx *zck) {
+static int read_header_from_file(zckCtx *zck) {
     if(zck->header_length > MAX_HEADER_IN_MEM) {
 
     }
@@ -213,7 +115,7 @@ int read_header_from_file(zckCtx *zck) {
     return True;
 }
 
-int read_preface(zckCtx *zck) {
+static int read_preface(zckCtx *zck) {
     VALIDATE_READ(zck);
 
     if(zck->header_digest == NULL) {
@@ -267,7 +169,7 @@ int read_preface(zckCtx *zck) {
     return True;
 }
 
-int read_index(zckCtx *zck) {
+static int read_index(zckCtx *zck) {
     VALIDATE_READ(zck);
 
     if(zck->preface_string == NULL) {
@@ -292,7 +194,7 @@ int read_index(zckCtx *zck) {
     return True;
 }
 
-int read_sig(zckCtx *zck) {
+static int read_sig(zckCtx *zck) {
     VALIDATE_READ(zck);
 
     if(zck->index_string == NULL) {
@@ -329,21 +231,7 @@ int read_sig(zckCtx *zck) {
     return True;
 }
 
-int PUBLIC zck_read_header(zckCtx *zck) {
-    VALIDATE_READ(zck);
-
-    if(!read_header_from_file(zck))
-        return False;
-    if(!read_preface(zck))
-        return False;
-    if(!read_index(zck))
-        return False;
-    if(!read_sig(zck))
-        return False;
-    return True;
-}
-
-int preface_create(zckCtx *zck) {
+static int preface_create(zckCtx *zck) {
     int header_malloc = zck->hash_type.digest_size + 4 + 2*MAX_COMP_SIZE;
 
     char *header = zmalloc(header_malloc);
@@ -385,7 +273,7 @@ int preface_create(zckCtx *zck) {
     return True;
 }
 
-int sig_create(zckCtx *zck) {
+static int sig_create(zckCtx *zck) {
     char *header = zmalloc(MAX_COMP_SIZE);
     if(header == NULL) {
         zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", MAX_COMP_SIZE);
@@ -409,7 +297,7 @@ int sig_create(zckCtx *zck) {
     return True;
 }
 
-int lead_create(zckCtx *zck) {
+static int lead_create(zckCtx *zck) {
     int phs = 5 + 2*MAX_COMP_SIZE + zck->hash_type.digest_size;
     char *header = zmalloc(phs);
     if(header == NULL) {
@@ -532,3 +420,115 @@ int write_header(zckCtx *zck) {
         return False;
     return True;
 }
+
+int PUBLIC zck_read_lead(zckCtx *zck) {
+    VALIDATE_READ(zck);
+
+    int lead = 5 + 2*MAX_COMP_SIZE;
+
+    char *header = zmalloc(lead);
+    if(header == NULL) {
+        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n", lead);
+        return False;
+    }
+    size_t length = 0;
+
+    if(read_data(zck->fd, header, lead) < lead)
+        return False;
+
+    if(memcmp(header, "\0ZCK1", 5) != 0) {
+        free(header);
+        zck_log(ZCK_LOG_ERROR,
+                "Invalid lead, perhaps this is not a zck file?\n");
+        return False;
+    }
+    length += 5;
+
+    /* Read hash type for header and full digest and initialize check hash */
+    int hash_type = 0;
+    if(!compint_to_int(&hash_type, header+length, &length, lead))
+        return False;
+    if(zck->prep_hash_type > -1 && zck->prep_hash_type != hash_type) {
+        zck_log(ZCK_LOG_ERROR,
+                "Hash type (%i) doesn't match requested hash type "
+                "(%i)\n", hash_type, zck->prep_hash_type);
+        return False;
+    }
+    if(!hash_setup(&(zck->hash_type), hash_type))
+        return False;
+    zck_log(ZCK_LOG_DEBUG, "Setting header and full digest hash type to %s\n",
+            zck_hash_name_from_type(hash_type));
+
+    /* Read header size */
+    size_t header_length = 0;
+    if(!compint_to_size(&header_length, header+length, &length, lead))
+        return False;
+    zck->header_length = header_length;
+
+    /* Set header digest location */
+    zck->hdr_digest_loc = length;
+
+    /* Read header digest */
+    zck_log(ZCK_LOG_DEBUG, "Reading header digest\n");
+    header = realloc(header, length + zck->hash_type.digest_size);
+    if(header == NULL) {
+        zck_log(ZCK_LOG_ERROR, "Unable to re-allocate %lu bytes\n",
+                length + zck->hash_type.digest_size);
+        return False;
+    }
+    size_t to_read = 0;
+    if(lead < length + zck->hash_type.digest_size)
+        to_read = length + zck->hash_type.digest_size - lead;
+    if(read_data(zck->fd, header + lead, to_read) < to_read)
+        return False;
+    lead += to_read;
+
+    if(zck->prep_digest &&
+       memcmp(zck->prep_digest, header + length, zck->hash_type.digest_size) != 0) {
+        zck_log(ZCK_LOG_ERROR,
+                "Header digest doesn't match requested header digest\n"
+                "Expected: %s\nActual: %s\n",
+                get_digest_string(zck->prep_digest, zck->hash_type.digest_size),
+                get_digest_string(header + length, zck->hash_type.digest_size));
+        return False;
+    }
+    zck->header_digest = zmalloc(zck->hash_type.digest_size);
+    if(zck->header_digest == NULL) {
+        zck_log(ZCK_LOG_ERROR, "Unable to allocate %lu bytes\n",
+                zck->hash_type.digest_size);
+        return False;
+    }
+    memcpy(zck->header_digest, header + length, zck->hash_type.digest_size);
+    length += zck->hash_type.digest_size;
+
+    /* Check whether full header length matches specified header length */
+    if(zck->prep_hdr_size > -1 &&
+       (size_t)zck->prep_hdr_size != zck->header_length + length) {
+        zck_log(ZCK_LOG_ERROR,
+                "Header length (%lu) doesn't match requested header length "
+                "(%lu)\n", zck->header_length + length,
+                zck->prep_hdr_size);
+        return False;
+    }
+    /* Store pre-header */
+    zck->header = header;
+    zck->header_size = lead;
+    zck->lead_string = header;
+    zck->lead_size = length;
+    zck_log(ZCK_LOG_DEBUG, "Parsed lead: %lu bytes\n", length);
+    return True;
+}
+
+int PUBLIC zck_read_header(zckCtx *zck) {
+    VALIDATE_READ(zck);
+
+    if(!read_header_from_file(zck))
+        return False;
+    if(!read_preface(zck))
+        return False;
+    if(!read_index(zck))
+        return False;
+    if(!read_sig(zck))
+        return False;
+    return True;
+}
diff --git a/src/lib/zck_private.h b/src/lib/zck_private.h
index 190b851..993fa82 100644
--- a/src/lib/zck_private.h
+++ b/src/lib/zck_private.h
@@ -230,20 +230,10 @@ int chunks_from_temp(zckCtx *zck)
     __attribute__ ((warn_unused_result));
 
 /* header.c */
-int read_preface(zckCtx *zck)
-    __attribute__ ((warn_unused_result));
-int read_index(zckCtx *zck)
-    __attribute__ ((warn_unused_result));
-int read_sig(zckCtx *zck)
-    __attribute__ ((warn_unused_result));
 int header_create(zckCtx *zck)
     __attribute__ ((warn_unused_result));
-int sig_create(zckCtx *zck)
-    __attribute__ ((warn_unused_result));
 int write_header(zckCtx *zck)
     __attribute__ ((warn_unused_result));
-int write_sigs(zckCtx *zck)
-    __attribute__ ((warn_unused_result));
 
 /* comp/comp.c */
 int comp_init(zckCtx *zck)
@@ -254,10 +244,6 @@ int comp_reset(zckCtx *zck)
     __attribute__ ((warn_unused_result));
 int comp_add_to_dc(zckComp *comp, const char *src, size_t src_size)
     __attribute__ ((warn_unused_result));
-int comp_add_to_data(zckComp *comp, const char *src, size_t src_size)
-    __attribute__ ((warn_unused_result));
-size_t 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)