"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);
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);
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);
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);
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);
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;
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) {
}
return True;
}
-int read_preface(zckCtx *zck) {
+static int read_preface(zckCtx *zck) {
VALIDATE_READ(zck);
if(zck->header_digest == NULL) {
return True;
}
-int read_index(zckCtx *zck) {
+static int read_index(zckCtx *zck) {
VALIDATE_READ(zck);
if(zck->preface_string == NULL) {
return True;
}
-int read_sig(zckCtx *zck) {
+static int read_sig(zckCtx *zck) {
VALIDATE_READ(zck);
if(zck->index_string == NULL) {
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);
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);
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) {
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;
+}
__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)
__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)
projects / zchunk.git / commitdiff