revert s/assert/exit changes

Author: Rafael Vanoni

mtbl/compression.c

@@ -482,14 +482,8 @@ _mtbl_decompress_zlib(
 
 	do {
 		zret = inflate(&zs, Z_FINISH);
-		if (zret != Z_STREAM_END && zret != Z_BUF_ERROR) {
-			goto fail;
-		}
-
+		assert(zret == Z_STREAM_END || zret == Z_BUF_ERROR);
 		if (zret != Z_STREAM_END) {
-			if (*output_size > SIZE_MAX / 2) {
-				goto fail;
-			}
 			*output = my_realloc(*output, *output_size * 2);
 			zs.next_out = *output + *output_size;
 			zs.avail_out = *output_size;
@@ -499,11 +493,6 @@ _mtbl_decompress_zlib(
 
 	*output_size = zs.total_out;
 	inflateEnd(&zs);
+
 	return (mtbl_res_success);
-fail:
-	free(*output);
-	*output = NULL;
-	*output_size = 0;
-	inflateEnd(&zs);
-	return (mtbl_res_failure);
 }

mtbl/reader.c

@@ -461,7 +461,7 @@ reader_iter_seek(void *v,
 	       const uint8_t *key, size_t len_key)
 {
 	struct reader_iter *it = (struct reader_iter *) v;
-	
+
 	const uint8_t *ikey, *ival;
 	size_t len_ikey, len_ival;
 	uint64_t new_offset;
@@ -481,7 +481,7 @@ reader_iter_seek(void *v,
 	mtbl_varint_decode64(ival, &new_offset);
 
 	/* We can skip decoding a new block if our new key is within the
-	 * currently-decoded block. */ 
+	 * currently-decoded block. */
 	if (it->b == NULL || it->block_offset != new_offset) {
 		block_destroy(&it->b);
 		block_iter_destroy(&it->bi);
@@ -523,8 +523,7 @@ reader_iter_next(void *v,
 			return (mtbl_res_failure);
 
 		it->b = get_block_at_index(it->r, it->index_iter);
-		if (it->b == NULL)
-			return (mtbl_res_failure);
+		assert(it->b != NULL);
 
 		it->bi = block_iter_init(it->b);
 		block_iter_seek_to_first(it->bi);

mtbl/sorter.c

@@ -140,11 +140,7 @@ mtbl_sorter_init(const struct mtbl_sorter_options *opt)
 	if (s->opt.pool != NULL) {
 		s->pool = s->opt.pool->pool;
 		s->rhandler = result_handler_init(_collect_readers_cb, s);
-		if (s->rhandler == NULL) {
-			entry_vec_destroy(&s->vec);
-			reader_vec_destroy(&s->readers);
-			return (NULL);
-		}
+		assert(s->rhandler != NULL);
 	}
 
 	return (s);
@@ -198,31 +194,16 @@ _mtbl_sorter_write_chunk(struct entry_batch *b)
 	ubuf_append(tmp_fname, (const uint8_t *) "\x00", 1);
 
 	int fd = mkstemp((char *) ubuf_data(tmp_fname));
-	if (fd < 0) {
-		ubuf_destroy(&tmp_fname);
-		return (NULL);
-	}
-
+	assert(fd >= 0);
 	int unlink_ret = unlink((char *) ubuf_data(tmp_fname));
-	if (unlink_ret == -1) {
-		ubuf_destroy(&tmp_fname);
-		close(fd);
-		return (NULL);
-	}
-
+	assert(unlink_ret == 0);
 	ubuf_destroy(&tmp_fname);
 
 	struct mtbl_writer_options *wopt = mtbl_writer_options_init();
 	mtbl_writer_options_set_compression(wopt, MTBL_COMPRESSION_SNAPPY);
 
 	struct mtbl_writer *w = mtbl_writer_init_fd(fd, wopt);
-	if (w == NULL) {
-		mtbl_writer_options_destroy(&wopt);
-		close(fd);
-		entry_vec_destroy(&b->entries);
-		free(b);
-		return (NULL);
-	}
+	assert(w != NULL);
 
 	mtbl_writer_options_destroy(&wopt);
 

mtbl/threadpool.c

@@ -15,11 +15,9 @@
  */
 
 #include <stdlib.h>
-#include <stdio.h>
 #include <pthread.h>
 #include <assert.h>
 #include <stdbool.h>
-#include <string.h>
 #include <mtbl.h>
 
 #include "threadpool.h"
@@ -195,16 +193,7 @@ threadpool_next(struct threadpool *pool)
 		pthread_cond_init(&thr->c, NULL);
 
 		ret = pthread_create(&thr->t, NULL, thread_worker, thr);
-		if (ret != 0) {
-			fprintf(stderr, "%s: pthread_create() failed: %s\n", __func__, strerror(ret));
-			pthread_cond_destroy(&thr->c);
-			pthread_mutex_destroy(&thr->m);
-			free(thr);
-			thr = NULL;
-			pthread_mutex_lock(&pool->m);
-			pool->count--;
-			pthread_mutex_unlock(&pool->m);
-		}
+		assert(ret == 0);
 	}
 
 	return thr;
@@ -400,12 +389,7 @@ result_handler_init(result_cb cb, void *cbdata)
 	rh->cbdata = cbdata;
 
 	ret = pthread_create(&rh->thread, NULL, result_worker, rh);
-	if (ret != 0) {
-		fprintf(stderr, "%s: pthread_create() failed: %s\n", __func__, strerror(ret));
-		resultq_destroy(&rh->rq);
-		free(rh);
-		return (NULL);
-	}
+	assert(ret == 0);
 
 	return rh;
 }
@@ -414,7 +398,9 @@ void
 result_handler_destroy(struct result_handler **prh)
 {
 	struct result_handler *rh = *prh;
-	if (rh == NULL) return;
+	if (rh == NULL)
+		return;
+
 	resultq_finish(rh->rq);
 	pthread_join(rh->thread, NULL);
 	free(rh);

mtbl/writer.c

@@ -146,10 +146,7 @@ mtbl_writer_init_fd(int orig_fd, const struct mtbl_writer_options *opt)
 	int fd;
 
 	fd = dup(orig_fd);
-	if (fd < 0) {
-		return (NULL);
-	}
-
+	assert(fd >= 0);
 	w = my_calloc(1, sizeof(*w));
 	if (opt == NULL) {
 		w->opt.compression_type = DEFAULT_COMPRESSION_TYPE;
@@ -166,14 +163,9 @@ mtbl_writer_init_fd(int orig_fd, const struct mtbl_writer_options *opt)
 	 * to reserve some initial bytes in the file.
 	 */
 	off_t offset = lseek(fd, 0, SEEK_CUR);
-	if (offset == (off_t)-1) {
-		close(fd);
-		free(w);
-		return (NULL);
-	}
-	w->last_offset = (uint64_t)offset;
+	assert(offset != (off_t)-1);
 
-	w->pending_offset = w->last_offset;
+	w->pending_offset = (uint64_t)offset;
 	w->last_key = ubuf_init(256);
 	w->m.file_version = MTBL_FORMAT_V2;
 	w->m.compression_algorithm = w->opt.compression_type;
@@ -185,11 +177,7 @@ mtbl_writer_init_fd(int orig_fd, const struct mtbl_writer_options *opt)
 	if (w->opt.pool != NULL) {
 		w->pool = w->opt.pool->pool;
 		w->rhandler = result_handler_init(_write_data_block_wrapper, w);
-		if (w->rhandler == NULL) {
-			close(fd);
-			free(w);
-			return (NULL);
-		}
+		assert(w->rhandler != NULL);
 	}
 
 	return (w);

src/mtbl_merge.c

@@ -199,6 +199,11 @@ merge(void)
 	 * mtbl_iter_next() returns the same value for end-of-data and error, so we check that the count equals the
 	 * sum of all input entries minus count_merged. Any shortfall means iteration stopped early.
 	 */
+	if (count_merged > total_input_entries) {
+		fprintf(stderr, "%s: error: count_merged (%" PRIu64 ") exceeds total_input_entries (%" PRIu64 ")\n",
+			program_name, count_merged, total_input_entries);
+		exit(EXIT_FAILURE);
+	}
 	uint64_t expected = total_input_entries - count_merged;
 	if (count != expected) {
 		fprintf(stderr, "%s: error: wrote %" PRIu64 " of %" PRIu64 " expected entries; input may be truncated or corrupt\n",