diff --git a/.clang-format b/.clang-format
index 55909c0..8bb62b8 100644
--- a/.clang-format
+++ b/.clang-format
@@ -8,5 +8,5 @@
 BraceWrapping:
   BeforeElse: true
 AlignEscapedNewlines: Left
-UseTab: ForContinuationAndIndentation
+UseTab: Never
 #PPDirectiveIndentStyle: AfterHash
diff --git a/examples/in-memory.c b/examples/in-memory.c
index b86089a..1a6f9fa 100644
--- a/examples/in-memory.c
+++ b/examples/in-memory.c
@@ -46,34 +46,34 @@
     FILE *fp;
 
     if ((fp = fopen(archive, "rb")) == NULL) {
-	if (errno != ENOENT) {
-	    fprintf(stderr, "can't open %s: %s\n", archive, strerror(errno));
-	    return -1;
-	}
+        if (errno != ENOENT) {
+            fprintf(stderr, "can't open %s: %s\n", archive, strerror(errno));
+            return -1;
+        }
 
-	*datap = NULL;
-	*sizep = 0;
+        *datap = NULL;
+        *sizep = 0;
 
-	return 0;
+        return 0;
     }
 
     if (fstat(fileno(fp), &st) < 0) {
-	fprintf(stderr, "can't stat %s: %s\n", archive, strerror(errno));
-	fclose(fp);
-	return -1;
+        fprintf(stderr, "can't stat %s: %s\n", archive, strerror(errno));
+        fclose(fp);
+        return -1;
     }
 
     if ((*datap = malloc((size_t)st.st_size)) == NULL) {
-	fprintf(stderr, "can't allocate buffer\n");
-	fclose(fp);
-	return -1;
+        fprintf(stderr, "can't allocate buffer\n");
+        fclose(fp);
+        return -1;
     }
 
     if (fread(*datap, 1, (size_t)st.st_size, fp) < (size_t)st.st_size) {
-	fprintf(stderr, "can't read %s: %s\n", archive, strerror(errno));
-	free(*datap);
-	fclose(fp);
-	return -1;
+        fprintf(stderr, "can't read %s: %s\n", archive, strerror(errno));
+        free(*datap);
+        fclose(fp);
+        return -1;
     }
 
     fclose(fp);
@@ -95,25 +95,25 @@
     FILE *fp;
 
     if (data == NULL) {
-	if (remove(archive) < 0 && errno != ENOENT) {
-	    fprintf(stderr, "can't remove %s: %s\n", archive, strerror(errno));
-	    return -1;
-	}
-	return 0;
+        if (remove(archive) < 0 && errno != ENOENT) {
+            fprintf(stderr, "can't remove %s: %s\n", archive, strerror(errno));
+            return -1;
+        }
+        return 0;
     }
 
     if ((fp = fopen(archive, "wb")) == NULL) {
-	fprintf(stderr, "can't open %s: %s\n", archive, strerror(errno));
-	return -1;
+        fprintf(stderr, "can't open %s: %s\n", archive, strerror(errno));
+        return -1;
     }
     if (fwrite(data, 1, size, fp) < size) {
-	fprintf(stderr, "can't write %s: %s\n", archive, strerror(errno));
-	fclose(fp);
-	return -1;
+        fprintf(stderr, "can't write %s: %s\n", archive, strerror(errno));
+        fclose(fp);
+        return -1;
     }
     if (fclose(fp) < 0) {
-	fprintf(stderr, "can't write %s: %s\n", archive, strerror(errno));
-	return -1;
+        fprintf(stderr, "can't write %s: %s\n", archive, strerror(errno));
+        return -1;
     }
 
     return 0;
@@ -130,31 +130,31 @@
     size_t size;
 
     if (argc < 2) {
-	fprintf(stderr, "usage: %s archive\n", argv[0]);
-	return 1;
+        fprintf(stderr, "usage: %s archive\n", argv[0]);
+        return 1;
     }
     archive = argv[1];
 
     /* get buffer with zip archive inside */
     if (get_data(&data, &size, archive) < 0) {
-	return 1;
+        return 1;
     }
 
     zip_error_init(&error);
     /* create source from buffer */
     if ((src = zip_source_buffer_create(data, size, 1, &error)) == NULL) {
-	fprintf(stderr, "can't create source: %s\n", zip_error_strerror(&error));
-	free(data);
-	zip_error_fini(&error);
-	return 1;
+        fprintf(stderr, "can't create source: %s\n", zip_error_strerror(&error));
+        free(data);
+        zip_error_fini(&error);
+        return 1;
     }
 
     /* open zip archive from source */
     if ((za = zip_open_from_source(src, 0, &error)) == NULL) {
-	fprintf(stderr, "can't open zip from source: %s\n", zip_error_strerror(&error));
-	zip_source_free(src);
-	zip_error_fini(&error);
-	return 1;
+        fprintf(stderr, "can't open zip from source: %s\n", zip_error_strerror(&error));
+        zip_source_free(src);
+        zip_error_fini(&error);
+        return 1;
     }
     zip_error_fini(&error);
 
@@ -166,43 +166,43 @@
 
     /* close archive */
     if (zip_close(za) < 0) {
-	fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
-	return 1;
+        fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
+        return 1;
     }
 
 
     /* copy new archive to buffer */
 
     if (zip_source_is_deleted(src)) {
-	/* new archive is empty, thus no data */
-	data = NULL;
+        /* new archive is empty, thus no data */
+        data = NULL;
     }
     else {
-	zip_stat_t zst;
+        zip_stat_t zst;
 
-	if (zip_source_stat(src, &zst) < 0) {
-	    fprintf(stderr, "can't stat source: %s\n", zip_error_strerror(zip_source_error(src)));
-	    return 1;
-	}
+        if (zip_source_stat(src, &zst) < 0) {
+            fprintf(stderr, "can't stat source: %s\n", zip_error_strerror(zip_source_error(src)));
+            return 1;
+        }
 
-	size = zst.size;
+        size = zst.size;
 
-	if (zip_source_open(src) < 0) {
-	    fprintf(stderr, "can't open source: %s\n", zip_error_strerror(zip_source_error(src)));
-	    return 1;
-	}
-	if ((data = malloc(size)) == NULL) {
-	    fprintf(stderr, "malloc failed: %s\n", strerror(errno));
-	    zip_source_close(src);
-	    return 1;
-	}
-	if ((zip_uint64_t)zip_source_read(src, data, size) < size) {
-	    fprintf(stderr, "can't read data from source: %s\n", zip_error_strerror(zip_source_error(src)));
-	    zip_source_close(src);
-	    free(data);
-	    return 1;
-	}
-	zip_source_close(src);
+        if (zip_source_open(src) < 0) {
+            fprintf(stderr, "can't open source: %s\n", zip_error_strerror(zip_source_error(src)));
+            return 1;
+        }
+        if ((data = malloc(size)) == NULL) {
+            fprintf(stderr, "malloc failed: %s\n", strerror(errno));
+            zip_source_close(src);
+            return 1;
+        }
+        if ((zip_uint64_t)zip_source_read(src, data, size) < size) {
+            fprintf(stderr, "can't read data from source: %s\n", zip_error_strerror(zip_source_error(src)));
+            zip_source_close(src);
+            free(data);
+            return 1;
+        }
+        zip_source_close(src);
     }
 
     /* we're done with src */
diff --git a/examples/windows-open.c b/examples/windows-open.c
index bc8660d..31704a6 100644
--- a/examples/windows-open.c
+++ b/examples/windows-open.c
@@ -42,17 +42,17 @@
     zip_error_init(&error);
     /* create source from buffer */
     if ((src = zip_source_win32w_create(name, 0, -1, &error)) == NULL) {
-	fprintf(stderr, "can't create source: %s\n", zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return NULL;
+        fprintf(stderr, "can't create source: %s\n", zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return NULL;
     }
 
     /* open zip archive from source */
     if ((za = zip_open_from_source(src, flags, &error)) == NULL) {
-	fprintf(stderr, "can't open zip from source: %s\n", zip_error_strerror(&error));
-	zip_source_free(src);
-	zip_error_fini(&error);
-	return NULL;
+        fprintf(stderr, "can't open zip from source: %s\n", zip_error_strerror(&error));
+        zip_source_free(src);
+        zip_error_fini(&error);
+        return NULL;
     }
     zip_error_fini(&error);
 
diff --git a/lib/zip_add.c b/lib/zip_add.c
index 1954235..74723c5 100644
--- a/lib/zip_add.c
+++ b/lib/zip_add.c
@@ -38,9 +38,9 @@
 
 /*
   NOTE: Return type is signed so we can return -1 on error.
-	The index can not be larger than ZIP_INT64_MAX since the size
-	of the central directory cannot be larger than
-	ZIP_UINT64_MAX, and each entry is larger than 2 bytes.
+        The index can not be larger than ZIP_INT64_MAX since the size
+        of the central directory cannot be larger than
+        ZIP_UINT64_MAX, and each entry is larger than 2 bytes.
 */
 
 ZIP_EXTERN zip_int64_t
diff --git a/lib/zip_add_entry.c b/lib/zip_add_entry.c
index f52e0b5..b202231 100644
--- a/lib/zip_add_entry.c
+++ b/lib/zip_add_entry.c
@@ -44,32 +44,32 @@
     zip_uint64_t idx;
 
     if (za->nentry + 1 >= za->nentry_alloc) {
-	zip_entry_t *rentries;
-	zip_uint64_t nalloc = za->nentry_alloc;
-	zip_uint64_t additional_entries = 2 * nalloc;
-	zip_uint64_t realloc_size;
+        zip_entry_t *rentries;
+        zip_uint64_t nalloc = za->nentry_alloc;
+        zip_uint64_t additional_entries = 2 * nalloc;
+        zip_uint64_t realloc_size;
 
-	if (additional_entries < 16) {
-	    additional_entries = 16;
-	}
-	else if (additional_entries > 1024) {
-	    additional_entries = 1024;
-	}
-	/* neither + nor * overflows can happen: nentry_alloc * sizeof(struct zip_entry) < UINT64_MAX */
-	nalloc += additional_entries;
-	realloc_size = sizeof(struct zip_entry) * (size_t)nalloc;
+        if (additional_entries < 16) {
+            additional_entries = 16;
+        }
+        else if (additional_entries > 1024) {
+            additional_entries = 1024;
+        }
+        /* neither + nor * overflows can happen: nentry_alloc * sizeof(struct zip_entry) < UINT64_MAX */
+        nalloc += additional_entries;
+        realloc_size = sizeof(struct zip_entry) * (size_t)nalloc;
 
-	if (sizeof(struct zip_entry) * (size_t)za->nentry_alloc > realloc_size) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
-	rentries = (zip_entry_t *)realloc(za->entry, sizeof(struct zip_entry) * (size_t)nalloc);
-	if (!rentries) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
-	za->entry = rentries;
-	za->nentry_alloc = nalloc;
+        if (sizeof(struct zip_entry) * (size_t)za->nentry_alloc > realloc_size) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
+        rentries = (zip_entry_t *)realloc(za->entry, sizeof(struct zip_entry) * (size_t)nalloc);
+        if (!rentries) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
+        za->entry = rentries;
+        za->nentry_alloc = nalloc;
     }
 
     idx = za->nentry++;
diff --git a/lib/zip_algorithm_bzip2.c b/lib/zip_algorithm_bzip2.c
index f846ac3..59fe1e6 100644
--- a/lib/zip_algorithm_bzip2.c
+++ b/lib/zip_algorithm_bzip2.c
@@ -51,7 +51,7 @@
     zip_uint64_t compressed_size = (zip_uint64_t)((double)uncompressed_size * 1.006);
 
     if (compressed_size < uncompressed_size) {
-	return ZIP_UINT64_MAX;
+        return ZIP_UINT64_MAX;
     }
     return compressed_size;
 }
@@ -62,14 +62,14 @@
     struct ctx *ctx;
 
     if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     ctx->error = error;
     ctx->compress = compress;
     ctx->compression_flags = compression_flags;
     if (ctx->compression_flags < 1 || ctx->compression_flags > 9) {
-	ctx->compression_flags = 9;
+        ctx->compression_flags = 9;
     }
     ctx->end_of_input = false;
 
@@ -115,27 +115,27 @@
     case BZ_OK:
     case BZ_RUN_OK:
     case BZ_STREAM_END:
-	return ZIP_ER_OK;
+        return ZIP_ER_OK;
 
     case BZ_DATA_ERROR:
     case BZ_DATA_ERROR_MAGIC:
     case BZ_UNEXPECTED_EOF:
-	return ZIP_ER_COMPRESSED_DATA;
+        return ZIP_ER_COMPRESSED_DATA;
 
     case BZ_MEM_ERROR:
-	return ZIP_ER_MEMORY;
+        return ZIP_ER_MEMORY;
 
     case BZ_PARAM_ERROR:
-	return ZIP_ER_INVAL;
+        return ZIP_ER_INVAL;
 
     case BZ_CONFIG_ERROR: /* actually, bzip2 miscompiled */
     case BZ_IO_ERROR:
     case BZ_OUTBUFF_FULL:
     case BZ_SEQUENCE_ERROR:
-	return ZIP_ER_INTERNAL;
+        return ZIP_ER_INTERNAL;
 
     default:
-	return ZIP_ER_INTERNAL;
+        return ZIP_ER_INTERNAL;
     }
 }
 
@@ -150,15 +150,15 @@
     ctx->zstr.next_out = NULL;
 
     if (ctx->compress) {
-	ret = BZ2_bzCompressInit(&ctx->zstr, ctx->compression_flags, 0, 30);
+        ret = BZ2_bzCompressInit(&ctx->zstr, ctx->compression_flags, 0, 30);
     }
     else {
-	ret = BZ2_bzDecompressInit(&ctx->zstr, 0, 0);
+        ret = BZ2_bzDecompressInit(&ctx->zstr, 0, 0);
     }
 
     if (ret != BZ_OK) {
-	zip_error_set(ctx->error, map_error(ret), 0);
-	return false;
+        zip_error_set(ctx->error, map_error(ret), 0);
+        return false;
     }
 
     return true;
@@ -171,15 +171,15 @@
     int err;
 
     if (ctx->compress) {
-	err = BZ2_bzCompressEnd(&ctx->zstr);
+        err = BZ2_bzCompressEnd(&ctx->zstr);
     }
     else {
-	err = BZ2_bzDecompressEnd(&ctx->zstr);
+        err = BZ2_bzDecompressEnd(&ctx->zstr);
     }
 
     if (err != BZ_OK) {
-	zip_error_set(ctx->error, map_error(err), 0);
-	return false;
+        zip_error_set(ctx->error, map_error(err), 0);
+        return false;
     }
 
     return true;
@@ -191,8 +191,8 @@
     struct ctx *ctx = (struct ctx *)ud;
 
     if (length > UINT_MAX || ctx->zstr.avail_in > 0) {
-	zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
-	return false;
+        zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
+        return false;
     }
 
     ctx->zstr.avail_in = (unsigned int)length;
@@ -217,39 +217,39 @@
     int ret;
 
     if (ctx->zstr.avail_in == 0 && !ctx->end_of_input) {
-	*length = 0;
-	return ZIP_COMPRESSION_NEED_DATA;
+        *length = 0;
+        return ZIP_COMPRESSION_NEED_DATA;
     }
 
     ctx->zstr.avail_out = (unsigned int)ZIP_MIN(UINT_MAX, *length);
     ctx->zstr.next_out = (char *)data;
 
     if (ctx->compress) {
-	ret = BZ2_bzCompress(&ctx->zstr, ctx->end_of_input ? BZ_FINISH : BZ_RUN);
+        ret = BZ2_bzCompress(&ctx->zstr, ctx->end_of_input ? BZ_FINISH : BZ_RUN);
     }
     else {
-	ret = BZ2_bzDecompress(&ctx->zstr);
+        ret = BZ2_bzDecompress(&ctx->zstr);
     }
 
     *length = *length - ctx->zstr.avail_out;
 
     switch (ret) {
     case BZ_FINISH_OK: /* compression */
-	return ZIP_COMPRESSION_OK;
+        return ZIP_COMPRESSION_OK;
 
     case BZ_OK:     /* decompression */
     case BZ_RUN_OK: /* compression */
-	if (ctx->zstr.avail_in == 0) {
-	    return ZIP_COMPRESSION_NEED_DATA;
-	}
-	return ZIP_COMPRESSION_OK;
+        if (ctx->zstr.avail_in == 0) {
+            return ZIP_COMPRESSION_NEED_DATA;
+        }
+        return ZIP_COMPRESSION_OK;
 
     case BZ_STREAM_END:
-	return ZIP_COMPRESSION_END;
+        return ZIP_COMPRESSION_END;
 
     default:
-	zip_error_set(ctx->error, map_error(ret), 0);
-	return ZIP_COMPRESSION_ERROR;
+        zip_error_set(ctx->error, map_error(ret), 0);
+        return ZIP_COMPRESSION_ERROR;
     }
 }
 
diff --git a/lib/zip_algorithm_deflate.c b/lib/zip_algorithm_deflate.c
index 061a170..14e32a1 100644
--- a/lib/zip_algorithm_deflate.c
+++ b/lib/zip_algorithm_deflate.c
@@ -53,7 +53,7 @@
     zip_uint64_t compressed_size = uncompressed_size + (uncompressed_size + 16383) / 16384 * 5 + 6;
 
     if (compressed_size < uncompressed_size) {
-	return ZIP_UINT64_MAX;
+        return ZIP_UINT64_MAX;
     }
     return compressed_size;
 }
@@ -64,15 +64,15 @@
     struct ctx *ctx;
 
     if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ET_SYS, errno);
-	return NULL;
+        zip_error_set(error, ZIP_ET_SYS, errno);
+        return NULL;
     }
 
     ctx->error = error;
     ctx->compress = compress;
     ctx->compression_flags = compression_flags;
     if (ctx->compression_flags < 1 || ctx->compression_flags > 9) {
-	ctx->compression_flags = Z_BEST_COMPRESSION;
+        ctx->compression_flags = Z_BEST_COMPRESSION;
     }
     ctx->end_of_input = false;
 
@@ -109,14 +109,14 @@
     struct ctx *ctx = (struct ctx *)ud;
 
     if (!ctx->compress) {
-	return 0;
+        return 0;
     }
 
     if (ctx->compression_flags < 3) {
-	return 2 << 1;
+        return 2 << 1;
     }
     else if (ctx->compression_flags > 7) {
-	return 1 << 1;
+        return 1 << 1;
     }
     return 0;
 }
@@ -133,16 +133,16 @@
     ctx->zstr.next_out = NULL;
 
     if (ctx->compress) {
-	/* negative value to tell zlib not to write a header */
-	ret = deflateInit2(&ctx->zstr, ctx->compression_flags, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+        /* negative value to tell zlib not to write a header */
+        ret = deflateInit2(&ctx->zstr, ctx->compression_flags, Z_DEFLATED, -MAX_WBITS, MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
     }
     else {
-	ret = inflateInit2(&ctx->zstr, -MAX_WBITS);
+        ret = inflateInit2(&ctx->zstr, -MAX_WBITS);
     }
 
     if (ret != Z_OK) {
-	zip_error_set(ctx->error, ZIP_ER_ZLIB, ret);
-	return false;
+        zip_error_set(ctx->error, ZIP_ER_ZLIB, ret);
+        return false;
     }
 
 
@@ -156,15 +156,15 @@
     int err;
 
     if (ctx->compress) {
-	err = deflateEnd(&ctx->zstr);
+        err = deflateEnd(&ctx->zstr);
     }
     else {
-	err = inflateEnd(&ctx->zstr);
+        err = inflateEnd(&ctx->zstr);
     }
 
     if (err != Z_OK) {
-	zip_error_set(ctx->error, ZIP_ER_ZLIB, err);
-	return false;
+        zip_error_set(ctx->error, ZIP_ER_ZLIB, err);
+        return false;
     }
 
     return true;
@@ -176,8 +176,8 @@
     struct ctx *ctx = (struct ctx *)ud;
 
     if (length > UINT_MAX || ctx->zstr.avail_in > 0) {
-	zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
-	return false;
+        zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
+        return false;
     }
 
     ctx->zstr.avail_in = (uInt)length;
@@ -205,31 +205,31 @@
     ctx->zstr.next_out = (Bytef *)data;
 
     if (ctx->compress) {
-	ret = deflate(&ctx->zstr, ctx->end_of_input ? Z_FINISH : 0);
+        ret = deflate(&ctx->zstr, ctx->end_of_input ? Z_FINISH : 0);
     }
     else {
-	ret = inflate(&ctx->zstr, Z_SYNC_FLUSH);
+        ret = inflate(&ctx->zstr, Z_SYNC_FLUSH);
     }
 
     *length = *length - ctx->zstr.avail_out;
 
     switch (ret) {
     case Z_OK:
-	return ZIP_COMPRESSION_OK;
+        return ZIP_COMPRESSION_OK;
 
     case Z_STREAM_END:
-	return ZIP_COMPRESSION_END;
+        return ZIP_COMPRESSION_END;
 
     case Z_BUF_ERROR:
-	if (ctx->zstr.avail_in == 0) {
-	    return ZIP_COMPRESSION_NEED_DATA;
-	}
+        if (ctx->zstr.avail_in == 0) {
+            return ZIP_COMPRESSION_NEED_DATA;
+        }
 
-	/* fallthrough */
+        /* fallthrough */
 
     default:
-	zip_error_set(ctx->error, ZIP_ER_ZLIB, ret);
-	return ZIP_COMPRESSION_ERROR;
+        zip_error_set(ctx->error, ZIP_ER_ZLIB, ret);
+        return ZIP_COMPRESSION_ERROR;
     }
 }
 
diff --git a/lib/zip_algorithm_xz.c b/lib/zip_algorithm_xz.c
index 7b7317c..e8f7328 100644
--- a/lib/zip_algorithm_xz.c
+++ b/lib/zip_algorithm_xz.c
@@ -63,7 +63,7 @@
     zip_uint64_t compressed_size = (zip_uint64_t)((double)uncompressed_size * 1.1) + 64 * 1024;
 
     if (compressed_size < uncompressed_size) {
-	return ZIP_UINT64_MAX;
+        return ZIP_UINT64_MAX;
     }
     return compressed_size;
 }
@@ -74,13 +74,13 @@
     struct ctx *ctx;
 
     if (compression_flags < 0) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     ctx->error = error;
@@ -123,16 +123,16 @@
 map_error(lzma_ret ret) {
     switch (ret) {
     case LZMA_UNSUPPORTED_CHECK:
-	return ZIP_ER_COMPRESSED_DATA;
+        return ZIP_ER_COMPRESSED_DATA;
 
     case LZMA_MEM_ERROR:
-	return ZIP_ER_MEMORY;
+        return ZIP_ER_MEMORY;
 
     case LZMA_OPTIONS_ERROR:
-	return ZIP_ER_INVAL;
+        return ZIP_ER_INVAL;
 
     default:
-	return ZIP_ER_INTERNAL;
+        return ZIP_ER_INTERNAL;
     }
 }
 
@@ -145,8 +145,8 @@
     lzma_options_lzma opt_lzma;
     lzma_lzma_preset(&opt_lzma, ctx->compression_flags);
     lzma_filter filters[] = {
-	{.id = (ctx->method == ZIP_CM_LZMA ? LZMA_FILTER_LZMA1 : LZMA_FILTER_LZMA2), .options = &opt_lzma},
-	{.id = LZMA_VLI_UNKNOWN, .options = NULL},
+        {.id = (ctx->method == ZIP_CM_LZMA ? LZMA_FILTER_LZMA1 : LZMA_FILTER_LZMA2), .options = &opt_lzma},
+        {.id = LZMA_VLI_UNKNOWN, .options = NULL},
     };
 
     ctx->zstr.avail_in = 0;
@@ -155,21 +155,21 @@
     ctx->zstr.next_out = NULL;
 
     if (ctx->compress) {
-	if (ctx->method == ZIP_CM_LZMA)
-	    ret = lzma_alone_encoder(&ctx->zstr, filters[0].options);
-	else
-	    ret = lzma_stream_encoder(&ctx->zstr, filters, LZMA_CHECK_CRC64);
+        if (ctx->method == ZIP_CM_LZMA)
+            ret = lzma_alone_encoder(&ctx->zstr, filters[0].options);
+        else
+            ret = lzma_stream_encoder(&ctx->zstr, filters, LZMA_CHECK_CRC64);
     }
     else {
-	if (ctx->method == ZIP_CM_LZMA)
-	    ret = lzma_alone_decoder(&ctx->zstr, UINT64_MAX);
-	else
-	    ret = lzma_stream_decoder(&ctx->zstr, UINT64_MAX, LZMA_CONCATENATED);
+        if (ctx->method == ZIP_CM_LZMA)
+            ret = lzma_alone_decoder(&ctx->zstr, UINT64_MAX);
+        else
+            ret = lzma_stream_decoder(&ctx->zstr, UINT64_MAX, LZMA_CONCATENATED);
     }
 
     if (ret != LZMA_OK) {
-	zip_error_set(ctx->error, map_error(ret), 0);
-	return false;
+        zip_error_set(ctx->error, map_error(ret), 0);
+        return false;
     }
 
     return true;
@@ -190,8 +190,8 @@
     struct ctx *ctx = (struct ctx *)ud;
 
     if (length > UINT_MAX || ctx->zstr.avail_in > 0) {
-	zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
-	return false;
+        zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
+        return false;
     }
 
     ctx->zstr.avail_in = (uInt)length;
@@ -222,20 +222,20 @@
 
     switch (ret) {
     case LZMA_OK:
-	return ZIP_COMPRESSION_OK;
+        return ZIP_COMPRESSION_OK;
 
     case LZMA_STREAM_END:
-	return ZIP_COMPRESSION_END;
+        return ZIP_COMPRESSION_END;
 
     case LZMA_BUF_ERROR:
-	if (ctx->zstr.avail_in == 0) {
-	    return ZIP_COMPRESSION_NEED_DATA;
-	}
+        if (ctx->zstr.avail_in == 0) {
+            return ZIP_COMPRESSION_NEED_DATA;
+        }
 
-	/* fallthrough */
+        /* fallthrough */
     default:
-	zip_error_set(ctx->error, map_error(ret), 0);
-	return ZIP_COMPRESSION_ERROR;
+        zip_error_set(ctx->error, map_error(ret), 0);
+        return ZIP_COMPRESSION_ERROR;
     }
 }
 
diff --git a/lib/zip_algorithm_zstd.c b/lib/zip_algorithm_zstd.c
index b92a07b..f1535d3 100644
--- a/lib/zip_algorithm_zstd.c
+++ b/lib/zip_algorithm_zstd.c
@@ -61,11 +61,11 @@
 
     /* 0: let zstd choose */
     if (compression_flags < 0 || compression_flags > 9) {
-	compression_flags = 0;
+        compression_flags = 0;
     }
 
     if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     ctx->error = error;
@@ -115,23 +115,23 @@
 map_error(size_t ret) {
     switch (ret) {
     case ZSTD_error_no_error:
-	return ZIP_ER_OK;
+        return ZIP_ER_OK;
 
     case ZSTD_error_corruption_detected:
     case ZSTD_error_checksum_wrong:
     case ZSTD_error_dictionary_corrupted:
     case ZSTD_error_dictionary_wrong:
-	return ZIP_ER_COMPRESSED_DATA;
+        return ZIP_ER_COMPRESSED_DATA;
 
     case ZSTD_error_memory_allocation:
-	return ZIP_ER_MEMORY;
+        return ZIP_ER_MEMORY;
 
     case ZSTD_error_parameter_unsupported:
     case ZSTD_error_parameter_outOfBound:
-	return ZIP_ER_INVAL;
+        return ZIP_ER_INVAL;
 
     default:
-	return ZIP_ER_INTERNAL;
+        return ZIP_ER_INTERNAL;
     }
 }
 
@@ -146,24 +146,24 @@
     ctx->out.pos = 0;
     ctx->out.size = 0;
     if (ctx->compress) {
-	size_t ret;
-	ctx->zcstream = ZSTD_createCStream();
-	if (ctx->zcstream == NULL) {
-	    zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
-	    return false;
-	}
-	ret = ZSTD_initCStream(ctx->zcstream, ctx->compression_flags);
-	if (ZSTD_isError(ret)) {
-	    zip_error_set(ctx->error, ZIP_ER_ZLIB, map_error(ret));
-	    return false;
-	}
+        size_t ret;
+        ctx->zcstream = ZSTD_createCStream();
+        if (ctx->zcstream == NULL) {
+            zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
+            return false;
+        }
+        ret = ZSTD_initCStream(ctx->zcstream, ctx->compression_flags);
+        if (ZSTD_isError(ret)) {
+            zip_error_set(ctx->error, ZIP_ER_ZLIB, map_error(ret));
+            return false;
+        }
     }
     else {
-	ctx->zdstream = ZSTD_createDStream();
-	if (ctx->zdstream == NULL) {
-	    zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
-	    return false;
-	}
+        ctx->zdstream = ZSTD_createDStream();
+        if (ctx->zdstream == NULL) {
+            zip_error_set(ctx->error, ZIP_ER_MEMORY, 0);
+            return false;
+        }
     }
 
     return true;
@@ -176,17 +176,17 @@
     size_t ret;
 
     if (ctx->compress) {
-	ret = ZSTD_freeCStream(ctx->zcstream);
-	ctx->zcstream = NULL;
+        ret = ZSTD_freeCStream(ctx->zcstream);
+        ctx->zcstream = NULL;
     }
     else {
-	ret = ZSTD_freeDStream(ctx->zdstream);
-	ctx->zdstream = NULL;
+        ret = ZSTD_freeDStream(ctx->zdstream);
+        ctx->zdstream = NULL;
     }
 
     if (ZSTD_isError(ret)) {
-	zip_error_set(ctx->error, map_error(ret), 0);
-	return false;
+        zip_error_set(ctx->error, map_error(ret), 0);
+        return false;
     }
 
     return true;
@@ -197,8 +197,8 @@
 input(void *ud, zip_uint8_t *data, zip_uint64_t length) {
     struct ctx *ctx = (struct ctx *)ud;
     if (length > SIZE_MAX || ctx->in.pos != ctx->in.size) {
-	zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
-	return false;
+        zip_error_set(ctx->error, ZIP_ER_INVAL, 0);
+        return false;
     }
     ctx->in.src = (const void *)data;
     ctx->in.size = (size_t)length;
@@ -222,8 +222,8 @@
     size_t ret;
 
     if (ctx->in.pos == ctx->in.size && !ctx->end_of_input) {
-	*length = 0;
-	return ZIP_COMPRESSION_NEED_DATA;
+        *length = 0;
+        return ZIP_COMPRESSION_NEED_DATA;
     }
 
     ctx->out.dst = data;
@@ -231,28 +231,28 @@
     ctx->out.size = ZIP_MIN(SIZE_MAX, *length);
 
     if (ctx->compress) {
-	if (ctx->in.pos == ctx->in.size && ctx->end_of_input) {
-	    ret = ZSTD_endStream(ctx->zcstream, &ctx->out);
-	    if (ret == 0) {
-		*length = ctx->out.pos;
-		return ZIP_COMPRESSION_END;
-	    }
-	}
-	else {
-	    ret = ZSTD_compressStream(ctx->zcstream, &ctx->out, &ctx->in);
-	}
+        if (ctx->in.pos == ctx->in.size && ctx->end_of_input) {
+            ret = ZSTD_endStream(ctx->zcstream, &ctx->out);
+            if (ret == 0) {
+                *length = ctx->out.pos;
+                return ZIP_COMPRESSION_END;
+            }
+        }
+        else {
+            ret = ZSTD_compressStream(ctx->zcstream, &ctx->out, &ctx->in);
+        }
     }
     else {
-	ret = ZSTD_decompressStream(ctx->zdstream, &ctx->out, &ctx->in);
+        ret = ZSTD_decompressStream(ctx->zdstream, &ctx->out, &ctx->in);
     }
     if (ZSTD_isError(ret)) {
-	zip_error_set(ctx->error, map_error(ret), 0);
-	return ZIP_COMPRESSION_ERROR;
+        zip_error_set(ctx->error, map_error(ret), 0);
+        return ZIP_COMPRESSION_ERROR;
     }
 
     *length = ctx->out.pos;
     if (ctx->in.pos == ctx->in.size) {
-	return ZIP_COMPRESSION_NEED_DATA;
+        return ZIP_COMPRESSION_NEED_DATA;
     }
 
     return ZIP_COMPRESSION_OK;
diff --git a/lib/zip_buffer.c b/lib/zip_buffer.c
index 8c24b27..8db2ce5 100644
--- a/lib/zip_buffer.c
+++ b/lib/zip_buffer.c
@@ -45,11 +45,11 @@
 void
 _zip_buffer_free(zip_buffer_t *buffer) {
     if (buffer == NULL) {
-	return;
+        return;
     }
 
     if (buffer->free_data) {
-	free(buffer->data);
+        free(buffer->data);
     }
 
     free(buffer);
@@ -69,7 +69,7 @@
     data = _zip_buffer_peek(buffer, length);
 
     if (data != NULL) {
-	buffer->offset += length;
+        buffer->offset += length;
     }
 
     return data;
@@ -81,7 +81,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 2);
 
     if (data == NULL) {
-	return 0;
+        return 0;
     }
 
     return (zip_uint16_t)(data[0] + (data[1] << 8));
@@ -93,7 +93,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 4);
 
     if (data == NULL) {
-	return 0;
+        return 0;
     }
 
     return ((((((zip_uint32_t)data[3] << 8) + data[2]) << 8) + data[1]) << 8) + data[0];
@@ -105,7 +105,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 8);
 
     if (data == NULL) {
-	return 0;
+        return 0;
     }
 
     return ((zip_uint64_t)data[7] << 56) + ((zip_uint64_t)data[6] << 48) + ((zip_uint64_t)data[5] << 40) + ((zip_uint64_t)data[4] << 32) + ((zip_uint64_t)data[3] << 24) + ((zip_uint64_t)data[2] << 16) + ((zip_uint64_t)data[1] << 8) + (zip_uint64_t)data[0];
@@ -117,7 +117,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 1);
 
     if (data == NULL) {
-	return 0;
+        return 0;
     }
 
     return data[0];
@@ -133,7 +133,7 @@
 zip_uint64_t
 _zip_buffer_read(zip_buffer_t *buffer, zip_uint8_t *data, zip_uint64_t length) {
     if (_zip_buffer_left(buffer) < length) {
-	length = _zip_buffer_left(buffer);
+        length = _zip_buffer_left(buffer);
     }
 
     memcpy(data, _zip_buffer_get(buffer, length), length);
@@ -148,16 +148,16 @@
     zip_buffer_t *buffer;
 
     if (data == NULL) {
-	if ((data = (zip_uint8_t *)malloc(size)) == NULL) {
-	    return NULL;
-	}
+        if ((data = (zip_uint8_t *)malloc(size)) == NULL) {
+            return NULL;
+        }
     }
 
     if ((buffer = (zip_buffer_t *)malloc(sizeof(*buffer))) == NULL) {
-	if (free_data) {
-	    free(data);
-	}
-	return NULL;
+        if (free_data) {
+            free(data);
+        }
+        return NULL;
     }
 
     buffer->ok = true;
@@ -175,13 +175,13 @@
     zip_buffer_t *buffer;
 
     if ((buffer = _zip_buffer_new(buf, size)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if (_zip_read(src, buffer->data, size, error) < 0) {
-	_zip_buffer_free(buffer);
-	return NULL;
+        _zip_buffer_free(buffer);
+        return NULL;
     }
 
     return buffer;
@@ -205,8 +205,8 @@
     zip_uint8_t *data;
 
     if (!buffer->ok || buffer->offset + length < length || buffer->offset + length > buffer->size) {
-	buffer->ok = false;
-	return NULL;
+        buffer->ok = false;
+        return NULL;
     }
 
     data = buffer->data + buffer->offset;
@@ -218,7 +218,7 @@
     zip_uint8_t *dst = _zip_buffer_get(buffer, length);
 
     if (dst == NULL) {
-	return -1;
+        return -1;
     }
 
     memcpy(dst, src, length);
@@ -231,7 +231,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 2);
 
     if (data == NULL) {
-	return -1;
+        return -1;
     }
 
     data[0] = (zip_uint8_t)(i & 0xff);
@@ -246,7 +246,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 4);
 
     if (data == NULL) {
-	return -1;
+        return -1;
     }
 
     data[0] = (zip_uint8_t)(i & 0xff);
@@ -263,7 +263,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 8);
 
     if (data == NULL) {
-	return -1;
+        return -1;
     }
 
     data[0] = (zip_uint8_t)(i & 0xff);
@@ -284,7 +284,7 @@
     zip_uint8_t *data = _zip_buffer_get(buffer, 1);
 
     if (data == NULL) {
-	return -1;
+        return -1;
     }
 
     data[0] = i;
@@ -296,8 +296,8 @@
 int
 _zip_buffer_set_offset(zip_buffer_t *buffer, zip_uint64_t offset) {
     if (offset > buffer->size) {
-	buffer->ok = false;
-	return -1;
+        buffer->ok = false;
+        return -1;
     }
 
     buffer->ok = true;
@@ -312,8 +312,8 @@
     zip_uint64_t offset = buffer->offset + length;
 
     if (offset < buffer->offset) {
-	buffer->ok = false;
-	return -1;
+        buffer->ok = false;
+        return -1;
     }
     return _zip_buffer_set_offset(buffer, offset);
 }
diff --git a/lib/zip_close.c b/lib/zip_close.c
index cb640ce..5bd327b 100644
--- a/lib/zip_close.c
+++ b/lib/zip_close.c
@@ -57,225 +57,225 @@
     int changed;
 
     if (za == NULL)
-	return -1;
+        return -1;
 
     changed = _zip_changed(za, &survivors);
 
     /* don't create zip files with no entries */
     if (survivors == 0) {
-	if ((za->open_flags & ZIP_TRUNCATE) || changed) {
-	    if (zip_source_remove(za->src) < 0) {
-		if (!((zip_error_code_zip(zip_source_error(za->src)) == ZIP_ER_REMOVE) && (zip_error_code_system(zip_source_error(za->src)) == ENOENT))) {
-		    _zip_error_set_from_source(&za->error, za->src);
-		    return -1;
-		}
-	    }
-	}
-	zip_discard(za);
-	return 0;
+        if ((za->open_flags & ZIP_TRUNCATE) || changed) {
+            if (zip_source_remove(za->src) < 0) {
+                if (!((zip_error_code_zip(zip_source_error(za->src)) == ZIP_ER_REMOVE) && (zip_error_code_system(zip_source_error(za->src)) == ENOENT))) {
+                    _zip_error_set_from_source(&za->error, za->src);
+                    return -1;
+                }
+            }
+        }
+        zip_discard(za);
+        return 0;
     }
 
     if (!changed) {
-	zip_discard(za);
-	return 0;
+        zip_discard(za);
+        return 0;
     }
 
     if (survivors > za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     if ((filelist = (zip_filelist_t *)malloc(sizeof(filelist[0]) * (size_t)survivors)) == NULL)
-	return -1;
+        return -1;
 
     unchanged_offset = ZIP_UINT64_MAX;
     /* create list of files with index into original archive  */
     for (i = j = 0; i < za->nentry; i++) {
-	if (za->entry[i].orig != NULL && ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
-	    unchanged_offset = ZIP_MIN(unchanged_offset, za->entry[i].orig->offset);
-	}
-	if (za->entry[i].deleted) {
-	    continue;
-	}
+        if (za->entry[i].orig != NULL && ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
+            unchanged_offset = ZIP_MIN(unchanged_offset, za->entry[i].orig->offset);
+        }
+        if (za->entry[i].deleted) {
+            continue;
+        }
 
-	if (j >= survivors) {
-	    free(filelist);
-	    zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	    return -1;
-	}
+        if (j >= survivors) {
+            free(filelist);
+            zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+            return -1;
+        }
 
-	filelist[j].idx = i;
-	j++;
+        filelist[j].idx = i;
+        j++;
     }
     if (j < survivors) {
-	free(filelist);
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        free(filelist);
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     if ((zip_source_supports(za->src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING)) == 0) {
-	unchanged_offset = 0;
+        unchanged_offset = 0;
     }
     else {
-	if (unchanged_offset == ZIP_UINT64_MAX) {
-	    /* we're keeping all file data, find the end of the last one */
-	    zip_uint64_t last_index = ZIP_UINT64_MAX;
-	    unchanged_offset = 0;
+        if (unchanged_offset == ZIP_UINT64_MAX) {
+            /* we're keeping all file data, find the end of the last one */
+            zip_uint64_t last_index = ZIP_UINT64_MAX;
+            unchanged_offset = 0;
 
-	    for (i = 0; i < za->nentry; i++) {
-		if (za->entry[i].orig != NULL) {
-		    if (za->entry[i].orig->offset >= unchanged_offset) {
-			unchanged_offset = za->entry[i].orig->offset;
-			last_index = i;
-		    }
-		}
-	    }
-	    if (last_index != ZIP_UINT64_MAX) {
-		if ((unchanged_offset = _zip_file_get_end(za, last_index, &za->error)) == 0) {
-		    free(filelist);
-		    return -1;
-		}
-	    }
-	}
-	if (unchanged_offset > 0) {
-	    if (zip_source_begin_write_cloning(za->src, unchanged_offset) < 0) {
-		/* cloning not supported, need to copy everything */
-		unchanged_offset = 0;
-	    }
-	}
+            for (i = 0; i < za->nentry; i++) {
+                if (za->entry[i].orig != NULL) {
+                    if (za->entry[i].orig->offset >= unchanged_offset) {
+                        unchanged_offset = za->entry[i].orig->offset;
+                        last_index = i;
+                    }
+                }
+            }
+            if (last_index != ZIP_UINT64_MAX) {
+                if ((unchanged_offset = _zip_file_get_end(za, last_index, &za->error)) == 0) {
+                    free(filelist);
+                    return -1;
+                }
+            }
+        }
+        if (unchanged_offset > 0) {
+            if (zip_source_begin_write_cloning(za->src, unchanged_offset) < 0) {
+                /* cloning not supported, need to copy everything */
+                unchanged_offset = 0;
+            }
+        }
     }
     if (unchanged_offset == 0) {
-	if (zip_source_begin_write(za->src) < 0) {
-	    _zip_error_set_from_source(&za->error, za->src);
-	    free(filelist);
-	    return -1;
-	}
+        if (zip_source_begin_write(za->src) < 0) {
+            _zip_error_set_from_source(&za->error, za->src);
+            free(filelist);
+            return -1;
+        }
     }
 
     if (_zip_progress_start(za->progress) != 0) {
-	zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
-	zip_source_rollback_write(za->src);
-	free(filelist);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
+        zip_source_rollback_write(za->src);
+        free(filelist);
+        return -1;
     }
     error = 0;
     for (j = 0; j < survivors; j++) {
-	int new_data;
-	zip_entry_t *entry;
-	zip_dirent_t *de;
+        int new_data;
+        zip_entry_t *entry;
+        zip_dirent_t *de;
 
-	if (_zip_progress_subrange(za->progress, (double)j / (double)survivors, (double)(j + 1) / (double)survivors) != 0) {
-	    zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
-	    error = 1;
-	    break;
-	}
+        if (_zip_progress_subrange(za->progress, (double)j / (double)survivors, (double)(j + 1) / (double)survivors) != 0) {
+            zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
+            error = 1;
+            break;
+        }
 
-	i = filelist[j].idx;
-	entry = za->entry + i;
+        i = filelist[j].idx;
+        entry = za->entry + i;
 
-	if (entry->orig != NULL && entry->orig->offset < unchanged_offset) {
-	    /* already implicitly copied by cloning */
-	    continue;
-	}
+        if (entry->orig != NULL && entry->orig->offset < unchanged_offset) {
+            /* already implicitly copied by cloning */
+            continue;
+        }
 
-	new_data = (ZIP_ENTRY_DATA_CHANGED(entry) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_COMP_METHOD) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_ENCRYPTION_METHOD));
+        new_data = (ZIP_ENTRY_DATA_CHANGED(entry) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_COMP_METHOD) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_ENCRYPTION_METHOD));
 
-	/* create new local directory entry */
-	if (entry->changes == NULL) {
-	    if ((entry->changes = _zip_dirent_clone(entry->orig)) == NULL) {
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		error = 1;
-		break;
-	    }
-	}
-	de = entry->changes;
+        /* create new local directory entry */
+        if (entry->changes == NULL) {
+            if ((entry->changes = _zip_dirent_clone(entry->orig)) == NULL) {
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                error = 1;
+                break;
+            }
+        }
+        de = entry->changes;
 
-	if (_zip_read_local_ef(za, i) < 0) {
-	    error = 1;
-	    break;
-	}
+        if (_zip_read_local_ef(za, i) < 0) {
+            error = 1;
+            break;
+        }
 
-	if ((off = zip_source_tell_write(za->src)) < 0) {
-	    _zip_error_set_from_source(&za->error, za->src);
-	    error = 1;
-	    break;
-	}
-	de->offset = (zip_uint64_t)off;
+        if ((off = zip_source_tell_write(za->src)) < 0) {
+            _zip_error_set_from_source(&za->error, za->src);
+            error = 1;
+            break;
+        }
+        de->offset = (zip_uint64_t)off;
 
-	if (new_data) {
-	    zip_source_t *zs;
+        if (new_data) {
+            zip_source_t *zs;
 
-	    zs = NULL;
-	    if (!ZIP_ENTRY_DATA_CHANGED(entry)) {
-		if ((zs = _zip_source_zip_new(za, za, i, ZIP_FL_UNCHANGED, 0, 0, NULL)) == NULL) {
-		    error = 1;
-		    break;
-		}
-	    }
+            zs = NULL;
+            if (!ZIP_ENTRY_DATA_CHANGED(entry)) {
+                if ((zs = _zip_source_zip_new(za, za, i, ZIP_FL_UNCHANGED, 0, 0, NULL)) == NULL) {
+                    error = 1;
+                    break;
+                }
+            }
 
-	    /* add_data writes dirent */
-	    if (add_data(za, zs ? zs : entry->source, de, entry->changes ? entry->changes->changed : 0) < 0) {
-		error = 1;
-		if (zs)
-		    zip_source_free(zs);
-		break;
-	    }
-	    if (zs)
-		zip_source_free(zs);
-	}
-	else {
-	    zip_uint64_t offset;
+            /* add_data writes dirent */
+            if (add_data(za, zs ? zs : entry->source, de, entry->changes ? entry->changes->changed : 0) < 0) {
+                error = 1;
+                if (zs)
+                    zip_source_free(zs);
+                break;
+            }
+            if (zs)
+                zip_source_free(zs);
+        }
+        else {
+            zip_uint64_t offset;
 
-	    if (de->encryption_method != ZIP_EM_TRAD_PKWARE) {
-		/* when copying data, all sizes are known -> no data descriptor needed */
-		/* except for PKWare encryption, where removing the data descriptor breaks password validation */
-		de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
-	    }
-	    if (_zip_dirent_write(za, de, ZIP_FL_LOCAL) < 0) {
-		error = 1;
-		break;
-	    }
-	    if ((offset = _zip_file_get_offset(za, i, &za->error)) == 0) {
-		error = 1;
-		break;
-	    }
-	    if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
-		_zip_error_set_from_source(&za->error, za->src);
-		error = 1;
-		break;
-	    }
-	    if (copy_data(za, de->comp_size) < 0) {
-		error = 1;
-		break;
-	    }
+            if (de->encryption_method != ZIP_EM_TRAD_PKWARE) {
+                /* when copying data, all sizes are known -> no data descriptor needed */
+                /* except for PKWare encryption, where removing the data descriptor breaks password validation */
+                de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
+            }
+            if (_zip_dirent_write(za, de, ZIP_FL_LOCAL) < 0) {
+                error = 1;
+                break;
+            }
+            if ((offset = _zip_file_get_offset(za, i, &za->error)) == 0) {
+                error = 1;
+                break;
+            }
+            if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
+                _zip_error_set_from_source(&za->error, za->src);
+                error = 1;
+                break;
+            }
+            if (copy_data(za, de->comp_size) < 0) {
+                error = 1;
+                break;
+            }
 
-	    if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
-		if (write_data_descriptor(za, de, _zip_dirent_needs_zip64(de, 0)) < 0) {
-		    error = 1;
-		    break;
-		}
-	    }
-	}
+            if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
+                if (write_data_descriptor(za, de, _zip_dirent_needs_zip64(de, 0)) < 0) {
+                    error = 1;
+                    break;
+                }
+            }
+        }
     }
 
     if (!error) {
-	if (write_cdir(za, filelist, survivors) < 0)
-	    error = 1;
+        if (write_cdir(za, filelist, survivors) < 0)
+            error = 1;
     }
 
     free(filelist);
 
     if (!error) {
-	if (zip_source_commit_write(za->src) != 0) {
-	    _zip_error_set_from_source(&za->error, za->src);
-	    error = 1;
-	}
-	_zip_progress_end(za->progress);
+        if (zip_source_commit_write(za->src) != 0) {
+            _zip_error_set_from_source(&za->error, za->src);
+            error = 1;
+        }
+        _zip_progress_end(za->progress);
     }
 
     if (error) {
-	zip_source_rollback_write(za->src);
-	return -1;
+        zip_source_rollback_write(za->src);
+        return -1;
     }
 
     zip_discard(za);
@@ -296,78 +296,78 @@
     bool needs_recompress, needs_decompress, needs_crc, needs_compress, needs_reencrypt, needs_decrypt, needs_encrypt;
 
     if (zip_source_stat(src, &st) < 0) {
-	_zip_error_set_from_source(&za->error, src);
-	return -1;
+        _zip_error_set_from_source(&za->error, src);
+        return -1;
     }
 
     if ((st.valid & ZIP_STAT_COMP_METHOD) == 0) {
-	st.valid |= ZIP_STAT_COMP_METHOD;
-	st.comp_method = ZIP_CM_STORE;
+        st.valid |= ZIP_STAT_COMP_METHOD;
+        st.comp_method = ZIP_CM_STORE;
     }
 
     if (ZIP_CM_IS_DEFAULT(de->comp_method) && st.comp_method != ZIP_CM_STORE)
-	de->comp_method = st.comp_method;
+        de->comp_method = st.comp_method;
     else if (de->comp_method == ZIP_CM_STORE && (st.valid & ZIP_STAT_SIZE)) {
-	st.valid |= ZIP_STAT_COMP_SIZE;
-	st.comp_size = st.size;
+        st.valid |= ZIP_STAT_COMP_SIZE;
+        st.comp_size = st.size;
     }
     else {
-	/* we'll recompress */
-	st.valid &= ~ZIP_STAT_COMP_SIZE;
+        /* we'll recompress */
+        st.valid &= ~ZIP_STAT_COMP_SIZE;
     }
 
     if ((st.valid & ZIP_STAT_ENCRYPTION_METHOD) == 0) {
-	st.valid |= ZIP_STAT_ENCRYPTION_METHOD;
-	st.encryption_method = ZIP_EM_NONE;
+        st.valid |= ZIP_STAT_ENCRYPTION_METHOD;
+        st.encryption_method = ZIP_EM_NONE;
     }
 
     flags = ZIP_EF_LOCAL;
 
     if ((st.valid & ZIP_STAT_SIZE) == 0) {
-	flags |= ZIP_FL_FORCE_ZIP64;
-	data_length = -1;
+        flags |= ZIP_FL_FORCE_ZIP64;
+        data_length = -1;
     }
     else {
-	de->uncomp_size = st.size;
-	/* this is technically incorrect (copy_source counts compressed data), but it's the best we have */
-	data_length = (zip_int64_t)st.size;
+        de->uncomp_size = st.size;
+        /* this is technically incorrect (copy_source counts compressed data), but it's the best we have */
+        data_length = (zip_int64_t)st.size;
 
-	if ((st.valid & ZIP_STAT_COMP_SIZE) == 0) {
-	    zip_uint64_t max_compressed_size;
-	    zip_uint16_t compression_method = ZIP_CM_ACTUAL(de->comp_method);
+        if ((st.valid & ZIP_STAT_COMP_SIZE) == 0) {
+            zip_uint64_t max_compressed_size;
+            zip_uint16_t compression_method = ZIP_CM_ACTUAL(de->comp_method);
 
-	    if (compression_method == ZIP_CM_STORE) {
-		max_compressed_size = st.size;
-	    }
-	    else {
-		zip_compression_algorithm_t *algorithm = _zip_get_compression_algorithm(compression_method, true);
-		if (algorithm == NULL) {
-		    max_compressed_size = ZIP_UINT64_MAX;
-		}
-		else {
-		    max_compressed_size = algorithm->maximum_compressed_size(st.size);
-		}
-	    }
+            if (compression_method == ZIP_CM_STORE) {
+                max_compressed_size = st.size;
+            }
+            else {
+                zip_compression_algorithm_t *algorithm = _zip_get_compression_algorithm(compression_method, true);
+                if (algorithm == NULL) {
+                    max_compressed_size = ZIP_UINT64_MAX;
+                }
+                else {
+                    max_compressed_size = algorithm->maximum_compressed_size(st.size);
+                }
+            }
 
-	    if (max_compressed_size > 0xffffffffu) {
-		flags |= ZIP_FL_FORCE_ZIP64;
-	    }
-	}
-	else {
-	    de->comp_size = st.comp_size;
-	    data_length = (zip_int64_t)st.comp_size;
-	}
+            if (max_compressed_size > 0xffffffffu) {
+                flags |= ZIP_FL_FORCE_ZIP64;
+            }
+        }
+        else {
+            de->comp_size = st.comp_size;
+            data_length = (zip_int64_t)st.comp_size;
+        }
     }
 
     if ((offstart = zip_source_tell_write(za->src)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
 
     /* as long as we don't support non-seekable output, clear data descriptor bit */
     de->bitflags &= (zip_uint16_t)~ZIP_GPBF_DATA_DESCRIPTOR;
     if ((is_zip64 = _zip_dirent_write(za, de, flags)) < 0) {
-	return -1;
+        return -1;
     }
 
     needs_recompress = st.comp_method != ZIP_CM_ACTUAL(de->comp_method);
@@ -384,127 +384,127 @@
     zip_source_keep(src_final);
 
     if (needs_decrypt) {
-	zip_encryption_implementation impl;
+        zip_encryption_implementation impl;
 
-	if ((impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	    zip_source_free(src_final);
-	    return -1;
-	}
-	if ((src_tmp = impl(za, src_final, st.encryption_method, ZIP_CODEC_DECODE, za->default_password)) == NULL) {
-	    /* error set by impl */
-	    zip_source_free(src_final);
-	    return -1;
-	}
+        if ((impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+            zip_source_free(src_final);
+            return -1;
+        }
+        if ((src_tmp = impl(za, src_final, st.encryption_method, ZIP_CODEC_DECODE, za->default_password)) == NULL) {
+            /* error set by impl */
+            zip_source_free(src_final);
+            return -1;
+        }
 
-	zip_source_free(src_final);
-	src_final = src_tmp;
+        zip_source_free(src_final);
+        src_final = src_tmp;
     }
 
     if (needs_decompress) {
-	if ((src_tmp = zip_source_decompress(za, src_final, st.comp_method)) == NULL) {
-	    zip_source_free(src_final);
-	    return -1;
-	}
+        if ((src_tmp = zip_source_decompress(za, src_final, st.comp_method)) == NULL) {
+            zip_source_free(src_final);
+            return -1;
+        }
 
-	zip_source_free(src_final);
-	src_final = src_tmp;
+        zip_source_free(src_final);
+        src_final = src_tmp;
     }
 
     if (needs_crc) {
-	if ((src_tmp = zip_source_crc(za, src_final, 0)) == NULL) {
-	    zip_source_free(src_final);
-	    return -1;
-	}
+        if ((src_tmp = zip_source_crc(za, src_final, 0)) == NULL) {
+            zip_source_free(src_final);
+            return -1;
+        }
 
-	zip_source_free(src_final);
-	src_final = src_tmp;
+        zip_source_free(src_final);
+        src_final = src_tmp;
     }
 
     if (needs_compress) {
-	if ((src_tmp = zip_source_compress(za, src_final, de->comp_method, de->compression_level)) == NULL) {
-	    zip_source_free(src_final);
-	    return -1;
-	}
+        if ((src_tmp = zip_source_compress(za, src_final, de->comp_method, de->compression_level)) == NULL) {
+            zip_source_free(src_final);
+            return -1;
+        }
 
-	zip_source_free(src_final);
-	src_final = src_tmp;
+        zip_source_free(src_final);
+        src_final = src_tmp;
     }
 
 
     if (needs_encrypt) {
-	zip_encryption_implementation impl;
-	const char *password = NULL;
+        zip_encryption_implementation impl;
+        const char *password = NULL;
 
-	if (de->password) {
-	    password = de->password;
-	}
-	else if (za->default_password) {
-	    password = za->default_password;
-	}
+        if (de->password) {
+            password = de->password;
+        }
+        else if (za->default_password) {
+            password = za->default_password;
+        }
 
-	if ((impl = _zip_get_encryption_implementation(de->encryption_method, ZIP_CODEC_ENCODE)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	    zip_source_free(src_final);
-	    return -1;
-	}
-	if ((src_tmp = impl(za, src_final, de->encryption_method, ZIP_CODEC_ENCODE, password)) == NULL) {
-	    /* error set by impl */
-	    zip_source_free(src_final);
-	    return -1;
-	}
-	if (de->encryption_method == ZIP_EM_TRAD_PKWARE) {
-	    de->bitflags |= ZIP_GPBF_DATA_DESCRIPTOR;
-	}
+        if ((impl = _zip_get_encryption_implementation(de->encryption_method, ZIP_CODEC_ENCODE)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+            zip_source_free(src_final);
+            return -1;
+        }
+        if ((src_tmp = impl(za, src_final, de->encryption_method, ZIP_CODEC_ENCODE, password)) == NULL) {
+            /* error set by impl */
+            zip_source_free(src_final);
+            return -1;
+        }
+        if (de->encryption_method == ZIP_EM_TRAD_PKWARE) {
+            de->bitflags |= ZIP_GPBF_DATA_DESCRIPTOR;
+        }
 
-	zip_source_free(src_final);
-	src_final = src_tmp;
+        zip_source_free(src_final);
+        src_final = src_tmp;
     }
 
 
     if ((offdata = zip_source_tell_write(za->src)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
 
     ret = copy_source(za, src_final, data_length);
 
     if (zip_source_stat(src_final, &st) < 0) {
-	_zip_error_set_from_source(&za->error, src_final);
-	ret = -1;
+        _zip_error_set_from_source(&za->error, src_final);
+        ret = -1;
     }
 
     if (zip_source_get_file_attributes(src_final, &attributes) != 0) {
-	_zip_error_set_from_source(&za->error, src_final);
-	ret = -1;
+        _zip_error_set_from_source(&za->error, src_final);
+        ret = -1;
     }
 
     zip_source_free(src_final);
 
     if (ret < 0) {
-	return -1;
+        return -1;
     }
 
     if ((offend = zip_source_tell_write(za->src)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
 
     if (zip_source_seek_write(za->src, offstart, SEEK_SET) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
 
     if ((st.valid & (ZIP_STAT_COMP_METHOD | ZIP_STAT_CRC | ZIP_STAT_SIZE)) != (ZIP_STAT_COMP_METHOD | ZIP_STAT_CRC | ZIP_STAT_SIZE)) {
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     if ((de->changed & ZIP_DIRENT_LAST_MOD) == 0) {
-	if (st.valid & ZIP_STAT_MTIME)
-	    de->last_mod = st.mtime;
-	else
-	    time(&de->last_mod);
+        if (st.valid & ZIP_STAT_MTIME)
+            de->last_mod = st.mtime;
+        else
+            time(&de->last_mod);
     }
     de->comp_method = st.comp_method;
     de->crc = st.crc;
@@ -513,23 +513,23 @@
     _zip_dirent_apply_attributes(de, &attributes, (flags & ZIP_FL_FORCE_ZIP64) != 0, changed);
 
     if ((ret = _zip_dirent_write(za, de, flags)) < 0)
-	return -1;
+        return -1;
 
     if (is_zip64 != ret) {
-	/* Zip64 mismatch between preliminary file header written before data and final file header written afterwards */
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        /* Zip64 mismatch between preliminary file header written before data and final file header written afterwards */
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     if (zip_source_seek_write(za->src, offend, SEEK_SET) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
 
     if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
-	if (write_data_descriptor(za, de, is_zip64) < 0) {
-	    return -1;
-	}
+        if (write_data_descriptor(za, de, is_zip64) < 0) {
+            return -1;
+        }
     }
 
     return 0;
@@ -543,28 +543,28 @@
     double total = (double)len;
 
     if (!byte_array_init(buf, BUFSIZE)) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     while (len > 0) {
-	n = len > BUFSIZE ? BUFSIZE : len;
-	if (_zip_read(za->src, buf, n, &za->error) < 0) {
-	    byte_array_fini(buf);
-	    return -1;
-	}
+        n = len > BUFSIZE ? BUFSIZE : len;
+        if (_zip_read(za->src, buf, n, &za->error) < 0) {
+            byte_array_fini(buf);
+            return -1;
+        }
 
-	if (_zip_write(za, buf, n) < 0) {
-	    byte_array_fini(buf);
-	    return -1;
-	}
+        if (_zip_write(za, buf, n) < 0) {
+            byte_array_fini(buf);
+            return -1;
+        }
 
-	len -= n;
+        len -= n;
 
-	if (_zip_progress_update(za->progress, (total - (double)len) / total) != 0) {
-	    zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
-	    return -1;
-	}
+        if (_zip_progress_update(za->progress, (total - (double)len) / total) != 0) {
+            zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
+            return -1;
+        }
     }
 
     byte_array_fini(buf);
@@ -579,35 +579,35 @@
     int ret;
 
     if (zip_source_open(src) < 0) {
-	_zip_error_set_from_source(&za->error, src);
-	return -1;
+        _zip_error_set_from_source(&za->error, src);
+        return -1;
     }
 
     if (!byte_array_init(buf, BUFSIZE)) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     ret = 0;
     current = 0;
     while ((n = zip_source_read(src, buf, BUFSIZE)) > 0) {
-	if (_zip_write(za, buf, (zip_uint64_t)n) < 0) {
-	    ret = -1;
-	    break;
-	}
-	if (n == BUFSIZE && za->progress && data_length > 0) {
-	    current += n;
-	    if (_zip_progress_update(za->progress, (double)current / (double)data_length) != 0) {
-		zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
-		ret = -1;
-		break;
-	    }
-	}
+        if (_zip_write(za, buf, (zip_uint64_t)n) < 0) {
+            ret = -1;
+            break;
+        }
+        if (n == BUFSIZE && za->progress && data_length > 0) {
+            current += n;
+            if (_zip_progress_update(za->progress, (double)current / (double)data_length) != 0) {
+                zip_error_set(&za->error, ZIP_ER_CANCELLED, 0);
+                ret = -1;
+                break;
+            }
+        }
     }
 
     if (n < 0) {
-	_zip_error_set_from_source(&za->error, src);
-	ret = -1;
+        _zip_error_set_from_source(&za->error, src);
+        ret = -1;
     }
 
     byte_array_fini(buf);
@@ -622,15 +622,15 @@
     zip_int64_t cd_start, end, size;
 
     if ((cd_start = zip_source_tell_write(za->src)) < 0) {
-	return -1;
+        return -1;
     }
 
     if ((size = _zip_cdir_write(za, filelist, survivors)) < 0) {
-	return -1;
+        return -1;
     }
 
     if ((end = zip_source_tell_write(za->src)) < 0) {
-	return -1;
+        return -1;
     }
 
     return 0;
@@ -646,20 +646,20 @@
     survivors = 0;
 
     if (za->comment_changed || za->ch_flags != za->flags) {
-	changed = 1;
+        changed = 1;
     }
 
     for (i = 0; i < za->nentry; i++) {
-	if (ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
-	    changed = 1;
-	}
-	if (!za->entry[i].deleted) {
-	    survivors++;
-	}
+        if (ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
+            changed = 1;
+        }
+        if (!za->entry[i].deleted) {
+            survivors++;
+        }
     }
 
     if (survivorsp) {
-	*survivorsp = survivors;
+        *survivorsp = survivors;
     }
 
     return changed;
@@ -671,27 +671,27 @@
     int ret = 0;
 
     if (buffer == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     _zip_buffer_put(buffer, DATADES_MAGIC, 4);
     _zip_buffer_put_32(buffer, de->crc);
     if (is_zip64) {
-	_zip_buffer_put_64(buffer, de->comp_size);
-	_zip_buffer_put_64(buffer, de->uncomp_size);
+        _zip_buffer_put_64(buffer, de->comp_size);
+        _zip_buffer_put_64(buffer, de->uncomp_size);
     }
     else {
-	_zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);
-	_zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);
+        _zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);
+        _zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);
     }
 
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	ret = -1;
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        ret = -1;
     }
     else {
-	ret = _zip_write(za, _zip_buffer_data(buffer), _zip_buffer_offset(buffer));
+        ret = _zip_write(za, _zip_buffer_data(buffer), _zip_buffer_offset(buffer));
     }
 
     _zip_buffer_free(buffer);
diff --git a/lib/zip_crypto_commoncrypto.c b/lib/zip_crypto_commoncrypto.c
index 2d57bd4..84ac514 100644
--- a/lib/zip_crypto_commoncrypto.c
+++ b/lib/zip_crypto_commoncrypto.c
@@ -43,7 +43,7 @@
 void
 _zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-	return;
+        return;
     }
 
     CCCryptorRelease(aes);
@@ -67,19 +67,19 @@
 
     switch (ret) {
     case kCCSuccess:
-	return aes;
+        return aes;
 
     case kCCMemoryFailure:
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
 
     case kCCParamError:
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
 
     default:
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        return NULL;
     }
 }
 
@@ -87,7 +87,7 @@
 void
 _zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     if (hmac == NULL) {
-	return;
+        return;
     }
 
     _zip_crypto_clear(hmac, sizeof(*hmac));
@@ -100,8 +100,8 @@
     _zip_crypto_hmac_t *hmac;
 
     if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     CCHmacInit(hmac, kCCHmacAlgSHA1, secret, secret_length);
diff --git a/lib/zip_crypto_gnutls.c b/lib/zip_crypto_gnutls.c
index 9aa9efd..e5b9b1a 100644
--- a/lib/zip_crypto_gnutls.c
+++ b/lib/zip_crypto_gnutls.c
@@ -42,26 +42,26 @@
     _zip_crypto_aes_t *aes;
 
     if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     aes->key_size = key_size;
 
     switch (aes->key_size) {
     case 128:
-	nettle_aes128_set_encrypt_key(&aes->ctx.ctx_128, key);
-	break;
+        nettle_aes128_set_encrypt_key(&aes->ctx.ctx_128, key);
+        break;
     case 192:
-	nettle_aes192_set_encrypt_key(&aes->ctx.ctx_192, key);
-	break;
+        nettle_aes192_set_encrypt_key(&aes->ctx.ctx_192, key);
+        break;
     case 256:
-	nettle_aes256_set_encrypt_key(&aes->ctx.ctx_256, key);
-	break;
+        nettle_aes256_set_encrypt_key(&aes->ctx.ctx_256, key);
+        break;
     default:
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	free(aes);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        free(aes);
+        return NULL;
     }
 
     return aes;
@@ -71,14 +71,14 @@
 _zip_crypto_aes_encrypt_block(_zip_crypto_aes_t *aes, const zip_uint8_t *in, zip_uint8_t *out) {
     switch (aes->key_size) {
     case 128:
-	nettle_aes128_encrypt(&aes->ctx.ctx_128, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
-	break;
+        nettle_aes128_encrypt(&aes->ctx.ctx_128, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
+        break;
     case 192:
-	nettle_aes192_encrypt(&aes->ctx.ctx_192, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
-	break;
+        nettle_aes192_encrypt(&aes->ctx.ctx_192, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
+        break;
     case 256:
-	nettle_aes256_encrypt(&aes->ctx.ctx_256, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
-	break;
+        nettle_aes256_encrypt(&aes->ctx.ctx_256, ZIP_CRYPTO_AES_BLOCK_LENGTH, out, in);
+        break;
     }
 
     return true;
@@ -87,7 +87,7 @@
 void
 _zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-	return;
+        return;
     }
 
     _zip_crypto_clear(aes, sizeof(*aes));
@@ -101,14 +101,14 @@
     int ret;
 
     if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ret = gnutls_hmac_init(hmac, GNUTLS_MAC_SHA1, secret, secret_length)) < 0) {
-	/* TODO: set error */
-	free(hmac);
-	return NULL;
+        /* TODO: set error */
+        free(hmac);
+        return NULL;
     }
 
     return hmac;
@@ -120,7 +120,7 @@
     zip_uint8_t buf[ZIP_CRYPTO_SHA1_LENGTH];
 
     if (hmac == NULL) {
-	return;
+        return;
     }
 
     gnutls_hmac_deinit(*hmac, buf);
diff --git a/lib/zip_crypto_gnutls.h b/lib/zip_crypto_gnutls.h
index 30645ef..19abed6 100644
--- a/lib/zip_crypto_gnutls.h
+++ b/lib/zip_crypto_gnutls.h
@@ -45,9 +45,9 @@
 
 typedef struct {
     union {
-	struct aes128_ctx ctx_128;
-	struct aes192_ctx ctx_192;
-	struct aes256_ctx ctx_256;
+        struct aes128_ctx ctx_128;
+        struct aes192_ctx ctx_192;
+        struct aes256_ctx ctx_256;
     } ctx;
     zip_uint16_t key_size;
 } _zip_crypto_aes_t;
diff --git a/lib/zip_crypto_mbedtls.c b/lib/zip_crypto_mbedtls.c
index 7063c6b..d5b76dd 100644
--- a/lib/zip_crypto_mbedtls.c
+++ b/lib/zip_crypto_mbedtls.c
@@ -48,8 +48,8 @@
     _zip_crypto_aes_t *aes;
 
     if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     mbedtls_aes_init(aes);
@@ -61,7 +61,7 @@
 void
 _zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-	return;
+        return;
     }
 
     mbedtls_aes_free(aes);
@@ -74,27 +74,27 @@
     _zip_crypto_hmac_t *hmac;
 
     if (secret_length > INT_MAX) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     mbedtls_md_init(hmac);
 
     if (mbedtls_md_setup(hmac, mbedtls_md_info_from_type(MBEDTLS_MD_SHA1), 1) != 0) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	free(hmac);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        free(hmac);
+        return NULL;
     }
 
     if (mbedtls_md_hmac_starts(hmac, (const unsigned char *)secret, (size_t)secret_length) != 0) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	free(hmac);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        free(hmac);
+        return NULL;
     }
 
     return hmac;
@@ -104,7 +104,7 @@
 void
 _zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     if (hmac == NULL) {
-	return;
+        return;
     }
 
     mbedtls_md_free(hmac);
@@ -120,11 +120,11 @@
     mbedtls_md_init(&sha1_ctx);
 
     if (mbedtls_md_setup(&sha1_ctx, mbedtls_md_info_from_type(MBEDTLS_MD_SHA1), 1) != 0) {
-	ok = false;
+        ok = false;
     }
 
     if (ok && mbedtls_pkcs5_pbkdf2_hmac(&sha1_ctx, (const unsigned char *)key, (size_t)key_length, (const unsigned char *)salt, (size_t)salt_length, (unsigned int)iterations, (uint32_t)output_length, (unsigned char *)output) != 0) {
-	ok = false;
+        ok = false;
     }
 
     mbedtls_md_free(&sha1_ctx);
@@ -143,19 +143,19 @@
     const unsigned char *pers = "zip_crypto_mbedtls";
 
     if (!ctx) {
-	ctx = (zip_random_context_t *)malloc(sizeof(zip_random_context_t));
-	if (!ctx) {
-	    return false;
-	}
-	mbedtls_entropy_init(&ctx->entropy);
-	mbedtls_ctr_drbg_init(&ctx->ctr_drbg);
-	if (mbedtls_ctr_drbg_seed(&ctx->ctr_drbg, mbedtls_entropy_func, &ctx->entropy, pers, strlen(pers)) != 0) {
-	    mbedtls_ctr_drbg_free(&ctx->ctr_drbg);
-	    mbedtls_entropy_free(&ctx->entropy);
-	    free(ctx);
-	    ctx = NULL;
-	    return false;
-	}
+        ctx = (zip_random_context_t *)malloc(sizeof(zip_random_context_t));
+        if (!ctx) {
+            return false;
+        }
+        mbedtls_entropy_init(&ctx->entropy);
+        mbedtls_ctr_drbg_init(&ctx->ctr_drbg);
+        if (mbedtls_ctr_drbg_seed(&ctx->ctr_drbg, mbedtls_entropy_func, &ctx->entropy, pers, strlen(pers)) != 0) {
+            mbedtls_ctr_drbg_free(&ctx->ctr_drbg);
+            mbedtls_entropy_free(&ctx->entropy);
+            free(ctx);
+            ctx = NULL;
+            return false;
+        }
     }
 
     return mbedtls_ctr_drbg_random(&ctx->ctr_drbg, (unsigned char *)buffer, (size_t)length) == 0;
diff --git a/lib/zip_crypto_openssl.c b/lib/zip_crypto_openssl.c
index 55c9d9d..446e640 100644
--- a/lib/zip_crypto_openssl.c
+++ b/lib/zip_crypto_openssl.c
@@ -50,8 +50,8 @@
     _zip_crypto_aes_t *aes;
 
     if ((aes = (_zip_crypto_aes_t *)malloc(sizeof(*aes))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     AES_set_encrypt_key(key, key_size, aes);
@@ -62,7 +62,7 @@
 void
 _zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-	return;
+        return;
     }
 
     _zip_crypto_clear(aes, sizeof(*aes));
@@ -75,32 +75,32 @@
     _zip_crypto_hmac_t *hmac;
 
     if (secret_length > INT_MAX) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
 #ifdef USE_OPENSSL_1_0_API
     if ((hmac = (_zip_crypto_hmac_t *)malloc(sizeof(*hmac))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     HMAC_CTX_init(hmac);
 #else
     if ((hmac = HMAC_CTX_new()) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 #endif
 
     if (HMAC_Init_ex(hmac, secret, (int)secret_length, EVP_sha1(), NULL) != 1) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
 #ifdef USE_OPENSSL_1_0_API
-	free(hmac);
+        free(hmac);
 #else
-	HMAC_CTX_free(hmac);
+        HMAC_CTX_free(hmac);
 #endif
-	return NULL;
+        return NULL;
     }
 
     return hmac;
@@ -110,7 +110,7 @@
 void
 _zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     if (hmac == NULL) {
-	return;
+        return;
     }
 
 #ifdef USE_OPENSSL_1_0_API
diff --git a/lib/zip_crypto_win.c b/lib/zip_crypto_win.c
index 7eb42c3..a6bdc0d 100644
--- a/lib/zip_crypto_win.c
+++ b/lib/zip_crypto_win.c
@@ -91,7 +91,7 @@
     BCRYPT_ALG_HANDLE hAlgorithm = NULL;
 
     if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG))) {
-	return false;
+        return false;
     }
 
     bool result = BCRYPT_SUCCESS(BCryptDeriveKeyPBKDF2(hAlgorithm, (PUCHAR)key, (ULONG)key_length, (PUCHAR)salt, salt_length, iterations, output, output_length, 0));
@@ -120,13 +120,13 @@
 static void
 hmacFree(PRF_CTX *pContext) {
     if (pContext->hOuterHash)
-	BCryptDestroyHash(pContext->hOuterHash);
+        BCryptDestroyHash(pContext->hOuterHash);
     if (pContext->hInnerHash)
-	BCryptDestroyHash(pContext->hInnerHash);
+        BCryptDestroyHash(pContext->hInnerHash);
     free(pContext->pbOuterHash);
     free(pContext->pbInnerHash);
     if (pContext->hAlgorithm)
-	BCryptCloseAlgorithmProvider(pContext->hAlgorithm, 0);
+        BCryptCloseAlgorithmProvider(pContext->hAlgorithm, 0);
 }
 
 static BOOL
@@ -135,13 +135,13 @@
     DWORD i;
 
     if (cbPassword > BLOCK_SIZE) {
-	return FALSE;
+        return FALSE;
     }
 
     memset(buffer, mask, sizeof(buffer));
 
     for (i = 0; i < cbPassword; ++i) {
-	buffer[i] = (char)(pbPassword[i] ^ mask);
+        buffer[i] = (char)(pbPassword[i] ^ mask);
     }
 
     return BCRYPT_SUCCESS(BCryptHashData(hHash, buffer, sizeof(buffer), 0));
@@ -154,27 +154,27 @@
     BYTE key[DIGEST_SIZE];
 
     if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&pContext->hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, 0)) || !BCRYPT_SUCCESS(BCryptGetProperty(pContext->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&pContext->cbHashObject, sizeof(pContext->cbHashObject), &cbResult, 0)) || ((pContext->pbInnerHash = malloc(pContext->cbHashObject)) == NULL) || ((pContext->pbOuterHash = malloc(pContext->cbHashObject)) == NULL) || !BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &pContext->hInnerHash, pContext->pbInnerHash, pContext->cbHashObject, NULL, 0, 0)) || !BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &pContext->hOuterHash, pContext->pbOuterHash, pContext->cbHashObject, NULL, 0, 0))) {
-	goto hmacInit_end;
+        goto hmacInit_end;
     }
 
     if (cbPassword > BLOCK_SIZE) {
-	BCRYPT_HASH_HANDLE hHash = NULL;
-	PUCHAR pbHashObject = malloc(pContext->cbHashObject);
-	if (pbHashObject == NULL) {
-	    goto hmacInit_end;
-	}
+        BCRYPT_HASH_HANDLE hHash = NULL;
+        PUCHAR pbHashObject = malloc(pContext->cbHashObject);
+        if (pbHashObject == NULL) {
+            goto hmacInit_end;
+        }
 
-	bStatus = BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &hHash, pbHashObject, pContext->cbHashObject, NULL, 0, 0)) && BCRYPT_SUCCESS(BCryptHashData(hHash, pbPassword, cbPassword, 0)) && BCRYPT_SUCCESS(BCryptGetProperty(hHash, BCRYPT_HASH_LENGTH, (PUCHAR)&cbPassword, sizeof(cbPassword), &cbResult, 0)) && BCRYPT_SUCCESS(BCryptFinishHash(hHash, key, cbPassword, 0));
+        bStatus = BCRYPT_SUCCESS(BCryptCreateHash(pContext->hAlgorithm, &hHash, pbHashObject, pContext->cbHashObject, NULL, 0, 0)) && BCRYPT_SUCCESS(BCryptHashData(hHash, pbPassword, cbPassword, 0)) && BCRYPT_SUCCESS(BCryptGetProperty(hHash, BCRYPT_HASH_LENGTH, (PUCHAR)&cbPassword, sizeof(cbPassword), &cbResult, 0)) && BCRYPT_SUCCESS(BCryptFinishHash(hHash, key, cbPassword, 0));
 
-	if (hHash)
-	    BCryptDestroyHash(hHash);
-	free(pbHashObject);
+        if (hHash)
+            BCryptDestroyHash(hHash);
+        free(pbHashObject);
 
-	if (!bStatus) {
-	    goto hmacInit_end;
-	}
+        if (!bStatus) {
+            goto hmacInit_end;
+        }
 
-	pbPassword = key;
+        pbPassword = key;
     }
 
     bStatus = hmacPrecomputeDigest(pContext->hInnerHash, pbPassword, cbPassword, 0x36) && hmacPrecomputeDigest(pContext->hOuterHash, pbPassword, cbPassword, 0x5C);
@@ -182,7 +182,7 @@
 hmacInit_end:
 
     if (bStatus == FALSE)
-	hmacFree(pContext);
+        hmacFree(pContext);
 
     return bStatus;
 }
@@ -194,13 +194,13 @@
     PUCHAR pbHashObject = malloc(cbHashObject);
 
     if (pbHashObject == NULL) {
-	return FALSE;
+        return FALSE;
     }
 
     if (BCRYPT_SUCCESS(BCryptDuplicateHash(hHashTemplate, &hHash, pbHashObject, cbHashObject, 0))) {
-	success = BCRYPT_SUCCESS(BCryptHashData(hHash, pbData, cbData, 0)) && BCRYPT_SUCCESS(BCryptFinishHash(hHash, pbOutput, cbOutput, 0));
+        success = BCRYPT_SUCCESS(BCryptHashData(hHash, pbData, cbData, 0)) && BCRYPT_SUCCESS(BCryptFinishHash(hHash, pbOutput, cbOutput, 0));
 
-	BCryptDestroyHash(hHash);
+        BCryptDestroyHash(hHash);
     }
 
     free(pbHashObject);
@@ -219,7 +219,7 @@
 static void
 myxor(LPBYTE ptr1, LPBYTE ptr2, DWORD dwLen) {
     while (dwLen--)
-	*ptr1++ ^= *ptr2++;
+        *ptr1++ ^= *ptr2++;
 }
 
 BOOL
@@ -232,52 +232,52 @@
     PRF_CTX prfCtx = {0};
 
     if (U == NULL) {
-	return FALSE;
+        return FALSE;
     }
 
     if (pbPassword == NULL || cbPassword == 0 || pbSalt == NULL || cbSalt == 0 || cIterations == 0 || pbDerivedKey == NULL || cbDerivedKey == 0) {
-	free(U);
-	return FALSE;
+        free(U);
+        return FALSE;
     }
 
     if (!hmacInit(&prfCtx, pbPassword, cbPassword)) {
-	goto PBKDF2_end;
+        goto PBKDF2_end;
     }
 
     l = (DWORD)ceil((double)cbDerivedKey / (double)DIGEST_SIZE);
     r = cbDerivedKey - (l - 1) * DIGEST_SIZE;
 
     for (i = 1; i <= l; i++) {
-	ZeroMemory(Ti, DIGEST_SIZE);
-	for (j = 0; j < cIterations; j++) {
-	    if (j == 0) {
-		/* construct first input for PRF */
-		memcpy(U, pbSalt, cbSalt);
-		U[cbSalt] = (BYTE)((i & 0xFF000000) >> 24);
-		U[cbSalt + 1] = (BYTE)((i & 0x00FF0000) >> 16);
-		U[cbSalt + 2] = (BYTE)((i & 0x0000FF00) >> 8);
-		U[cbSalt + 3] = (BYTE)((i & 0x000000FF));
-		dwULen = cbSalt + 4;
-	    }
-	    else {
-		memcpy(U, V, DIGEST_SIZE);
-		dwULen = DIGEST_SIZE;
-	    }
+        ZeroMemory(Ti, DIGEST_SIZE);
+        for (j = 0; j < cIterations; j++) {
+            if (j == 0) {
+                /* construct first input for PRF */
+                memcpy(U, pbSalt, cbSalt);
+                U[cbSalt] = (BYTE)((i & 0xFF000000) >> 24);
+                U[cbSalt + 1] = (BYTE)((i & 0x00FF0000) >> 16);
+                U[cbSalt + 2] = (BYTE)((i & 0x0000FF00) >> 8);
+                U[cbSalt + 3] = (BYTE)((i & 0x000000FF));
+                dwULen = cbSalt + 4;
+            }
+            else {
+                memcpy(U, V, DIGEST_SIZE);
+                dwULen = DIGEST_SIZE;
+            }
 
-	    if (!hmacCalculate(&prfCtx, U, dwULen, V)) {
-		goto PBKDF2_end;
-	    }
+            if (!hmacCalculate(&prfCtx, U, dwULen, V)) {
+                goto PBKDF2_end;
+            }
 
-	    myxor(Ti, V, DIGEST_SIZE);
-	}
+            myxor(Ti, V, DIGEST_SIZE);
+        }
 
-	if (i != l) {
-	    memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, DIGEST_SIZE);
-	}
-	else {
-	    /* Take only the first r bytes */
-	    memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, r);
-	}
+        if (i != l) {
+            memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, DIGEST_SIZE);
+        }
+        else {
+            /* Take only the first r bytes */
+            memcpy(&pbDerivedKey[(i - 1) * DIGEST_SIZE], Ti, r);
+        }
     }
 
     bStatus = TRUE;
@@ -312,35 +312,35 @@
     ULONG key_length = key_size / 8;
 
     if (aes == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if (!BCRYPT_SUCCESS(BCryptOpenAlgorithmProvider(&aes->hAlgorithm, BCRYPT_AES_ALGORITHM, NULL, 0))) {
-	_zip_crypto_aes_free(aes);
-	return NULL;
+        _zip_crypto_aes_free(aes);
+        return NULL;
     }
 
     if (!BCRYPT_SUCCESS(BCryptSetProperty(aes->hAlgorithm, BCRYPT_CHAINING_MODE, (PUCHAR)BCRYPT_CHAIN_MODE_ECB, sizeof(BCRYPT_CHAIN_MODE_ECB), 0))) {
-	_zip_crypto_aes_free(aes);
-	return NULL;
+        _zip_crypto_aes_free(aes);
+        return NULL;
     }
 
     if (!BCRYPT_SUCCESS(BCryptGetProperty(aes->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&aes->cbKeyObject, sizeof(aes->cbKeyObject), &cbResult, 0))) {
-	_zip_crypto_aes_free(aes);
-	return NULL;
+        _zip_crypto_aes_free(aes);
+        return NULL;
     }
 
     aes->pbKeyObject = malloc(aes->cbKeyObject);
     if (aes->pbKeyObject == NULL) {
-	_zip_crypto_aes_free(aes);
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        _zip_crypto_aes_free(aes);
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if (!BCRYPT_SUCCESS(BCryptGenerateSymmetricKey(aes->hAlgorithm, &aes->hKey, aes->pbKeyObject, aes->cbKeyObject, (PUCHAR)key, key_length, 0))) {
-	_zip_crypto_aes_free(aes);
-	return NULL;
+        _zip_crypto_aes_free(aes);
+        return NULL;
     }
 
     return aes;
@@ -349,19 +349,19 @@
 void
 _zip_crypto_aes_free(_zip_crypto_aes_t *aes) {
     if (aes == NULL) {
-	return;
+        return;
     }
 
     if (aes->hKey != NULL) {
-	BCryptDestroyKey(aes->hKey);
+        BCryptDestroyKey(aes->hKey);
     }
 
     if (aes->pbKeyObject != NULL) {
-	free(aes->pbKeyObject);
+        free(aes->pbKeyObject);
     }
 
     if (aes->hAlgorithm != NULL) {
-	BCryptCloseAlgorithmProvider(aes->hAlgorithm, 0);
+        BCryptCloseAlgorithmProvider(aes->hAlgorithm, 0);
     }
 
     free(aes);
@@ -392,53 +392,53 @@
     _zip_crypto_hmac_t *hmac;
 
     if (secret_length > INT_MAX) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     hmac = (_zip_crypto_hmac_t *)calloc(1, sizeof(*hmac));
 
     if (hmac == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     status = BCryptOpenAlgorithmProvider(&hmac->hAlgorithm, BCRYPT_SHA1_ALGORITHM, NULL, BCRYPT_ALG_HANDLE_HMAC_FLAG);
     if (!BCRYPT_SUCCESS(status)) {
-	_zip_crypto_hmac_free(hmac);
-	return NULL;
+        _zip_crypto_hmac_free(hmac);
+        return NULL;
     }
 
     status = BCryptGetProperty(hmac->hAlgorithm, BCRYPT_OBJECT_LENGTH, (PUCHAR)&hmac->cbHashObject, sizeof(hmac->cbHashObject), &cbResult, 0);
     if (!BCRYPT_SUCCESS(status)) {
-	_zip_crypto_hmac_free(hmac);
-	return NULL;
+        _zip_crypto_hmac_free(hmac);
+        return NULL;
     }
 
     hmac->pbHashObject = malloc(hmac->cbHashObject);
     if (hmac->pbHashObject == NULL) {
-	_zip_crypto_hmac_free(hmac);
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        _zip_crypto_hmac_free(hmac);
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     status = BCryptGetProperty(hmac->hAlgorithm, BCRYPT_HASH_LENGTH, (PUCHAR)&hmac->cbHash, sizeof(hmac->cbHash), &cbResult, 0);
     if (!BCRYPT_SUCCESS(status)) {
-	_zip_crypto_hmac_free(hmac);
-	return NULL;
+        _zip_crypto_hmac_free(hmac);
+        return NULL;
     }
 
     hmac->pbHash = malloc(hmac->cbHash);
     if (hmac->pbHash == NULL) {
-	_zip_crypto_hmac_free(hmac);
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        _zip_crypto_hmac_free(hmac);
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     status = BCryptCreateHash(hmac->hAlgorithm, &hmac->hHash, hmac->pbHashObject, hmac->cbHashObject, (PUCHAR)secret, (ULONG)secret_length, 0);
     if (!BCRYPT_SUCCESS(status)) {
-	_zip_crypto_hmac_free(hmac);
-	return NULL;
+        _zip_crypto_hmac_free(hmac);
+        return NULL;
     }
 
     return hmac;
@@ -447,23 +447,23 @@
 void
 _zip_crypto_hmac_free(_zip_crypto_hmac_t *hmac) {
     if (hmac == NULL) {
-	return;
+        return;
     }
 
     if (hmac->hHash != NULL) {
-	BCryptDestroyHash(hmac->hHash);
+        BCryptDestroyHash(hmac->hHash);
     }
 
     if (hmac->pbHash != NULL) {
-	free(hmac->pbHash);
+        free(hmac->pbHash);
     }
 
     if (hmac->pbHashObject != NULL) {
-	free(hmac->pbHashObject);
+        free(hmac->pbHashObject);
     }
 
     if (hmac->hAlgorithm) {
-	BCryptCloseAlgorithmProvider(hmac->hAlgorithm, 0);
+        BCryptCloseAlgorithmProvider(hmac->hAlgorithm, 0);
     }
 
     free(hmac);
@@ -472,7 +472,7 @@
 bool
 _zip_crypto_hmac(_zip_crypto_hmac_t *hmac, zip_uint8_t *data, zip_uint64_t length) {
     if (hmac == NULL || length > ULONG_MAX) {
-	return false;
+        return false;
     }
 
     return BCRYPT_SUCCESS(BCryptHashData(hmac->hHash, data, (ULONG)length, 0));
@@ -481,7 +481,7 @@
 bool
 _zip_crypto_hmac_output(_zip_crypto_hmac_t *hmac, zip_uint8_t *data) {
     if (hmac == NULL) {
-	return false;
+        return false;
     }
 
     return BCRYPT_SUCCESS(BCryptFinishHash(hmac->hHash, data, hmac->cbHash, 0));
diff --git a/lib/zip_delete.c b/lib/zip_delete.c
index 97701a0..67314ee 100644
--- a/lib/zip_delete.c
+++ b/lib/zip_delete.c
@@ -40,27 +40,27 @@
     const char *name;
 
     if (idx >= za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if ((name = _zip_get_name(za, idx, 0, &za->error)) == NULL) {
-	return -1;
+        return -1;
     }
 
     if (!_zip_hash_delete(za->names, (const zip_uint8_t *)name, &za->error)) {
-	return -1;
+        return -1;
     }
 
     /* allow duplicate file names, because the file will
      * be removed directly afterwards */
     if (_zip_unchange(za, idx, 1) != 0)
-	return -1;
+        return -1;
 
     za->entry[idx].deleted = 1;
 
diff --git a/lib/zip_dir_add.c b/lib/zip_dir_add.c
index c40b1cb..07da101 100644
--- a/lib/zip_dir_add.c
+++ b/lib/zip_dir_add.c
@@ -48,31 +48,31 @@
     zip_source_t *source;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (name == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     s = NULL;
     len = strlen(name);
 
     if (name[len - 1] != '/') {
-	if ((s = (char *)malloc(len + 2)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
-	strcpy(s, name);
-	s[len] = '/';
-	s[len + 1] = '\0';
+        if ((s = (char *)malloc(len + 2)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
+        strcpy(s, name);
+        s[len] = '/';
+        s[len + 1] = '\0';
     }
 
     if ((source = zip_source_buffer(za, NULL, 0, 0)) == NULL) {
-	free(s);
-	return -1;
+        free(s);
+        return -1;
     }
 
     idx = _zip_file_replace(za, ZIP_UINT64_MAX, s ? s : name, source, flags);
@@ -80,12 +80,12 @@
     free(s);
 
     if (idx < 0)
-	zip_source_free(source);
+        zip_source_free(source);
     else {
-	if (zip_file_set_external_attributes(za, (zip_uint64_t)idx, 0, ZIP_OPSYS_DEFAULT, ZIP_EXT_ATTRIB_DEFAULT_DIR) < 0) {
-	    zip_delete(za, (zip_uint64_t)idx);
-	    return -1;
-	}
+        if (zip_file_set_external_attributes(za, (zip_uint64_t)idx, 0, ZIP_OPSYS_DEFAULT, ZIP_EXT_ATTRIB_DEFAULT_DIR) < 0) {
+            zip_delete(za, (zip_uint64_t)idx);
+            return -1;
+        }
     }
 
     return idx;
diff --git a/lib/zip_dirent.c b/lib/zip_dirent.c
index 1691071..5226a6e 100644
--- a/lib/zip_dirent.c
+++ b/lib/zip_dirent.c
@@ -50,10 +50,10 @@
     zip_uint64_t i;
 
     if (!cd)
-	return;
+        return;
 
     for (i = 0; i < cd->nentry; i++)
-	_zip_entry_finalize(cd->entry + i);
+        _zip_entry_finalize(cd->entry + i);
     free(cd->entry);
     _zip_string_free(cd->comment);
     free(cd);
@@ -65,8 +65,8 @@
     zip_cdir_t *cd;
 
     if ((cd = (zip_cdir_t *)malloc(sizeof(*cd))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     cd->entry = NULL;
@@ -76,8 +76,8 @@
     cd->is_zip64 = false;
 
     if (!_zip_cdir_grow(cd, nentry, error)) {
-	_zip_cdir_free(cd);
-	return NULL;
+        _zip_cdir_free(cd);
+        return NULL;
     }
 
     return cd;
@@ -90,25 +90,25 @@
     zip_entry_t *new_entry;
 
     if (additional_entries == 0) {
-	return true;
+        return true;
     }
 
     new_alloc = cd->nentry_alloc + additional_entries;
 
     if (new_alloc < additional_entries || new_alloc > SIZE_MAX / sizeof(*(cd->entry))) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return false;
     }
 
     if ((new_entry = (zip_entry_t *)realloc(cd->entry, sizeof(*(cd->entry)) * (size_t)new_alloc)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return false;
     }
 
     cd->entry = new_entry;
 
     for (i = cd->nentry; i < new_alloc; i++) {
-	_zip_entry_init(cd->entry + i);
+        _zip_entry_init(cd->entry + i);
     }
 
     cd->nentry = cd->nentry_alloc = new_alloc;
@@ -129,52 +129,52 @@
     int ret;
 
     if ((off = zip_source_tell_write(za->src)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
     offset = (zip_uint64_t)off;
 
     is_zip64 = false;
 
     for (i = 0; i < survivors; i++) {
-	zip_entry_t *entry = za->entry + filelist[i].idx;
+        zip_entry_t *entry = za->entry + filelist[i].idx;
 
-	if ((ret = _zip_dirent_write(za, entry->changes ? entry->changes : entry->orig, ZIP_FL_CENTRAL)) < 0)
-	    return -1;
-	if (ret)
-	    is_zip64 = true;
+        if ((ret = _zip_dirent_write(za, entry->changes ? entry->changes : entry->orig, ZIP_FL_CENTRAL)) < 0)
+            return -1;
+        if (ret)
+            is_zip64 = true;
     }
 
     if ((off = zip_source_tell_write(za->src)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
     size = (zip_uint64_t)off - offset;
 
     if (offset > ZIP_UINT32_MAX || survivors > ZIP_UINT16_MAX)
-	is_zip64 = true;
+        is_zip64 = true;
 
 
     if ((buffer = _zip_buffer_new(buf, sizeof(buf))) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     if (is_zip64) {
-	_zip_buffer_put(buffer, EOCD64_MAGIC, 4);
-	_zip_buffer_put_64(buffer, EOCD64LEN - 12);
-	_zip_buffer_put_16(buffer, 45);
-	_zip_buffer_put_16(buffer, 45);
-	_zip_buffer_put_32(buffer, 0);
-	_zip_buffer_put_32(buffer, 0);
-	_zip_buffer_put_64(buffer, survivors);
-	_zip_buffer_put_64(buffer, survivors);
-	_zip_buffer_put_64(buffer, size);
-	_zip_buffer_put_64(buffer, offset);
-	_zip_buffer_put(buffer, EOCD64LOC_MAGIC, 4);
-	_zip_buffer_put_32(buffer, 0);
-	_zip_buffer_put_64(buffer, offset + size);
-	_zip_buffer_put_32(buffer, 1);
+        _zip_buffer_put(buffer, EOCD64_MAGIC, 4);
+        _zip_buffer_put_64(buffer, EOCD64LEN - 12);
+        _zip_buffer_put_16(buffer, 45);
+        _zip_buffer_put_16(buffer, 45);
+        _zip_buffer_put_32(buffer, 0);
+        _zip_buffer_put_32(buffer, 0);
+        _zip_buffer_put_64(buffer, survivors);
+        _zip_buffer_put_64(buffer, survivors);
+        _zip_buffer_put_64(buffer, size);
+        _zip_buffer_put_64(buffer, offset);
+        _zip_buffer_put(buffer, EOCD64LOC_MAGIC, 4);
+        _zip_buffer_put_32(buffer, 0);
+        _zip_buffer_put_64(buffer, offset + size);
+        _zip_buffer_put_32(buffer, 1);
     }
 
     _zip_buffer_put(buffer, EOCD_MAGIC, 4);
@@ -189,22 +189,22 @@
     _zip_buffer_put_16(buffer, (zip_uint16_t)(comment ? comment->length : 0));
 
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	_zip_buffer_free(buffer);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        _zip_buffer_free(buffer);
+        return -1;
     }
 
     if (_zip_write(za, _zip_buffer_data(buffer), _zip_buffer_offset(buffer)) < 0) {
-	_zip_buffer_free(buffer);
-	return -1;
+        _zip_buffer_free(buffer);
+        return -1;
     }
 
     _zip_buffer_free(buffer);
 
     if (comment) {
-	if (_zip_write(za, comment->raw, comment->length) < 0) {
-	    return -1;
-	}
+        if (_zip_write(za, comment->raw, comment->length) < 0) {
+            return -1;
+        }
     }
 
     return (zip_int64_t)size;
@@ -216,12 +216,12 @@
     zip_dirent_t *tde;
 
     if ((tde = (zip_dirent_t *)malloc(sizeof(*tde))) == NULL)
-	return NULL;
+        return NULL;
 
     if (sde)
-	memcpy(tde, sde, sizeof(*sde));
+        memcpy(tde, sde, sizeof(*sde));
     else
-	_zip_dirent_init(tde);
+        _zip_dirent_init(tde);
 
     tde->changed = 0;
     tde->cloned = 1;
@@ -233,23 +233,23 @@
 void
 _zip_dirent_finalize(zip_dirent_t *zde) {
     if (!zde->cloned || zde->changed & ZIP_DIRENT_FILENAME) {
-	_zip_string_free(zde->filename);
-	zde->filename = NULL;
+        _zip_string_free(zde->filename);
+        zde->filename = NULL;
     }
     if (!zde->cloned || zde->changed & ZIP_DIRENT_EXTRA_FIELD) {
-	_zip_ef_free(zde->extra_fields);
-	zde->extra_fields = NULL;
+        _zip_ef_free(zde->extra_fields);
+        zde->extra_fields = NULL;
     }
     if (!zde->cloned || zde->changed & ZIP_DIRENT_COMMENT) {
-	_zip_string_free(zde->comment);
-	zde->comment = NULL;
+        _zip_string_free(zde->comment);
+        zde->comment = NULL;
     }
     if (!zde->cloned || zde->changed & ZIP_DIRENT_PASSWORD) {
-	if (zde->password) {
-	    _zip_crypto_clear(zde->password, strlen(zde->password));
-	}
-	free(zde->password);
-	zde->password = NULL;
+        if (zde->password) {
+            _zip_crypto_clear(zde->password, strlen(zde->password));
+        }
+        free(zde->password);
+        zde->password = NULL;
     }
 }
 
@@ -257,7 +257,7 @@
 void
 _zip_dirent_free(zip_dirent_t *zde) {
     if (zde == NULL)
-	return;
+        return;
 
     _zip_dirent_finalize(zde);
     free(zde);
@@ -295,7 +295,7 @@
 bool
 _zip_dirent_needs_zip64(const zip_dirent_t *de, zip_flags_t flags) {
     if (de->uncomp_size >= ZIP_UINT32_MAX || de->comp_size >= ZIP_UINT32_MAX || ((flags & ZIP_FL_CENTRAL) && de->offset >= ZIP_UINT32_MAX))
-	return true;
+        return true;
 
     return false;
 }
@@ -306,7 +306,7 @@
     zip_dirent_t *de;
 
     if ((de = (zip_dirent_t *)malloc(sizeof(*de))) == NULL)
-	return NULL;
+        return NULL;
 
     _zip_dirent_init(de);
     return de;
@@ -335,32 +335,32 @@
     size = local ? LENTRYSIZE : CDENTRYSIZE;
 
     if (buffer) {
-	if (_zip_buffer_left(buffer) < size) {
-	    zip_error_set(error, ZIP_ER_NOZIP, 0);
-	    return -1;
-	}
+        if (_zip_buffer_left(buffer) < size) {
+            zip_error_set(error, ZIP_ER_NOZIP, 0);
+            return -1;
+        }
     }
     else {
-	if ((buffer = _zip_buffer_new_from_source(src, size, buf, error)) == NULL) {
-	    return -1;
-	}
+        if ((buffer = _zip_buffer_new_from_source(src, size, buf, error)) == NULL) {
+            return -1;
+        }
     }
 
     if (memcmp(_zip_buffer_get(buffer, 4), (local ? LOCAL_MAGIC : CENTRAL_MAGIC), 4) != 0) {
-	zip_error_set(error, ZIP_ER_NOZIP, 0);
-	if (!from_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return -1;
+        zip_error_set(error, ZIP_ER_NOZIP, 0);
+        if (!from_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return -1;
     }
 
     /* convert buffercontents to zip_dirent */
 
     _zip_dirent_init(zde);
     if (!local)
-	zde->version_madeby = _zip_buffer_get_16(buffer);
+        zde->version_madeby = _zip_buffer_get_16(buffer);
     else
-	zde->version_madeby = 0;
+        zde->version_madeby = 0;
     zde->version_needed = _zip_buffer_get_16(buffer);
     zde->bitflags = _zip_buffer_get_16(buffer);
     zde->comp_method = _zip_buffer_get_16(buffer);
@@ -378,39 +378,39 @@
     ef_len = _zip_buffer_get_16(buffer);
 
     if (local) {
-	comment_len = 0;
-	zde->disk_number = 0;
-	zde->int_attrib = 0;
-	zde->ext_attrib = 0;
-	zde->offset = 0;
+        comment_len = 0;
+        zde->disk_number = 0;
+        zde->int_attrib = 0;
+        zde->ext_attrib = 0;
+        zde->offset = 0;
     }
     else {
-	comment_len = _zip_buffer_get_16(buffer);
-	zde->disk_number = _zip_buffer_get_16(buffer);
-	zde->int_attrib = _zip_buffer_get_16(buffer);
-	zde->ext_attrib = _zip_buffer_get_32(buffer);
-	zde->offset = _zip_buffer_get_32(buffer);
+        comment_len = _zip_buffer_get_16(buffer);
+        zde->disk_number = _zip_buffer_get_16(buffer);
+        zde->int_attrib = _zip_buffer_get_16(buffer);
+        zde->ext_attrib = _zip_buffer_get_32(buffer);
+        zde->offset = _zip_buffer_get_32(buffer);
     }
 
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	if (!from_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return -1;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        if (!from_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return -1;
     }
 
     if (zde->bitflags & ZIP_GPBF_ENCRYPTED) {
-	if (zde->bitflags & ZIP_GPBF_STRONG_ENCRYPTION) {
-	    /* TODO */
-	    zde->encryption_method = ZIP_EM_UNKNOWN;
-	}
-	else {
-	    zde->encryption_method = ZIP_EM_TRAD_PKWARE;
-	}
+        if (zde->bitflags & ZIP_GPBF_STRONG_ENCRYPTION) {
+            /* TODO */
+            zde->encryption_method = ZIP_EM_UNKNOWN;
+        }
+        else {
+            zde->encryption_method = ZIP_EM_TRAD_PKWARE;
+        }
     }
     else {
-	zde->encryption_method = ZIP_EM_NONE;
+        zde->encryption_method = ZIP_EM_NONE;
     }
 
     zde->filename = NULL;
@@ -420,80 +420,80 @@
     variable_size = (zip_uint32_t)filename_len + (zip_uint32_t)ef_len + (zip_uint32_t)comment_len;
 
     if (from_buffer) {
-	if (_zip_buffer_left(buffer) < variable_size) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    return -1;
-	}
+        if (_zip_buffer_left(buffer) < variable_size) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            return -1;
+        }
     }
     else {
-	_zip_buffer_free(buffer);
+        _zip_buffer_free(buffer);
 
-	if ((buffer = _zip_buffer_new_from_source(src, variable_size, NULL, error)) == NULL) {
-	    return -1;
-	}
+        if ((buffer = _zip_buffer_new_from_source(src, variable_size, NULL, error)) == NULL) {
+            return -1;
+        }
     }
 
     if (filename_len) {
-	zde->filename = _zip_read_string(buffer, src, filename_len, 1, error);
-	if (!zde->filename) {
-	    if (zip_error_code_zip(error) == ZIP_ER_EOF) {
-		zip_error_set(error, ZIP_ER_INCONS, 0);
-	    }
-	    if (!from_buffer) {
-		_zip_buffer_free(buffer);
-	    }
-	    return -1;
-	}
+        zde->filename = _zip_read_string(buffer, src, filename_len, 1, error);
+        if (!zde->filename) {
+            if (zip_error_code_zip(error) == ZIP_ER_EOF) {
+                zip_error_set(error, ZIP_ER_INCONS, 0);
+            }
+            if (!from_buffer) {
+                _zip_buffer_free(buffer);
+            }
+            return -1;
+        }
 
-	if (zde->bitflags & ZIP_GPBF_ENCODING_UTF_8) {
-	    if (_zip_guess_encoding(zde->filename, ZIP_ENCODING_UTF8_KNOWN) == ZIP_ENCODING_ERROR) {
-		zip_error_set(error, ZIP_ER_INCONS, 0);
-		if (!from_buffer) {
-		    _zip_buffer_free(buffer);
-		}
-		return -1;
-	    }
-	}
+        if (zde->bitflags & ZIP_GPBF_ENCODING_UTF_8) {
+            if (_zip_guess_encoding(zde->filename, ZIP_ENCODING_UTF8_KNOWN) == ZIP_ENCODING_ERROR) {
+                zip_error_set(error, ZIP_ER_INCONS, 0);
+                if (!from_buffer) {
+                    _zip_buffer_free(buffer);
+                }
+                return -1;
+            }
+        }
     }
 
     if (ef_len) {
-	zip_uint8_t *ef = _zip_read_data(buffer, src, ef_len, 0, error);
+        zip_uint8_t *ef = _zip_read_data(buffer, src, ef_len, 0, error);
 
-	if (ef == NULL) {
-	    if (!from_buffer) {
-		_zip_buffer_free(buffer);
-	    }
-	    return -1;
-	}
-	if (!_zip_ef_parse(ef, ef_len, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, &zde->extra_fields, error)) {
-	    free(ef);
-	    if (!from_buffer) {
-		_zip_buffer_free(buffer);
-	    }
-	    return -1;
-	}
-	free(ef);
-	if (local)
-	    zde->local_extra_fields_read = 1;
+        if (ef == NULL) {
+            if (!from_buffer) {
+                _zip_buffer_free(buffer);
+            }
+            return -1;
+        }
+        if (!_zip_ef_parse(ef, ef_len, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, &zde->extra_fields, error)) {
+            free(ef);
+            if (!from_buffer) {
+                _zip_buffer_free(buffer);
+            }
+            return -1;
+        }
+        free(ef);
+        if (local)
+            zde->local_extra_fields_read = 1;
     }
 
     if (comment_len) {
-	zde->comment = _zip_read_string(buffer, src, comment_len, 0, error);
-	if (!zde->comment) {
-	    if (!from_buffer) {
-		_zip_buffer_free(buffer);
-	    }
-	    return -1;
-	}
-	if (zde->bitflags & ZIP_GPBF_ENCODING_UTF_8) {
-	    if (_zip_guess_encoding(zde->comment, ZIP_ENCODING_UTF8_KNOWN) == ZIP_ENCODING_ERROR) {
-		zip_error_set(error, ZIP_ER_INCONS, 0);
-		if (!from_buffer) {
-		    _zip_buffer_free(buffer);
-		}
-		return -1;
-	    }
-	}
+        zde->comment = _zip_read_string(buffer, src, comment_len, 0, error);
+        if (!zde->comment) {
+            if (!from_buffer) {
+                _zip_buffer_free(buffer);
+            }
+            return -1;
+        }
+        if (zde->bitflags & ZIP_GPBF_ENCODING_UTF_8) {
+            if (_zip_guess_encoding(zde->comment, ZIP_ENCODING_UTF8_KNOWN) == ZIP_ENCODING_ERROR) {
+                zip_error_set(error, ZIP_ER_INCONS, 0);
+                if (!from_buffer) {
+                    _zip_buffer_free(buffer);
+                }
+                return -1;
+            }
+        }
     }
 
     zde->filename = _zip_dirent_process_ef_utf_8(zde, ZIP_EF_UTF_8_NAME, zde->filename);
@@ -502,96 +502,96 @@
     /* Zip64 */
 
     if (zde->uncomp_size == ZIP_UINT32_MAX || zde->comp_size == ZIP_UINT32_MAX || zde->offset == ZIP_UINT32_MAX) {
-	zip_uint16_t got_len;
-	zip_buffer_t *ef_buffer;
-	const zip_uint8_t *ef = _zip_ef_get_by_id(zde->extra_fields, &got_len, ZIP_EF_ZIP64, 0, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, error);
-	/* TODO: if got_len == 0 && !ZIP64_EOCD: no error, 0xffffffff is valid value */
-	if (ef == NULL) {
-	    if (!from_buffer) {
-		_zip_buffer_free(buffer);
-	    }
-	    return -1;
-	}
+        zip_uint16_t got_len;
+        zip_buffer_t *ef_buffer;
+        const zip_uint8_t *ef = _zip_ef_get_by_id(zde->extra_fields, &got_len, ZIP_EF_ZIP64, 0, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, error);
+        /* TODO: if got_len == 0 && !ZIP64_EOCD: no error, 0xffffffff is valid value */
+        if (ef == NULL) {
+            if (!from_buffer) {
+                _zip_buffer_free(buffer);
+            }
+            return -1;
+        }
 
-	if ((ef_buffer = _zip_buffer_new((zip_uint8_t *)ef, got_len)) == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    if (!from_buffer) {
-		_zip_buffer_free(buffer);
-	    }
-	    return -1;
-	}
+        if ((ef_buffer = _zip_buffer_new((zip_uint8_t *)ef, got_len)) == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            if (!from_buffer) {
+                _zip_buffer_free(buffer);
+            }
+            return -1;
+        }
 
-	if (zde->uncomp_size == ZIP_UINT32_MAX) {
-	    zde->uncomp_size = _zip_buffer_get_64(ef_buffer);
-	}
-	else if (local) {
-	    /* From appnote.txt: This entry in the Local header MUST
-	       include BOTH original and compressed file size fields. */
-	    (void)_zip_buffer_skip(ef_buffer, 8); /* error is caught by _zip_buffer_eof() call */
-	}
-	if (zde->comp_size == ZIP_UINT32_MAX) {
-	    zde->comp_size = _zip_buffer_get_64(ef_buffer);
-	}
-	if (!local) {
-	    if (zde->offset == ZIP_UINT32_MAX) {
-		zde->offset = _zip_buffer_get_64(ef_buffer);
-	    }
-	    if (zde->disk_number == ZIP_UINT16_MAX) {
-		zde->disk_number = _zip_buffer_get_32(ef_buffer);
-	    }
-	}
+        if (zde->uncomp_size == ZIP_UINT32_MAX) {
+            zde->uncomp_size = _zip_buffer_get_64(ef_buffer);
+        }
+        else if (local) {
+            /* From appnote.txt: This entry in the Local header MUST
+               include BOTH original and compressed file size fields. */
+            (void)_zip_buffer_skip(ef_buffer, 8); /* error is caught by _zip_buffer_eof() call */
+        }
+        if (zde->comp_size == ZIP_UINT32_MAX) {
+            zde->comp_size = _zip_buffer_get_64(ef_buffer);
+        }
+        if (!local) {
+            if (zde->offset == ZIP_UINT32_MAX) {
+                zde->offset = _zip_buffer_get_64(ef_buffer);
+            }
+            if (zde->disk_number == ZIP_UINT16_MAX) {
+                zde->disk_number = _zip_buffer_get_32(ef_buffer);
+            }
+        }
 
-	if (!_zip_buffer_eof(ef_buffer)) {
-	    /* accept additional fields if values match */
-	    bool ok = true;
-	    switch (got_len) {
-	    case 28:
-		_zip_buffer_set_offset(ef_buffer, 24);
-		if (zde->disk_number != _zip_buffer_get_32(ef_buffer)) {
-		    ok = false;
-		}
-		/* fallthrough */
-	    case 24:
-		_zip_buffer_set_offset(ef_buffer, 0);
-		if ((zde->uncomp_size != _zip_buffer_get_64(ef_buffer)) || (zde->comp_size != _zip_buffer_get_64(ef_buffer)) || (zde->offset != _zip_buffer_get_64(ef_buffer))) {
-		    ok = false;
-		}
-		break;
+        if (!_zip_buffer_eof(ef_buffer)) {
+            /* accept additional fields if values match */
+            bool ok = true;
+            switch (got_len) {
+            case 28:
+                _zip_buffer_set_offset(ef_buffer, 24);
+                if (zde->disk_number != _zip_buffer_get_32(ef_buffer)) {
+                    ok = false;
+                }
+                /* fallthrough */
+            case 24:
+                _zip_buffer_set_offset(ef_buffer, 0);
+                if ((zde->uncomp_size != _zip_buffer_get_64(ef_buffer)) || (zde->comp_size != _zip_buffer_get_64(ef_buffer)) || (zde->offset != _zip_buffer_get_64(ef_buffer))) {
+                    ok = false;
+                }
+                break;
 
-	    default:
-		ok = false;
-	    }
-	    if (!ok) {
-		zip_error_set(error, ZIP_ER_INCONS, 0);
-		_zip_buffer_free(ef_buffer);
-		if (!from_buffer) {
-		    _zip_buffer_free(buffer);
-		}
-		return -1;
-	    }
-	}
-	_zip_buffer_free(ef_buffer);
+            default:
+                ok = false;
+            }
+            if (!ok) {
+                zip_error_set(error, ZIP_ER_INCONS, 0);
+                _zip_buffer_free(ef_buffer);
+                if (!from_buffer) {
+                    _zip_buffer_free(buffer);
+                }
+                return -1;
+            }
+        }
+        _zip_buffer_free(ef_buffer);
     }
 
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	if (!from_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return -1;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        if (!from_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return -1;
     }
     if (!from_buffer) {
-	_zip_buffer_free(buffer);
+        _zip_buffer_free(buffer);
     }
 
     /* zip_source_seek / zip_source_tell don't support values > ZIP_INT64_MAX */
     if (zde->offset > ZIP_INT64_MAX) {
-	zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	return -1;
+        zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+        return -1;
     }
 
     if (!_zip_dirent_process_winzip_aes(zde, error)) {
-	return -1;
+        return -1;
     }
 
     zde->extra_fields = _zip_ef_remove_internal(zde->extra_fields);
@@ -609,24 +609,24 @@
     const zip_uint8_t *ef = _zip_ef_get_by_id(de->extra_fields, &ef_len, id, 0, ZIP_EF_BOTH, NULL);
 
     if (ef == NULL || ef_len < 5 || ef[0] != 1) {
-	return str;
+        return str;
     }
 
     if ((buffer = _zip_buffer_new((zip_uint8_t *)ef, ef_len)) == NULL) {
-	return str;
+        return str;
     }
 
     _zip_buffer_get_8(buffer);
     ef_crc = _zip_buffer_get_32(buffer);
 
     if (_zip_string_crc32(str) == ef_crc) {
-	zip_uint16_t len = (zip_uint16_t)_zip_buffer_left(buffer);
-	zip_string_t *ef_str = _zip_string_new(_zip_buffer_get(buffer, len), len, ZIP_FL_ENC_UTF_8, NULL);
+        zip_uint16_t len = (zip_uint16_t)_zip_buffer_left(buffer);
+        zip_string_t *ef_str = _zip_string_new(_zip_buffer_get(buffer, len), len, ZIP_FL_ENC_UTF_8, NULL);
 
-	if (ef_str != NULL) {
-	    _zip_string_free(str);
-	    str = ef_str;
-	}
+        if (ef_str != NULL) {
+            _zip_string_free(str);
+            str = ef_str;
+        }
     }
 
     _zip_buffer_free(buffer);
@@ -645,19 +645,19 @@
 
 
     if (de->comp_method != ZIP_CM_WINZIP_AES) {
-	return true;
+        return true;
     }
 
     ef = _zip_ef_get_by_id(de->extra_fields, &ef_len, ZIP_EF_WINZIP_AES, 0, ZIP_EF_BOTH, NULL);
 
     if (ef == NULL || ef_len < 7) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return false;
     }
 
     if ((buffer = _zip_buffer_new((zip_uint8_t *)ef, ef_len)) == NULL) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        return false;
     }
 
     /* version */
@@ -665,48 +665,48 @@
     crc_valid = true;
     switch (_zip_buffer_get_16(buffer)) {
     case 1:
-	break;
+        break;
 
     case 2:
-	if (de->uncomp_size < 20 /* TODO: constant */) {
-	    crc_valid = false;
-	}
-	break;
+        if (de->uncomp_size < 20 /* TODO: constant */) {
+            crc_valid = false;
+        }
+        break;
 
     default:
-	zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
-	_zip_buffer_free(buffer);
-	return false;
+        zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
+        _zip_buffer_free(buffer);
+        return false;
     }
 
     /* vendor */
     if (memcmp(_zip_buffer_get(buffer, 2), "AE", 2) != 0) {
-	zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
-	_zip_buffer_free(buffer);
-	return false;
+        zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
+        _zip_buffer_free(buffer);
+        return false;
     }
 
     /* mode */
     switch (_zip_buffer_get_8(buffer)) {
     case 1:
-	enc_method = ZIP_EM_AES_128;
-	break;
+        enc_method = ZIP_EM_AES_128;
+        break;
     case 2:
-	enc_method = ZIP_EM_AES_192;
-	break;
+        enc_method = ZIP_EM_AES_192;
+        break;
     case 3:
-	enc_method = ZIP_EM_AES_256;
-	break;
+        enc_method = ZIP_EM_AES_256;
+        break;
     default:
-	zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
-	_zip_buffer_free(buffer);
-	return false;
+        zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
+        _zip_buffer_free(buffer);
+        return false;
     }
 
     if (ef_len != 7) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	_zip_buffer_free(buffer);
-	return false;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        _zip_buffer_free(buffer);
+        return false;
     }
 
     de->crc_valid = crc_valid;
@@ -729,22 +729,22 @@
     size = local ? LENTRYSIZE : CDENTRYSIZE;
 
     if (zip_source_seek(src, local ? 26 : 28, SEEK_CUR) < 0) {
-	_zip_error_set_from_source(error, src);
-	return -1;
+        _zip_error_set_from_source(error, src);
+        return -1;
     }
 
     if ((buffer = _zip_buffer_new_from_source(src, local ? 4 : 6, b, error)) == NULL) {
-	return -1;
+        return -1;
     }
 
     for (i = 0; i < (local ? 2 : 3); i++) {
-	size += _zip_buffer_get_16(buffer);
+        size += _zip_buffer_get_16(buffer);
     }
 
     if (!_zip_buffer_eof(buffer)) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	_zip_buffer_free(buffer);
-	return -1;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        _zip_buffer_free(buffer);
+        return -1;
     }
 
     _zip_buffer_free(buffer);
@@ -781,30 +781,30 @@
     com_enc = _zip_guess_encoding(de->comment, ZIP_ENCODING_UNKNOWN);
 
     if ((name_enc == ZIP_ENCODING_UTF8_KNOWN && com_enc == ZIP_ENCODING_ASCII) || (name_enc == ZIP_ENCODING_ASCII && com_enc == ZIP_ENCODING_UTF8_KNOWN) || (name_enc == ZIP_ENCODING_UTF8_KNOWN && com_enc == ZIP_ENCODING_UTF8_KNOWN))
-	de->bitflags |= ZIP_GPBF_ENCODING_UTF_8;
+        de->bitflags |= ZIP_GPBF_ENCODING_UTF_8;
     else {
-	de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCODING_UTF_8;
-	if (name_enc == ZIP_ENCODING_UTF8_KNOWN) {
-	    ef = _zip_ef_utf8(ZIP_EF_UTF_8_NAME, de->filename, &za->error);
-	    if (ef == NULL)
-		return -1;
-	}
-	if ((flags & ZIP_FL_LOCAL) == 0 && com_enc == ZIP_ENCODING_UTF8_KNOWN) {
-	    zip_extra_field_t *ef2 = _zip_ef_utf8(ZIP_EF_UTF_8_COMMENT, de->comment, &za->error);
-	    if (ef2 == NULL) {
-		_zip_ef_free(ef);
-		return -1;
-	    }
-	    ef2->next = ef;
-	    ef = ef2;
-	}
+        de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCODING_UTF_8;
+        if (name_enc == ZIP_ENCODING_UTF8_KNOWN) {
+            ef = _zip_ef_utf8(ZIP_EF_UTF_8_NAME, de->filename, &za->error);
+            if (ef == NULL)
+                return -1;
+        }
+        if ((flags & ZIP_FL_LOCAL) == 0 && com_enc == ZIP_ENCODING_UTF8_KNOWN) {
+            zip_extra_field_t *ef2 = _zip_ef_utf8(ZIP_EF_UTF_8_COMMENT, de->comment, &za->error);
+            if (ef2 == NULL) {
+                _zip_ef_free(ef);
+                return -1;
+            }
+            ef2->next = ef;
+            ef = ef2;
+        }
     }
 
     if (de->encryption_method == ZIP_EM_NONE) {
-	de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCRYPTED;
+        de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCRYPTED;
     }
     else {
-	de->bitflags |= (zip_uint16_t)ZIP_GPBF_ENCRYPTED;
+        de->bitflags |= (zip_uint16_t)ZIP_GPBF_ENCRYPTED;
     }
 
     is_really_zip64 = _zip_dirent_needs_zip64(de, flags);
@@ -812,94 +812,94 @@
     is_winzip_aes = de->encryption_method == ZIP_EM_AES_128 || de->encryption_method == ZIP_EM_AES_192 || de->encryption_method == ZIP_EM_AES_256;
 
     if (is_zip64) {
-	zip_uint8_t ef_zip64[EFZIP64SIZE];
-	zip_buffer_t *ef_buffer = _zip_buffer_new(ef_zip64, sizeof(ef_zip64));
-	if (ef_buffer == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    _zip_ef_free(ef);
-	    return -1;
-	}
+        zip_uint8_t ef_zip64[EFZIP64SIZE];
+        zip_buffer_t *ef_buffer = _zip_buffer_new(ef_zip64, sizeof(ef_zip64));
+        if (ef_buffer == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            _zip_ef_free(ef);
+            return -1;
+        }
 
-	if (flags & ZIP_FL_LOCAL) {
-	    if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX) {
-		_zip_buffer_put_64(ef_buffer, de->uncomp_size);
-		_zip_buffer_put_64(ef_buffer, de->comp_size);
-	    }
-	}
-	else {
-	    if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX || de->offset > ZIP_UINT32_MAX) {
-		if (de->uncomp_size >= ZIP_UINT32_MAX) {
-		    _zip_buffer_put_64(ef_buffer, de->uncomp_size);
-		}
-		if (de->comp_size >= ZIP_UINT32_MAX) {
-		    _zip_buffer_put_64(ef_buffer, de->comp_size);
-		}
-		if (de->offset >= ZIP_UINT32_MAX) {
-		    _zip_buffer_put_64(ef_buffer, de->offset);
-		}
-	    }
-	}
+        if (flags & ZIP_FL_LOCAL) {
+            if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX) {
+                _zip_buffer_put_64(ef_buffer, de->uncomp_size);
+                _zip_buffer_put_64(ef_buffer, de->comp_size);
+            }
+        }
+        else {
+            if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX || de->offset > ZIP_UINT32_MAX) {
+                if (de->uncomp_size >= ZIP_UINT32_MAX) {
+                    _zip_buffer_put_64(ef_buffer, de->uncomp_size);
+                }
+                if (de->comp_size >= ZIP_UINT32_MAX) {
+                    _zip_buffer_put_64(ef_buffer, de->comp_size);
+                }
+                if (de->offset >= ZIP_UINT32_MAX) {
+                    _zip_buffer_put_64(ef_buffer, de->offset);
+                }
+            }
+        }
 
-	if (!_zip_buffer_ok(ef_buffer)) {
-	    zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	    _zip_buffer_free(ef_buffer);
-	    _zip_ef_free(ef);
-	    return -1;
-	}
+        if (!_zip_buffer_ok(ef_buffer)) {
+            zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+            _zip_buffer_free(ef_buffer);
+            _zip_ef_free(ef);
+            return -1;
+        }
 
-	ef64 = _zip_ef_new(ZIP_EF_ZIP64, (zip_uint16_t)(_zip_buffer_offset(ef_buffer)), ef_zip64, ZIP_EF_BOTH);
-	_zip_buffer_free(ef_buffer);
-	ef64->next = ef;
-	ef = ef64;
+        ef64 = _zip_ef_new(ZIP_EF_ZIP64, (zip_uint16_t)(_zip_buffer_offset(ef_buffer)), ef_zip64, ZIP_EF_BOTH);
+        _zip_buffer_free(ef_buffer);
+        ef64->next = ef;
+        ef = ef64;
     }
 
     if (is_winzip_aes) {
-	zip_uint8_t data[EF_WINZIP_AES_SIZE];
-	zip_buffer_t *ef_buffer = _zip_buffer_new(data, sizeof(data));
-	zip_extra_field_t *ef_winzip;
+        zip_uint8_t data[EF_WINZIP_AES_SIZE];
+        zip_buffer_t *ef_buffer = _zip_buffer_new(data, sizeof(data));
+        zip_extra_field_t *ef_winzip;
 
-	if (ef_buffer == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    _zip_ef_free(ef);
-	    return -1;
-	}
+        if (ef_buffer == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            _zip_ef_free(ef);
+            return -1;
+        }
 
-	_zip_buffer_put_16(ef_buffer, 2);
-	_zip_buffer_put(ef_buffer, "AE", 2);
-	_zip_buffer_put_8(ef_buffer, (zip_uint8_t)(de->encryption_method & 0xff));
-	_zip_buffer_put_16(ef_buffer, (zip_uint16_t)de->comp_method);
+        _zip_buffer_put_16(ef_buffer, 2);
+        _zip_buffer_put(ef_buffer, "AE", 2);
+        _zip_buffer_put_8(ef_buffer, (zip_uint8_t)(de->encryption_method & 0xff));
+        _zip_buffer_put_16(ef_buffer, (zip_uint16_t)de->comp_method);
 
-	if (!_zip_buffer_ok(ef_buffer)) {
-	    zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	    _zip_buffer_free(ef_buffer);
-	    _zip_ef_free(ef);
-	    return -1;
-	}
+        if (!_zip_buffer_ok(ef_buffer)) {
+            zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+            _zip_buffer_free(ef_buffer);
+            _zip_ef_free(ef);
+            return -1;
+        }
 
-	ef_winzip = _zip_ef_new(ZIP_EF_WINZIP_AES, EF_WINZIP_AES_SIZE, data, ZIP_EF_BOTH);
-	_zip_buffer_free(ef_buffer);
-	ef_winzip->next = ef;
-	ef = ef_winzip;
+        ef_winzip = _zip_ef_new(ZIP_EF_WINZIP_AES, EF_WINZIP_AES_SIZE, data, ZIP_EF_BOTH);
+        _zip_buffer_free(ef_buffer);
+        ef_winzip->next = ef;
+        ef = ef_winzip;
     }
 
     if ((buffer = _zip_buffer_new(buf, sizeof(buf))) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	_zip_ef_free(ef);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        _zip_ef_free(ef);
+        return -1;
     }
 
     _zip_buffer_put(buffer, (flags & ZIP_FL_LOCAL) ? LOCAL_MAGIC : CENTRAL_MAGIC, 4);
 
     if ((flags & ZIP_FL_LOCAL) == 0) {
-	_zip_buffer_put_16(buffer, de->version_madeby);
+        _zip_buffer_put_16(buffer, de->version_madeby);
     }
     _zip_buffer_put_16(buffer, ZIP_MAX(is_really_zip64 ? 45 : 0, de->version_needed));
     _zip_buffer_put_16(buffer, de->bitflags);
     if (is_winzip_aes) {
-	_zip_buffer_put_16(buffer, ZIP_CM_WINZIP_AES);
+        _zip_buffer_put_16(buffer, ZIP_CM_WINZIP_AES);
     }
     else {
-	_zip_buffer_put_16(buffer, (zip_uint16_t)de->comp_method);
+        _zip_buffer_put_16(buffer, (zip_uint16_t)de->comp_method);
     }
 
     _zip_u2d_time(de->last_mod, &dostime, &dosdate);
@@ -907,34 +907,34 @@
     _zip_buffer_put_16(buffer, dosdate);
 
     if (is_winzip_aes && de->uncomp_size < 20) {
-	_zip_buffer_put_32(buffer, 0);
+        _zip_buffer_put_32(buffer, 0);
     }
     else {
-	_zip_buffer_put_32(buffer, de->crc);
+        _zip_buffer_put_32(buffer, de->crc);
     }
 
     if (((flags & ZIP_FL_LOCAL) == ZIP_FL_LOCAL) && ((de->comp_size >= ZIP_UINT32_MAX) || (de->uncomp_size >= ZIP_UINT32_MAX))) {
-	/* In local headers, if a ZIP64 EF is written, it MUST contain
-	 * both compressed and uncompressed sizes (even if one of the
-	 * two is smaller than 0xFFFFFFFF); on the other hand, those
-	 * may only appear when the corresponding standard entry is
-	 * 0xFFFFFFFF.  (appnote.txt 4.5.3) */
-	_zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
-	_zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
+        /* In local headers, if a ZIP64 EF is written, it MUST contain
+         * both compressed and uncompressed sizes (even if one of the
+         * two is smaller than 0xFFFFFFFF); on the other hand, those
+         * may only appear when the corresponding standard entry is
+         * 0xFFFFFFFF.  (appnote.txt 4.5.3) */
+        _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
+        _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
     }
     else {
-	if (de->comp_size < ZIP_UINT32_MAX) {
-	    _zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);
-	}
-	else {
-	    _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
-	}
-	if (de->uncomp_size < ZIP_UINT32_MAX) {
-	    _zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);
-	}
-	else {
-	    _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
-	}
+        if (de->comp_size < ZIP_UINT32_MAX) {
+            _zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);
+        }
+        else {
+            _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
+        }
+        if (de->uncomp_size < ZIP_UINT32_MAX) {
+            _zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);
+        }
+        else {
+            _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
+        }
     }
 
     _zip_buffer_put_16(buffer, _zip_string_length(de->filename));
@@ -943,57 +943,57 @@
     _zip_buffer_put_16(buffer, (zip_uint16_t)ef_total_size);
 
     if ((flags & ZIP_FL_LOCAL) == 0) {
-	_zip_buffer_put_16(buffer, _zip_string_length(de->comment));
-	_zip_buffer_put_16(buffer, (zip_uint16_t)de->disk_number);
-	_zip_buffer_put_16(buffer, de->int_attrib);
-	_zip_buffer_put_32(buffer, de->ext_attrib);
-	if (de->offset < ZIP_UINT32_MAX)
-	    _zip_buffer_put_32(buffer, (zip_uint32_t)de->offset);
-	else
-	    _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
+        _zip_buffer_put_16(buffer, _zip_string_length(de->comment));
+        _zip_buffer_put_16(buffer, (zip_uint16_t)de->disk_number);
+        _zip_buffer_put_16(buffer, de->int_attrib);
+        _zip_buffer_put_32(buffer, de->ext_attrib);
+        if (de->offset < ZIP_UINT32_MAX)
+            _zip_buffer_put_32(buffer, (zip_uint32_t)de->offset);
+        else
+            _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
     }
 
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	_zip_buffer_free(buffer);
-	_zip_ef_free(ef);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        _zip_buffer_free(buffer);
+        _zip_ef_free(ef);
+        return -1;
     }
 
     if (_zip_write(za, buf, _zip_buffer_offset(buffer)) < 0) {
-	_zip_buffer_free(buffer);
-	_zip_ef_free(ef);
-	return -1;
+        _zip_buffer_free(buffer);
+        _zip_ef_free(ef);
+        return -1;
     }
 
     _zip_buffer_free(buffer);
 
     if (de->filename) {
-	if (_zip_string_write(za, de->filename) < 0) {
-	    _zip_ef_free(ef);
-	    return -1;
-	}
+        if (_zip_string_write(za, de->filename) < 0) {
+            _zip_ef_free(ef);
+            return -1;
+        }
     }
 
     if (ef) {
-	if (_zip_ef_write(za, ef, ZIP_EF_BOTH) < 0) {
-	    _zip_ef_free(ef);
-	    return -1;
-	}
+        if (_zip_ef_write(za, ef, ZIP_EF_BOTH) < 0) {
+            _zip_ef_free(ef);
+            return -1;
+        }
     }
     _zip_ef_free(ef);
     if (de->extra_fields) {
-	if (_zip_ef_write(za, de->extra_fields, flags) < 0) {
-	    return -1;
-	}
+        if (_zip_ef_write(za, de->extra_fields, flags) < 0) {
+            return -1;
+        }
     }
 
     if ((flags & ZIP_FL_LOCAL) == 0) {
-	if (de->comment) {
-	    if (_zip_string_write(za, de->comment) < 0) {
-		return -1;
-	    }
-	}
+        if (de->comment) {
+            if (_zip_string_write(za, de->comment) < 0) {
+                return -1;
+            }
+        }
     }
 
 
@@ -1030,18 +1030,18 @@
     zip_extra_field_t *ef;
 
     if ((raw = _zip_string_get(str, &len, ZIP_FL_ENC_RAW, NULL)) == NULL) {
-	/* error already set */
-	return NULL;
+        /* error already set */
+        return NULL;
     }
 
     if (len + 5 > ZIP_UINT16_MAX) {
-	zip_error_set(error, ZIP_ER_INVAL, 0); /* TODO: better error code? */
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0); /* TODO: better error code? */
+        return NULL;
     }
 
     if ((buffer = _zip_buffer_new(NULL, len + 5)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     _zip_buffer_put_8(buffer, 1);
@@ -1049,9 +1049,9 @@
     _zip_buffer_put(buffer, raw, len);
 
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	_zip_buffer_free(buffer);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        _zip_buffer_free(buffer);
+        return NULL;
     }
 
     ef = _zip_ef_new(id, (zip_uint16_t)(_zip_buffer_offset(buffer)), _zip_buffer_data(buffer), ZIP_EF_BOTH);
@@ -1064,26 +1064,26 @@
 zip_dirent_t *
 _zip_get_dirent(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_error_t *error) {
     if (error == NULL)
-	error = &za->error;
+        error = &za->error;
 
     if (idx >= za->nentry) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((flags & ZIP_FL_UNCHANGED) || za->entry[idx].changes == NULL) {
-	if (za->entry[idx].orig == NULL) {
-	    zip_error_set(error, ZIP_ER_INVAL, 0);
-	    return NULL;
-	}
-	if (za->entry[idx].deleted && (flags & ZIP_FL_UNCHANGED) == 0) {
-	    zip_error_set(error, ZIP_ER_DELETED, 0);
-	    return NULL;
-	}
-	return za->entry[idx].orig;
+        if (za->entry[idx].orig == NULL) {
+            zip_error_set(error, ZIP_ER_INVAL, 0);
+            return NULL;
+        }
+        if (za->entry[idx].deleted && (flags & ZIP_FL_UNCHANGED) == 0) {
+            zip_error_set(error, ZIP_ER_DELETED, 0);
+            return NULL;
+        }
+        return za->entry[idx].orig;
     }
     else
-	return za->entry[idx].changes;
+        return za->entry[idx].changes;
 }
 
 
@@ -1098,13 +1098,13 @@
     tpm = localtime(&intime);
 #endif
     if (tpm == NULL) {
-	/* if localtime() fails, return an arbitrary date (1980-01-01 00:00:00) */
-	*ddate = (1 << 5) + 1;
-	*dtime = 0;
-	return;
+        /* if localtime() fails, return an arbitrary date (1980-01-01 00:00:00) */
+        *ddate = (1 << 5) + 1;
+        *dtime = 0;
+        return;
     }
     if (tpm->tm_year < 80) {
-	tpm->tm_year = 80;
+        tpm->tm_year = 80;
     }
 
     *ddate = (zip_uint16_t)(((tpm->tm_year + 1900 - 1980) << 9) + ((tpm->tm_mon + 1) << 5) + tpm->tm_mday);
@@ -1119,45 +1119,45 @@
     zip_uint16_t length;
 
     if (attributes->valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS) {
-	zip_uint16_t mask = attributes->general_purpose_bit_mask & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;
-	de->bitflags = (de->bitflags & ~mask) | (attributes->general_purpose_bit_flags & mask);
+        zip_uint16_t mask = attributes->general_purpose_bit_mask & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;
+        de->bitflags = (de->bitflags & ~mask) | (attributes->general_purpose_bit_flags & mask);
     }
     if (attributes->valid & ZIP_FILE_ATTRIBUTES_ASCII) {
-	de->int_attrib = (de->int_attrib & ~0x1) | (attributes->ascii ? 1 : 0);
+        de->int_attrib = (de->int_attrib & ~0x1) | (attributes->ascii ? 1 : 0);
     }
     /* manually set attributes are preferred over attributes provided by source */
     if ((changed & ZIP_DIRENT_ATTRIBUTES) == 0 && (attributes->valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES)) {
-	de->ext_attrib = attributes->external_file_attributes;
+        de->ext_attrib = attributes->external_file_attributes;
     }
 
     if (de->comp_method == ZIP_CM_LZMA) {
-	de->version_needed = 63;
+        de->version_needed = 63;
     }
     else if (de->encryption_method == ZIP_EM_AES_128 || de->encryption_method == ZIP_EM_AES_192 || de->encryption_method == ZIP_EM_AES_256) {
-	de->version_needed = 51;
+        de->version_needed = 51;
     }
     else if (de->comp_method == ZIP_CM_BZIP2) {
-	de->version_needed = 46;
+        de->version_needed = 46;
     }
     else if (force_zip64 || _zip_dirent_needs_zip64(de, 0)) {
-	de->version_needed = 45;
+        de->version_needed = 45;
     }
     else if (de->comp_method == ZIP_CM_DEFLATE || de->encryption_method == ZIP_EM_TRAD_PKWARE) {
-	de->version_needed = 20;
+        de->version_needed = 20;
     }
     else if ((length = _zip_string_length(de->filename)) > 0 && de->filename->raw[length - 1] == '/') {
-	de->version_needed = 20;
+        de->version_needed = 20;
     }
     else {
-	de->version_needed = 10;
+        de->version_needed = 10;
     }
 
     if (attributes->valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED) {
-	de->version_needed = ZIP_MAX(de->version_needed, attributes->version_needed);
+        de->version_needed = ZIP_MAX(de->version_needed, attributes->version_needed);
     }
 
     de->version_madeby = 63 | (de->version_madeby & 0xff00);
     if ((changed & ZIP_DIRENT_ATTRIBUTES) == 0 && (attributes->valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM)) {
-	de->version_madeby = (de->version_madeby & 0xff) | (zip_uint16_t)(attributes->host_system << 8);
+        de->version_madeby = (de->version_madeby & 0xff) | (zip_uint16_t)(attributes->host_system << 8);
     }
 }
diff --git a/lib/zip_discard.c b/lib/zip_discard.c
index 12f0636..7447814 100644
--- a/lib/zip_discard.c
+++ b/lib/zip_discard.c
@@ -46,11 +46,11 @@
     zip_uint64_t i;
 
     if (za == NULL)
-	return;
+        return;
 
     if (za->src) {
-	zip_source_close(za->src);
-	zip_source_free(za->src);
+        zip_source_close(za->src);
+        zip_source_free(za->src);
     }
 
     free(za->default_password);
@@ -60,13 +60,13 @@
     _zip_hash_free(za->names);
 
     if (za->entry) {
-	for (i = 0; i < za->nentry; i++)
-	    _zip_entry_finalize(za->entry + i);
-	free(za->entry);
+        for (i = 0; i < za->nentry; i++)
+            _zip_entry_finalize(za->entry + i);
+        free(za->entry);
     }
 
     for (i = 0; i < za->nopen_source; i++) {
-	_zip_source_invalidate(za->open_source[i]);
+        _zip_source_invalidate(za->open_source[i]);
     }
     free(za->open_source);
 
diff --git a/lib/zip_error.c b/lib/zip_error.c
index a0f74f0..64e830e 100644
--- a/lib/zip_error.c
+++ b/lib/zip_error.c
@@ -68,12 +68,12 @@
     error->zip_err = ze;
     switch (zip_error_system_type(error)) {
     case ZIP_ET_SYS:
-	error->sys_err = errno;
-	break;
+        error->sys_err = errno;
+        break;
 
     default:
-	error->sys_err = 0;
-	break;
+        error->sys_err = 0;
+        break;
     }
 }
 
@@ -81,7 +81,7 @@
 ZIP_EXTERN int
 zip_error_system_type(const zip_error_t *error) {
     if (error->zip_err < 0 || error->zip_err >= _zip_nerr_str)
-	return ZIP_ET_NONE;
+        return ZIP_ET_NONE;
 
     return _zip_err_type[error->zip_err];
 }
@@ -90,7 +90,7 @@
 void
 _zip_error_clear(zip_error_t *err) {
     if (err == NULL)
-	return;
+        return;
 
     err->zip_err = ZIP_ER_OK;
     err->sys_err = 0;
@@ -100,7 +100,7 @@
 void
 _zip_error_copy(zip_error_t *dst, const zip_error_t *src) {
     if (dst == NULL) {
-	return;
+        return;
     }
 
     dst->zip_err = src->zip_err;
@@ -111,12 +111,12 @@
 void
 _zip_error_get(const zip_error_t *err, int *zep, int *sep) {
     if (zep)
-	*zep = err->zip_err;
+        *zep = err->zip_err;
     if (sep) {
-	if (zip_error_system_type(err) != ZIP_ET_NONE)
-	    *sep = err->sys_err;
-	else
-	    *sep = 0;
+        if (zip_error_system_type(err) != ZIP_ET_NONE)
+            *sep = err->sys_err;
+        else
+            *sep = 0;
     }
 }
 
@@ -124,8 +124,8 @@
 void
 zip_error_set(zip_error_t *err, int ze, int se) {
     if (err) {
-	err->zip_err = ze;
-	err->sys_err = se;
+        err->zip_err = ze;
+        err->sys_err = se;
     }
 }
 
@@ -141,7 +141,7 @@
     int *e = (int *)data;
 
     if (length < sizeof(int) * 2) {
-	return -1;
+        return -1;
     }
 
     e[0] = zip_error_code_zip(error);
diff --git a/lib/zip_error_clear.c b/lib/zip_error_clear.c
index eec1568..0098063 100644
--- a/lib/zip_error_clear.c
+++ b/lib/zip_error_clear.c
@@ -38,7 +38,7 @@
 ZIP_EXTERN void
 zip_error_clear(zip_t *za) {
     if (za == NULL)
-	return;
+        return;
 
     _zip_error_clear(&za->error);
 }
diff --git a/lib/zip_error_get_sys_type.c b/lib/zip_error_get_sys_type.c
index 3dfe5c2..7df5edb 100644
--- a/lib/zip_error_get_sys_type.c
+++ b/lib/zip_error_get_sys_type.c
@@ -38,7 +38,7 @@
 ZIP_EXTERN int
 zip_error_get_sys_type(int ze) {
     if (ze < 0 || ze >= _zip_nerr_str)
-	return 0;
+        return 0;
 
     return _zip_err_type[ze];
 }
diff --git a/lib/zip_error_strerror.c b/lib/zip_error_strerror.c
index 93b24ea..607fd84 100644
--- a/lib/zip_error_strerror.c
+++ b/lib/zip_error_strerror.c
@@ -48,36 +48,36 @@
     zip_error_fini(err);
 
     if (err->zip_err < 0 || err->zip_err >= _zip_nerr_str) {
-	sprintf(buf, "Unknown error %d", err->zip_err);
-	zs = NULL;
-	ss = buf;
+        sprintf(buf, "Unknown error %d", err->zip_err);
+        zs = NULL;
+        ss = buf;
     }
     else {
-	zs = _zip_err_str[err->zip_err];
+        zs = _zip_err_str[err->zip_err];
 
-	switch (_zip_err_type[err->zip_err]) {
-	case ZIP_ET_SYS:
-	    ss = strerror(err->sys_err);
-	    break;
+        switch (_zip_err_type[err->zip_err]) {
+        case ZIP_ET_SYS:
+            ss = strerror(err->sys_err);
+            break;
 
-	case ZIP_ET_ZLIB:
-	    ss = zError(err->sys_err);
-	    break;
+        case ZIP_ET_ZLIB:
+            ss = zError(err->sys_err);
+            break;
 
-	default:
-	    ss = NULL;
-	}
+        default:
+            ss = NULL;
+        }
     }
 
     if (ss == NULL)
-	return zs;
+        return zs;
     else {
-	if ((s = (char *)malloc(strlen(ss) + (zs ? strlen(zs) + 2 : 0) + 1)) == NULL)
-	    return _zip_err_str[ZIP_ER_MEMORY];
+        if ((s = (char *)malloc(strlen(ss) + (zs ? strlen(zs) + 2 : 0) + 1)) == NULL)
+            return _zip_err_str[ZIP_ER_MEMORY];
 
-	sprintf(s, "%s%s%s", (zs ? zs : ""), (zs ? ": " : ""), ss);
-	err->str = s;
+        sprintf(s, "%s%s%s", (zs ? zs : ""), (zs ? ": " : ""), ss);
+        err->str = s;
 
-	return s;
+        return s;
     }
 }
diff --git a/lib/zip_error_to_str.c b/lib/zip_error_to_str.c
index 34a3331..66eba94 100644
--- a/lib/zip_error_to_str.c
+++ b/lib/zip_error_to_str.c
@@ -45,21 +45,21 @@
     const char *zs, *ss;
 
     if (ze < 0 || ze >= _zip_nerr_str)
-	return snprintf(buf, len, "Unknown error %d", ze);
+        return snprintf(buf, len, "Unknown error %d", ze);
 
     zs = _zip_err_str[ze];
 
     switch (_zip_err_type[ze]) {
     case ZIP_ET_SYS:
-	ss = strerror(se);
-	break;
+        ss = strerror(se);
+        break;
 
     case ZIP_ET_ZLIB:
-	ss = zError(se);
-	break;
+        ss = zError(se);
+        break;
 
     default:
-	ss = NULL;
+        ss = NULL;
     }
 
     return snprintf(buf, len, "%s%s%s", zs, (ss ? ": " : ""), (ss ? ss : ""));
diff --git a/lib/zip_extra_field.c b/lib/zip_extra_field.c
index 7114a25..32c67c8 100644
--- a/lib/zip_extra_field.c
+++ b/lib/zip_extra_field.c
@@ -44,19 +44,19 @@
     head = prev = NULL;
 
     while (ef) {
-	if ((def = _zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    _zip_ef_free(head);
-	    return NULL;
-	}
+        if ((def = _zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            _zip_ef_free(head);
+            return NULL;
+        }
 
-	if (head == NULL)
-	    head = def;
-	if (prev)
-	    prev->next = def;
-	prev = def;
+        if (head == NULL)
+            head = def;
+        if (prev)
+            prev->next = def;
+        prev = def;
 
-	ef = ef->next;
+        ef = ef->next;
     }
 
     return head;
@@ -72,27 +72,27 @@
     head = ef;
     prev = NULL;
     for (; ef; ef = (prev ? prev->next : head)) {
-	if ((ef->flags & flags & ZIP_EF_BOTH) && ((ef->id == id) || (id == ZIP_EXTRA_FIELD_ALL))) {
-	    if (id_idx == ZIP_EXTRA_FIELD_ALL || i == id_idx) {
-		ef->flags &= ~(flags & ZIP_EF_BOTH);
-		if ((ef->flags & ZIP_EF_BOTH) == 0) {
-		    if (prev)
-			prev->next = ef->next;
-		    else
-			head = ef->next;
-		    ef->next = NULL;
-		    _zip_ef_free(ef);
+        if ((ef->flags & flags & ZIP_EF_BOTH) && ((ef->id == id) || (id == ZIP_EXTRA_FIELD_ALL))) {
+            if (id_idx == ZIP_EXTRA_FIELD_ALL || i == id_idx) {
+                ef->flags &= ~(flags & ZIP_EF_BOTH);
+                if ((ef->flags & ZIP_EF_BOTH) == 0) {
+                    if (prev)
+                        prev->next = ef->next;
+                    else
+                        head = ef->next;
+                    ef->next = NULL;
+                    _zip_ef_free(ef);
 
-		    if (id_idx == ZIP_EXTRA_FIELD_ALL)
-			continue;
-		}
-	    }
+                    if (id_idx == ZIP_EXTRA_FIELD_ALL)
+                        continue;
+                }
+            }
 
-	    i++;
-	    if (i > id_idx)
-		break;
-	}
-	prev = ef;
+            i++;
+            if (i > id_idx)
+                break;
+        }
+        prev = ef;
     }
 
     return head;
@@ -104,10 +104,10 @@
     zip_extra_field_t *ef2;
 
     while (ef) {
-	ef2 = ef->next;
-	free(ef->data);
-	free(ef);
-	ef = ef2;
+        ef2 = ef->next;
+        free(ef->data);
+        free(ef);
+        ef = ef2;
     }
 }
 
@@ -120,19 +120,19 @@
 
     i = 0;
     for (; ef; ef = ef->next) {
-	if (ef->id == id && (ef->flags & flags & ZIP_EF_BOTH)) {
-	    if (i < id_idx) {
-		i++;
-		continue;
-	    }
+        if (ef->id == id && (ef->flags & flags & ZIP_EF_BOTH)) {
+            if (i < id_idx) {
+                i++;
+                continue;
+            }
 
-	    if (lenp)
-		*lenp = ef->size;
-	    if (ef->size > 0)
-		return ef->data;
-	    else
-		return empty;
-	}
+            if (lenp)
+                *lenp = ef->size;
+            if (ef->size > 0)
+                return ef->data;
+            else
+                return empty;
+        }
     }
 
     zip_error_set(error, ZIP_ER_NOENT, 0);
@@ -146,28 +146,28 @@
     int duplicate;
 
     if (to == NULL)
-	return from;
+        return from;
 
     for (tail = to; tail->next; tail = tail->next)
-	;
+        ;
 
     for (; from; from = ef2) {
-	ef2 = from->next;
+        ef2 = from->next;
 
-	duplicate = 0;
-	for (tt = to; tt; tt = tt->next) {
-	    if (tt->id == from->id && tt->size == from->size && (tt->size == 0 || memcmp(tt->data, from->data, tt->size) == 0)) {
-		tt->flags |= (from->flags & ZIP_EF_BOTH);
-		duplicate = 1;
-		break;
-	    }
-	}
+        duplicate = 0;
+        for (tt = to; tt; tt = tt->next) {
+            if (tt->id == from->id && tt->size == from->size && (tt->size == 0 || memcmp(tt->data, from->data, tt->size) == 0)) {
+                tt->flags |= (from->flags & ZIP_EF_BOTH);
+                duplicate = 1;
+                break;
+            }
+        }
 
-	from->next = NULL;
-	if (duplicate)
-	    _zip_ef_free(from);
-	else
-	    tail = tail->next = from;
+        from->next = NULL;
+        if (duplicate)
+            _zip_ef_free(from);
+        else
+            tail = tail->next = from;
     }
 
     return to;
@@ -179,20 +179,20 @@
     zip_extra_field_t *ef;
 
     if ((ef = (zip_extra_field_t *)malloc(sizeof(*ef))) == NULL)
-	return NULL;
+        return NULL;
 
     ef->next = NULL;
     ef->flags = flags;
     ef->id = id;
     ef->size = size;
     if (size > 0) {
-	if ((ef->data = (zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) {
-	    free(ef);
-	    return NULL;
-	}
+        if ((ef->data = (zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) {
+            free(ef);
+            return NULL;
+        }
     }
     else
-	ef->data = NULL;
+        ef->data = NULL;
 
     return ef;
 }
@@ -204,63 +204,63 @@
     zip_extra_field_t *ef, *ef2, *ef_head;
 
     if ((buffer = _zip_buffer_new((zip_uint8_t *)data, len)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return false;
     }
 
     ef_head = ef = NULL;
 
     while (_zip_buffer_ok(buffer) && _zip_buffer_left(buffer) >= 4) {
-	zip_uint16_t fid, flen;
-	zip_uint8_t *ef_data;
+        zip_uint16_t fid, flen;
+        zip_uint8_t *ef_data;
 
-	fid = _zip_buffer_get_16(buffer);
-	flen = _zip_buffer_get_16(buffer);
-	ef_data = _zip_buffer_get(buffer, flen);
+        fid = _zip_buffer_get_16(buffer);
+        flen = _zip_buffer_get_16(buffer);
+        ef_data = _zip_buffer_get(buffer, flen);
 
-	if (ef_data == NULL) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    _zip_buffer_free(buffer);
-	    _zip_ef_free(ef_head);
-	    return false;
-	}
+        if (ef_data == NULL) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            _zip_buffer_free(buffer);
+            _zip_ef_free(ef_head);
+            return false;
+        }
 
-	if ((ef2 = _zip_ef_new(fid, flen, ef_data, flags)) == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    _zip_buffer_free(buffer);
-	    _zip_ef_free(ef_head);
-	    return false;
-	}
+        if ((ef2 = _zip_ef_new(fid, flen, ef_data, flags)) == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            _zip_buffer_free(buffer);
+            _zip_ef_free(ef_head);
+            return false;
+        }
 
-	if (ef_head) {
-	    ef->next = ef2;
-	    ef = ef2;
-	}
-	else
-	    ef_head = ef = ef2;
+        if (ef_head) {
+            ef->next = ef2;
+            ef = ef2;
+        }
+        else
+            ef_head = ef = ef2;
     }
 
     if (!_zip_buffer_eof(buffer)) {
-	/* Android APK files align stored file data with padding in extra fields; ignore. */
-	/* see https://android.googlesource.com/platform/build/+/master/tools/zipalign/ZipAlign.cpp */
-	size_t glen = _zip_buffer_left(buffer);
-	zip_uint8_t *garbage;
-	garbage = _zip_buffer_get(buffer, glen);
-	if (glen >= 4 || garbage == NULL || memcmp(garbage, "\0\0\0", glen) != 0) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    _zip_buffer_free(buffer);
-	    _zip_ef_free(ef_head);
-	    return false;
-	}
+        /* Android APK files align stored file data with padding in extra fields; ignore. */
+        /* see https://android.googlesource.com/platform/build/+/master/tools/zipalign/ZipAlign.cpp */
+        size_t glen = _zip_buffer_left(buffer);
+        zip_uint8_t *garbage;
+        garbage = _zip_buffer_get(buffer, glen);
+        if (glen >= 4 || garbage == NULL || memcmp(garbage, "\0\0\0", glen) != 0) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            _zip_buffer_free(buffer);
+            _zip_ef_free(ef_head);
+            return false;
+        }
     }
 
     _zip_buffer_free(buffer);
 
     if (ef_head_p) {
-	*ef_head_p = ef_head;
+        *ef_head_p = ef_head;
     }
     else {
-	_zip_ef_free(ef_head);
+        _zip_ef_free(ef_head);
     }
 
     return true;
@@ -276,20 +276,20 @@
     prev = NULL;
 
     while (ef) {
-	if (ZIP_EF_IS_INTERNAL(ef->id)) {
-	    next = ef->next;
-	    if (ef_head == ef)
-		ef_head = next;
-	    ef->next = NULL;
-	    _zip_ef_free(ef);
-	    if (prev)
-		prev->next = next;
-	    ef = next;
-	}
-	else {
-	    prev = ef;
-	    ef = ef->next;
-	}
+        if (ZIP_EF_IS_INTERNAL(ef->id)) {
+            next = ef->next;
+            if (ef_head == ef)
+                ef_head = next;
+            ef->next = NULL;
+            _zip_ef_free(ef);
+            if (prev)
+                prev->next = next;
+            ef = next;
+        }
+        else {
+            prev = ef;
+            ef = ef->next;
+        }
     }
 
     return ef_head;
@@ -302,8 +302,8 @@
 
     size = 0;
     for (; ef; ef = ef->next) {
-	if (ef->flags & flags & ZIP_EF_BOTH)
-	    size = (zip_uint16_t)(size + 4 + ef->size);
+        if (ef->flags & flags & ZIP_EF_BOTH)
+            size = (zip_uint16_t)(size + 4 + ef->size);
     }
 
     return size;
@@ -316,30 +316,30 @@
     zip_buffer_t *buffer = _zip_buffer_new(b, sizeof(b));
 
     if (buffer == NULL) {
-	return -1;
+        return -1;
     }
 
     for (; ef; ef = ef->next) {
-	if (ef->flags & flags & ZIP_EF_BOTH) {
-	    _zip_buffer_set_offset(buffer, 0);
-	    _zip_buffer_put_16(buffer, ef->id);
-	    _zip_buffer_put_16(buffer, ef->size);
-	    if (!_zip_buffer_ok(buffer)) {
-		zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-		_zip_buffer_free(buffer);
-		return -1;
-	    }
-	    if (_zip_write(za, b, 4) < 0) {
-		_zip_buffer_free(buffer);
-		return -1;
-	    }
-	    if (ef->size > 0) {
-		if (_zip_write(za, ef->data, ef->size) < 0) {
-		    _zip_buffer_free(buffer);
-		    return -1;
-		}
-	    }
-	}
+        if (ef->flags & flags & ZIP_EF_BOTH) {
+            _zip_buffer_set_offset(buffer, 0);
+            _zip_buffer_put_16(buffer, ef->id);
+            _zip_buffer_put_16(buffer, ef->size);
+            if (!_zip_buffer_ok(buffer)) {
+                zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+                _zip_buffer_free(buffer);
+                return -1;
+            }
+            if (_zip_write(za, b, 4) < 0) {
+                _zip_buffer_free(buffer);
+                return -1;
+            }
+            if (ef->size > 0) {
+                if (_zip_write(za, ef->data, ef->size) < 0) {
+                    _zip_buffer_free(buffer);
+                    return -1;
+                }
+            }
+        }
     }
 
     _zip_buffer_free(buffer);
@@ -355,71 +355,71 @@
     zip_uint16_t fname_len, ef_len;
 
     if (idx >= za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     e = za->entry + idx;
 
     if (e->orig == NULL || e->orig->local_extra_fields_read)
-	return 0;
+        return 0;
 
     if (e->orig->offset + 26 > ZIP_INT64_MAX) {
-	zip_error_set(&za->error, ZIP_ER_SEEK, EFBIG);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_SEEK, EFBIG);
+        return -1;
     }
 
     if (zip_source_seek(za->src, (zip_int64_t)(e->orig->offset + 26), SEEK_SET) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
 
     if ((buffer = _zip_buffer_new_from_source(za->src, sizeof(b), b, &za->error)) == NULL) {
-	return -1;
+        return -1;
     }
 
     fname_len = _zip_buffer_get_16(buffer);
     ef_len = _zip_buffer_get_16(buffer);
 
     if (!_zip_buffer_eof(buffer)) {
-	_zip_buffer_free(buffer);
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        _zip_buffer_free(buffer);
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     _zip_buffer_free(buffer);
 
     if (ef_len > 0) {
-	zip_extra_field_t *ef;
-	zip_uint8_t *ef_raw;
+        zip_extra_field_t *ef;
+        zip_uint8_t *ef_raw;
 
-	if (zip_source_seek(za->src, fname_len, SEEK_CUR) < 0) {
-	    zip_error_set(&za->error, ZIP_ER_SEEK, errno);
-	    return -1;
-	}
+        if (zip_source_seek(za->src, fname_len, SEEK_CUR) < 0) {
+            zip_error_set(&za->error, ZIP_ER_SEEK, errno);
+            return -1;
+        }
 
-	ef_raw = _zip_read_data(NULL, za->src, ef_len, 0, &za->error);
+        ef_raw = _zip_read_data(NULL, za->src, ef_len, 0, &za->error);
 
-	if (ef_raw == NULL)
-	    return -1;
+        if (ef_raw == NULL)
+            return -1;
 
-	if (!_zip_ef_parse(ef_raw, ef_len, ZIP_EF_LOCAL, &ef, &za->error)) {
-	    free(ef_raw);
-	    return -1;
-	}
-	free(ef_raw);
+        if (!_zip_ef_parse(ef_raw, ef_len, ZIP_EF_LOCAL, &ef, &za->error)) {
+            free(ef_raw);
+            return -1;
+        }
+        free(ef_raw);
 
-	if (ef) {
-	    ef = _zip_ef_remove_internal(ef);
-	    e->orig->extra_fields = _zip_ef_merge(e->orig->extra_fields, ef);
-	}
+        if (ef) {
+            ef = _zip_ef_remove_internal(ef);
+            e->orig->extra_fields = _zip_ef_merge(e->orig->extra_fields, ef);
+        }
     }
 
     e->orig->local_extra_fields_read = 1;
 
     if (e->changes && e->changes->local_extra_fields_read == 0) {
-	e->changes->extra_fields = e->orig->extra_fields;
-	e->changes->local_extra_fields_read = 1;
+        e->changes->extra_fields = e->orig->extra_fields;
+        e->changes->local_extra_fields_read = 1;
     }
 
     return 0;
diff --git a/lib/zip_extra_field_api.c b/lib/zip_extra_field_api.c
index 605f95d..19c77ea 100644
--- a/lib/zip_extra_field_api.c
+++ b/lib/zip_extra_field_api.c
@@ -40,25 +40,25 @@
     zip_dirent_t *de;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (((flags & ZIP_EF_BOTH) == ZIP_EF_BOTH) && (ef_idx != ZIP_EXTRA_FIELD_ALL)) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
-	return -1;
+        return -1;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (_zip_file_extra_field_prepare_for_change(za, idx) < 0)
-	return -1;
+        return -1;
 
     de = za->entry[idx].changes;
 
@@ -72,25 +72,25 @@
     zip_dirent_t *de;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (((flags & ZIP_EF_BOTH) == ZIP_EF_BOTH) && (ef_idx != ZIP_EXTRA_FIELD_ALL)) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
-	return -1;
+        return -1;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (_zip_file_extra_field_prepare_for_change(za, idx) < 0)
-	return -1;
+        return -1;
 
     de = za->entry[idx].changes;
 
@@ -108,34 +108,34 @@
     int i;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)
-	return NULL;
+        return NULL;
 
     if (flags & ZIP_FL_LOCAL)
-	if (_zip_read_local_ef(za, idx) < 0)
-	    return NULL;
+        if (_zip_read_local_ef(za, idx) < 0)
+            return NULL;
 
     i = 0;
     for (ef = de->extra_fields; ef; ef = ef->next) {
-	if (ef->flags & flags & ZIP_EF_BOTH) {
-	    if (i < ef_idx) {
-		i++;
-		continue;
-	    }
+        if (ef->flags & flags & ZIP_EF_BOTH) {
+            if (i < ef_idx) {
+                i++;
+                continue;
+            }
 
-	    if (idp)
-		*idp = ef->id;
-	    if (lenp)
-		*lenp = ef->size;
-	    if (ef->size > 0)
-		return ef->data;
-	    else
-		return empty;
-	}
+            if (idp)
+                *idp = ef->id;
+            if (lenp)
+                *lenp = ef->size;
+            if (ef->size > 0)
+                return ef->data;
+            else
+                return empty;
+        }
     }
 
     zip_error_set(&za->error, ZIP_ER_NOENT, 0);
@@ -148,16 +148,16 @@
     zip_dirent_t *de;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)
-	return NULL;
+        return NULL;
 
     if (flags & ZIP_FL_LOCAL)
-	if (_zip_read_local_ef(za, idx) < 0)
-	    return NULL;
+        if (_zip_read_local_ef(za, idx) < 0)
+            return NULL;
 
     return _zip_ef_get_by_id(de->extra_fields, lenp, ef_id, ef_idx, flags, &za->error);
 }
@@ -170,21 +170,21 @@
     zip_uint16_t n;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)
-	return -1;
+        return -1;
 
     if (flags & ZIP_FL_LOCAL)
-	if (_zip_read_local_ef(za, idx) < 0)
-	    return -1;
+        if (_zip_read_local_ef(za, idx) < 0)
+            return -1;
 
     n = 0;
     for (ef = de->extra_fields; ef; ef = ef->next)
-	if (ef->flags & flags & ZIP_EF_BOTH)
-	    n++;
+        if (ef->flags & flags & ZIP_EF_BOTH)
+            n++;
 
     return (zip_int16_t)n;
 }
@@ -197,21 +197,21 @@
     zip_uint16_t n;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)
-	return -1;
+        return -1;
 
     if (flags & ZIP_FL_LOCAL)
-	if (_zip_read_local_ef(za, idx) < 0)
-	    return -1;
+        if (_zip_read_local_ef(za, idx) < 0)
+            return -1;
 
     n = 0;
     for (ef = de->extra_fields; ef; ef = ef->next)
-	if (ef->id == ef_id && (ef->flags & flags & ZIP_EF_BOTH))
-	    n++;
+        if (ef->id == ef_id && (ef->flags & flags & ZIP_EF_BOTH))
+            n++;
 
     return (zip_int16_t)n;
 }
@@ -225,25 +225,25 @@
     int i, found, new_len;
 
     if ((flags & ZIP_EF_BOTH) == 0) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
-	return -1;
+        return -1;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (ZIP_EF_IS_INTERNAL(ef_id)) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_file_extra_field_prepare_for_change(za, idx) < 0)
-	return -1;
+        return -1;
 
     de = za->entry[idx].changes;
 
@@ -253,67 +253,67 @@
     found = 0;
 
     for (; ef; ef = ef->next) {
-	if (ef->id == ef_id && (ef->flags & flags & ZIP_EF_BOTH)) {
-	    if (i == ef_idx) {
-		found = 1;
-		break;
-	    }
-	    i++;
-	}
-	ef_prev = ef;
+        if (ef->id == ef_id && (ef->flags & flags & ZIP_EF_BOTH)) {
+            if (i == ef_idx) {
+                found = 1;
+                break;
+            }
+            i++;
+        }
+        ef_prev = ef;
     }
 
     if (i < ef_idx && ef_idx != ZIP_EXTRA_FIELD_NEW) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (flags & ZIP_EF_LOCAL)
-	ls = _zip_ef_size(de->extra_fields, ZIP_EF_LOCAL);
+        ls = _zip_ef_size(de->extra_fields, ZIP_EF_LOCAL);
     else
-	ls = 0;
+        ls = 0;
     if (flags & ZIP_EF_CENTRAL)
-	cs = _zip_ef_size(de->extra_fields, ZIP_EF_CENTRAL);
+        cs = _zip_ef_size(de->extra_fields, ZIP_EF_CENTRAL);
     else
-	cs = 0;
+        cs = 0;
 
     new_len = ls > cs ? ls : cs;
     if (found)
-	new_len -= ef->size + 4;
+        new_len -= ef->size + 4;
     new_len += len + 4;
 
     if (new_len > ZIP_UINT16_MAX) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if ((ef_new = _zip_ef_new(ef_id, len, data, flags)) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     if (found) {
-	if ((ef->flags & ZIP_EF_BOTH) == (flags & ZIP_EF_BOTH)) {
-	    ef_new->next = ef->next;
-	    ef->next = NULL;
-	    _zip_ef_free(ef);
-	    if (ef_prev)
-		ef_prev->next = ef_new;
-	    else
-		de->extra_fields = ef_new;
-	}
-	else {
-	    ef->flags &= ~(flags & ZIP_EF_BOTH);
-	    ef_new->next = ef->next;
-	    ef->next = ef_new;
-	}
+        if ((ef->flags & ZIP_EF_BOTH) == (flags & ZIP_EF_BOTH)) {
+            ef_new->next = ef->next;
+            ef->next = NULL;
+            _zip_ef_free(ef);
+            if (ef_prev)
+                ef_prev->next = ef_new;
+            else
+                de->extra_fields = ef_new;
+        }
+        else {
+            ef->flags &= ~(flags & ZIP_EF_BOTH);
+            ef_new->next = ef->next;
+            ef->next = ef_new;
+        }
     }
     else if (ef_prev) {
-	ef_new->next = ef_prev->next;
-	ef_prev->next = ef_new;
+        ef_new->next = ef_prev->next;
+        ef_prev->next = ef_new;
     }
     else
-	de->extra_fields = ef_new;
+        de->extra_fields = ef_new;
 
     return 0;
 }
@@ -324,30 +324,30 @@
     zip_entry_t *e;
 
     if (idx >= za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     e = za->entry + idx;
 
     if (e->changes && (e->changes->changed & ZIP_DIRENT_EXTRA_FIELD))
-	return 0;
+        return 0;
 
     if (e->orig) {
-	if (_zip_read_local_ef(za, idx) < 0)
-	    return -1;
+        if (_zip_read_local_ef(za, idx) < 0)
+            return -1;
     }
 
     if (e->changes == NULL) {
-	if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
+        if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
     }
 
     if (e->orig && e->orig->extra_fields) {
-	if ((e->changes->extra_fields = _zip_ef_clone(e->orig->extra_fields, &za->error)) == NULL)
-	    return -1;
+        if ((e->changes->extra_fields = _zip_ef_clone(e->orig->extra_fields, &za->error)) == NULL)
+            return -1;
     }
     e->changes->changed |= ZIP_DIRENT_EXTRA_FIELD;
 
diff --git a/lib/zip_fclose.c b/lib/zip_fclose.c
index 6eb9dc9..e836429 100644
--- a/lib/zip_fclose.c
+++ b/lib/zip_fclose.c
@@ -42,11 +42,11 @@
     int ret;
 
     if (zf->src)
-	zip_source_free(zf->src);
+        zip_source_free(zf->src);
 
     ret = 0;
     if (zf->error.zip_err)
-	ret = zf->error.zip_err;
+        ret = zf->error.zip_err;
 
     zip_error_fini(&zf->error);
     free(zf);
diff --git a/lib/zip_fdopen.c b/lib/zip_fdopen.c
index 5a732cd..6ad0048 100644
--- a/lib/zip_fdopen.c
+++ b/lib/zip_fdopen.c
@@ -47,37 +47,37 @@
     struct zip_error error;
 
     if (_flags < 0 || (_flags & ~(ZIP_CHECKCONS | ZIP_RDONLY))) {
-	_zip_set_open_error(zep, NULL, ZIP_ER_INVAL);
-	return NULL;
+        _zip_set_open_error(zep, NULL, ZIP_ER_INVAL);
+        return NULL;
     }
 
     /* We dup() here to avoid messing with the passed in fd.
        We could not restore it to the original state in case of error. */
 
     if ((fd = dup(fd_orig)) < 0) {
-	_zip_set_open_error(zep, NULL, ZIP_ER_OPEN);
-	return NULL;
+        _zip_set_open_error(zep, NULL, ZIP_ER_OPEN);
+        return NULL;
     }
 
     if ((fp = fdopen(fd, "rb")) == NULL) {
-	close(fd);
-	_zip_set_open_error(zep, NULL, ZIP_ER_OPEN);
-	return NULL;
+        close(fd);
+        _zip_set_open_error(zep, NULL, ZIP_ER_OPEN);
+        return NULL;
     }
 
     zip_error_init(&error);
     if ((src = zip_source_filep_create(fp, 0, -1, &error)) == NULL) {
-	fclose(fp);
-	_zip_set_open_error(zep, &error, 0);
-	zip_error_fini(&error);
-	return NULL;
+        fclose(fp);
+        _zip_set_open_error(zep, &error, 0);
+        zip_error_fini(&error);
+        return NULL;
     }
 
     if ((za = zip_open_from_source(src, _flags, &error)) == NULL) {
-	zip_source_free(src);
-	_zip_set_open_error(zep, &error, 0);
-	zip_error_fini(&error);
-	return NULL;
+        zip_source_free(src);
+        _zip_set_open_error(zep, &error, 0);
+        zip_error_fini(&error);
+        return NULL;
     }
 
     zip_error_fini(&error);
diff --git a/lib/zip_file_add.c b/lib/zip_file_add.c
index c019d8d..7d2b169 100644
--- a/lib/zip_file_add.c
+++ b/lib/zip_file_add.c
@@ -36,16 +36,16 @@
 
 /*
   NOTE: Return type is signed so we can return -1 on error.
-	The index can not be larger than ZIP_INT64_MAX since the size
-	of the central directory cannot be larger than
-	ZIP_UINT64_MAX, and each entry is larger than 2 bytes.
+        The index can not be larger than ZIP_INT64_MAX since the size
+        of the central directory cannot be larger than
+        ZIP_UINT64_MAX, and each entry is larger than 2 bytes.
 */
 
 ZIP_EXTERN zip_int64_t
 zip_file_add(zip_t *za, const char *name, zip_source_t *source, zip_flags_t flags) {
     if (name == NULL || source == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     return _zip_file_replace(za, ZIP_UINT64_MAX, name, source, flags);
diff --git a/lib/zip_file_error_clear.c b/lib/zip_file_error_clear.c
index 47e5da6..83c588d 100644
--- a/lib/zip_file_error_clear.c
+++ b/lib/zip_file_error_clear.c
@@ -38,7 +38,7 @@
 ZIP_EXTERN void
 zip_file_error_clear(zip_file_t *zf) {
     if (zf == NULL)
-	return;
+        return;
 
     _zip_error_clear(&zf->error);
 }
diff --git a/lib/zip_file_get_comment.c b/lib/zip_file_get_comment.c
index 8f68141..ddf73e5 100644
--- a/lib/zip_file_get_comment.c
+++ b/lib/zip_file_get_comment.c
@@ -43,13 +43,13 @@
     const zip_uint8_t *str;
 
     if ((de = _zip_get_dirent(za, idx, flags, NULL)) == NULL)
-	return NULL;
+        return NULL;
 
     if ((str = _zip_string_get(de->comment, &len, flags, &za->error)) == NULL)
-	return NULL;
+        return NULL;
 
     if (lenp)
-	*lenp = len;
+        *lenp = len;
 
     return (const char *)str;
 }
diff --git a/lib/zip_file_get_external_attributes.c b/lib/zip_file_get_external_attributes.c
index ebc2058..0bc2aa6 100644
--- a/lib/zip_file_get_external_attributes.c
+++ b/lib/zip_file_get_external_attributes.c
@@ -38,13 +38,13 @@
     zip_dirent_t *de;
 
     if ((de = _zip_get_dirent(za, idx, flags, NULL)) == NULL)
-	return -1;
+        return -1;
 
     if (opsys)
-	*opsys = (zip_uint8_t)((de->version_madeby >> 8) & 0xff);
+        *opsys = (zip_uint8_t)((de->version_madeby >> 8) & 0xff);
 
     if (attributes)
-	*attributes = de->ext_attrib;
+        *attributes = de->ext_attrib;
 
     return 0;
 }
diff --git a/lib/zip_file_get_offset.c b/lib/zip_file_get_offset.c
index 2cf4480..ae962ac 100644
--- a/lib/zip_file_get_offset.c
+++ b/lib/zip_file_get_offset.c
@@ -50,24 +50,24 @@
     zip_int32_t size;
 
     if (za->entry[idx].orig == NULL) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	return 0;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        return 0;
     }
 
     offset = za->entry[idx].orig->offset;
 
     if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
-	_zip_error_set_from_source(error, za->src);
-	return 0;
+        _zip_error_set_from_source(error, za->src);
+        return 0;
     }
 
     /* TODO: cache? */
     if ((size = _zip_dirent_size(za->src, ZIP_EF_LOCAL, error)) < 0)
-	return 0;
+        return 0;
 
     if (offset + (zip_uint32_t)size > ZIP_INT64_MAX) {
-	zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	return 0;
+        zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+        return 0;
     }
 
     return offset + (zip_uint32_t)size;
@@ -79,38 +79,38 @@
     zip_dirent_t *entry;
 
     if ((offset = _zip_file_get_offset(za, index, error)) == 0) {
-	return 0;
+        return 0;
     }
 
     entry = za->entry[index].orig;
 
     if (offset + entry->comp_size < offset || offset + entry->comp_size > ZIP_INT64_MAX) {
-	zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	return 0;
+        zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+        return 0;
     }
     offset += entry->comp_size;
 
     if (entry->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
-	zip_uint8_t buf[4];
-	if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
-	    _zip_error_set_from_source(error, za->src);
-	    return 0;
-	}
-	if (zip_source_read(za->src, buf, 4) != 4) {
-	    _zip_error_set_from_source(error, za->src);
-	    return 0;
-	}
-	if (memcmp(buf, DATADES_MAGIC, 4) == 0) {
-	    offset += 4;
-	}
-	offset += 12;
-	if (_zip_dirent_needs_zip64(entry, 0)) {
-	    offset += 8;
-	}
-	if (offset > ZIP_INT64_MAX) {
-	    zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	    return 0;
-	}
+        zip_uint8_t buf[4];
+        if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
+            _zip_error_set_from_source(error, za->src);
+            return 0;
+        }
+        if (zip_source_read(za->src, buf, 4) != 4) {
+            _zip_error_set_from_source(error, za->src);
+            return 0;
+        }
+        if (memcmp(buf, DATADES_MAGIC, 4) == 0) {
+            offset += 4;
+        }
+        offset += 12;
+        if (_zip_dirent_needs_zip64(entry, 0)) {
+            offset += 8;
+        }
+        if (offset > ZIP_INT64_MAX) {
+            zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+            return 0;
+        }
     }
 
     return offset;
diff --git a/lib/zip_file_rename.c b/lib/zip_file_rename.c
index 7ca428c..91af73d 100644
--- a/lib/zip_file_rename.c
+++ b/lib/zip_file_rename.c
@@ -43,24 +43,24 @@
     int old_is_dir, new_is_dir;
 
     if (idx >= za->nentry || (name != NULL && strlen(name) > ZIP_UINT16_MAX)) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if ((old_name = zip_get_name(za, idx, 0)) == NULL)
-	return -1;
+        return -1;
 
     new_is_dir = (name != NULL && name[strlen(name) - 1] == '/');
     old_is_dir = (old_name[strlen(old_name) - 1] == '/');
 
     if (new_is_dir != old_is_dir) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     return _zip_set_name(za, idx, name, flags);
diff --git a/lib/zip_file_replace.c b/lib/zip_file_replace.c
index 87401f4..dab498b 100644
--- a/lib/zip_file_replace.c
+++ b/lib/zip_file_replace.c
@@ -38,12 +38,12 @@
 ZIP_EXTERN int
 zip_file_replace(zip_t *za, zip_uint64_t idx, zip_source_t *source, zip_flags_t flags) {
     if (idx >= za->nentry || source == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_file_replace(za, idx, NULL, source, flags) == -1)
-	return -1;
+        return -1;
 
     return 0;
 }
@@ -56,31 +56,31 @@
     zip_uint64_t za_nentry_prev;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     za_nentry_prev = za->nentry;
     if (idx == ZIP_UINT64_MAX) {
-	zip_int64_t i = -1;
+        zip_int64_t i = -1;
 
-	if (flags & ZIP_FL_OVERWRITE)
-	    i = _zip_name_locate(za, name, flags, NULL);
+        if (flags & ZIP_FL_OVERWRITE)
+            i = _zip_name_locate(za, name, flags, NULL);
 
-	if (i == -1) {
-	    /* create and use new entry, used by zip_add */
-	    if ((i = _zip_add_entry(za)) < 0)
-		return -1;
-	}
-	idx = (zip_uint64_t)i;
+        if (i == -1) {
+            /* create and use new entry, used by zip_add */
+            if ((i = _zip_add_entry(za)) < 0)
+                return -1;
+        }
+        idx = (zip_uint64_t)i;
     }
 
     if (name && _zip_set_name(za, idx, name, flags) != 0) {
-	if (za->nentry != za_nentry_prev) {
-	    _zip_entry_finalize(za->entry + idx);
-	    za->nentry = za_nentry_prev;
-	}
-	return -1;
+        if (za->nentry != za_nentry_prev) {
+            _zip_entry_finalize(za->entry + idx);
+            za->nentry = za_nentry_prev;
+        }
+        return -1;
     }
 
     /* does not change any name related data, so we can do it here;
@@ -88,15 +88,15 @@
     _zip_unchange_data(za->entry + idx);
 
     if (za->entry[idx].orig != NULL && (za->entry[idx].changes == NULL || (za->entry[idx].changes->changed & ZIP_DIRENT_COMP_METHOD) == 0)) {
-	if (za->entry[idx].changes == NULL) {
-	    if ((za->entry[idx].changes = _zip_dirent_clone(za->entry[idx].orig)) == NULL) {
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	}
+        if (za->entry[idx].changes == NULL) {
+            if ((za->entry[idx].changes = _zip_dirent_clone(za->entry[idx].orig)) == NULL) {
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+        }
 
-	za->entry[idx].changes->comp_method = ZIP_CM_REPLACED_DEFAULT;
-	za->entry[idx].changes->changed |= ZIP_DIRENT_COMP_METHOD;
+        za->entry[idx].changes->comp_method = ZIP_CM_REPLACED_DEFAULT;
+        za->entry[idx].changes->changed |= ZIP_DIRENT_COMP_METHOD;
     }
 
     za->entry[idx].source = source;
diff --git a/lib/zip_file_set_comment.c b/lib/zip_file_set_comment.c
index c309db8..135ad7b 100644
--- a/lib/zip_file_set_comment.c
+++ b/lib/zip_file_set_comment.c
@@ -44,57 +44,57 @@
     int changed;
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
-	return -1;
+        return -1;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (len > 0 && comment == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (len > 0) {
-	if ((cstr = _zip_string_new((const zip_uint8_t *)comment, len, flags, &za->error)) == NULL)
-	    return -1;
-	if ((flags & ZIP_FL_ENCODING_ALL) == ZIP_FL_ENC_GUESS && _zip_guess_encoding(cstr, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_UTF8_GUESSED)
-	    cstr->encoding = ZIP_ENCODING_UTF8_KNOWN;
+        if ((cstr = _zip_string_new((const zip_uint8_t *)comment, len, flags, &za->error)) == NULL)
+            return -1;
+        if ((flags & ZIP_FL_ENCODING_ALL) == ZIP_FL_ENC_GUESS && _zip_guess_encoding(cstr, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_UTF8_GUESSED)
+            cstr->encoding = ZIP_ENCODING_UTF8_KNOWN;
     }
     else
-	cstr = NULL;
+        cstr = NULL;
 
     e = za->entry + idx;
 
     if (e->changes) {
-	_zip_string_free(e->changes->comment);
-	e->changes->comment = NULL;
-	e->changes->changed &= ~ZIP_DIRENT_COMMENT;
+        _zip_string_free(e->changes->comment);
+        e->changes->comment = NULL;
+        e->changes->changed &= ~ZIP_DIRENT_COMMENT;
     }
 
     if (e->orig && e->orig->comment)
-	changed = !_zip_string_equal(e->orig->comment, cstr);
+        changed = !_zip_string_equal(e->orig->comment, cstr);
     else
-	changed = (cstr != NULL);
+        changed = (cstr != NULL);
 
     if (changed) {
-	if (e->changes == NULL) {
-	    if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		_zip_string_free(cstr);
-		return -1;
-	    }
-	}
-	e->changes->comment = cstr;
-	e->changes->changed |= ZIP_DIRENT_COMMENT;
+        if (e->changes == NULL) {
+            if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                _zip_string_free(cstr);
+                return -1;
+            }
+        }
+        e->changes->comment = cstr;
+        e->changes->changed |= ZIP_DIRENT_COMMENT;
     }
     else {
-	_zip_string_free(cstr);
-	if (e->changes && e->changes->changed == 0) {
-	    _zip_dirent_free(e->changes);
-	    e->changes = NULL;
-	}
+        _zip_string_free(cstr);
+        if (e->changes && e->changes->changed == 0) {
+            _zip_dirent_free(e->changes);
+            e->changes = NULL;
+        }
     }
 
     return 0;
diff --git a/lib/zip_file_set_encryption.c b/lib/zip_file_set_encryption.c
index a66a1b5..3d9727d 100644
--- a/lib/zip_file_set_encryption.c
+++ b/lib/zip_file_set_encryption.c
@@ -43,18 +43,18 @@
     zip_uint16_t old_method;
 
     if (idx >= za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (method != ZIP_EM_NONE && _zip_get_encryption_implementation(method, ZIP_CODEC_ENCODE) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+        return -1;
     }
 
     e = za->entry + idx;
@@ -62,54 +62,54 @@
     old_method = (e->orig == NULL ? ZIP_EM_NONE : e->orig->encryption_method);
 
     if (method == old_method && password == NULL) {
-	if (e->changes) {
-	    if (e->changes->changed & ZIP_DIRENT_PASSWORD) {
-		_zip_crypto_clear(e->changes->password, strlen(e->changes->password));
-		free(e->changes->password);
-		e->changes->password = (e->orig == NULL ? NULL : e->orig->password);
-	    }
-	    e->changes->changed &= ~(ZIP_DIRENT_ENCRYPTION_METHOD | ZIP_DIRENT_PASSWORD);
-	    if (e->changes->changed == 0) {
-		_zip_dirent_free(e->changes);
-		e->changes = NULL;
-	    }
-	}
+        if (e->changes) {
+            if (e->changes->changed & ZIP_DIRENT_PASSWORD) {
+                _zip_crypto_clear(e->changes->password, strlen(e->changes->password));
+                free(e->changes->password);
+                e->changes->password = (e->orig == NULL ? NULL : e->orig->password);
+            }
+            e->changes->changed &= ~(ZIP_DIRENT_ENCRYPTION_METHOD | ZIP_DIRENT_PASSWORD);
+            if (e->changes->changed == 0) {
+                _zip_dirent_free(e->changes);
+                e->changes = NULL;
+            }
+        }
     }
     else {
-	char *our_password = NULL;
+        char *our_password = NULL;
 
-	if (password) {
-	    if ((our_password = strdup(password)) == NULL) {
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	}
+        if (password) {
+            if ((our_password = strdup(password)) == NULL) {
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+        }
 
-	if (e->changes == NULL) {
-	    if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-		if (our_password) {
-		    _zip_crypto_clear(our_password, strlen(our_password));
-		}
-		free(our_password);
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	}
+        if (e->changes == NULL) {
+            if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+                if (our_password) {
+                    _zip_crypto_clear(our_password, strlen(our_password));
+                }
+                free(our_password);
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+        }
 
-	e->changes->encryption_method = method;
-	e->changes->changed |= ZIP_DIRENT_ENCRYPTION_METHOD;
-	if (password) {
-	    e->changes->password = our_password;
-	    e->changes->changed |= ZIP_DIRENT_PASSWORD;
-	}
-	else {
-	    if (e->changes->changed & ZIP_DIRENT_PASSWORD) {
-		_zip_crypto_clear(e->changes->password, strlen(e->changes->password));
-		free(e->changes->password);
-		e->changes->password = e->orig ? e->orig->password : NULL;
-		e->changes->changed &= ~ZIP_DIRENT_PASSWORD;
-	    }
-	}
+        e->changes->encryption_method = method;
+        e->changes->changed |= ZIP_DIRENT_ENCRYPTION_METHOD;
+        if (password) {
+            e->changes->password = our_password;
+            e->changes->changed |= ZIP_DIRENT_PASSWORD;
+        }
+        else {
+            if (e->changes->changed & ZIP_DIRENT_PASSWORD) {
+                _zip_crypto_clear(e->changes->password, strlen(e->changes->password));
+                free(e->changes->password);
+                e->changes->password = e->orig ? e->orig->password : NULL;
+                e->changes->changed &= ~ZIP_DIRENT_PASSWORD;
+            }
+        }
     }
 
     return 0;
diff --git a/lib/zip_file_set_external_attributes.c b/lib/zip_file_set_external_attributes.c
index bb2ea61..52842d8 100644
--- a/lib/zip_file_set_external_attributes.c
+++ b/lib/zip_file_set_external_attributes.c
@@ -41,11 +41,11 @@
     zip_uint32_t unchanged_attributes;
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
-	return -1;
+        return -1;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     e = za->entry + idx;
@@ -56,26 +56,26 @@
     changed = (opsys != unchanged_opsys || attributes != unchanged_attributes);
 
     if (changed) {
-	if (e->changes == NULL) {
-	    if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	}
-	e->changes->version_madeby = (zip_uint16_t)((opsys << 8) | (e->changes->version_madeby & 0xff));
-	e->changes->ext_attrib = attributes;
-	e->changes->changed |= ZIP_DIRENT_ATTRIBUTES;
+        if (e->changes == NULL) {
+            if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+        }
+        e->changes->version_madeby = (zip_uint16_t)((opsys << 8) | (e->changes->version_madeby & 0xff));
+        e->changes->ext_attrib = attributes;
+        e->changes->changed |= ZIP_DIRENT_ATTRIBUTES;
     }
     else if (e->changes) {
-	e->changes->changed &= ~ZIP_DIRENT_ATTRIBUTES;
-	if (e->changes->changed == 0) {
-	    _zip_dirent_free(e->changes);
-	    e->changes = NULL;
-	}
-	else {
-	    e->changes->version_madeby = (zip_uint16_t)((unchanged_opsys << 8) | (e->changes->version_madeby & 0xff));
-	    e->changes->ext_attrib = unchanged_attributes;
-	}
+        e->changes->changed &= ~ZIP_DIRENT_ATTRIBUTES;
+        if (e->changes->changed == 0) {
+            _zip_dirent_free(e->changes);
+            e->changes = NULL;
+        }
+        else {
+            e->changes->version_madeby = (zip_uint16_t)((unchanged_opsys << 8) | (e->changes->version_madeby & 0xff));
+            e->changes->ext_attrib = unchanged_attributes;
+        }
     }
 
     return 0;
diff --git a/lib/zip_file_set_mtime.c b/lib/zip_file_set_mtime.c
index 838548e..2753d59 100644
--- a/lib/zip_file_set_mtime.c
+++ b/lib/zip_file_set_mtime.c
@@ -45,20 +45,20 @@
     zip_entry_t *e;
 
     if (_zip_get_dirent(za, idx, 0, NULL) == NULL)
-	return -1;
+        return -1;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     e = za->entry + idx;
 
     if (e->changes == NULL) {
-	if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
+        if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
     }
 
     e->changes->last_mod = mtime;
diff --git a/lib/zip_fopen.c b/lib/zip_fopen.c
index 4f1a051..5b58ce3 100644
--- a/lib/zip_fopen.c
+++ b/lib/zip_fopen.c
@@ -40,7 +40,7 @@
     zip_int64_t idx;
 
     if ((idx = zip_name_locate(za, fname, flags)) < 0)
-	return NULL;
+        return NULL;
 
     return zip_fopen_index_encrypted(za, (zip_uint64_t)idx, flags, za->default_password);
 }
diff --git a/lib/zip_fopen_encrypted.c b/lib/zip_fopen_encrypted.c
index 9e9b13e..e6860fd 100644
--- a/lib/zip_fopen_encrypted.c
+++ b/lib/zip_fopen_encrypted.c
@@ -40,7 +40,7 @@
     zip_int64_t idx;
 
     if ((idx = zip_name_locate(za, fname, flags)) < 0)
-	return NULL;
+        return NULL;
 
     return zip_fopen_index_encrypted(za, (zip_uint64_t)idx, flags, password);
 }
diff --git a/lib/zip_fopen_index_encrypted.c b/lib/zip_fopen_index_encrypted.c
index 6712c32..c14f8c5 100644
--- a/lib/zip_fopen_index_encrypted.c
+++ b/lib/zip_fopen_index_encrypted.c
@@ -46,17 +46,17 @@
     zip_source_t *src;
 
     if ((src = _zip_source_zip_new(za, za, index, flags, 0, 0, password)) == NULL)
-	return NULL;
+        return NULL;
 
     if (zip_source_open(src) < 0) {
-	_zip_error_set_from_source(&za->error, src);
-	zip_source_free(src);
-	return NULL;
+        _zip_error_set_from_source(&za->error, src);
+        zip_source_free(src);
+        return NULL;
     }
 
     if ((zf = _zip_file_new(za)) == NULL) {
-	zip_source_free(src);
-	return NULL;
+        zip_source_free(src);
+        return NULL;
     }
 
     zf->src = src;
@@ -70,8 +70,8 @@
     zip_file_t *zf;
 
     if ((zf = (zip_file_t *)malloc(sizeof(struct zip_file))) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     zf->za = za;
diff --git a/lib/zip_fread.c b/lib/zip_fread.c
index 646d712..7d102db 100644
--- a/lib/zip_fread.c
+++ b/lib/zip_fread.c
@@ -40,22 +40,22 @@
     zip_int64_t n;
 
     if (!zf)
-	return -1;
+        return -1;
 
     if (zf->error.zip_err != 0)
-	return -1;
+        return -1;
 
     if (toread > ZIP_INT64_MAX) {
-	zip_error_set(&zf->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&zf->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if ((zf->eof) || (toread == 0))
-	return 0;
+        return 0;
 
     if ((n = zip_source_read(zf->src, outbuf, toread)) < 0) {
-	_zip_error_set_from_source(&zf->error, zf->src);
-	return -1;
+        _zip_error_set_from_source(&zf->error, zf->src);
+        return -1;
     }
 
     return n;
diff --git a/lib/zip_fseek.c b/lib/zip_fseek.c
index dc6d978..fdec5d1 100644
--- a/lib/zip_fseek.c
+++ b/lib/zip_fseek.c
@@ -37,14 +37,14 @@
 ZIP_EXTERN zip_int8_t
 zip_fseek(zip_file_t *zf, zip_int64_t offset, int whence) {
     if (!zf)
-	return -1;
+        return -1;
 
     if (zf->error.zip_err != 0)
-	return -1;
+        return -1;
 
     if (zip_source_seek(zf->src, offset, whence) < 0) {
-	_zip_error_set_from_source(&zf->error, zf->src);
-	return -1;
+        _zip_error_set_from_source(&zf->error, zf->src);
+        return -1;
     }
 
     return 0;
diff --git a/lib/zip_ftell.c b/lib/zip_ftell.c
index 944db7b..cedee04 100644
--- a/lib/zip_ftell.c
+++ b/lib/zip_ftell.c
@@ -39,15 +39,15 @@
     zip_int64_t res;
 
     if (!zf)
-	return -1;
+        return -1;
 
     if (zf->error.zip_err != 0)
-	return -1;
+        return -1;
 
     res = zip_source_tell(zf->src);
     if (res < 0) {
-	_zip_error_set_from_source(&zf->error, zf->src);
-	return -1;
+        _zip_error_set_from_source(&zf->error, zf->src);
+        return -1;
     }
 
     return res;
diff --git a/lib/zip_get_archive_comment.c b/lib/zip_get_archive_comment.c
index 953c6f4..2f5a795 100644
--- a/lib/zip_get_archive_comment.c
+++ b/lib/zip_get_archive_comment.c
@@ -44,15 +44,15 @@
     const zip_uint8_t *str;
 
     if ((flags & ZIP_FL_UNCHANGED) || (za->comment_changes == NULL))
-	comment = za->comment_orig;
+        comment = za->comment_orig;
     else
-	comment = za->comment_changes;
+        comment = za->comment_changes;
 
     if ((str = _zip_string_get(comment, &len, flags, &za->error)) == NULL)
-	return NULL;
+        return NULL;
 
     if (lenp)
-	*lenp = (int)len;
+        *lenp = (int)len;
 
     return (const char *)str;
 }
diff --git a/lib/zip_get_encryption_implementation.c b/lib/zip_get_encryption_implementation.c
index 3909e6f..54456ad 100644
--- a/lib/zip_get_encryption_implementation.c
+++ b/lib/zip_get_encryption_implementation.c
@@ -39,24 +39,24 @@
 _zip_get_encryption_implementation(zip_uint16_t em, int operation) {
     switch (em) {
     case ZIP_EM_TRAD_PKWARE:
-	return operation == ZIP_CODEC_DECODE ? zip_source_pkware_decode : zip_source_pkware_encode;
+        return operation == ZIP_CODEC_DECODE ? zip_source_pkware_decode : zip_source_pkware_encode;
 
 #if defined(HAVE_CRYPTO)
     case ZIP_EM_AES_128:
     case ZIP_EM_AES_192:
     case ZIP_EM_AES_256:
-	return operation == ZIP_CODEC_DECODE ? zip_source_winzip_aes_decode : zip_source_winzip_aes_encode;
+        return operation == ZIP_CODEC_DECODE ? zip_source_winzip_aes_decode : zip_source_winzip_aes_encode;
 #endif
 
     default:
-	return NULL;
+        return NULL;
     }
 }
 
 ZIP_EXTERN int
 zip_encryption_method_supported(zip_uint16_t method, int encode) {
     if (method == ZIP_EM_NONE) {
-	return 1;
+        return 1;
     }
     return _zip_get_encryption_implementation(method, encode ? ZIP_CODEC_ENCODE : ZIP_CODEC_DECODE) != NULL;
 }
diff --git a/lib/zip_get_file_comment.c b/lib/zip_get_file_comment.c
index f800686..d4a5a73 100644
--- a/lib/zip_get_file_comment.c
+++ b/lib/zip_get_file_comment.c
@@ -42,8 +42,8 @@
     const char *s;
 
     if ((s = zip_file_get_comment(za, idx, &len, (zip_flags_t)flags)) != NULL) {
-	if (lenp)
-	    *lenp = (int)len;
+        if (lenp)
+            *lenp = (int)len;
     }
 
     return s;
diff --git a/lib/zip_get_name.c b/lib/zip_get_name.c
index 4344209..f9947c4 100644
--- a/lib/zip_get_name.c
+++ b/lib/zip_get_name.c
@@ -49,10 +49,10 @@
     const zip_uint8_t *str;
 
     if ((de = _zip_get_dirent(za, idx, flags, error)) == NULL)
-	return NULL;
+        return NULL;
 
     if ((str = _zip_string_get(de->filename, NULL, flags, error)) == NULL)
-	return NULL;
+        return NULL;
 
     return (const char *)str;
 }
diff --git a/lib/zip_get_num_entries.c b/lib/zip_get_num_entries.c
index 410d26e..3dc38e3 100644
--- a/lib/zip_get_num_entries.c
+++ b/lib/zip_get_num_entries.c
@@ -40,13 +40,13 @@
     zip_uint64_t n;
 
     if (za == NULL)
-	return -1;
+        return -1;
 
     if (flags & ZIP_FL_UNCHANGED) {
-	n = za->nentry;
-	while (n > 0 && za->entry[n - 1].orig == NULL)
-	    --n;
-	return (zip_int64_t)n;
+        n = za->nentry;
+        while (n > 0 && za->entry[n - 1].orig == NULL)
+            --n;
+        return (zip_int64_t)n;
     }
     return (zip_int64_t)za->nentry;
 }
diff --git a/lib/zip_get_num_files.c b/lib/zip_get_num_files.c
index 4895eaa..2171e31 100644
--- a/lib/zip_get_num_files.c
+++ b/lib/zip_get_num_files.c
@@ -40,11 +40,11 @@
 ZIP_EXTERN int
 zip_get_num_files(zip_t *za) {
     if (za == NULL)
-	return -1;
+        return -1;
 
     if (za->nentry > INT_MAX) {
-	zip_error_set(&za->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 
     return (int)za->nentry;
diff --git a/lib/zip_hash.c b/lib/zip_hash.c
index 3206dbf..66d8d2c 100644
--- a/lib/zip_hash.c
+++ b/lib/zip_hash.c
@@ -67,9 +67,9 @@
 static void
 free_list(zip_hash_entry_t *entry) {
     while (entry != NULL) {
-	zip_hash_entry_t *next = entry->next;
-	free(entry);
-	entry = next;
+        zip_hash_entry_t *next = entry->next;
+        free(entry);
+        entry = next;
     }
 }
 
@@ -80,12 +80,12 @@
     zip_uint64_t value = HASH_START;
 
     if (name == NULL) {
-	return 0;
+        return 0;
     }
 
     while (*name != 0) {
-	value = (zip_uint64_t)(((value * HASH_MULTIPLIER) + (zip_uint8_t)*name) % 0x100000000ul);
-	name++;
+        value = (zip_uint64_t)(((value * HASH_MULTIPLIER) + (zip_uint8_t)*name) % 0x100000000ul);
+        name++;
     }
 
     return (zip_uint32_t)value;
@@ -98,30 +98,30 @@
     zip_hash_entry_t **new_table;
 
     if (new_size == hash->table_size) {
-	return true;
+        return true;
     }
 
     if ((new_table = (zip_hash_entry_t **)calloc(new_size, sizeof(zip_hash_entry_t *))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return false;
     }
 
     if (hash->nentries > 0) {
-	zip_uint32_t i;
+        zip_uint32_t i;
 
-	for (i = 0; i < hash->table_size; i++) {
-	    zip_hash_entry_t *entry = hash->table[i];
-	    while (entry) {
-		zip_hash_entry_t *next = entry->next;
+        for (i = 0; i < hash->table_size; i++) {
+            zip_hash_entry_t *entry = hash->table[i];
+            while (entry) {
+                zip_hash_entry_t *next = entry->next;
 
-		zip_uint32_t new_index = entry->hash_value % new_size;
+                zip_uint32_t new_index = entry->hash_value % new_size;
 
-		entry->next = new_table[new_index];
-		new_table[new_index] = entry;
+                entry->next = new_table[new_index];
+                new_table[new_index] = entry;
 
-		entry = next;
-	    }
-	}
+                entry = next;
+            }
+        }
     }
 
     free(hash->table);
@@ -138,14 +138,14 @@
     zip_uint32_t v;
 
     if (needed_size > ZIP_UINT32_MAX) {
-	v = ZIP_UINT32_MAX;
+        v = ZIP_UINT32_MAX;
     }
     else {
-	v = (zip_uint32_t)needed_size;
+        v = (zip_uint32_t)needed_size;
     }
 
     if (v > HASH_MAX_SIZE) {
-	return HASH_MAX_SIZE;
+        return HASH_MAX_SIZE;
     }
 
     /* From Bit Twiddling Hacks by Sean Eron Anderson <seander@cs.stanford.edu>
@@ -168,8 +168,8 @@
     zip_hash_t *hash;
 
     if ((hash = (zip_hash_t *)malloc(sizeof(zip_hash_t))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     hash->table_size = 0;
@@ -185,16 +185,16 @@
     zip_uint32_t i;
 
     if (hash == NULL) {
-	return;
+        return;
     }
 
     if (hash->table != NULL) {
-	for (i = 0; i < hash->table_size; i++) {
-	    if (hash->table[i] != NULL) {
-		free_list(hash->table[i]);
-	    }
-	}
-	free(hash->table);
+        for (i = 0; i < hash->table_size; i++) {
+            if (hash->table[i] != NULL) {
+                free_list(hash->table[i]);
+            }
+        }
+        free(hash->table);
     }
     free(hash);
 }
@@ -207,51 +207,51 @@
     zip_hash_entry_t *entry;
 
     if (hash == NULL || name == NULL || index > ZIP_INT64_MAX) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return false;
     }
 
     if (hash->table_size == 0) {
-	if (!hash_resize(hash, HASH_MIN_SIZE, error)) {
-	    return false;
-	}
+        if (!hash_resize(hash, HASH_MIN_SIZE, error)) {
+            return false;
+        }
     }
 
     hash_value = hash_string(name);
     table_index = hash_value % hash->table_size;
 
     for (entry = hash->table[table_index]; entry != NULL; entry = entry->next) {
-	if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {
-	    if (((flags & ZIP_FL_UNCHANGED) && entry->orig_index != -1) || entry->current_index != -1) {
-		zip_error_set(error, ZIP_ER_EXISTS, 0);
-		return false;
-	    }
-	    else {
-		break;
-	    }
-	}
+        if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {
+            if (((flags & ZIP_FL_UNCHANGED) && entry->orig_index != -1) || entry->current_index != -1) {
+                zip_error_set(error, ZIP_ER_EXISTS, 0);
+                return false;
+            }
+            else {
+                break;
+            }
+        }
     }
 
     if (entry == NULL) {
-	if ((entry = (zip_hash_entry_t *)malloc(sizeof(zip_hash_entry_t))) == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    return false;
-	}
-	entry->name = name;
-	entry->next = hash->table[table_index];
-	hash->table[table_index] = entry;
-	entry->hash_value = hash_value;
-	entry->orig_index = -1;
-	hash->nentries++;
-	if (hash->nentries > hash->table_size * HASH_MAX_FILL && hash->table_size < HASH_MAX_SIZE) {
-	    if (!hash_resize(hash, hash->table_size * 2, error)) {
-		return false;
-	    }
-	}
+        if ((entry = (zip_hash_entry_t *)malloc(sizeof(zip_hash_entry_t))) == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            return false;
+        }
+        entry->name = name;
+        entry->next = hash->table[table_index];
+        hash->table[table_index] = entry;
+        entry->hash_value = hash_value;
+        entry->orig_index = -1;
+        hash->nentries++;
+        if (hash->nentries > hash->table_size * HASH_MAX_FILL && hash->table_size < HASH_MAX_SIZE) {
+            if (!hash_resize(hash, hash->table_size * 2, error)) {
+                return false;
+            }
+        }
     }
 
     if (flags & ZIP_FL_UNCHANGED) {
-	entry->orig_index = (zip_int64_t)index;
+        entry->orig_index = (zip_int64_t)index;
     }
     entry->current_index = (zip_int64_t)index;
 
@@ -266,40 +266,40 @@
     zip_hash_entry_t *entry, *previous;
 
     if (hash == NULL || name == NULL) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return false;
     }
 
     if (hash->nentries > 0) {
-	hash_value = hash_string(name);
-	index = hash_value % hash->table_size;
-	previous = NULL;
-	entry = hash->table[index];
-	while (entry) {
-	    if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {
-		if (entry->orig_index == -1) {
-		    if (previous) {
-			previous->next = entry->next;
-		    }
-		    else {
-			hash->table[index] = entry->next;
-		    }
-		    free(entry);
-		    hash->nentries--;
-		    if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {
-			if (!hash_resize(hash, hash->table_size / 2, error)) {
-			    return false;
-			}
-		    }
-		}
-		else {
-		    entry->current_index = -1;
-		}
-		return true;
-	    }
-	    previous = entry;
-	    entry = entry->next;
-	}
+        hash_value = hash_string(name);
+        index = hash_value % hash->table_size;
+        previous = NULL;
+        entry = hash->table[index];
+        while (entry) {
+            if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {
+                if (entry->orig_index == -1) {
+                    if (previous) {
+                        previous->next = entry->next;
+                    }
+                    else {
+                        hash->table[index] = entry->next;
+                    }
+                    free(entry);
+                    hash->nentries--;
+                    if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {
+                        if (!hash_resize(hash, hash->table_size / 2, error)) {
+                            return false;
+                        }
+                    }
+                }
+                else {
+                    entry->current_index = -1;
+                }
+                return true;
+            }
+            previous = entry;
+            entry = entry->next;
+        }
     }
 
     zip_error_set(error, ZIP_ER_NOENT, 0);
@@ -314,28 +314,28 @@
     zip_hash_entry_t *entry;
 
     if (hash == NULL || name == NULL) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (hash->nentries > 0) {
-	hash_value = hash_string(name);
-	index = hash_value % hash->table_size;
-	for (entry = hash->table[index]; entry != NULL; entry = entry->next) {
-	    if (strcmp((const char *)name, (const char *)entry->name) == 0) {
-		if (flags & ZIP_FL_UNCHANGED) {
-		    if (entry->orig_index != -1) {
-			return entry->orig_index;
-		    }
-		}
-		else {
-		    if (entry->current_index != -1) {
-			return entry->current_index;
-		    }
-		}
-		break;
-	    }
-	}
+        hash_value = hash_string(name);
+        index = hash_value % hash->table_size;
+        for (entry = hash->table[index]; entry != NULL; entry = entry->next) {
+            if (strcmp((const char *)name, (const char *)entry->name) == 0) {
+                if (flags & ZIP_FL_UNCHANGED) {
+                    if (entry->orig_index != -1) {
+                        return entry->orig_index;
+                    }
+                }
+                else {
+                    if (entry->current_index != -1) {
+                        return entry->current_index;
+                    }
+                }
+                break;
+            }
+        }
     }
 
     zip_error_set(error, ZIP_ER_NOENT, 0);
@@ -348,17 +348,17 @@
     zip_uint32_t new_size;
 
     if (capacity == 0) {
-	return true;
+        return true;
     }
 
     new_size = size_for_capacity(capacity);
 
     if (new_size <= hash->table_size) {
-	return true;
+        return true;
     }
 
     if (!hash_resize(hash, new_size, error)) {
-	return false;
+        return false;
     }
 
     return true;
@@ -371,39 +371,39 @@
     zip_hash_entry_t *entry, *previous;
 
     for (i = 0; i < hash->table_size; i++) {
-	previous = NULL;
-	entry = hash->table[i];
-	while (entry) {
-	    if (entry->orig_index == -1) {
-		zip_hash_entry_t *p;
-		if (previous) {
-		    previous->next = entry->next;
-		}
-		else {
-		    hash->table[i] = entry->next;
-		}
-		p = entry;
-		entry = entry->next;
-		/* previous does not change */
-		free(p);
-		hash->nentries--;
-	    }
-	    else {
-		entry->current_index = entry->orig_index;
-		previous = entry;
-		entry = entry->next;
-	    }
-	}
+        previous = NULL;
+        entry = hash->table[i];
+        while (entry) {
+            if (entry->orig_index == -1) {
+                zip_hash_entry_t *p;
+                if (previous) {
+                    previous->next = entry->next;
+                }
+                else {
+                    hash->table[i] = entry->next;
+                }
+                p = entry;
+                entry = entry->next;
+                /* previous does not change */
+                free(p);
+                hash->nentries--;
+            }
+            else {
+                entry->current_index = entry->orig_index;
+                previous = entry;
+                entry = entry->next;
+            }
+        }
     }
 
     if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {
-	zip_uint32_t new_size = hash->table_size / 2;
-	while (hash->nentries < new_size * HASH_MIN_FILL && new_size > HASH_MIN_SIZE) {
-	    new_size /= 2;
-	}
-	if (!hash_resize(hash, new_size, error)) {
-	    return false;
-	}
+        zip_uint32_t new_size = hash->table_size / 2;
+        while (hash->nentries < new_size * HASH_MIN_FILL && new_size > HASH_MIN_SIZE) {
+            new_size /= 2;
+        }
+        if (!hash_resize(hash, new_size, error)) {
+            return false;
+        }
     }
 
     return true;
diff --git a/lib/zip_io_util.c b/lib/zip_io_util.c
index dd07cbb..d5fd543 100644
--- a/lib/zip_io_util.c
+++ b/lib/zip_io_util.c
@@ -41,18 +41,18 @@
     zip_int64_t n;
 
     if (length > ZIP_INT64_MAX) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     if ((n = zip_source_read(src, b, length)) < 0) {
-	_zip_error_set_from_source(error, src);
-	return -1;
+        _zip_error_set_from_source(error, src);
+        return -1;
     }
 
     if (n < (zip_int64_t)length) {
-	zip_error_set(error, ZIP_ER_EOF, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_EOF, 0);
+        return -1;
     }
 
     return 0;
@@ -64,39 +64,39 @@
     zip_uint8_t *r;
 
     if (length == 0 && !nulp) {
-	return NULL;
+        return NULL;
     }
 
     r = (zip_uint8_t *)malloc(length + (nulp ? 1 : 0));
     if (!r) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if (buffer) {
-	zip_uint8_t *data = _zip_buffer_get(buffer, length);
+        zip_uint8_t *data = _zip_buffer_get(buffer, length);
 
-	if (data == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    free(r);
-	    return NULL;
-	}
-	memcpy(r, data, length);
+        if (data == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            free(r);
+            return NULL;
+        }
+        memcpy(r, data, length);
     }
     else {
-	if (_zip_read(src, r, length, error) < 0) {
-	    free(r);
-	    return NULL;
-	}
+        if (_zip_read(src, r, length, error) < 0) {
+            free(r);
+            return NULL;
+        }
     }
 
     if (nulp) {
-	zip_uint8_t *o;
-	/* replace any in-string NUL characters with spaces */
-	r[length] = 0;
-	for (o = r; o < r + length; o++)
-	    if (*o == '\0')
-		*o = ' ';
+        zip_uint8_t *o;
+        /* replace any in-string NUL characters with spaces */
+        r[length] = 0;
+        for (o = r; o < r + length; o++)
+            if (*o == '\0')
+                *o = ' ';
     }
 
     return r;
@@ -109,7 +109,7 @@
     zip_string_t *s;
 
     if ((raw = _zip_read_data(buffer, src, len, nulp, error)) == NULL)
-	return NULL;
+        return NULL;
 
     s = _zip_string_new(raw, len, ZIP_FL_ENC_GUESS, error);
     free(raw);
@@ -122,12 +122,12 @@
     zip_int64_t n;
 
     if ((n = zip_source_write(za->src, data, length)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return -1;
+        _zip_error_set_from_source(&za->error, za->src);
+        return -1;
     }
     if ((zip_uint64_t)n != length) {
-	zip_error_set(&za->error, ZIP_ER_WRITE, EINTR);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_WRITE, EINTR);
+        return -1;
     }
 
     return 0;
diff --git a/lib/zip_memdup.c b/lib/zip_memdup.c
index 05fcb7b..e0ea940 100644
--- a/lib/zip_memdup.c
+++ b/lib/zip_memdup.c
@@ -42,12 +42,12 @@
     void *ret;
 
     if (len == 0)
-	return NULL;
+        return NULL;
 
     ret = malloc(len);
     if (!ret) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     memcpy(ret, mem, len);
diff --git a/lib/zip_mkstempm.c b/lib/zip_mkstempm.c
index c1afade..dba21a9 100644
--- a/lib/zip_mkstempm.c
+++ b/lib/zip_mkstempm.c
@@ -52,42 +52,42 @@
     end = path + strlen(path);
     start = end - 1;
     while (start >= path && *start == 'X') {
-	xcnt++;
-	start--;
+        xcnt++;
+        start--;
     }
 
     if (xcnt == 0) {
-	errno = EINVAL;
-	return -1;
+        errno = EINVAL;
+        return -1;
     }
 
     start++;
 
     for (;;) {
-	zip_uint32_t value = zip_random_uint32();
+        zip_uint32_t value = zip_random_uint32();
 
-	xs = start;
+        xs = start;
 
-	while (xs < end) {
-	    char digit = value % 36;
-	    if (digit < 10) {
-		*(xs++) = digit + '0';
-	    }
-	    else {
-		*(xs++) = digit - 10 + 'a';
-	    }
-	    value /= 36;
-	}
+        while (xs < end) {
+            char digit = value % 36;
+            if (digit < 10) {
+                *(xs++) = digit + '0';
+            }
+            else {
+                *(xs++) = digit - 10 + 'a';
+            }
+            value /= 36;
+        }
 
-	if ((fd = open(path, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, mode == -1 ? 0666 : (mode_t)mode)) >= 0) {
-	    if (mode != -1) {
-		/* open() honors umask(), which we don't want in this case */
-		(void)chmod(path, (mode_t)mode);
-	    }
-	    return fd;
-	}
-	if (errno != EEXIST) {
-	    return -1;
-	}
+        if ((fd = open(path, O_CREAT | O_EXCL | O_RDWR | O_CLOEXEC, mode == -1 ? 0666 : (mode_t)mode)) >= 0) {
+            if (mode != -1) {
+                /* open() honors umask(), which we don't want in this case */
+                (void)chmod(path, (mode_t)mode);
+            }
+            return fd;
+        }
+        if (errno != EEXIST) {
+            return -1;
+        }
     }
 }
diff --git a/lib/zip_name_locate.c b/lib/zip_name_locate.c
index f7318ec..8694ae6 100644
--- a/lib/zip_name_locate.c
+++ b/lib/zip_name_locate.c
@@ -53,40 +53,40 @@
     zip_uint64_t i;
 
     if (za == NULL)
-	return -1;
+        return -1;
 
     if (fname == NULL) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (flags & (ZIP_FL_NOCASE | ZIP_FL_NODIR | ZIP_FL_ENC_CP437)) {
-	/* can't use hash table */
-	cmp = (flags & ZIP_FL_NOCASE) ? strcasecmp : strcmp;
+        /* can't use hash table */
+        cmp = (flags & ZIP_FL_NOCASE) ? strcasecmp : strcmp;
 
-	for (i = 0; i < za->nentry; i++) {
-	    fn = _zip_get_name(za, i, flags, error);
+        for (i = 0; i < za->nentry; i++) {
+            fn = _zip_get_name(za, i, flags, error);
 
-	    /* newly added (partially filled) entry or error */
-	    if (fn == NULL)
-		continue;
+            /* newly added (partially filled) entry or error */
+            if (fn == NULL)
+                continue;
 
-	    if (flags & ZIP_FL_NODIR) {
-		p = strrchr(fn, '/');
-		if (p)
-		    fn = p + 1;
-	    }
+            if (flags & ZIP_FL_NODIR) {
+                p = strrchr(fn, '/');
+                if (p)
+                    fn = p + 1;
+            }
 
-	    if (cmp(fname, fn) == 0) {
-		_zip_error_clear(error);
-		return (zip_int64_t)i;
-	    }
-	}
+            if (cmp(fname, fn) == 0) {
+                _zip_error_clear(error);
+                return (zip_int64_t)i;
+            }
+        }
 
-	zip_error_set(error, ZIP_ER_NOENT, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_NOENT, 0);
+        return -1;
     }
     else {
-	return _zip_hash_lookup(za->names, (const zip_uint8_t *)fname, flags, error);
+        return _zip_hash_lookup(za->names, (const zip_uint8_t *)fname, flags, error);
     }
 }
diff --git a/lib/zip_new.c b/lib/zip_new.c
index 4f58ecc..0cf3cf8 100644
--- a/lib/zip_new.c
+++ b/lib/zip_new.c
@@ -47,13 +47,13 @@
 
     za = (zip_t *)malloc(sizeof(struct zip));
     if (!za) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((za->names = _zip_hash_new(error)) == NULL) {
-	free(za);
-	return NULL;
+        free(za);
+        return NULL;
     }
 
     za->src = NULL;
diff --git a/lib/zip_open.c b/lib/zip_open.c
index 019cd98..a4cf515 100644
--- a/lib/zip_open.c
+++ b/lib/zip_open.c
@@ -58,16 +58,16 @@
 
     zip_error_init(&error);
     if ((src = zip_source_file_create(fn, 0, -1, &error)) == NULL) {
-	_zip_set_open_error(zep, &error, 0);
-	zip_error_fini(&error);
-	return NULL;
+        _zip_set_open_error(zep, &error, 0);
+        zip_error_fini(&error);
+        return NULL;
     }
 
     if ((za = zip_open_from_source(src, _flags, &error)) == NULL) {
-	zip_source_free(src);
-	_zip_set_open_error(zep, &error, 0);
-	zip_error_fini(&error);
-	return NULL;
+        zip_source_free(src);
+        _zip_set_open_error(zep, &error, 0);
+        zip_error_fini(&error);
+        return NULL;
     }
 
     zip_error_fini(&error);
@@ -85,65 +85,65 @@
     exists_t exists;
 
     if (_flags < 0 || src == NULL) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
     flags = (unsigned int)_flags;
 
     supported = zip_source_supports(src);
     if (needed_support_read == -1) {
-	needed_support_read = zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_STAT, -1);
-	needed_support_write = zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, -1);
+        needed_support_read = zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_STAT, -1);
+        needed_support_write = zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, -1);
     }
     if ((supported & needed_support_read) != needed_support_read) {
-	zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
+        return NULL;
     }
     if ((supported & needed_support_write) != needed_support_write) {
-	flags |= ZIP_RDONLY;
+        flags |= ZIP_RDONLY;
     }
 
     if ((flags & (ZIP_RDONLY | ZIP_TRUNCATE)) == (ZIP_RDONLY | ZIP_TRUNCATE)) {
-	zip_error_set(error, ZIP_ER_RDONLY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_RDONLY, 0);
+        return NULL;
     }
 
     exists = _zip_file_exists(src, error);
     switch (exists) {
     case EXISTS_ERROR:
-	return NULL;
+        return NULL;
 
     case EXISTS_NOT:
-	if ((flags & ZIP_CREATE) == 0) {
-	    zip_error_set(error, ZIP_ER_NOENT, 0);
-	    return NULL;
-	}
-	return _zip_allocate_new(src, flags, error);
+        if ((flags & ZIP_CREATE) == 0) {
+            zip_error_set(error, ZIP_ER_NOENT, 0);
+            return NULL;
+        }
+        return _zip_allocate_new(src, flags, error);
 
     default: {
-	zip_t *za;
-	if (flags & ZIP_EXCL) {
-	    zip_error_set(error, ZIP_ER_EXISTS, 0);
-	    return NULL;
-	}
-	if (zip_source_open(src) < 0) {
-	    _zip_error_set_from_source(error, src);
-	    return NULL;
-	}
+        zip_t *za;
+        if (flags & ZIP_EXCL) {
+            zip_error_set(error, ZIP_ER_EXISTS, 0);
+            return NULL;
+        }
+        if (zip_source_open(src) < 0) {
+            _zip_error_set_from_source(error, src);
+            return NULL;
+        }
 
-	if (flags & ZIP_TRUNCATE) {
-	    za = _zip_allocate_new(src, flags, error);
-	}
-	else {
-	    /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, just like open() */
-	    za = _zip_open(src, flags, error);
-	}
+        if (flags & ZIP_TRUNCATE) {
+            za = _zip_allocate_new(src, flags, error);
+        }
+        else {
+            /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, just like open() */
+            za = _zip_open(src, flags, error);
+        }
 
-	if (za == NULL) {
-	    zip_source_close(src);
-	    return NULL;
-	}
-	return za;
+        if (za == NULL) {
+            zip_source_close(src);
+            return NULL;
+        }
+        return za;
     }
     }
 }
@@ -158,31 +158,31 @@
 
     zip_stat_init(&st);
     if (zip_source_stat(src, &st) < 0) {
-	_zip_error_set_from_source(error, src);
-	return NULL;
+        _zip_error_set_from_source(error, src);
+        return NULL;
     }
     if ((st.valid & ZIP_STAT_SIZE) == 0) {
-	zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);
-	return NULL;
+        zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);
+        return NULL;
     }
     len = st.size;
 
 
     if ((za = _zip_allocate_new(src, flags, error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     /* treat empty files as empty archives */
     if (len == 0 && zip_source_accept_empty(src)) {
-	return za;
+        return za;
     }
 
     if ((cdir = _zip_find_central_dir(za, len)) == NULL) {
-	_zip_error_copy(error, &za->error);
-	/* keep src so discard does not get rid of it */
-	zip_source_keep(src);
-	zip_discard(za);
-	return NULL;
+        _zip_error_copy(error, &za->error);
+        /* keep src so discard does not get rid of it */
+        zip_source_keep(src);
+        zip_discard(za);
+        return NULL;
     }
 
     za->entry = cdir->entry;
@@ -195,23 +195,23 @@
     _zip_hash_reserve_capacity(za->names, za->nentry, &za->error);
 
     for (idx = 0; idx < za->nentry; idx++) {
-	const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error);
-	if (name == NULL) {
-	    /* keep src so discard does not get rid of it */
-	    zip_source_keep(src);
-	    zip_discard(za);
-	    return NULL;
-	}
+        const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error);
+        if (name == NULL) {
+            /* keep src so discard does not get rid of it */
+            zip_source_keep(src);
+            zip_discard(za);
+            return NULL;
+        }
 
-	if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) {
-	    if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) {
-		_zip_error_copy(error, &za->error);
-		/* keep src so discard does not get rid of it */
-		zip_source_keep(src);
-		zip_discard(za);
-		return NULL;
-	    }
-	}
+        if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) {
+            if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) {
+                _zip_error_copy(error, &za->error);
+                /* keep src so discard does not get rid of it */
+                zip_source_keep(src);
+                zip_discard(za);
+                return NULL;
+            }
+        }
     }
 
     za->ch_flags = za->flags;
@@ -223,14 +223,14 @@
 void
 _zip_set_open_error(int *zep, const zip_error_t *err, int ze) {
     if (err) {
-	ze = zip_error_code_zip(err);
-	if (zip_error_system_type(err) == ZIP_ET_SYS) {
-	    errno = zip_error_code_system(err);
-	}
+        ze = zip_error_code_zip(err);
+        if (zip_error_system_type(err) == ZIP_ET_SYS) {
+            errno = zip_error_code_system(err);
+        }
     }
 
     if (zep)
-	*zep = ze;
+        *zep = ze;
 }
 
 
@@ -249,156 +249,156 @@
     zip_buffer_t *cd_buffer;
 
     if (_zip_buffer_left(buffer) < EOCDLEN) {
-	/* not enough bytes left for comment */
-	zip_error_set(error, ZIP_ER_NOZIP, 0);
-	return NULL;
+        /* not enough bytes left for comment */
+        zip_error_set(error, ZIP_ER_NOZIP, 0);
+        return NULL;
     }
 
     /* check for end-of-central-dir magic */
     if (memcmp(_zip_buffer_get(buffer, 4), EOCD_MAGIC, 4) != 0) {
-	zip_error_set(error, ZIP_ER_NOZIP, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_NOZIP, 0);
+        return NULL;
     }
 
     if (eocd_offset >= EOCD64LOCLEN && memcmp(_zip_buffer_data(buffer) + eocd_offset - EOCD64LOCLEN, EOCD64LOC_MAGIC, 4) == 0) {
-	_zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);
-	cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);
+        _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);
+        cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);
     }
     else {
-	_zip_buffer_set_offset(buffer, eocd_offset);
-	cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);
+        _zip_buffer_set_offset(buffer, eocd_offset);
+        cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);
     }
 
     if (cd == NULL)
-	return NULL;
+        return NULL;
 
     _zip_buffer_set_offset(buffer, eocd_offset + 20);
     comment_len = _zip_buffer_get_16(buffer);
 
     if (cd->offset + cd->size > buf_offset + eocd_offset) {
-	/* cdir spans past EOCD record */
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	_zip_cdir_free(cd);
-	return NULL;
+        /* cdir spans past EOCD record */
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        _zip_cdir_free(cd);
+        return NULL;
     }
 
     if (comment_len || (za->open_flags & ZIP_CHECKCONS)) {
-	zip_uint64_t tail_len;
+        zip_uint64_t tail_len;
 
-	_zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN);
-	tail_len = _zip_buffer_left(buffer);
+        _zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN);
+        tail_len = _zip_buffer_left(buffer);
 
-	if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    _zip_cdir_free(cd);
-	    return NULL;
-	}
+        if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            _zip_cdir_free(cd);
+            return NULL;
+        }
 
-	if (comment_len) {
-	    if ((cd->comment = _zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) {
-		_zip_cdir_free(cd);
-		return NULL;
-	    }
-	}
+        if (comment_len) {
+            if ((cd->comment = _zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) {
+                _zip_cdir_free(cd);
+                return NULL;
+            }
+        }
     }
 
     if (cd->offset >= buf_offset) {
-	zip_uint8_t *data;
-	/* if buffer already read in, use it */
-	_zip_buffer_set_offset(buffer, cd->offset - buf_offset);
+        zip_uint8_t *data;
+        /* if buffer already read in, use it */
+        _zip_buffer_set_offset(buffer, cd->offset - buf_offset);
 
-	if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    _zip_cdir_free(cd);
-	    return NULL;
-	}
-	if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    _zip_cdir_free(cd);
-	    return NULL;
-	}
+        if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            _zip_cdir_free(cd);
+            return NULL;
+        }
+        if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            _zip_cdir_free(cd);
+            return NULL;
+        }
     }
     else {
-	cd_buffer = NULL;
+        cd_buffer = NULL;
 
-	if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) {
-	    _zip_error_set_from_source(error, za->src);
-	    _zip_cdir_free(cd);
-	    return NULL;
-	}
+        if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) {
+            _zip_error_set_from_source(error, za->src);
+            _zip_cdir_free(cd);
+            return NULL;
+        }
 
-	/* possible consistency check: cd->offset = len-(cd->size+cd->comment_len+EOCDLEN) ? */
-	if (zip_source_tell(za->src) != (zip_int64_t)cd->offset) {
-	    zip_error_set(error, ZIP_ER_NOZIP, 0);
-	    _zip_cdir_free(cd);
-	    return NULL;
-	}
+        /* possible consistency check: cd->offset = len-(cd->size+cd->comment_len+EOCDLEN) ? */
+        if (zip_source_tell(za->src) != (zip_int64_t)cd->offset) {
+            zip_error_set(error, ZIP_ER_NOZIP, 0);
+            _zip_cdir_free(cd);
+            return NULL;
+        }
     }
 
     left = (zip_uint64_t)cd->size;
     i = 0;
     while (left > 0) {
-	bool grown = false;
-	zip_int64_t entry_size;
+        bool grown = false;
+        zip_int64_t entry_size;
 
-	if (i == cd->nentry) {
-	    /* InfoZIP has a hack to avoid using Zip64: it stores nentries % 0x10000 */
-	    /* This hack isn't applicable if we're using Zip64, or if there is no central directory entry following. */
+        if (i == cd->nentry) {
+            /* InfoZIP has a hack to avoid using Zip64: it stores nentries % 0x10000 */
+            /* This hack isn't applicable if we're using Zip64, or if there is no central directory entry following. */
 
-	    if (cd->is_zip64 || left < CDENTRYSIZE) {
-		break;
-	    }
+            if (cd->is_zip64 || left < CDENTRYSIZE) {
+                break;
+            }
 
-	    if (!_zip_cdir_grow(cd, 0x10000, error)) {
-		_zip_cdir_free(cd);
-		_zip_buffer_free(cd_buffer);
-		return NULL;
-	    }
-	    grown = true;
-	}
+            if (!_zip_cdir_grow(cd, 0x10000, error)) {
+                _zip_cdir_free(cd);
+                _zip_buffer_free(cd_buffer);
+                return NULL;
+            }
+            grown = true;
+        }
 
-	if ((cd->entry[i].orig = _zip_dirent_new()) == NULL || (entry_size = _zip_dirent_read(cd->entry[i].orig, za->src, cd_buffer, false, error)) < 0) {
-	    if (grown && zip_error_code_zip(error) == ZIP_ER_NOZIP) {
-		zip_error_set(error, ZIP_ER_INCONS, 0);
-	    }
-	    _zip_cdir_free(cd);
-	    _zip_buffer_free(cd_buffer);
-	    return NULL;
-	}
-	i++;
-	left -= (zip_uint64_t)entry_size;
+        if ((cd->entry[i].orig = _zip_dirent_new()) == NULL || (entry_size = _zip_dirent_read(cd->entry[i].orig, za->src, cd_buffer, false, error)) < 0) {
+            if (grown && zip_error_code_zip(error) == ZIP_ER_NOZIP) {
+                zip_error_set(error, ZIP_ER_INCONS, 0);
+            }
+            _zip_cdir_free(cd);
+            _zip_buffer_free(cd_buffer);
+            return NULL;
+        }
+        i++;
+        left -= (zip_uint64_t)entry_size;
     }
 
     if (i != cd->nentry || left > 0) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	_zip_buffer_free(cd_buffer);
-	_zip_cdir_free(cd);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        _zip_buffer_free(cd_buffer);
+        _zip_cdir_free(cd);
+        return NULL;
     }
 
     if (za->open_flags & ZIP_CHECKCONS) {
-	bool ok;
+        bool ok;
 
-	if (cd_buffer) {
-	    ok = _zip_buffer_eof(cd_buffer);
-	}
-	else {
-	    zip_int64_t offset = zip_source_tell(za->src);
+        if (cd_buffer) {
+            ok = _zip_buffer_eof(cd_buffer);
+        }
+        else {
+            zip_int64_t offset = zip_source_tell(za->src);
 
-	    if (offset < 0) {
-		_zip_error_set_from_source(error, za->src);
-		_zip_cdir_free(cd);
-		return NULL;
-	    }
-	    ok = ((zip_uint64_t)offset == cd->offset + cd->size);
-	}
+            if (offset < 0) {
+                _zip_error_set_from_source(error, za->src);
+                _zip_cdir_free(cd);
+                return NULL;
+            }
+            ok = ((zip_uint64_t)offset == cd->offset + cd->size);
+        }
 
-	if (!ok) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    _zip_buffer_free(cd_buffer);
-	    _zip_cdir_free(cd);
-	    return NULL;
-	}
+        if (!ok) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            _zip_buffer_free(cd_buffer);
+            _zip_cdir_free(cd);
+            return NULL;
+        }
     }
 
     _zip_buffer_free(cd_buffer);
@@ -420,49 +420,49 @@
 
     _zip_dirent_init(&temp);
     if (cd->nentry) {
-	max = cd->entry[0].orig->offset;
-	min = cd->entry[0].orig->offset;
+        max = cd->entry[0].orig->offset;
+        min = cd->entry[0].orig->offset;
     }
     else
-	min = max = 0;
+        min = max = 0;
 
     for (i = 0; i < cd->nentry; i++) {
-	if (cd->entry[i].orig->offset < min)
-	    min = cd->entry[i].orig->offset;
-	if (min > (zip_uint64_t)cd->offset) {
-	    zip_error_set(error, ZIP_ER_NOZIP, 0);
-	    return -1;
-	}
+        if (cd->entry[i].orig->offset < min)
+            min = cd->entry[i].orig->offset;
+        if (min > (zip_uint64_t)cd->offset) {
+            zip_error_set(error, ZIP_ER_NOZIP, 0);
+            return -1;
+        }
 
-	j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size + _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE;
-	if (j > max)
-	    max = j;
-	if (max > (zip_uint64_t)cd->offset) {
-	    zip_error_set(error, ZIP_ER_NOZIP, 0);
-	    return -1;
-	}
+        j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size + _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE;
+        if (j > max)
+            max = j;
+        if (max > (zip_uint64_t)cd->offset) {
+            zip_error_set(error, ZIP_ER_NOZIP, 0);
+            return -1;
+        }
 
-	if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) {
-	    _zip_error_set_from_source(error, za->src);
-	    return -1;
-	}
+        if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) {
+            _zip_error_set_from_source(error, za->src);
+            return -1;
+        }
 
-	if (_zip_dirent_read(&temp, za->src, NULL, true, error) == -1) {
-	    _zip_dirent_finalize(&temp);
-	    return -1;
-	}
+        if (_zip_dirent_read(&temp, za->src, NULL, true, error) == -1) {
+            _zip_dirent_finalize(&temp);
+            return -1;
+        }
 
-	if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) {
-	    zip_error_set(error, ZIP_ER_INCONS, 0);
-	    _zip_dirent_finalize(&temp);
-	    return -1;
-	}
+        if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) {
+            zip_error_set(error, ZIP_ER_INCONS, 0);
+            _zip_dirent_finalize(&temp);
+            return -1;
+        }
 
-	cd->entry[i].orig->extra_fields = _zip_ef_merge(cd->entry[i].orig->extra_fields, temp.extra_fields);
-	cd->entry[i].orig->local_extra_fields_read = 1;
-	temp.extra_fields = NULL;
+        cd->entry[i].orig->extra_fields = _zip_ef_merge(cd->entry[i].orig->extra_fields, temp.extra_fields);
+        cd->entry[i].orig->local_extra_fields_read = 1;
+        temp.extra_fields = NULL;
 
-	_zip_dirent_finalize(&temp);
+        _zip_dirent_finalize(&temp);
     }
 
     return (max - min) < ZIP_INT64_MAX ? (zip_int64_t)(max - min) : ZIP_INT64_MAX;
@@ -481,14 +481,14 @@
 	   and global headers for the bitflags */
 	|| (central->bitflags != local->bitflags)
 #endif
-	|| (central->comp_method != local->comp_method) || (central->last_mod != local->last_mod) || !_zip_string_equal(central->filename, local->filename))
-	return -1;
+        || (central->comp_method != local->comp_method) || (central->last_mod != local->last_mod) || !_zip_string_equal(central->filename, local->filename))
+        return -1;
 
     if ((central->crc != local->crc) || (central->comp_size != local->comp_size) || (central->uncomp_size != local->uncomp_size)) {
-	/* InfoZip stores valid values in local header even when data descriptor is used.
-	   This is in violation of the appnote. */
-	if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))
-	    return -1;
+        /* InfoZip stores valid values in local header even when data descriptor is used.
+           This is in violation of the appnote. */
+        if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))
+            return -1;
     }
 
     return 0;
@@ -500,14 +500,14 @@
     zip_t *za;
 
     if ((za = _zip_new(error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     za->src = src;
     za->open_flags = flags;
     if (flags & ZIP_RDONLY) {
-	za->flags |= ZIP_AFL_RDONLY;
-	za->ch_flags |= ZIP_AFL_RDONLY;
+        za->flags |= ZIP_AFL_RDONLY;
+        za->ch_flags |= ZIP_AFL_RDONLY;
     }
     return za;
 }
@@ -522,12 +522,12 @@
 
     zip_stat_init(&st);
     if (zip_source_stat(src, &st) != 0) {
-	zip_error_t *src_error = zip_source_error(src);
-	if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) {
-	    return EXISTS_NOT;
-	}
-	_zip_error_copy(error, src_error);
-	return EXISTS_ERROR;
+        zip_error_t *src_error = zip_source_error(src);
+        if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) {
+            return EXISTS_NOT;
+        }
+        _zip_error_copy(error, src_error);
+        return EXISTS_ERROR;
     }
 
     return EXISTS_OK;
@@ -546,76 +546,76 @@
     zip_buffer_t *buffer;
 
     if (len < EOCDLEN) {
-	zip_error_set(&za->error, ZIP_ER_NOZIP, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_NOZIP, 0);
+        return NULL;
     }
 
     buflen = (len < CDBUFSIZE ? len : CDBUFSIZE);
     if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) {
-	zip_error_t *src_error = zip_source_error(za->src);
-	if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) {
-	    /* seek before start of file on my machine */
-	    _zip_error_copy(&za->error, src_error);
-	    return NULL;
-	}
+        zip_error_t *src_error = zip_source_error(za->src);
+        if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) {
+            /* seek before start of file on my machine */
+            _zip_error_copy(&za->error, src_error);
+            return NULL;
+        }
     }
     if ((buf_offset = zip_source_tell(za->src)) < 0) {
-	_zip_error_set_from_source(&za->error, za->src);
-	return NULL;
+        _zip_error_set_from_source(&za->error, za->src);
+        return NULL;
     }
 
     if ((buffer = _zip_buffer_new_from_source(za->src, buflen, NULL, &za->error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     best = -1;
     cdir = NULL;
     if (buflen >= CDBUFSIZE) {
-	/* EOCD64 locator is before EOCD, so leave place for it */
-	_zip_buffer_set_offset(buffer, EOCD64LOCLEN);
+        /* EOCD64 locator is before EOCD, so leave place for it */
+        _zip_buffer_set_offset(buffer, EOCD64LOCLEN);
     }
     zip_error_set(&error, ZIP_ER_NOZIP, 0);
 
     match = _zip_buffer_get(buffer, 0);
     while ((match = _zip_memmem(match, _zip_buffer_left(buffer) - (EOCDLEN - 4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) {
-	_zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
-	if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) {
-	    if (cdir) {
-		if (best <= 0) {
-		    best = _zip_checkcons(za, cdir, &error);
-		}
+        _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
+        if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) {
+            if (cdir) {
+                if (best <= 0) {
+                    best = _zip_checkcons(za, cdir, &error);
+                }
 
-		a = _zip_checkcons(za, cdirnew, &error);
-		if (best < a) {
-		    _zip_cdir_free(cdir);
-		    cdir = cdirnew;
-		    best = a;
-		}
-		else {
-		    _zip_cdir_free(cdirnew);
-		}
-	    }
-	    else {
-		cdir = cdirnew;
-		if (za->open_flags & ZIP_CHECKCONS)
-		    best = _zip_checkcons(za, cdir, &error);
-		else {
-		    best = 0;
-		}
-	    }
-	    cdirnew = NULL;
-	}
+                a = _zip_checkcons(za, cdirnew, &error);
+                if (best < a) {
+                    _zip_cdir_free(cdir);
+                    cdir = cdirnew;
+                    best = a;
+                }
+                else {
+                    _zip_cdir_free(cdirnew);
+                }
+            }
+            else {
+                cdir = cdirnew;
+                if (za->open_flags & ZIP_CHECKCONS)
+                    best = _zip_checkcons(za, cdir, &error);
+                else {
+                    best = 0;
+                }
+            }
+            cdirnew = NULL;
+        }
 
-	match++;
-	_zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
+        match++;
+        _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
     }
 
     _zip_buffer_free(buffer);
 
     if (best < 0) {
-	_zip_error_copy(&za->error, &error);
-	_zip_cdir_free(cdir);
-	return NULL;
+        _zip_error_copy(&za->error, &error);
+        _zip_cdir_free(cdir);
+        return NULL;
     }
 
     return cdir;
@@ -627,11 +627,11 @@
     const unsigned char *p;
 
     if ((biglen < littlelen) || (littlelen == 0))
-	return NULL;
+        return NULL;
     p = big - 1;
     while ((p = (const unsigned char *)memchr(p + 1, little[0], (size_t)(big - (p + 1)) + (size_t)(biglen - littlelen) + 1)) != NULL) {
-	if (memcmp(p + 1, little + 1, littlelen - 1) == 0)
-	    return (unsigned char *)p;
+        if (memcmp(p + 1, little + 1, littlelen - 1) == 0)
+            return (unsigned char *)p;
     }
 
     return NULL;
@@ -644,8 +644,8 @@
     zip_uint64_t i, nentry, size, offset, eocd_offset;
 
     if (_zip_buffer_left(buffer) < EOCDLEN) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
 
     eocd_offset = _zip_buffer_offset(buffer);
@@ -653,8 +653,8 @@
     _zip_buffer_get(buffer, 4); /* magic already verified */
 
     if (_zip_buffer_get_32(buffer) != 0) {
-	zip_error_set(error, ZIP_ER_MULTIDISK, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MULTIDISK, 0);
+        return NULL;
     }
 
     /* number of cdir-entries on this disk */
@@ -663,31 +663,31 @@
     nentry = _zip_buffer_get_16(buffer);
 
     if (nentry != i) {
-	zip_error_set(error, ZIP_ER_NOZIP, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_NOZIP, 0);
+        return NULL;
     }
 
     size = _zip_buffer_get_32(buffer);
     offset = _zip_buffer_get_32(buffer);
 
     if (offset + size < offset) {
-	zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	return NULL;
+        zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+        return NULL;
     }
 
     if (offset + size > buf_offset + eocd_offset) {
-	/* cdir spans past EOCD record */
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        /* cdir spans past EOCD record */
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
 
     if ((flags & ZIP_CHECKCONS) && offset + size != buf_offset + eocd_offset) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
 
     if ((cd = _zip_cdir_new(nentry, error)) == NULL)
-	return NULL;
+        return NULL;
 
     cd->is_zip64 = false;
     cd->size = size;
@@ -717,38 +717,38 @@
 
     /* valid seek value for start of EOCD */
     if (eocd_offset > ZIP_INT64_MAX) {
-	zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	return NULL;
+        zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+        return NULL;
     }
 
     /* does EOCD fit before EOCD locator? */
     if (eocd_offset + EOCD64LEN > eocdloc_offset + buf_offset) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
 
     /* make sure current position of buffer is beginning of EOCD */
     if (eocd_offset >= buf_offset && eocd_offset + EOCD64LEN <= buf_offset + _zip_buffer_size(buffer)) {
-	_zip_buffer_set_offset(buffer, eocd_offset - buf_offset);
-	free_buffer = false;
+        _zip_buffer_set_offset(buffer, eocd_offset - buf_offset);
+        free_buffer = false;
     }
     else {
-	if (zip_source_seek(src, (zip_int64_t)eocd_offset, SEEK_SET) < 0) {
-	    _zip_error_set_from_source(error, src);
-	    return NULL;
-	}
-	if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) {
-	    return NULL;
-	}
-	free_buffer = true;
+        if (zip_source_seek(src, (zip_int64_t)eocd_offset, SEEK_SET) < 0) {
+            _zip_error_set_from_source(error, src);
+            return NULL;
+        }
+        if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) {
+            return NULL;
+        }
+        free_buffer = true;
     }
 
     if (memcmp(_zip_buffer_get(buffer, 4), EOCD64_MAGIC, 4) != 0) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	if (free_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        if (free_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return NULL;
     }
 
     /* size of EOCD */
@@ -756,11 +756,11 @@
 
     /* is there a hole between EOCD and EOCD locator, or do they overlap? */
     if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	if (free_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        if (free_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return NULL;
     }
 
     _zip_buffer_get(buffer, 4); /* skip version made by/needed */
@@ -772,35 +772,35 @@
        otherwise, if the values are not the same, it's inconsistent;
        in any case, if the value is not 0, we don't support it */
     if (num_disks == 0xffff) {
-	num_disks = num_disks64;
+        num_disks = num_disks64;
     }
     if (eocd_disk == 0xffff) {
-	eocd_disk = eocd_disk64;
+        eocd_disk = eocd_disk64;
     }
     if ((flags & ZIP_CHECKCONS) && (eocd_disk != eocd_disk64 || num_disks != num_disks64)) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	if (free_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        if (free_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return NULL;
     }
     if (num_disks != 0 || eocd_disk != 0) {
-	zip_error_set(error, ZIP_ER_MULTIDISK, 0);
-	if (free_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return NULL;
+        zip_error_set(error, ZIP_ER_MULTIDISK, 0);
+        if (free_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return NULL;
     }
 
     nentry = _zip_buffer_get_64(buffer);
     i = _zip_buffer_get_64(buffer);
 
     if (nentry != i) {
-	zip_error_set(error, ZIP_ER_MULTIDISK, 0);
-	if (free_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return NULL;
+        zip_error_set(error, ZIP_ER_MULTIDISK, 0);
+        if (free_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return NULL;
     }
 
     size = _zip_buffer_get_64(buffer);
@@ -808,38 +808,38 @@
 
     /* did we read past the end of the buffer? */
     if (!_zip_buffer_ok(buffer)) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	if (free_buffer) {
-	    _zip_buffer_free(buffer);
-	}
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        if (free_buffer) {
+            _zip_buffer_free(buffer);
+        }
+        return NULL;
     }
 
     if (free_buffer) {
-	_zip_buffer_free(buffer);
+        _zip_buffer_free(buffer);
     }
 
     if (offset > ZIP_INT64_MAX || offset + size < offset) {
-	zip_error_set(error, ZIP_ER_SEEK, EFBIG);
-	return NULL;
+        zip_error_set(error, ZIP_ER_SEEK, EFBIG);
+        return NULL;
     }
     if (offset + size > buf_offset + eocd_offset) {
-	/* cdir spans past EOCD record */
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        /* cdir spans past EOCD record */
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
     if ((flags & ZIP_CHECKCONS) && offset + size != buf_offset + eocd_offset) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
 
     if (nentry > size / CDENTRYSIZE) {
-	zip_error_set(error, ZIP_ER_INCONS, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INCONS, 0);
+        return NULL;
     }
 
     if ((cd = _zip_cdir_new(nentry, error)) == NULL)
-	return NULL;
+        return NULL;
 
     cd->is_zip64 = true;
     cd->size = size;
diff --git a/lib/zip_pkware.c b/lib/zip_pkware.c
index eb12b1e..1b1b461 100644
--- a/lib/zip_pkware.c
+++ b/lib/zip_pkware.c
@@ -75,18 +75,18 @@
     zip_uint8_t tmp;
 
     for (i = 0; i < len; i++) {
-	b = in[i];
+        b = in[i];
 
-	if (out != NULL) {
-	    tmp = crypt_byte(keys);
-	    update_keys(keys, b);
-	    b ^= tmp;
-	    out[i] = b;
-	}
-	else {
-	    /* during initialization, we're only interested in key updates */
-	    update_keys(keys, b);
-	}
+        if (out != NULL) {
+            tmp = crypt_byte(keys);
+            update_keys(keys, b);
+            b ^= tmp;
+            out[i] = b;
+        }
+        else {
+            /* during initialization, we're only interested in key updates */
+            update_keys(keys, b);
+        }
     }
 }
 
@@ -98,15 +98,15 @@
     zip_uint8_t tmp;
 
     for (i = 0; i < len; i++) {
-	b = in[i];
+        b = in[i];
 
-	/* during initialization, we're only interested in key updates */
-	if (out != NULL) {
-	    tmp = crypt_byte(keys);
-	    b ^= tmp;
-	    out[i] = b;
-	}
+        /* during initialization, we're only interested in key updates */
+        if (out != NULL) {
+            tmp = crypt_byte(keys);
+            b ^= tmp;
+            out[i] = b;
+        }
 
-	update_keys(keys, b);
+        update_keys(keys, b);
     }
 }
diff --git a/lib/zip_progress.c b/lib/zip_progress.c
index ddb47c7..a881df4 100644
--- a/lib/zip_progress.c
+++ b/lib/zip_progress.c
@@ -73,7 +73,7 @@
 void
 _zip_progress_free(zip_progress_t *progress) {
     if (progress == NULL) {
-	return;
+        return;
     }
 
     _zip_progress_free_progress_callback(progress);
@@ -88,8 +88,8 @@
     zip_progress_t *progress = (zip_progress_t *)malloc(sizeof(*progress));
 
     if (progress == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     progress->za = za;
@@ -109,7 +109,7 @@
 static void
 _zip_progress_free_progress_callback(zip_progress_t *progress) {
     if (progress->ud_progress_free) {
-	progress->ud_progress_free(progress->ud_progress);
+        progress->ud_progress_free(progress->ud_progress);
     }
 
     progress->callback_progress = NULL;
@@ -120,7 +120,7 @@
 static void
 _zip_progress_free_cancel_callback(zip_progress_t *progress) {
     if (progress->ud_cancel_free) {
-	progress->ud_cancel_free(progress->ud_cancel);
+        progress->ud_cancel_free(progress->ud_cancel);
     }
 
     progress->callback_cancel = NULL;
@@ -150,18 +150,18 @@
 int
 _zip_progress_start(zip_progress_t *progress) {
     if (progress == NULL) {
-	return 0;
+        return 0;
     }
 
     if (progress->callback_progress != NULL) {
-	progress->last_update = 0.0;
-	progress->callback_progress(progress->za, 0.0, progress->ud_progress);
+        progress->last_update = 0.0;
+        progress->callback_progress(progress->za, 0.0, progress->ud_progress);
     }
 
     if (progress->callback_cancel != NULL) {
-	if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
-	    return -1;
-	}
+        if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
+            return -1;
+        }
     }
 
     return 0;
@@ -171,7 +171,7 @@
 int
 _zip_progress_subrange(zip_progress_t *progress, double start, double end) {
     if (progress == NULL) {
-	return 0;
+        return 0;
     }
 
     progress->start = start;
@@ -185,22 +185,22 @@
     double current;
 
     if (progress == NULL) {
-	return 0;
+        return 0;
     }
 
     if (progress->callback_progress != NULL) {
-	current = ZIP_MIN(ZIP_MAX(sub_current, 0.0), 1.0) * (progress->end - progress->start) + progress->start;
+        current = ZIP_MIN(ZIP_MAX(sub_current, 0.0), 1.0) * (progress->end - progress->start) + progress->start;
 
-	if (current - progress->last_update > progress->precision) {
-	    progress->callback_progress(progress->za, current, progress->ud_progress);
-	    progress->last_update = current;
-	}
+        if (current - progress->last_update > progress->precision) {
+            progress->callback_progress(progress->za, current, progress->ud_progress);
+            progress->last_update = current;
+        }
     }
 
     if (progress->callback_cancel != NULL) {
-	if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
-	    return -1;
-	}
+        if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
+            return -1;
+        }
     }
 
     return 0;
@@ -210,24 +210,24 @@
 ZIP_EXTERN int
 zip_register_progress_callback_with_state(zip_t *za, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud) {
     if (callback != NULL) {
-	if (za->progress == NULL) {
-	    if ((za->progress = _zip_progress_new(za)) == NULL) {
-		return -1;
-	    }
-	}
+        if (za->progress == NULL) {
+            if ((za->progress = _zip_progress_new(za)) == NULL) {
+                return -1;
+            }
+        }
 
-	_zip_progress_set_progress_callback(za->progress, precision, callback, ud_free, ud);
+        _zip_progress_set_progress_callback(za->progress, precision, callback, ud_free, ud);
     }
     else {
-	if (za->progress != NULL) {
-	    if (za->progress->callback_cancel == NULL) {
-		_zip_progress_free(za->progress);
-		za->progress = NULL;
-	    }
-	    else {
-		_zip_progress_free_progress_callback(za->progress);
-	    }
-	}
+        if (za->progress != NULL) {
+            if (za->progress->callback_cancel == NULL) {
+                _zip_progress_free(za->progress);
+                za->progress = NULL;
+            }
+            else {
+                _zip_progress_free_progress_callback(za->progress);
+            }
+        }
     }
 
     return 0;
@@ -237,24 +237,24 @@
 ZIP_EXTERN int
 zip_register_cancel_callback_with_state(zip_t *za, zip_cancel_callback callback, void (*ud_free)(void *), void *ud) {
     if (callback != NULL) {
-	if (za->progress == NULL) {
-	    if ((za->progress = _zip_progress_new(za)) == NULL) {
-		return -1;
-	    }
-	}
+        if (za->progress == NULL) {
+            if ((za->progress = _zip_progress_new(za)) == NULL) {
+                return -1;
+            }
+        }
 
-	_zip_progress_set_cancel_callback(za->progress, callback, ud_free, ud);
+        _zip_progress_set_cancel_callback(za->progress, callback, ud_free, ud);
     }
     else {
-	if (za->progress != NULL) {
-	    if (za->progress->callback_progress == NULL) {
-		_zip_progress_free(za->progress);
-		za->progress = NULL;
-	    }
-	    else {
-		_zip_progress_free_cancel_callback(za->progress);
-	    }
-	}
+        if (za->progress != NULL) {
+            if (za->progress->callback_progress == NULL) {
+                _zip_progress_free(za->progress);
+                za->progress = NULL;
+            }
+            else {
+                _zip_progress_free_cancel_callback(za->progress);
+            }
+        }
     }
 
     return 0;
@@ -278,16 +278,16 @@
     struct legacy_ud *ud;
 
     if (progress_callback == NULL) {
-	zip_register_progress_callback_with_state(za, 0, NULL, NULL, NULL);
+        zip_register_progress_callback_with_state(za, 0, NULL, NULL, NULL);
     }
 
     if ((ud = (struct legacy_ud *)malloc(sizeof(*ud))) == NULL) {
-	return;
+        return;
     }
 
     ud->callback = progress_callback;
 
     if (zip_register_progress_callback_with_state(za, 0.001, _zip_legacy_progress_callback, free, ud) < 0) {
-	free(ud);
+        free(ud);
     }
 }
diff --git a/lib/zip_random_unix.c b/lib/zip_random_unix.c
index 1d0c967..ef0207e 100644
--- a/lib/zip_random_unix.c
+++ b/lib/zip_random_unix.c
@@ -67,12 +67,12 @@
     int fd;
 
     if ((fd = open("/dev/urandom", O_RDONLY)) < 0) {
-	return false;
+        return false;
     }
 
     if (read(fd, buffer, length) != length) {
-	close(fd);
-	return false;
+        close(fd);
+        return false;
     }
 
     close(fd);
@@ -90,11 +90,11 @@
     zip_uint32_t value;
 
     if (zip_secure_random((zip_uint8_t *)&value, sizeof(value))) {
-	return value;
+        return value;
     }
 
     if (!seeded) {
-	srandom((unsigned int)time(NULL));
+        srandom((unsigned int)time(NULL));
     }
 
     return (zip_uint32_t)random();
diff --git a/lib/zip_random_uwp.c b/lib/zip_random_uwp.c
index f83c78f..ef2ec52 100644
--- a/lib/zip_random_uwp.c
+++ b/lib/zip_random_uwp.c
@@ -48,12 +48,12 @@
     BCRYPT_ALG_HANDLE hAlg = NULL;
     NTSTATUS hr = BCryptOpenAlgorithmProvider(&hAlg, BCRYPT_RNG_ALGORITHM, MS_PRIMITIVE_PROVIDER, 0);
     if (hr != STATUS_SUCCESS || hAlg == NULL) {
-	return false;
+        return false;
     }
     hr = BCryptGenRandom(&hAlg, buffer, length, 0);
     BCryptCloseAlgorithmProvider(&hAlg, 0);
     if (hr != STATUS_SUCCESS) {
-	return false;
+        return false;
     }
     return true;
 }
@@ -70,11 +70,11 @@
     zip_uint32_t value;
 
     if (zip_secure_random((zip_uint8_t *)&value, sizeof(value))) {
-	return value;
+        return value;
     }
 
     if (!seeded) {
-	srand((unsigned int)time(NULL));
+        srand((unsigned int)time(NULL));
     }
 
     return (zip_uint32_t)rand();
diff --git a/lib/zip_random_win32.c b/lib/zip_random_win32.c
index 19d488e..41c181d 100644
--- a/lib/zip_random_win32.c
+++ b/lib/zip_random_win32.c
@@ -47,13 +47,13 @@
 zip_secure_random(zip_uint8_t *buffer, zip_uint16_t length) {
     HCRYPTPROV hprov;
     if (!CryptAcquireContext(&hprov, NULL, NULL, PROV_RSA_AES, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
-	return false;
+        return false;
     }
     if (!CryptGenRandom(hprov, length, buffer)) {
-	return false;
+        return false;
     }
     if (!CryptReleaseContext(hprov, 0)) {
-	return false;
+        return false;
     }
     return true;
 }
@@ -69,11 +69,11 @@
     zip_uint32_t value;
 
     if (zip_secure_random((zip_uint8_t *)&value, sizeof(value))) {
-	return value;
+        return value;
     }
 
     if (!seeded) {
-	srand((unsigned int)time(NULL));
+        srand((unsigned int)time(NULL));
     }
 
     return (zip_uint32_t)rand();
diff --git a/lib/zip_set_archive_comment.c b/lib/zip_set_archive_comment.c
index 3f050b3..38cdfc8 100644
--- a/lib/zip_set_archive_comment.c
+++ b/lib/zip_set_archive_comment.c
@@ -42,38 +42,38 @@
     zip_string_t *cstr;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (len > 0 && comment == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (len > 0) {
-	if ((cstr = _zip_string_new((const zip_uint8_t *)comment, len, ZIP_FL_ENC_GUESS, &za->error)) == NULL)
-	    return -1;
+        if ((cstr = _zip_string_new((const zip_uint8_t *)comment, len, ZIP_FL_ENC_GUESS, &za->error)) == NULL)
+            return -1;
 
-	if (_zip_guess_encoding(cstr, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_CP437) {
-	    _zip_string_free(cstr);
-	    zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
+        if (_zip_guess_encoding(cstr, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_CP437) {
+            _zip_string_free(cstr);
+            zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
     }
     else
-	cstr = NULL;
+        cstr = NULL;
 
     _zip_string_free(za->comment_changes);
     za->comment_changes = NULL;
 
     if (((za->comment_orig && _zip_string_equal(za->comment_orig, cstr)) || (za->comment_orig == NULL && cstr == NULL))) {
-	_zip_string_free(cstr);
-	za->comment_changed = 0;
+        _zip_string_free(cstr);
+        za->comment_changed = 0;
     }
     else {
-	za->comment_changes = cstr;
-	za->comment_changed = 1;
+        za->comment_changes = cstr;
+        za->comment_changed = 1;
     }
 
     return 0;
diff --git a/lib/zip_set_archive_flag.c b/lib/zip_set_archive_flag.c
index e0d5502..3ba1e3f 100644
--- a/lib/zip_set_archive_flag.c
+++ b/lib/zip_set_archive_flag.c
@@ -40,23 +40,23 @@
     unsigned int new_flags;
 
     if (value)
-	new_flags = za->ch_flags | flag;
+        new_flags = za->ch_flags | flag;
     else
-	new_flags = za->ch_flags & ~flag;
+        new_flags = za->ch_flags & ~flag;
 
     if (new_flags == za->ch_flags)
-	return 0;
+        return 0;
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if ((flag & ZIP_AFL_RDONLY) && value && (za->ch_flags & ZIP_AFL_RDONLY) == 0) {
-	if (_zip_changed(za, NULL)) {
-	    zip_error_set(&za->error, ZIP_ER_CHANGED, 0);
-	    return -1;
-	}
+        if (_zip_changed(za, NULL)) {
+            zip_error_set(&za->error, ZIP_ER_CHANGED, 0);
+            return -1;
+        }
     }
 
     za->ch_flags = new_flags;
diff --git a/lib/zip_set_default_password.c b/lib/zip_set_default_password.c
index 41c7c51..70b2c3d 100644
--- a/lib/zip_set_default_password.c
+++ b/lib/zip_set_default_password.c
@@ -41,18 +41,18 @@
 ZIP_EXTERN int
 zip_set_default_password(zip_t *za, const char *passwd) {
     if (za == NULL)
-	return -1;
+        return -1;
 
     free(za->default_password);
 
     if (passwd) {
-	if ((za->default_password = strdup(passwd)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
+        if ((za->default_password = strdup(passwd)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
     }
     else
-	za->default_password = NULL;
+        za->default_password = NULL;
 
     return 0;
 }
diff --git a/lib/zip_set_file_comment.c b/lib/zip_set_file_comment.c
index 4277893..79f3edd 100644
--- a/lib/zip_set_file_comment.c
+++ b/lib/zip_set_file_comment.c
@@ -39,8 +39,8 @@
 ZIP_EXTERN int
 zip_set_file_comment(zip_t *za, zip_uint64_t idx, const char *comment, int len) {
     if (len < 0 || len > ZIP_UINT16_MAX) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
     return zip_file_set_comment(za, idx, comment, (zip_uint16_t)len, 0);
 }
diff --git a/lib/zip_set_file_compression.c b/lib/zip_set_file_compression.c
index 927fbb7..63b0bb1 100644
--- a/lib/zip_set_file_compression.c
+++ b/lib/zip_set_file_compression.c
@@ -41,18 +41,18 @@
     zip_int32_t old_method;
 
     if (idx >= za->nentry || flags > 9) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (!zip_compression_method_supported(method, true)) {
-	zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
+        return -1;
     }
 
     e = za->entry + idx;
@@ -65,26 +65,26 @@
      * to levels */
 
     if (method == old_method) {
-	if (e->changes) {
-	    e->changes->changed &= ~ZIP_DIRENT_COMP_METHOD;
-	    e->changes->compression_level = 0;
-	    if (e->changes->changed == 0) {
-		_zip_dirent_free(e->changes);
-		e->changes = NULL;
-	    }
-	}
+        if (e->changes) {
+            e->changes->changed &= ~ZIP_DIRENT_COMP_METHOD;
+            e->changes->compression_level = 0;
+            if (e->changes->changed == 0) {
+                _zip_dirent_free(e->changes);
+                e->changes = NULL;
+            }
+        }
     }
     else {
-	if (e->changes == NULL) {
-	    if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-		zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	}
+        if (e->changes == NULL) {
+            if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+                zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+        }
 
-	e->changes->comp_method = method;
-	e->changes->compression_level = (zip_uint16_t)flags;
-	e->changes->changed |= ZIP_DIRENT_COMP_METHOD;
+        e->changes->comp_method = method;
+        e->changes->compression_level = (zip_uint16_t)flags;
+        e->changes->changed |= ZIP_DIRENT_COMP_METHOD;
     }
 
     return 0;
diff --git a/lib/zip_set_name.c b/lib/zip_set_name.c
index 43c772e..65c78543 100644
--- a/lib/zip_set_name.c
+++ b/lib/zip_set_name.c
@@ -48,109 +48,109 @@
     zip_string_t *old_str;
 
     if (idx >= za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (ZIP_IS_RDONLY(za)) {
-	zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
+        return -1;
     }
 
     if (name && name[0] != '\0') {
-	/* TODO: check for string too long */
-	if ((str = _zip_string_new((const zip_uint8_t *)name, (zip_uint16_t)strlen(name), flags, &za->error)) == NULL)
-	    return -1;
-	if ((flags & ZIP_FL_ENCODING_ALL) == ZIP_FL_ENC_GUESS && _zip_guess_encoding(str, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_UTF8_GUESSED)
-	    str->encoding = ZIP_ENCODING_UTF8_KNOWN;
+        /* TODO: check for string too long */
+        if ((str = _zip_string_new((const zip_uint8_t *)name, (zip_uint16_t)strlen(name), flags, &za->error)) == NULL)
+            return -1;
+        if ((flags & ZIP_FL_ENCODING_ALL) == ZIP_FL_ENC_GUESS && _zip_guess_encoding(str, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_UTF8_GUESSED)
+            str->encoding = ZIP_ENCODING_UTF8_KNOWN;
     }
     else
-	str = NULL;
+        str = NULL;
 
     /* TODO: encoding flags needed for CP437? */
     if ((i = _zip_name_locate(za, name, 0, NULL)) >= 0 && (zip_uint64_t)i != idx) {
-	_zip_string_free(str);
-	zip_error_set(&za->error, ZIP_ER_EXISTS, 0);
-	return -1;
+        _zip_string_free(str);
+        zip_error_set(&za->error, ZIP_ER_EXISTS, 0);
+        return -1;
     }
 
     /* no effective name change */
     if (i >= 0 && (zip_uint64_t)i == idx) {
-	_zip_string_free(str);
-	return 0;
+        _zip_string_free(str);
+        return 0;
     }
 
     e = za->entry + idx;
 
     if (e->orig)
-	same_as_orig = _zip_string_equal(e->orig->filename, str);
+        same_as_orig = _zip_string_equal(e->orig->filename, str);
     else
-	same_as_orig = false;
+        same_as_orig = false;
 
     if (!same_as_orig && e->changes == NULL) {
-	if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    _zip_string_free(str);
-	    return -1;
-	}
+        if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            _zip_string_free(str);
+            return -1;
+        }
     }
 
     if ((new_name = _zip_string_get(same_as_orig ? e->orig->filename : str, NULL, 0, &za->error)) == NULL) {
-	_zip_string_free(str);
-	return -1;
+        _zip_string_free(str);
+        return -1;
     }
 
     if (e->changes) {
-	old_str = e->changes->filename;
+        old_str = e->changes->filename;
     }
     else if (e->orig) {
-	old_str = e->orig->filename;
+        old_str = e->orig->filename;
     }
     else {
-	old_str = NULL;
+        old_str = NULL;
     }
 
     if (old_str) {
-	if ((old_name = _zip_string_get(old_str, NULL, 0, &za->error)) == NULL) {
-	    _zip_string_free(str);
-	    return -1;
-	}
+        if ((old_name = _zip_string_get(old_str, NULL, 0, &za->error)) == NULL) {
+            _zip_string_free(str);
+            return -1;
+        }
     }
     else {
-	old_name = NULL;
+        old_name = NULL;
     }
 
     if (_zip_hash_add(za->names, new_name, idx, 0, &za->error) == false) {
-	_zip_string_free(str);
-	return -1;
+        _zip_string_free(str);
+        return -1;
     }
     if (old_name) {
-	_zip_hash_delete(za->names, old_name, NULL);
+        _zip_hash_delete(za->names, old_name, NULL);
     }
 
     if (same_as_orig) {
-	if (e->changes) {
-	    if (e->changes->changed & ZIP_DIRENT_FILENAME) {
-		_zip_string_free(e->changes->filename);
-		e->changes->changed &= ~ZIP_DIRENT_FILENAME;
-		if (e->changes->changed == 0) {
-		    _zip_dirent_free(e->changes);
-		    e->changes = NULL;
-		}
-		else {
-		    /* TODO: what if not cloned? can that happen? */
-		    e->changes->filename = e->orig->filename;
-		}
-	    }
-	}
-	_zip_string_free(str);
+        if (e->changes) {
+            if (e->changes->changed & ZIP_DIRENT_FILENAME) {
+                _zip_string_free(e->changes->filename);
+                e->changes->changed &= ~ZIP_DIRENT_FILENAME;
+                if (e->changes->changed == 0) {
+                    _zip_dirent_free(e->changes);
+                    e->changes = NULL;
+                }
+                else {
+                    /* TODO: what if not cloned? can that happen? */
+                    e->changes->filename = e->orig->filename;
+                }
+            }
+        }
+        _zip_string_free(str);
     }
     else {
-	if (e->changes->changed & ZIP_DIRENT_FILENAME) {
-	    _zip_string_free(e->changes->filename);
-	}
-	e->changes->changed |= ZIP_DIRENT_FILENAME;
-	e->changes->filename = str;
+        if (e->changes->changed & ZIP_DIRENT_FILENAME) {
+            _zip_string_free(e->changes->filename);
+        }
+        e->changes->changed |= ZIP_DIRENT_FILENAME;
+        e->changes->filename = str;
     }
 
     return 0;
diff --git a/lib/zip_source_accept_empty.c b/lib/zip_source_accept_empty.c
index e6d5151..8fe5124 100644
--- a/lib/zip_source_accept_empty.c
+++ b/lib/zip_source_accept_empty.c
@@ -40,10 +40,10 @@
     int ret;
 
     if ((zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ACCEPT_EMPTY)) == 0) {
-	if (ZIP_SOURCE_IS_LAYERED(src)) {
-	    return zip_source_accept_empty(src->src);
-	}
-	return true;
+        if (ZIP_SOURCE_IS_LAYERED(src)) {
+            return zip_source_accept_empty(src->src);
+        }
+        return true;
     }
 
     ret = (int)_zip_source_call(src, NULL, 0, ZIP_SOURCE_ACCEPT_EMPTY);
diff --git a/lib/zip_source_begin_write.c b/lib/zip_source_begin_write.c
index 432c2c1..1b0b157 100644
--- a/lib/zip_source_begin_write.c
+++ b/lib/zip_source_begin_write.c
@@ -38,12 +38,12 @@
 ZIP_EXTERN int
 zip_source_begin_write(zip_source_t *src) {
     if (ZIP_SOURCE_IS_OPEN_WRITING(src)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_BEGIN_WRITE) < 0) {
-	return -1;
+        return -1;
     }
 
     src->write_state = ZIP_SOURCE_WRITE_OPEN;
diff --git a/lib/zip_source_begin_write_cloning.c b/lib/zip_source_begin_write_cloning.c
index 41b4c73..87a6c92 100644
--- a/lib/zip_source_begin_write_cloning.c
+++ b/lib/zip_source_begin_write_cloning.c
@@ -38,12 +38,12 @@
 ZIP_EXTERN int
 zip_source_begin_write_cloning(zip_source_t *src, zip_uint64_t offset) {
     if (ZIP_SOURCE_IS_OPEN_WRITING(src)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (_zip_source_call(src, NULL, offset, ZIP_SOURCE_BEGIN_WRITE_CLONING) < 0) {
-	return -1;
+        return -1;
     }
 
     src->write_state = ZIP_SOURCE_WRITE_OPEN;
diff --git a/lib/zip_source_buffer.c b/lib/zip_source_buffer.c
index 519d2c3..a536f34 100644
--- a/lib/zip_source_buffer.c
+++ b/lib/zip_source_buffer.c
@@ -87,7 +87,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_buffer(zip_t *za, const void *data, zip_uint64_t len, int freep) {
     if (za == NULL)
-	return NULL;
+        return NULL;
 
     return zip_source_buffer_with_attributes_create(data, len, freep, NULL, &za->error);
 }
@@ -104,12 +104,12 @@
     zip_buffer_fragment_t fragment;
 
     if (data == NULL) {
-	if (len > 0) {
-	    zip_error_set(error, ZIP_ER_INVAL, 0);
-	    return NULL;
-	}
+        if (len > 0) {
+            zip_error_set(error, ZIP_ER_INVAL, 0);
+            return NULL;
+        }
 
-	return zip_source_buffer_fragment_with_attributes_create(NULL, 0, freep, attributes, error);
+        return zip_source_buffer_fragment_with_attributes_create(NULL, 0, freep, attributes, error);
     }
 
     fragment.data = (zip_uint8_t *)data;
@@ -122,7 +122,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_buffer_fragment(zip_t *za, const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int freep) {
     if (za == NULL) {
-	return NULL;
+        return NULL;
     }
 
     return zip_source_buffer_fragment_with_attributes_create(fragments, nfragments, freep, NULL, &za->error);
@@ -141,35 +141,35 @@
     buffer_t *buffer;
 
     if (fragments == NULL && nfragments > 0) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((buffer = buffer_new(fragments, nfragments, freep, error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     if ((ctx = (struct read_data *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	buffer_free(buffer);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        buffer_free(buffer);
+        return NULL;
     }
 
     ctx->in = buffer;
     ctx->out = NULL;
     ctx->mtime = time(NULL);
     if (attributes) {
-	memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
+        memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
     }
     else {
-	zip_file_attributes_init(&ctx->attributes);
+        zip_file_attributes_init(&ctx->attributes);
     }
     zip_error_init(&ctx->error);
 
     if ((zs = zip_source_function_create(read_data, ctx, error)) == NULL) {
-	buffer_free(ctx->in);
-	free(ctx);
-	return NULL;
+        buffer_free(ctx->in);
+        free(ctx);
+        return NULL;
     }
 
     return zs;
@@ -187,133 +187,133 @@
 
     switch (cmd) {
     case ZIP_SOURCE_BEGIN_WRITE:
-	if ((ctx->out = buffer_new(NULL, 0, 0, &ctx->error)) == NULL) {
-	    return -1;
-	}
-	ctx->out->offset = 0;
-	ctx->out->current_fragment = 0;
-	return 0;
+        if ((ctx->out = buffer_new(NULL, 0, 0, &ctx->error)) == NULL) {
+            return -1;
+        }
+        ctx->out->offset = 0;
+        ctx->out->current_fragment = 0;
+        return 0;
 
     case ZIP_SOURCE_BEGIN_WRITE_CLONING:
-	if ((ctx->out = buffer_clone(ctx->in, len, &ctx->error)) == NULL) {
-	    return -1;
-	}
-	ctx->out->offset = len;
-	ctx->out->current_fragment = ctx->out->nfragments;
-	return 0;
+        if ((ctx->out = buffer_clone(ctx->in, len, &ctx->error)) == NULL) {
+            return -1;
+        }
+        ctx->out->offset = len;
+        ctx->out->current_fragment = ctx->out->nfragments;
+        return 0;
 
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_COMMIT_WRITE:
-	buffer_free(ctx->in);
-	ctx->in = ctx->out;
-	ctx->out = NULL;
-	return 0;
+        buffer_free(ctx->in);
+        ctx->in = ctx->out;
+        ctx->out = NULL;
+        return 0;
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	buffer_free(ctx->in);
-	buffer_free(ctx->out);
-	free(ctx);
-	return 0;
+        buffer_free(ctx->in);
+        buffer_free(ctx->out);
+        free(ctx);
+        return 0;
 
     case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {
-	if (len < sizeof(ctx->attributes)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
+        if (len < sizeof(ctx->attributes)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
 
-	memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
+        memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
 
-	return sizeof(ctx->attributes);
+        return sizeof(ctx->attributes);
     }
 
     case ZIP_SOURCE_OPEN:
-	ctx->in->offset = 0;
-	ctx->in->current_fragment = 0;
-	return 0;
+        ctx->in->offset = 0;
+        ctx->in->current_fragment = 0;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	if (len > ZIP_INT64_MAX) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
-	return buffer_read(ctx->in, data, len);
+        if (len > ZIP_INT64_MAX) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
+        return buffer_read(ctx->in, data, len);
 
     case ZIP_SOURCE_REMOVE: {
-	buffer_t *empty = buffer_new(NULL, 0, 0, &ctx->error);
-	if (empty == NULL) {
-	    return -1;
-	}
+        buffer_t *empty = buffer_new(NULL, 0, 0, &ctx->error);
+        if (empty == NULL) {
+            return -1;
+        }
 
-	buffer_free(ctx->in);
-	ctx->in = empty;
-	return 0;
+        buffer_free(ctx->in);
+        ctx->in = empty;
+        return 0;
     }
 
     case ZIP_SOURCE_ROLLBACK_WRITE:
-	buffer_free(ctx->out);
-	ctx->out = NULL;
-	return 0;
+        buffer_free(ctx->out);
+        ctx->out = NULL;
+        return 0;
 
     case ZIP_SOURCE_SEEK:
-	return buffer_seek(ctx->in, data, len, &ctx->error);
+        return buffer_seek(ctx->in, data, len, &ctx->error);
 
     case ZIP_SOURCE_SEEK_WRITE:
-	return buffer_seek(ctx->out, data, len, &ctx->error);
+        return buffer_seek(ctx->out, data, len, &ctx->error);
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	if (len < sizeof(*st)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
+        if (len < sizeof(*st)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
 
-	st = (zip_stat_t *)data;
+        st = (zip_stat_t *)data;
 
-	zip_stat_init(st);
-	st->mtime = ctx->mtime;
-	st->size = ctx->in->size;
-	st->comp_size = st->size;
-	st->comp_method = ZIP_CM_STORE;
-	st->encryption_method = ZIP_EM_NONE;
-	st->valid = ZIP_STAT_MTIME | ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
+        zip_stat_init(st);
+        st->mtime = ctx->mtime;
+        st->size = ctx->in->size;
+        st->comp_size = st->size;
+        st->comp_method = ZIP_CM_STORE;
+        st->encryption_method = ZIP_EM_NONE;
+        st->valid = ZIP_STAT_MTIME | ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
 
-	return sizeof(*st);
+        return sizeof(*st);
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_BEGIN_WRITE_CLONING, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_BEGIN_WRITE_CLONING, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, -1);
 
     case ZIP_SOURCE_TELL:
-	if (ctx->in->offset > ZIP_INT64_MAX) {
-	    zip_error_set(&ctx->error, ZIP_ER_TELL, EOVERFLOW);
-	    return -1;
-	}
-	return (zip_int64_t)ctx->in->offset;
+        if (ctx->in->offset > ZIP_INT64_MAX) {
+            zip_error_set(&ctx->error, ZIP_ER_TELL, EOVERFLOW);
+            return -1;
+        }
+        return (zip_int64_t)ctx->in->offset;
 
 
     case ZIP_SOURCE_TELL_WRITE:
-	if (ctx->out->offset > ZIP_INT64_MAX) {
-	    zip_error_set(&ctx->error, ZIP_ER_TELL, EOVERFLOW);
-	    return -1;
-	}
-	return (zip_int64_t)ctx->out->offset;
+        if (ctx->out->offset > ZIP_INT64_MAX) {
+            zip_error_set(&ctx->error, ZIP_ER_TELL, EOVERFLOW);
+            return -1;
+        }
+        return (zip_int64_t)ctx->out->offset;
 
     case ZIP_SOURCE_WRITE:
-	if (len > ZIP_INT64_MAX) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
-	return buffer_write(ctx->out, data, len, &ctx->error);
+        if (len > ZIP_INT64_MAX) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
+        return buffer_write(ctx->out, data, len, &ctx->error);
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 }
 
@@ -324,34 +324,34 @@
     buffer_t *clone;
 
     if (offset == 0) {
-	return buffer_new(NULL, 0, 1, error);
+        return buffer_new(NULL, 0, 1, error);
     }
 
     if (offset > buffer->size) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
     if (buffer->shared_buffer != NULL) {
-	zip_error_set(error, ZIP_ER_INUSE, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INUSE, 0);
+        return NULL;
     }
 
     fragment = buffer_find_fragment(buffer, offset);
     fragment_offset = offset - buffer->fragment_offsets[fragment];
 
     if (fragment_offset == 0) {
-	fragment--;
-	fragment_offset = buffer->fragments[fragment].length;
+        fragment--;
+        fragment_offset = buffer->fragments[fragment].length;
     }
 
     waste = buffer->fragments[fragment].length - fragment_offset;
     if (waste > offset) {
-	zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
+        return NULL;
     }
 
     if ((clone = buffer_new(buffer->fragments, fragment + 1, 0, error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
 #ifndef __clang_analyzer__
@@ -380,16 +380,16 @@
     high = buffer->nfragments - 1;
 
     while (low < high) {
-	mid = (high - low) / 2 + low;
-	if (buffer->fragment_offsets[mid] > offset) {
-	    high = mid - 1;
-	}
-	else if (mid == buffer->nfragments || buffer->fragment_offsets[mid + 1] > offset) {
-	    return mid;
-	}
-	else {
-	    low = mid + 1;
-	}
+        mid = (high - low) / 2 + low;
+        if (buffer->fragment_offsets[mid] > offset) {
+            high = mid - 1;
+        }
+        else if (mid == buffer->nfragments || buffer->fragment_offsets[mid + 1] > offset) {
+            return mid;
+        }
+        else {
+            low = mid + 1;
+        }
     }
 
     return low;
@@ -401,18 +401,18 @@
     zip_uint64_t i;
 
     if (buffer == NULL) {
-	return;
+        return;
     }
 
     if (buffer->shared_buffer != NULL) {
-	buffer->shared_buffer->shared_buffer = NULL;
-	buffer->shared_buffer->shared_fragments = 0;
+        buffer->shared_buffer->shared_buffer = NULL;
+        buffer->shared_buffer->shared_fragments = 0;
 
-	buffer->first_owned_fragment = ZIP_MAX(buffer->first_owned_fragment, buffer->shared_fragments);
+        buffer->first_owned_fragment = ZIP_MAX(buffer->first_owned_fragment, buffer->shared_fragments);
     }
 
     for (i = buffer->first_owned_fragment; i < buffer->nfragments; i++) {
-	free(buffer->fragments[i].data);
+        free(buffer->fragments[i].data);
     }
     free(buffer->fragments);
     free(buffer->fragment_offsets);
@@ -426,17 +426,17 @@
     zip_uint64_t *offsets;
 
     if (capacity < buffer->fragments_capacity) {
-	return true;
+        return true;
     }
 
     if ((fragments = realloc(buffer->fragments, sizeof(buffer->fragments[0]) * capacity)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return false;
     }
     buffer->fragments = fragments;
     if ((offsets = realloc(buffer->fragment_offsets, sizeof(buffer->fragment_offsets[0]) * (capacity + 1))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return false;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return false;
     }
     buffer->fragment_offsets = offsets;
     buffer->fragments_capacity = capacity;
@@ -450,7 +450,7 @@
     buffer_t *buffer;
 
     if ((buffer = malloc(sizeof(*buffer))) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     buffer->offset = 0;
@@ -464,42 +464,42 @@
     buffer->shared_fragments = 0;
 
     if (nfragments == 0) {
-	if ((buffer->fragment_offsets = malloc(sizeof(buffer->fragment_offsets[0]))) == NULL) {
-	    free(buffer);
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    return NULL;
-	}
-	buffer->fragment_offsets[0] = 0;
+        if ((buffer->fragment_offsets = malloc(sizeof(buffer->fragment_offsets[0]))) == NULL) {
+            free(buffer);
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            return NULL;
+        }
+        buffer->fragment_offsets[0] = 0;
     }
     else {
-	zip_uint64_t i, j, offset;
+        zip_uint64_t i, j, offset;
 
-	if (!buffer_grow_fragments(buffer, nfragments, NULL)) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    buffer_free(buffer);
-	    return NULL;
-	}
+        if (!buffer_grow_fragments(buffer, nfragments, NULL)) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            buffer_free(buffer);
+            return NULL;
+        }
 
-	offset = 0;
-	for (i = 0, j = 0; i < nfragments; i++) {
-	    if (fragments[i].length == 0) {
-		continue;
-	    }
-	    if (fragments[i].data == NULL) {
-		zip_error_set(error, ZIP_ER_INVAL, 0);
-		buffer_free(buffer);
-		return NULL;
-	    }
-	    buffer->fragments[j].data = fragments[i].data;
-	    buffer->fragments[j].length = fragments[i].length;
-	    buffer->fragment_offsets[i] = offset;
-	    offset += fragments[i].length;
-	    j++;
-	}
-	buffer->nfragments = j;
-	buffer->first_owned_fragment = free_data ? 0 : buffer->nfragments;
-	buffer->fragment_offsets[buffer->nfragments] = offset;
-	buffer->size = offset;
+        offset = 0;
+        for (i = 0, j = 0; i < nfragments; i++) {
+            if (fragments[i].length == 0) {
+                continue;
+            }
+            if (fragments[i].data == NULL) {
+                zip_error_set(error, ZIP_ER_INVAL, 0);
+                buffer_free(buffer);
+                return NULL;
+            }
+            buffer->fragments[j].data = fragments[i].data;
+            buffer->fragments[j].length = fragments[i].length;
+            buffer->fragment_offsets[i] = offset;
+            offset += fragments[i].length;
+            j++;
+        }
+        buffer->nfragments = j;
+        buffer->first_owned_fragment = free_data ? 0 : buffer->nfragments;
+        buffer->fragment_offsets[buffer->nfragments] = offset;
+        buffer->size = offset;
     }
 
     return buffer;
@@ -512,25 +512,25 @@
     length = ZIP_MIN(length, buffer->size - buffer->offset);
 
     if (length == 0) {
-	return 0;
+        return 0;
     }
     if (length > ZIP_INT64_MAX) {
-	return -1;
+        return -1;
     }
 
     i = buffer->current_fragment;
     fragment_offset = buffer->offset - buffer->fragment_offsets[i];
     n = 0;
     while (n < length) {
-	zip_uint64_t left = ZIP_MIN(length - n, buffer->fragments[i].length - fragment_offset);
+        zip_uint64_t left = ZIP_MIN(length - n, buffer->fragments[i].length - fragment_offset);
 
-	memcpy(data + n, buffer->fragments[i].data + fragment_offset, left);
+        memcpy(data + n, buffer->fragments[i].data + fragment_offset, left);
 
-	if (left == buffer->fragments[i].length - fragment_offset) {
-	    i++;
-	}
-	n += left;
-	fragment_offset = 0;
+        if (left == buffer->fragments[i].length - fragment_offset) {
+            i++;
+        }
+        n += left;
+        fragment_offset = 0;
     }
 
     buffer->offset += n;
@@ -544,7 +544,7 @@
     zip_int64_t new_offset = zip_source_seek_compute_offset(buffer->offset, buffer->size, data, len, error);
 
     if (new_offset < 0) {
-	return -1;
+        return -1;
     }
 
     buffer->offset = (zip_uint64_t)new_offset;
@@ -558,62 +558,62 @@
     zip_uint64_t n, i, fragment_offset, capacity;
 
     if (buffer->offset + length + WRITE_FRAGMENT_SIZE - 1 < length) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     /* grow buffer if needed */
     capacity = buffer_capacity(buffer);
     if (buffer->offset + length > capacity) {
-	zip_uint64_t needed_fragments = buffer->nfragments + (length - (capacity - buffer->offset) + WRITE_FRAGMENT_SIZE - 1) / WRITE_FRAGMENT_SIZE;
+        zip_uint64_t needed_fragments = buffer->nfragments + (length - (capacity - buffer->offset) + WRITE_FRAGMENT_SIZE - 1) / WRITE_FRAGMENT_SIZE;
 
-	if (needed_fragments > buffer->fragments_capacity) {
-	    zip_uint64_t new_capacity = buffer->fragments_capacity;
+        if (needed_fragments > buffer->fragments_capacity) {
+            zip_uint64_t new_capacity = buffer->fragments_capacity;
 
-	    if (new_capacity == 0) {
-		new_capacity = 16;
-	    }
-	    while (new_capacity < needed_fragments) {
-		new_capacity *= 2;
-	    }
+            if (new_capacity == 0) {
+                new_capacity = 16;
+            }
+            while (new_capacity < needed_fragments) {
+                new_capacity *= 2;
+            }
 
-	    if (!buffer_grow_fragments(buffer, new_capacity, error)) {
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	}
+            if (!buffer_grow_fragments(buffer, new_capacity, error)) {
+                zip_error_set(error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+        }
 
-	while (buffer->nfragments < needed_fragments) {
-	    if ((buffer->fragments[buffer->nfragments].data = malloc(WRITE_FRAGMENT_SIZE)) == NULL) {
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	    buffer->fragments[buffer->nfragments].length = WRITE_FRAGMENT_SIZE;
-	    buffer->nfragments++;
-	    capacity += WRITE_FRAGMENT_SIZE;
-	    buffer->fragment_offsets[buffer->nfragments] = capacity;
-	}
+        while (buffer->nfragments < needed_fragments) {
+            if ((buffer->fragments[buffer->nfragments].data = malloc(WRITE_FRAGMENT_SIZE)) == NULL) {
+                zip_error_set(error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+            buffer->fragments[buffer->nfragments].length = WRITE_FRAGMENT_SIZE;
+            buffer->nfragments++;
+            capacity += WRITE_FRAGMENT_SIZE;
+            buffer->fragment_offsets[buffer->nfragments] = capacity;
+        }
     }
 
     i = buffer->current_fragment;
     fragment_offset = buffer->offset - buffer->fragment_offsets[i];
     n = 0;
     while (n < length) {
-	zip_uint64_t left = ZIP_MIN(length - n, buffer->fragments[i].length - fragment_offset);
+        zip_uint64_t left = ZIP_MIN(length - n, buffer->fragments[i].length - fragment_offset);
 
-	memcpy(buffer->fragments[i].data + fragment_offset, data + n, left);
+        memcpy(buffer->fragments[i].data + fragment_offset, data + n, left);
 
-	if (left == buffer->fragments[i].length - fragment_offset) {
-	    i++;
-	}
-	n += left;
-	fragment_offset = 0;
+        if (left == buffer->fragments[i].length - fragment_offset) {
+            i++;
+        }
+        n += left;
+        fragment_offset = 0;
     }
 
     buffer->offset += n;
     buffer->current_fragment = i;
     if (buffer->offset > buffer->size) {
-	buffer->size = buffer->offset;
+        buffer->size = buffer->offset;
     }
 
     return (zip_int64_t)n;
diff --git a/lib/zip_source_call.c b/lib/zip_source_call.c
index e7c2954..f4472ac 100644
--- a/lib/zip_source_call.c
+++ b/lib/zip_source_call.c
@@ -40,28 +40,28 @@
     zip_int64_t ret;
 
     if ((src->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(command)) == 0) {
-	zip_error_set(&src->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 
     if (src->src == NULL) {
-	ret = src->cb.f(src->ud, data, length, command);
+        ret = src->cb.f(src->ud, data, length, command);
     }
     else {
-	ret = src->cb.l(src->src, src->ud, data, length, command);
+        ret = src->cb.l(src->src, src->ud, data, length, command);
     }
 
     if (ret < 0) {
-	if (command != ZIP_SOURCE_ERROR && command != ZIP_SOURCE_SUPPORTS) {
-	    int e[2];
+        if (command != ZIP_SOURCE_ERROR && command != ZIP_SOURCE_SUPPORTS) {
+            int e[2];
 
-	    if (_zip_source_call(src, e, sizeof(e), ZIP_SOURCE_ERROR) < 0) {
-		zip_error_set(&src->error, ZIP_ER_INTERNAL, 0);
-	    }
-	    else {
-		zip_error_set(&src->error, e[0], e[1]);
-	    }
-	}
+            if (_zip_source_call(src, e, sizeof(e), ZIP_SOURCE_ERROR) < 0) {
+                zip_error_set(&src->error, ZIP_ER_INTERNAL, 0);
+            }
+            else {
+                zip_error_set(&src->error, e[0], e[1]);
+            }
+        }
     }
 
     return ret;
diff --git a/lib/zip_source_close.c b/lib/zip_source_close.c
index ab7898c..ff2cd9a 100644
--- a/lib/zip_source_close.c
+++ b/lib/zip_source_close.c
@@ -38,19 +38,19 @@
 int
 zip_source_close(zip_source_t *src) {
     if (!ZIP_SOURCE_IS_OPEN_READING(src)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     src->open_count--;
     if (src->open_count == 0) {
-	_zip_source_call(src, NULL, 0, ZIP_SOURCE_CLOSE);
+        _zip_source_call(src, NULL, 0, ZIP_SOURCE_CLOSE);
 
-	if (ZIP_SOURCE_IS_LAYERED(src)) {
-	    if (zip_source_close(src->src) < 0) {
-		zip_error_set(&src->error, ZIP_ER_INTERNAL, 0);
-	    }
-	}
+        if (ZIP_SOURCE_IS_LAYERED(src)) {
+            if (zip_source_close(src->src) < 0) {
+                zip_error_set(&src->error, ZIP_ER_INTERNAL, 0);
+            }
+        }
     }
 
     return 0;
diff --git a/lib/zip_source_commit_write.c b/lib/zip_source_commit_write.c
index d1254bf..fbd268f 100644
--- a/lib/zip_source_commit_write.c
+++ b/lib/zip_source_commit_write.c
@@ -38,23 +38,23 @@
 ZIP_EXTERN int
 zip_source_commit_write(zip_source_t *src) {
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (src->open_count > 1) {
-	zip_error_set(&src->error, ZIP_ER_INUSE, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INUSE, 0);
+        return -1;
     }
     else if (ZIP_SOURCE_IS_OPEN_READING(src)) {
-	if (zip_source_close(src) < 0) {
-	    return -1;
-	}
+        if (zip_source_close(src) < 0) {
+            return -1;
+        }
     }
 
     if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_COMMIT_WRITE) < 0) {
-	src->write_state = ZIP_SOURCE_WRITE_FAILED;
-	return -1;
+        src->write_state = ZIP_SOURCE_WRITE_FAILED;
+        return -1;
     }
 
     src->write_state = ZIP_SOURCE_WRITE_CLOSED;
diff --git a/lib/zip_source_compress.c b/lib/zip_source_compress.c
index a304322..1baa5f1 100644
--- a/lib/zip_source_compress.c
+++ b/lib/zip_source_compress.c
@@ -68,10 +68,10 @@
 #endif
 #if defined(HAVE_LIBLZMA)
     /*  Disabled - because 7z isn't able to unpack ZIP+LZMA ZIP+LZMA2
-	archives made this way - and vice versa.
+        archives made this way - and vice versa.
 
-	{ZIP_CM_LZMA, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},
-	{ZIP_CM_LZMA2, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},
+        {ZIP_CM_LZMA, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},
+        {ZIP_CM_LZMA2, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},
     */
     {ZIP_CM_XZ, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},
 #endif
@@ -95,14 +95,14 @@
     zip_uint16_t real_method = ZIP_CM_ACTUAL(method);
 
     for (i = 0; i < implementations_size; i++) {
-	if (implementations[i].method == real_method) {
-	    if (compress) {
-		return implementations[i].compress;
-	    }
-	    else {
-		return implementations[i].decompress;
-	    }
-	}
+        if (implementations[i].method == real_method) {
+            if (compress) {
+                return implementations[i].compress;
+            }
+            else {
+                return implementations[i].decompress;
+            }
+        }
     }
 
     return NULL;
@@ -111,7 +111,7 @@
 ZIP_EXTERN int
 zip_compression_method_supported(zip_int32_t method, int compress) {
     if (method == ZIP_CM_STORE) {
-	return 1;
+        return 1;
     }
     return _zip_get_compression_algorithm(method, compress) != NULL;
 }
@@ -134,23 +134,23 @@
     zip_compression_algorithm_t *algorithm = NULL;
 
     if (src == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((algorithm = _zip_get_compression_algorithm(method, compress)) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);
+        return NULL;
     }
 
     if ((ctx = context_new(method, compress, compression_flags, algorithm)) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((s2 = zip_source_layered(za, src, compress_callback, ctx)) == NULL) {
-	context_free(ctx);
-	return NULL;
+        context_free(ctx);
+        return NULL;
     }
 
     return s2;
@@ -162,7 +162,7 @@
     struct context *ctx;
 
     if ((ctx = (struct context *)malloc(sizeof(*ctx))) == NULL) {
-	return NULL;
+        return NULL;
     }
     zip_error_init(&ctx->error);
     ctx->can_store = compress ? ZIP_CM_IS_DEFAULT(method) : false;
@@ -174,9 +174,9 @@
     ctx->is_stored = false;
 
     if ((ctx->ud = ctx->algorithm->allocate(ZIP_CM_ACTUAL(method), compression_flags, &ctx->error)) == NULL) {
-	zip_error_fini(&ctx->error);
-	free(ctx);
-	return NULL;
+        zip_error_fini(&ctx->error);
+        free(ctx);
+        return NULL;
     }
 
     return ctx;
@@ -186,7 +186,7 @@
 static void
 context_free(struct context *ctx) {
     if (ctx == NULL) {
-	return;
+        return;
     }
 
     ctx->algorithm->deallocate(ctx->ud);
@@ -205,96 +205,96 @@
     zip_uint64_t out_len;
 
     if (zip_error_code_zip(&ctx->error) != ZIP_ER_OK) {
-	return -1;
+        return -1;
     }
 
     if (len == 0 || ctx->end_of_stream) {
-	return 0;
+        return 0;
     }
 
     out_offset = 0;
 
     end = false;
     while (!end && out_offset < len) {
-	out_len = len - out_offset;
-	ret = ctx->algorithm->process(ctx->ud, (zip_uint8_t *)data + out_offset, &out_len);
+        out_len = len - out_offset;
+        ret = ctx->algorithm->process(ctx->ud, (zip_uint8_t *)data + out_offset, &out_len);
 
-	if (ret != ZIP_COMPRESSION_ERROR) {
-	    out_offset += out_len;
-	}
+        if (ret != ZIP_COMPRESSION_ERROR) {
+            out_offset += out_len;
+        }
 
-	switch (ret) {
-	case ZIP_COMPRESSION_END:
-	    ctx->end_of_stream = true;
+        switch (ret) {
+        case ZIP_COMPRESSION_END:
+            ctx->end_of_stream = true;
 
-	    if (!ctx->end_of_input) {
-		/* TODO: garbage after stream, or compression ended before all data read */
-	    }
+            if (!ctx->end_of_input) {
+                /* TODO: garbage after stream, or compression ended before all data read */
+            }
 
-	    if (ctx->first_read < 0) {
-		/* we got end of processed stream before reading any input data */
-		zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-		end = true;
-		break;
-	    }
-	    if (ctx->can_store && (zip_uint64_t)ctx->first_read <= out_offset) {
-		ctx->is_stored = true;
-		ctx->size = (zip_uint64_t)ctx->first_read;
-		memcpy(data, ctx->buffer, ctx->size);
-		return (zip_int64_t)ctx->size;
-	    }
-	    end = true;
-	    break;
+            if (ctx->first_read < 0) {
+                /* we got end of processed stream before reading any input data */
+                zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+                end = true;
+                break;
+            }
+            if (ctx->can_store && (zip_uint64_t)ctx->first_read <= out_offset) {
+                ctx->is_stored = true;
+                ctx->size = (zip_uint64_t)ctx->first_read;
+                memcpy(data, ctx->buffer, ctx->size);
+                return (zip_int64_t)ctx->size;
+            }
+            end = true;
+            break;
 
-	case ZIP_COMPRESSION_OK:
-	    break;
+        case ZIP_COMPRESSION_OK:
+            break;
 
-	case ZIP_COMPRESSION_NEED_DATA:
-	    if (ctx->end_of_input) {
-		/* TODO: error: stream not ended, but no more input */
-		end = true;
-		break;
-	    }
+        case ZIP_COMPRESSION_NEED_DATA:
+            if (ctx->end_of_input) {
+                /* TODO: error: stream not ended, but no more input */
+                end = true;
+                break;
+            }
 
-	    if ((n = zip_source_read(src, ctx->buffer, sizeof(ctx->buffer))) < 0) {
-		_zip_error_set_from_source(&ctx->error, src);
-		end = true;
-		break;
-	    }
-	    else if (n == 0) {
-		ctx->end_of_input = true;
-		ctx->algorithm->end_of_input(ctx->ud);
-		if (ctx->first_read < 0) {
-		    ctx->first_read = 0;
-		}
-	    }
-	    else {
-		if (ctx->first_read >= 0) {
-		    /* we overwrote a previously filled ctx->buffer */
-		    ctx->can_store = false;
-		}
-		else {
-		    ctx->first_read = n;
-		}
+            if ((n = zip_source_read(src, ctx->buffer, sizeof(ctx->buffer))) < 0) {
+                _zip_error_set_from_source(&ctx->error, src);
+                end = true;
+                break;
+            }
+            else if (n == 0) {
+                ctx->end_of_input = true;
+                ctx->algorithm->end_of_input(ctx->ud);
+                if (ctx->first_read < 0) {
+                    ctx->first_read = 0;
+                }
+            }
+            else {
+                if (ctx->first_read >= 0) {
+                    /* we overwrote a previously filled ctx->buffer */
+                    ctx->can_store = false;
+                }
+                else {
+                    ctx->first_read = n;
+                }
 
-		ctx->algorithm->input(ctx->ud, ctx->buffer, (zip_uint64_t)n);
-	    }
-	    break;
+                ctx->algorithm->input(ctx->ud, ctx->buffer, (zip_uint64_t)n);
+            }
+            break;
 
-	case ZIP_COMPRESSION_ERROR:
-	    /* error set by algorithm */
-	    if (zip_error_code_zip(&ctx->error) == ZIP_ER_OK) {
-		zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	    }
-	    end = true;
-	    break;
-	}
+        case ZIP_COMPRESSION_ERROR:
+            /* error set by algorithm */
+            if (zip_error_code_zip(&ctx->error) == ZIP_ER_OK) {
+                zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+            }
+            end = true;
+            break;
+        }
     }
 
     if (out_offset > 0) {
-	ctx->can_store = false;
-	ctx->size += out_offset;
-	return (zip_int64_t)out_offset;
+        ctx->can_store = false;
+        ctx->size += out_offset;
+        return (zip_int64_t)out_offset;
     }
 
     return (zip_error_code_zip(&ctx->error) == ZIP_ER_OK) ? 0 : -1;
@@ -309,84 +309,84 @@
 
     switch (cmd) {
     case ZIP_SOURCE_OPEN:
-	ctx->size = 0;
-	ctx->end_of_input = false;
-	ctx->end_of_stream = false;
-	ctx->is_stored = false;
-	ctx->first_read = -1;
+        ctx->size = 0;
+        ctx->end_of_input = false;
+        ctx->end_of_stream = false;
+        ctx->is_stored = false;
+        ctx->first_read = -1;
 
-	if (!ctx->algorithm->start(ctx->ud)) {
-	    return -1;
-	}
+        if (!ctx->algorithm->start(ctx->ud)) {
+            return -1;
+        }
 
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	return compress_read(src, ctx, data, len);
+        return compress_read(src, ctx, data, len);
 
     case ZIP_SOURCE_CLOSE:
-	if (!ctx->algorithm->end(ctx->ud)) {
-	    return -1;
-	}
-	return 0;
+        if (!ctx->algorithm->end(ctx->ud)) {
+            return -1;
+        }
+        return 0;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
+        st = (zip_stat_t *)data;
 
-	if (ctx->compress) {
-	    if (ctx->end_of_stream) {
-		st->comp_method = ctx->is_stored ? ZIP_CM_STORE : ZIP_CM_ACTUAL(ctx->method);
-		st->comp_size = ctx->size;
-		st->valid |= ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD;
-	    }
-	    else {
-		st->valid &= ~(ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD);
-	    }
-	}
-	else {
-	    st->comp_method = ZIP_CM_STORE;
-	    st->valid |= ZIP_STAT_COMP_METHOD;
-	    if (ctx->end_of_stream) {
-		st->size = ctx->size;
-		st->valid |= ZIP_STAT_SIZE;
-	    }
-	    else {
-		st->valid &= ~ZIP_STAT_SIZE;
-	    }
-	}
+        if (ctx->compress) {
+            if (ctx->end_of_stream) {
+                st->comp_method = ctx->is_stored ? ZIP_CM_STORE : ZIP_CM_ACTUAL(ctx->method);
+                st->comp_size = ctx->size;
+                st->valid |= ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD;
+            }
+            else {
+                st->valid &= ~(ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD);
+            }
+        }
+        else {
+            st->comp_method = ZIP_CM_STORE;
+            st->valid |= ZIP_STAT_COMP_METHOD;
+            if (ctx->end_of_stream) {
+                st->size = ctx->size;
+                st->valid |= ZIP_STAT_SIZE;
+            }
+            else {
+                st->valid &= ~ZIP_STAT_SIZE;
+            }
+        }
     }
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	context_free(ctx);
-	return 0;
+        context_free(ctx);
+        return 0;
 
     case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {
-	zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
+        zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
 
-	if (len < sizeof(*attributes)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
+        if (len < sizeof(*attributes)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
 
-	attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED | ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;
-	attributes->version_needed = ctx->algorithm->version_needed;
-	attributes->general_purpose_bit_mask = ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;
-	attributes->general_purpose_bit_flags = (ctx->is_stored ? 0 : ctx->algorithm->general_purpose_bit_flags(ctx->ud));
+        attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED | ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;
+        attributes->version_needed = ctx->algorithm->version_needed;
+        attributes->general_purpose_bit_mask = ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;
+        attributes->general_purpose_bit_flags = (ctx->is_stored ? 0 : ctx->algorithm->general_purpose_bit_flags(ctx->ud));
 
-	return sizeof(*attributes);
+        return sizeof(*attributes);
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return ZIP_SOURCE_SUPPORTS_READABLE | zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
+        return ZIP_SOURCE_SUPPORTS_READABLE | zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 }
diff --git a/lib/zip_source_crc.c b/lib/zip_source_crc.c
index 4f3f223..a6122e0 100644
--- a/lib/zip_source_crc.c
+++ b/lib/zip_source_crc.c
@@ -56,13 +56,13 @@
     struct crc_context *ctx;
 
     if (src == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((ctx = (struct crc_context *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     zip_error_init(&ctx->error);
@@ -85,113 +85,113 @@
 
     switch (cmd) {
     case ZIP_SOURCE_OPEN:
-	ctx->position = 0;
-	return 0;
+        ctx->position = 0;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	if ((n = zip_source_read(src, data, len)) < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
+        if ((n = zip_source_read(src, data, len)) < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
 
-	if (n == 0) {
-	    if (ctx->crc_position == ctx->position) {
-		ctx->crc_complete = 1;
-		ctx->size = ctx->position;
+        if (n == 0) {
+            if (ctx->crc_position == ctx->position) {
+                ctx->crc_complete = 1;
+                ctx->size = ctx->position;
 
-		if (ctx->validate) {
-		    struct zip_stat st;
+                if (ctx->validate) {
+                    struct zip_stat st;
 
-		    if (zip_source_stat(src, &st) < 0) {
-			_zip_error_set_from_source(&ctx->error, src);
-			return -1;
-		    }
+                    if (zip_source_stat(src, &st) < 0) {
+                        _zip_error_set_from_source(&ctx->error, src);
+                        return -1;
+                    }
 
-		    if ((st.valid & ZIP_STAT_CRC) && st.crc != ctx->crc) {
-			zip_error_set(&ctx->error, ZIP_ER_CRC, 0);
-			return -1;
-		    }
-		    if ((st.valid & ZIP_STAT_SIZE) && st.size != ctx->size) {
-			zip_error_set(&ctx->error, ZIP_ER_INCONS, 0);
-			return -1;
-		    }
-		}
-	    }
-	}
-	else if (!ctx->crc_complete && ctx->position <= ctx->crc_position) {
-	    zip_uint64_t i, nn;
+                    if ((st.valid & ZIP_STAT_CRC) && st.crc != ctx->crc) {
+                        zip_error_set(&ctx->error, ZIP_ER_CRC, 0);
+                        return -1;
+                    }
+                    if ((st.valid & ZIP_STAT_SIZE) && st.size != ctx->size) {
+                        zip_error_set(&ctx->error, ZIP_ER_INCONS, 0);
+                        return -1;
+                    }
+                }
+            }
+        }
+        else if (!ctx->crc_complete && ctx->position <= ctx->crc_position) {
+            zip_uint64_t i, nn;
 
-	    for (i = ctx->crc_position - ctx->position; i < (zip_uint64_t)n; i += nn) {
-		nn = ZIP_MIN(UINT_MAX, (zip_uint64_t)n - i);
+            for (i = ctx->crc_position - ctx->position; i < (zip_uint64_t)n; i += nn) {
+                nn = ZIP_MIN(UINT_MAX, (zip_uint64_t)n - i);
 
-		ctx->crc = (zip_uint32_t)crc32(ctx->crc, (const Bytef *)data + i, (uInt)nn);
-		ctx->crc_position += nn;
-	    }
-	}
-	ctx->position += (zip_uint64_t)n;
-	return n;
+                ctx->crc = (zip_uint32_t)crc32(ctx->crc, (const Bytef *)data + i, (uInt)nn);
+                ctx->crc_position += nn;
+            }
+        }
+        ctx->position += (zip_uint64_t)n;
+        return n;
 
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
+        st = (zip_stat_t *)data;
 
-	if (ctx->crc_complete) {
-	    /* TODO: Set comp_size, comp_method, encryption_method?
-		    After all, this only works for uncompressed data. */
-	    st->size = ctx->size;
-	    st->crc = ctx->crc;
-	    st->comp_size = ctx->size;
-	    st->comp_method = ZIP_CM_STORE;
-	    st->encryption_method = ZIP_EM_NONE;
-	    st->valid |= ZIP_STAT_SIZE | ZIP_STAT_CRC | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
-	}
-	return 0;
+        if (ctx->crc_complete) {
+            /* TODO: Set comp_size, comp_method, encryption_method?
+                    After all, this only works for uncompressed data. */
+            st->size = ctx->size;
+            st->crc = ctx->crc;
+            st->comp_size = ctx->size;
+            st->comp_method = ZIP_CM_STORE;
+            st->encryption_method = ZIP_EM_NONE;
+            st->valid |= ZIP_STAT_SIZE | ZIP_STAT_CRC | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
+        }
+        return 0;
     }
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	free(ctx);
-	return 0;
+        free(ctx);
+        return 0;
 
     case ZIP_SOURCE_SUPPORTS: {
-	zip_int64_t mask = zip_source_supports(src);
+        zip_int64_t mask = zip_source_supports(src);
 
-	if (mask < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
+        if (mask < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
 
-	return mask & ~zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
+        return mask & ~zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
     }
 
     case ZIP_SOURCE_SEEK: {
-	zip_int64_t new_position;
-	zip_source_args_seek_t *args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
+        zip_int64_t new_position;
+        zip_source_args_seek_t *args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
 
-	if (args == NULL) {
-	    return -1;
-	}
-	if (zip_source_seek(src, args->offset, args->whence) < 0 || (new_position = zip_source_tell(src)) < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
+        if (args == NULL) {
+            return -1;
+        }
+        if (zip_source_seek(src, args->offset, args->whence) < 0 || (new_position = zip_source_tell(src)) < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
 
-	ctx->position = (zip_uint64_t)new_position;
+        ctx->position = (zip_uint64_t)new_position;
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_TELL:
-	return (zip_int64_t)ctx->position;
+        return (zip_int64_t)ctx->position;
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 }
diff --git a/lib/zip_source_file_common.c b/lib/zip_source_file_common.c
index be9bd94..bd31a05 100644
--- a/lib/zip_source_file_common.c
+++ b/lib/zip_source_file_common.c
@@ -56,70 +56,70 @@
     zip_source_file_stat_t sb;
 
     if (ops == NULL) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if (ops->close == NULL || ops->read == NULL || ops->seek == NULL || ops->stat == NULL) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        return NULL;
     }
 
     if (ops->write != NULL && (ops->commit_write == NULL || ops->create_temp_output == NULL || ops->remove == NULL || ops->rollback_write == NULL || ops->tell == NULL)) {
-	zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INTERNAL, 0);
+        return NULL;
     }
 
     if (fname != NULL) {
-	if (ops->open == NULL || ops->string_duplicate == NULL) {
-	    zip_error_set(error, ZIP_ER_INTERNAL, 0);
-	    return NULL;
-	}
+        if (ops->open == NULL || ops->string_duplicate == NULL) {
+            zip_error_set(error, ZIP_ER_INTERNAL, 0);
+            return NULL;
+        }
     }
     else if (file == NULL) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if (len < 0) {
-	len = 0;
+        len = 0;
     }
 
     if (start > ZIP_INT64_MAX || start + (zip_uint64_t)len < start) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((ctx = (zip_source_file_context_t *)malloc(sizeof(zip_source_file_context_t))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     ctx->ops = ops;
     ctx->ops_userdata = ops_userdata;
     ctx->fname = NULL;
     if (fname) {
-	if ((ctx->fname = ops->string_duplicate(ctx, fname)) == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    free(ctx);
-	    return NULL;
-	}
+        if ((ctx->fname = ops->string_duplicate(ctx, fname)) == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            free(ctx);
+            return NULL;
+        }
     }
     ctx->f = file;
     ctx->start = start;
     ctx->len = (zip_uint64_t)len;
     if (st) {
-	memcpy(&ctx->st, st, sizeof(ctx->st));
-	ctx->st.name = NULL;
-	ctx->st.valid &= ~ZIP_STAT_NAME;
+        memcpy(&ctx->st, st, sizeof(ctx->st));
+        ctx->st.name = NULL;
+        ctx->st.valid &= ~ZIP_STAT_NAME;
     }
     else {
-	zip_stat_init(&ctx->st);
+        zip_stat_init(&ctx->st);
     }
 
     if (ctx->len > 0) {
-	ctx->st.size = ctx->len;
-	ctx->st.valid |= ZIP_STAT_SIZE;
+        ctx->st.size = ctx->len;
+        ctx->st.valid |= ZIP_STAT_SIZE;
     }
 
     zip_error_init(&ctx->stat_error);
@@ -134,66 +134,66 @@
 
     zip_source_file_stat_init(&sb);
     if (!ops->stat(ctx, &sb)) {
-	_zip_error_copy(error, &ctx->error);
-	free(ctx->fname);
-	free(ctx);
-	return NULL;
+        _zip_error_copy(error, &ctx->error);
+        free(ctx->fname);
+        free(ctx);
+        return NULL;
     }
 
     if (!sb.exists) {
-	if (ctx->fname && ctx->start == 0 && ctx->len == 0 && ops->write != NULL) {
-	    ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
-	    /* zip_open_from_source checks for this to detect non-existing files */
-	    zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);
-	}
-	else {
-	    zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);
-	    free(ctx->fname);
-	    free(ctx);
-	    return NULL;
-	}
+        if (ctx->fname && ctx->start == 0 && ctx->len == 0 && ops->write != NULL) {
+            ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
+            /* zip_open_from_source checks for this to detect non-existing files */
+            zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);
+        }
+        else {
+            zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);
+            free(ctx->fname);
+            free(ctx);
+            return NULL;
+        }
     }
     else {
-	if ((ctx->st.valid & ZIP_STAT_MTIME) == 0) {
-	    ctx->st.mtime = sb.mtime;
-	    ctx->st.valid |= ZIP_STAT_MTIME;
-	}
-	if (sb.regular_file) {
-	    ctx->supports = ZIP_SOURCE_SUPPORTS_SEEKABLE;
+        if ((ctx->st.valid & ZIP_STAT_MTIME) == 0) {
+            ctx->st.mtime = sb.mtime;
+            ctx->st.valid |= ZIP_STAT_MTIME;
+        }
+        if (sb.regular_file) {
+            ctx->supports = ZIP_SOURCE_SUPPORTS_SEEKABLE;
 
-	    if (ctx->start + ctx->len > sb.size) {
-		zip_error_set(error, ZIP_ER_INVAL, 0);
-		free(ctx->fname);
-		free(ctx);
-		return NULL;
-	    }
+            if (ctx->start + ctx->len > sb.size) {
+                zip_error_set(error, ZIP_ER_INVAL, 0);
+                free(ctx->fname);
+                free(ctx);
+                return NULL;
+            }
 
-	    if (ctx->len == 0) {
-		ctx->len = sb.size - ctx->start;
-		ctx->st.size = ctx->len;
-		ctx->st.valid |= ZIP_STAT_SIZE;
+            if (ctx->len == 0) {
+                ctx->len = sb.size - ctx->start;
+                ctx->st.size = ctx->len;
+                ctx->st.valid |= ZIP_STAT_SIZE;
 
-		/* when using a partial file, don't allow writing */
-		if (ctx->fname && start == 0 && ops->write != NULL) {
-		    ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
-		}
-	    }
-	}
+                /* when using a partial file, don't allow writing */
+                if (ctx->fname && start == 0 && ops->write != NULL) {
+                    ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;
+                }
+            }
+        }
 
-	ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES);
+        ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES);
     }
 
     ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ACCEPT_EMPTY);
     if (ops->create_temp_output_cloning != NULL) {
-	if (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE)) {
-	    ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING);
-	}
+        if (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE)) {
+            ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING);
+        }
     }
 
     if ((zs = zip_source_function_create(read_file, ctx, error)) == NULL) {
-	free(ctx->fname);
-	free(ctx);
-	return NULL;
+        free(ctx->fname);
+        free(ctx);
+        return NULL;
     }
 
     return zs;
@@ -210,169 +210,169 @@
 
     switch (cmd) {
     case ZIP_SOURCE_ACCEPT_EMPTY:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_BEGIN_WRITE:
-	/* write support should not be set if fname is NULL */
-	if (ctx->fname == NULL) {
-	    zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	    return -1;
-	}
-	return ctx->ops->create_temp_output(ctx);
+        /* write support should not be set if fname is NULL */
+        if (ctx->fname == NULL) {
+            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+            return -1;
+        }
+        return ctx->ops->create_temp_output(ctx);
 
     case ZIP_SOURCE_BEGIN_WRITE_CLONING:
-	/* write support should not be set if fname is NULL */
-	if (ctx->fname == NULL) {
-	    zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	    return -1;
-	}
-	return ctx->ops->create_temp_output_cloning(ctx, len);
+        /* write support should not be set if fname is NULL */
+        if (ctx->fname == NULL) {
+            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+            return -1;
+        }
+        return ctx->ops->create_temp_output_cloning(ctx, len);
 
     case ZIP_SOURCE_CLOSE:
-	if (ctx->fname) {
-	    ctx->ops->close(ctx);
-	    ctx->f = NULL;
-	}
-	return 0;
+        if (ctx->fname) {
+            ctx->ops->close(ctx);
+            ctx->f = NULL;
+        }
+        return 0;
 
     case ZIP_SOURCE_COMMIT_WRITE: {
-	zip_int64_t ret = ctx->ops->commit_write(ctx);
-	ctx->fout = NULL;
-	if (ret == 0) {
-	    free(ctx->tmpname);
-	    ctx->tmpname = NULL;
-	}
-	return ret;
+        zip_int64_t ret = ctx->ops->commit_write(ctx);
+        ctx->fout = NULL;
+        if (ret == 0) {
+            free(ctx->tmpname);
+            ctx->tmpname = NULL;
+        }
+        return ret;
     }
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	free(ctx->fname);
-	free(ctx->tmpname);
-	if (ctx->f) {
-	    ctx->ops->close(ctx);
-	}
-	free(ctx);
-	return 0;
+        free(ctx->fname);
+        free(ctx->tmpname);
+        if (ctx->f) {
+            ctx->ops->close(ctx);
+        }
+        free(ctx);
+        return 0;
 
     case ZIP_SOURCE_GET_FILE_ATTRIBUTES:
-	if (len < sizeof(ctx->attributes)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
-	memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
-	return sizeof(ctx->attributes);
+        if (len < sizeof(ctx->attributes)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
+        memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
+        return sizeof(ctx->attributes);
 
     case ZIP_SOURCE_OPEN:
-	if (ctx->fname) {
-	    if (ctx->ops->open(ctx) == false) {
-		return -1;
-	    }
-	}
+        if (ctx->fname) {
+            if (ctx->ops->open(ctx) == false) {
+                return -1;
+            }
+        }
 
-	if (ctx->start > 0) { // TODO: rewind on re-open
-	    if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)ctx->start, SEEK_SET) == false) {
-		/* TODO: skip by reading */
-		return -1;
-	    }
-	}
-	ctx->offset = 0;
-	return 0;
+        if (ctx->start > 0) { // TODO: rewind on re-open
+            if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)ctx->start, SEEK_SET) == false) {
+                /* TODO: skip by reading */
+                return -1;
+            }
+        }
+        ctx->offset = 0;
+        return 0;
 
     case ZIP_SOURCE_READ: {
-	zip_int64_t i;
-	zip_uint64_t n;
+        zip_int64_t i;
+        zip_uint64_t n;
 
-	if (ctx->len > 0) {
-	    n = ZIP_MIN(ctx->len - ctx->offset, len);
-	}
-	else {
-	    n = len;
-	}
+        if (ctx->len > 0) {
+            n = ZIP_MIN(ctx->len - ctx->offset, len);
+        }
+        else {
+            n = len;
+        }
 
-	if ((i = ctx->ops->read(ctx, buf, n)) < 0) {
-	    zip_error_set(&ctx->error, ZIP_ER_READ, errno);
-	    return -1;
-	}
-	ctx->offset += (zip_uint64_t)i;
+        if ((i = ctx->ops->read(ctx, buf, n)) < 0) {
+            zip_error_set(&ctx->error, ZIP_ER_READ, errno);
+            return -1;
+        }
+        ctx->offset += (zip_uint64_t)i;
 
-	return i;
+        return i;
     }
 
     case ZIP_SOURCE_REMOVE:
-	return ctx->ops->remove(ctx);
+        return ctx->ops->remove(ctx);
 
     case ZIP_SOURCE_ROLLBACK_WRITE:
-	ctx->ops->rollback_write(ctx);
-	ctx->fout = NULL;
-	free(ctx->tmpname);
-	ctx->tmpname = NULL;
-	return 0;
+        ctx->ops->rollback_write(ctx);
+        ctx->fout = NULL;
+        free(ctx->tmpname);
+        ctx->tmpname = NULL;
+        return 0;
 
     case ZIP_SOURCE_SEEK: {
-	zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset, ctx->len, data, len, &ctx->error);
+        zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset, ctx->len, data, len, &ctx->error);
 
-	if (new_offset < 0) {
-	    return -1;
-	}
+        if (new_offset < 0) {
+            return -1;
+        }
 
-	/* The actual offset inside the file must be representable as zip_int64_t. */
-	if (new_offset > ZIP_INT64_MAX - (zip_int64_t)ctx->start) {
-	    zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);
-	    return -1;
-	}
+        /* The actual offset inside the file must be representable as zip_int64_t. */
+        if (new_offset > ZIP_INT64_MAX - (zip_int64_t)ctx->start) {
+            zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);
+            return -1;
+        }
 
-	ctx->offset = (zip_uint64_t)new_offset;
+        ctx->offset = (zip_uint64_t)new_offset;
 
-	if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)(ctx->offset + ctx->start), SEEK_SET) == false) {
-	    return -1;
-	}
-	return 0;
+        if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)(ctx->offset + ctx->start), SEEK_SET) == false) {
+            return -1;
+        }
+        return 0;
     }
 
     case ZIP_SOURCE_SEEK_WRITE: {
-	zip_source_args_seek_t *args;
+        zip_source_args_seek_t *args;
 
-	args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
-	if (args == NULL) {
-	    return -1;
-	}
+        args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);
+        if (args == NULL) {
+            return -1;
+        }
 
-	if (ctx->ops->seek(ctx, ctx->fout, args->offset, args->whence) == false) {
-	    return -1;
-	}
-	return 0;
+        if (ctx->ops->seek(ctx, ctx->fout, args->offset, args->whence) == false) {
+            return -1;
+        }
+        return 0;
     }
 
     case ZIP_SOURCE_STAT: {
-	if (len < sizeof(ctx->st))
-	    return -1;
+        if (len < sizeof(ctx->st))
+            return -1;
 
-	if (zip_error_code_zip(&ctx->stat_error) != 0) {
-	    zip_error_set(&ctx->error, zip_error_code_zip(&ctx->stat_error), zip_error_code_system(&ctx->stat_error));
-	    return -1;
-	}
+        if (zip_error_code_zip(&ctx->stat_error) != 0) {
+            zip_error_set(&ctx->error, zip_error_code_zip(&ctx->stat_error), zip_error_code_system(&ctx->stat_error));
+            return -1;
+        }
 
-	memcpy(data, &ctx->st, sizeof(ctx->st));
-	return sizeof(ctx->st);
+        memcpy(data, &ctx->st, sizeof(ctx->st));
+        return sizeof(ctx->st);
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return ctx->supports;
+        return ctx->supports;
 
     case ZIP_SOURCE_TELL:
-	return (zip_int64_t)ctx->offset;
+        return (zip_int64_t)ctx->offset;
 
     case ZIP_SOURCE_TELL_WRITE:
-	return ctx->ops->tell(ctx, ctx->fout);
+        return ctx->ops->tell(ctx, ctx->fout);
 
     case ZIP_SOURCE_WRITE:
-	return ctx->ops->write(ctx, data, len);
+        return ctx->ops->write(ctx, data, len);
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 }
diff --git a/lib/zip_source_file_stdio.c b/lib/zip_source_file_stdio.c
index 20cecf9..1581771 100644
--- a/lib/zip_source_file_stdio.c
+++ b/lib/zip_source_file_stdio.c
@@ -69,7 +69,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_filep(zip_t *za, FILE *file, zip_uint64_t start, zip_int64_t len) {
     if (za == NULL) {
-	return NULL;
+        return NULL;
     }
 
     return zip_source_filep_create(file, start, len, &za->error);
@@ -79,8 +79,8 @@
 ZIP_EXTERN zip_source_t *
 zip_source_filep_create(FILE *file, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {
     if (file == NULL || length < -1) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     return zip_source_file_common_new(NULL, file, start, length, NULL, &ops_stdio_read, NULL, error);
@@ -97,14 +97,14 @@
 _zip_stdio_op_read(zip_source_file_context_t *ctx, void *buf, zip_uint64_t len) {
     size_t i;
     if (len > SIZE_MAX) {
-	len = SIZE_MAX;
+        len = SIZE_MAX;
     }
 
     if ((i = fread(buf, 1, (size_t)len, ctx->f)) == 0) {
-	if (ferror((FILE *)ctx->f)) {
-	    zip_error_set(&ctx->error, ZIP_ER_READ, errno);
-	    return -1;
-	}
+        if (ferror((FILE *)ctx->f)) {
+            zip_error_set(&ctx->error, ZIP_ER_READ, errno);
+            return -1;
+        }
     }
 
     return (zip_int64_t)i;
@@ -115,14 +115,14 @@
 _zip_stdio_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset, int whence) {
 #if ZIP_FSEEK_MAX > ZIP_INT64_MAX
     if (offset > ZIP_FSEEK_MAX || offset < ZIP_FSEEK_MIN) {
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);
+        return false;
     }
 #endif
 
     if (fseeko((FILE *)f, (off_t)offset, whence) < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);
+        return false;
     }
     return true;
 }
@@ -135,19 +135,19 @@
     int ret;
 
     if (ctx->fname) {
-	ret = stat(ctx->fname, &sb);
+        ret = stat(ctx->fname, &sb);
     }
     else {
-	ret = fstat(fileno((FILE *)ctx->f), &sb);
+        ret = fstat(fileno((FILE *)ctx->f), &sb);
     }
 
     if (ret < 0) {
-	if (errno == ENOENT) {
-	    st->exists = false;
-	    return true;
-	}
-	zip_error_set(&ctx->error, ZIP_ER_READ, errno);
-	return false;
+        if (errno == ENOENT) {
+            st->exists = false;
+            return true;
+        }
+        zip_error_set(&ctx->error, ZIP_ER_READ, errno);
+        return false;
     }
 
     st->size = (zip_uint64_t)sb.st_size;
@@ -171,7 +171,7 @@
     off_t offset = ftello((FILE *)f);
 
     if (offset < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);
     }
 
     return offset;
@@ -191,18 +191,18 @@
 
     flags = O_CLOEXEC;
     if (writeable) {
-	flags |= O_RDWR;
+        flags |= O_RDWR;
     }
     else {
-	flags |= O_RDONLY;
+        flags |= O_RDONLY;
     }
 
     /* mode argument needed on Windows */
     if ((fd = open(name, flags, 0666)) < 0) {
-	return NULL;
+        return NULL;
     }
     if ((fp = fdopen(fd, writeable ? "r+b" : "rb")) == NULL) {
-	return NULL;
+        return NULL;
     }
     return fp;
 }
diff --git a/lib/zip_source_file_stdio_named.c b/lib/zip_source_file_stdio_named.c
index dae8177..5387c76 100644
--- a/lib/zip_source_file_stdio_named.c
+++ b/lib/zip_source_file_stdio_named.c
@@ -89,7 +89,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_file(zip_t *za, const char *fname, zip_uint64_t start, zip_int64_t len) {
     if (za == NULL)
-	return NULL;
+        return NULL;
 
     return zip_source_file_create(fname, start, len, &za->error);
 }
@@ -98,8 +98,8 @@
 ZIP_EXTERN zip_source_t *
 zip_source_file_create(const char *fname, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {
     if (fname == NULL || length < -1) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     return zip_source_file_common_new(fname, NULL, start, length, NULL, &ops_stdio_named, NULL, error);
@@ -109,12 +109,12 @@
 static zip_int64_t
 _zip_stdio_op_commit_write(zip_source_file_context_t *ctx) {
     if (fclose(ctx->fout) < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_WRITE, errno);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_WRITE, errno);
+        return -1;
     }
     if (rename(ctx->tmpname, ctx->fname) < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_RENAME, errno);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_RENAME, errno);
+        return -1;
     }
 
     return 0;
@@ -130,31 +130,31 @@
     struct stat st;
 
     if ((temp = (char *)malloc(strlen(ctx->fname) + 8)) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     if (stat(ctx->fname, &st) == 0) {
-	mode = st.st_mode;
+        mode = st.st_mode;
     }
     else {
-	mode = -1;
+        mode = -1;
     }
 
     sprintf(temp, "%s.XXXXXX", ctx->fname);
 
     if ((tfd = _zip_mkstempm(temp, mode)) == -1) {
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	free(temp);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+        free(temp);
+        return -1;
     }
 
     if ((tfp = fdopen(tfd, "r+b")) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	close(tfd);
-	(void)remove(temp);
-	free(temp);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+        close(tfd);
+        (void)remove(temp);
+        free(temp);
+        return -1;
     }
 
     ctx->fout = tfp;
@@ -170,13 +170,13 @@
     FILE *tfp;
 
     if (offset > ZIP_OFF_MAX) {
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, E2BIG);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, E2BIG);
+        return -1;
     }
 
     if ((temp = (char *)malloc(strlen(ctx->fname) + 8)) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
     sprintf(temp, "%s.XXXXXX", ctx->fname);
 
@@ -184,77 +184,77 @@
 #ifndef __clang_analyzer__
     /* we can't use mkstemp, since clonefile insists on creating the file */
     if (mktemp(temp) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	free(temp);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+        free(temp);
+        return -1;
     }
 #endif
 
     if (clonefile(ctx->fname, temp, 0) < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	free(temp);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+        free(temp);
+        return -1;
     }
     if ((tfp = _zip_fopen_close_on_exec(temp, true)) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	(void)remove(temp);
-	free(temp);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+        (void)remove(temp);
+        free(temp);
+        return -1;
     }
 #else
     {
-	int fd;
-	struct file_clone_range range;
-	struct stat st;
+        int fd;
+        struct file_clone_range range;
+        struct stat st;
 
-	if (fstat(fileno(ctx->f), &st) < 0) {
-	    zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	    free(temp);
-	    return -1;
-	}
+        if (fstat(fileno(ctx->f), &st) < 0) {
+            zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+            free(temp);
+            return -1;
+        }
 
-	if ((fd = mkstemp(temp)) < 0) {
-	    zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	    free(temp);
-	    return -1;
-	}
+        if ((fd = mkstemp(temp)) < 0) {
+            zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+            free(temp);
+            return -1;
+        }
 
-	range.src_fd = fileno(ctx->f);
-	range.src_offset = 0;
-	range.src_length = ((offset + st.st_blksize - 1) / st.st_blksize) * st.st_blksize;
-	if (range.src_length > st.st_size) {
-	    range.src_length = 0;
-	}
-	range.dest_offset = 0;
-	if (ioctl(fd, FICLONERANGE, &range) < 0) {
-	    zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	    (void)close(fd);
-	    (void)remove(temp);
-	    free(temp);
-	    return -1;
-	}
+        range.src_fd = fileno(ctx->f);
+        range.src_offset = 0;
+        range.src_length = ((offset + st.st_blksize - 1) / st.st_blksize) * st.st_blksize;
+        if (range.src_length > st.st_size) {
+            range.src_length = 0;
+        }
+        range.dest_offset = 0;
+        if (ioctl(fd, FICLONERANGE, &range) < 0) {
+            zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+            (void)close(fd);
+            (void)remove(temp);
+            free(temp);
+            return -1;
+        }
 
-	if ((tfp = fdopen(fd, "r+b")) == NULL) {
-	    zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
-	    (void)close(fd);
-	    (void)remove(temp);
-	    free(temp);
-	    return -1;
-	}
+        if ((tfp = fdopen(fd, "r+b")) == NULL) {
+            zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+            (void)close(fd);
+            (void)remove(temp);
+            free(temp);
+            return -1;
+        }
     }
 #endif
 
     if (ftruncate(fileno(tfp), (off_t)offset) < 0) {
-	(void)fclose(tfp);
-	(void)remove(temp);
-	free(temp);
-	return -1;
+        (void)fclose(tfp);
+        (void)remove(temp);
+        free(temp);
+        return -1;
     }
     if (fseeko(tfp, (off_t)offset, SEEK_SET) < 0) {
-	(void)fclose(tfp);
-	(void)remove(temp);
-	free(temp);
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
+        (void)fclose(tfp);
+        (void)remove(temp);
+        free(temp);
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, errno);
     }
 
     ctx->fout = tfp;
@@ -267,8 +267,8 @@
 static bool
 _zip_stdio_op_open(zip_source_file_context_t *ctx) {
     if ((ctx->f = _zip_fopen_close_on_exec(ctx->fname, false)) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_OPEN, errno);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_OPEN, errno);
+        return false;
     }
     return true;
 }
@@ -277,8 +277,8 @@
 static zip_int64_t
 _zip_stdio_op_remove(zip_source_file_context_t *ctx) {
     if (remove(ctx->fname) < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_REMOVE, errno);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_REMOVE, errno);
+        return -1;
     }
     return 0;
 }
@@ -287,7 +287,7 @@
 static void
 _zip_stdio_op_rollback_write(zip_source_file_context_t *ctx) {
     if (ctx->fout) {
-	fclose(ctx->fout);
+        fclose(ctx->fout);
     }
     (void)remove(ctx->tmpname);
 }
@@ -305,8 +305,8 @@
     clearerr((FILE *)ctx->fout);
     ret = fwrite(data, 1, len, (FILE *)ctx->fout);
     if (ret != len || ferror((FILE *)ctx->fout)) {
-	zip_error_set(&ctx->error, ZIP_ER_WRITE, errno);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_WRITE, errno);
+        return -1;
     }
 
     return (zip_int64_t)ret;
diff --git a/lib/zip_source_file_win32.c b/lib/zip_source_file_win32.c
index e0ae76d..d5b0553 100644
--- a/lib/zip_source_file_win32.c
+++ b/lib/zip_source_file_win32.c
@@ -60,7 +60,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_win32handle(zip_t *za, HANDLE h, zip_uint64_t start, zip_int64_t len) {
     if (za == NULL) {
-	return NULL;
+        return NULL;
     }
 
     return zip_source_win32handle_create(h, start, len, &za->error);
@@ -70,8 +70,8 @@
 ZIP_EXTERN zip_source_t *
 zip_source_win32handle_create(HANDLE h, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {
     if (h == INVALID_HANDLE_VALUE || length < -1) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     return zip_source_file_common_new(NULL, h, start, length, NULL, &ops_win32_read, NULL, error);
@@ -90,8 +90,8 @@
 
     /* TODO: cap len to "DWORD_MAX" */
     if (!ReadFile((HANDLE)ctx->f, buf, (DWORD)len, &i, NULL)) {
-	zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     return (zip_int64_t)i;
@@ -105,23 +105,23 @@
 
     switch (whence) {
     case SEEK_SET:
-	method = FILE_BEGIN;
-	break;
+        method = FILE_BEGIN;
+        break;
     case SEEK_END:
-	method = FILE_END;
-	break;
+        method = FILE_END;
+        break;
     case SEEK_CUR:
-	method = FILE_CURRENT;
-	break;
+        method = FILE_CURRENT;
+        break;
     default:
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, EINVAL);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, EINVAL);
+        return -1;
     }
 
     li.QuadPart = (LONGLONG)offset;
     if (!SetFilePointerEx((HANDLE)f, li, NULL, method)) {
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, _zip_win32_error_to_errno(GetLastError()));
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, _zip_win32_error_to_errno(GetLastError()));
+        return false;
     }
 
     return true;
@@ -141,8 +141,8 @@
 
     zero.QuadPart = 0;
     if (!SetFilePointerEx((HANDLE)f, zero, &new_offset, FILE_CURRENT)) {
-	zip_error_set(&ctx->error, ZIP_ER_SEEK, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_SEEK, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     return (zip_int64_t)new_offset.QuadPart;
@@ -154,21 +154,21 @@
     /* Note: This list isn't exhaustive, but should cover common cases. */
     switch (win32err) {
     case ERROR_INVALID_PARAMETER:
-	return EINVAL;
+        return EINVAL;
     case ERROR_FILE_NOT_FOUND:
-	return ENOENT;
+        return ENOENT;
     case ERROR_INVALID_HANDLE:
-	return EBADF;
+        return EBADF;
     case ERROR_ACCESS_DENIED:
-	return EACCES;
+        return EACCES;
     case ERROR_FILE_EXISTS:
-	return EEXIST;
+        return EEXIST;
     case ERROR_TOO_MANY_OPEN_FILES:
-	return EMFILE;
+        return EMFILE;
     case ERROR_DISK_FULL:
-	return ENOSPC;
+        return ENOSPC;
     default:
-	return 10000 + win32err;
+        return 10000 + win32err;
     }
 }
 
@@ -180,26 +180,26 @@
     LARGE_INTEGER size;
 
     if (!GetFileTime(h, NULL, NULL, &mtimeft)) {
-	zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));
+        return false;
     }
     if (_zip_filetime_to_time_t(mtimeft, &mtime) < 0) {
-	zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);
+        return false;
     }
 
     st->exists = true;
     st->mtime = mtime;
 
     if (GetFileType(h) == FILE_TYPE_DISK) {
-	st->regular_file = 1;
+        st->regular_file = 1;
 
-	if (!GetFileSizeEx(h, &size)) {
-	    zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));
-	    return false;
-	}
+        if (!GetFileSizeEx(h, &size)) {
+            zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));
+            return false;
+        }
 
-	st->size = (zip_uint64_t)size.QuadPart;
+        st->size = (zip_uint64_t)size.QuadPart;
     }
 
     /* TODO: fill in ctx->attributes */
@@ -225,7 +225,7 @@
 
     temp = (time_t)secs;
     if (secs != (zip_int64_t)temp) {
-	return false;
+        return false;
     }
 
     *t = temp;
diff --git a/lib/zip_source_file_win32_ansi.c b/lib/zip_source_file_win32_ansi.c
index 5785d2e..f299692 100644
--- a/lib/zip_source_file_win32_ansi.c
+++ b/lib/zip_source_file_win32_ansi.c
@@ -55,7 +55,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_win32a(zip_t *za, const char *fname, zip_uint64_t start, zip_int64_t len) {
     if (za == NULL)
-	return NULL;
+        return NULL;
 
     return zip_source_win32a_create(fname, start, len, &za->error);
 }
@@ -64,8 +64,8 @@
 ZIP_EXTERN zip_source_t *
 zip_source_win32a_create(const char *fname, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {
     if (fname == NULL || length < -1) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     return zip_source_file_common_new(fname, NULL, start, length, NULL, &_zip_source_file_win32_named_ops, &ops_ansi, error);
diff --git a/lib/zip_source_file_win32_named.c b/lib/zip_source_file_win32_named.c
index d76cc36..aa91f93 100644
--- a/lib/zip_source_file_win32_named.c
+++ b/lib/zip_source_file_win32_named.c
@@ -67,26 +67,26 @@
     zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;
 
     if (!CloseHandle((HANDLE)ctx->fout)) {
-	zip_error_set(&ctx->error, ZIP_ER_WRITE, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_WRITE, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     DWORD attributes = file_ops->get_file_attributes(ctx->tmpname);
     if (attributes == INVALID_FILE_ATTRIBUTES) {
-	zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     if (attributes & FILE_ATTRIBUTE_TEMPORARY) {
-	if (!file_ops->set_file_attributes(ctx->tmpname, attributes & ~FILE_ATTRIBUTE_TEMPORARY)) {
-	    zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));
-	    return -1;
-	}
+        if (!file_ops->set_file_attributes(ctx->tmpname, attributes & ~FILE_ATTRIBUTE_TEMPORARY)) {
+            zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));
+            return -1;
+        }
     }
 
     if (!file_ops->move_file(ctx->tmpname, ctx->fname, MOVEFILE_REPLACE_EXISTING)) {
-	zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     return 0;
@@ -109,14 +109,14 @@
     size_t tempname_size = 0;
 
     if ((HANDLE)ctx->f != INVALID_HANDLE_VALUE && GetFileType((HANDLE)ctx->f) == FILE_TYPE_DISK) {
-	si = DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION;
-	success = GetSecurityInfo((HANDLE)ctx->f, SE_FILE_OBJECT, si, NULL, NULL, &dacl, NULL, &psd);
-	if (success == ERROR_SUCCESS) {
-	    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
-	    sa.bInheritHandle = FALSE;
-	    sa.lpSecurityDescriptor = psd;
-	    psa = &sa;
-	}
+        si = DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION;
+        success = GetSecurityInfo((HANDLE)ctx->f, SE_FILE_OBJECT, si, NULL, NULL, &dacl, NULL, &psd);
+        if (success == ERROR_SUCCESS) {
+            sa.nLength = sizeof(SECURITY_ATTRIBUTES);
+            sa.bInheritHandle = FALSE;
+            sa.lpSecurityDescriptor = psd;
+            psa = &sa;
+        }
     }
 
 #ifndef MS_UWP
@@ -126,23 +126,23 @@
 #endif
 
     if ((tempname = file_ops->allocate_tempname(ctx->fname, 10, &tempname_size)) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     for (i = 0; i < 1024 && th == INVALID_HANDLE_VALUE; i++) {
-	file_ops->make_tempname(tempname, tempname_size, ctx->fname, value + i);
+        file_ops->make_tempname(tempname, tempname_size, ctx->fname, value + i);
 
-	th = win32_named_open(ctx, tempname, true, psa);
-	if (th == INVALID_HANDLE_VALUE && GetLastError() != ERROR_FILE_EXISTS)
-	    break;
+        th = win32_named_open(ctx, tempname, true, psa);
+        if (th == INVALID_HANDLE_VALUE && GetLastError() != ERROR_FILE_EXISTS)
+            break;
     }
 
     if (th == INVALID_HANDLE_VALUE) {
-	free(tempname);
-	LocalFree(psd);
-	zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        free(tempname);
+        LocalFree(psd);
+        zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     LocalFree(psd);
@@ -158,7 +158,7 @@
     HANDLE h = win32_named_open(ctx, ctx->fname, false, NULL);
 
     if (h == INVALID_HANDLE_VALUE) {
-	return false;
+        return false;
     }
 
     ctx->f = h;
@@ -171,8 +171,8 @@
     zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;
 
     if (!file_ops->delete_file(ctx->fname)) {
-	zip_error_set(&ctx->error, ZIP_ER_REMOVE, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_REMOVE, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     return 0;
@@ -184,7 +184,7 @@
     zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;
 
     if (ctx->fout) {
-	CloseHandle((HANDLE)ctx->fout);
+        CloseHandle((HANDLE)ctx->fout);
     }
     file_ops->delete_file(ctx->tmpname);
 }
@@ -197,20 +197,20 @@
     WIN32_FILE_ATTRIBUTE_DATA file_attributes;
 
     if (!file_ops->get_file_attributes_ex(ctx->fname, GetFileExInfoStandard, &file_attributes)) {
-	DWORD error = GetLastError();
-	if (error == ERROR_FILE_NOT_FOUND) {
-	    st->exists = false;
-	    return true;
-	}
-	zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(error));
-	return false;
+        DWORD error = GetLastError();
+        if (error == ERROR_FILE_NOT_FOUND) {
+            st->exists = false;
+            return true;
+        }
+        zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(error));
+        return false;
     }
 
     st->exists = true;
     st->regular_file = true; /* TODO: Is this always right? How to determine without a HANDLE? */
     if (!_zip_filetime_to_time_t(file_attributes.ftLastWriteTime, &st->mtime)) {
-	zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);
+        return false;
     }
     st->size = ((zip_uint64_t)file_attributes.nFileSizeHigh << 32) | file_attributes.nFileSizeLow;
 
@@ -232,8 +232,8 @@
 _zip_win32_named_op_write(zip_source_file_context_t *ctx, const void *data, zip_uint64_t len) {
     DWORD ret;
     if (!WriteFile((HANDLE)ctx->fout, data, (DWORD)len, &ret, NULL) || ret != len) {
-	zip_error_set(&ctx->error, ZIP_ER_WRITE, _zip_win32_error_to_errno(GetLastError()));
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_WRITE, _zip_win32_error_to_errno(GetLastError()));
+        return -1;
     }
 
     return (zip_int64_t)ret;
@@ -250,16 +250,16 @@
     DWORD file_attributes = FILE_ATTRIBUTE_NORMAL;
 
     if (temporary) {
-	access = GENERIC_READ | GENERIC_WRITE;
-	share_mode = FILE_SHARE_READ;
-	creation_disposition = CREATE_NEW;
-	file_attributes = FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_TEMPORARY;
+        access = GENERIC_READ | GENERIC_WRITE;
+        share_mode = FILE_SHARE_READ;
+        creation_disposition = CREATE_NEW;
+        file_attributes = FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_TEMPORARY;
     }
 
     HANDLE h = file_ops->create_file(name, access, share_mode, security_attributes, creation_disposition, file_attributes, NULL);
 
     if (h == INVALID_HANDLE_VALUE) {
-	zip_error_set(&ctx->error, ZIP_ER_OPEN, _zip_win32_error_to_errno(GetLastError()));
+        zip_error_set(&ctx->error, ZIP_ER_OPEN, _zip_win32_error_to_errno(GetLastError()));
     }
 
     return h;
diff --git a/lib/zip_source_file_win32_utf16.c b/lib/zip_source_file_win32_utf16.c
index 939d197..6aef2bb 100644
--- a/lib/zip_source_file_win32_utf16.c
+++ b/lib/zip_source_file_win32_utf16.c
@@ -57,7 +57,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_win32w(zip_t *za, const wchar_t *fname, zip_uint64_t start, zip_int64_t len) {
     if (za == NULL)
-	return NULL;
+        return NULL;
 
     return zip_source_win32w_create(fname, start, len, &za->error);
 }
@@ -66,8 +66,8 @@
 ZIP_EXTERN zip_source_t *
 zip_source_win32w_create(const wchar_t *fname, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {
     if (fname == NULL || length < -1) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
 
diff --git a/lib/zip_source_file_win32_utf8.c b/lib/zip_source_file_win32_utf8.c
index b6ecad1..d6728e3 100644
--- a/lib/zip_source_file_win32_utf8.c
+++ b/lib/zip_source_file_win32_utf8.c
@@ -36,7 +36,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_file(zip_t *za, const char *fname, zip_uint64_t start, zip_int64_t len) {
     if (za == NULL) {
-	return NULL;
+        return NULL;
     }
 
     return zip_source_file_create(fname, start, len, &za->error);
@@ -50,19 +50,19 @@
     zip_source_t *source;
 
     if (fname == NULL || length < -1) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     /* Convert fname from UTF-8 to Windows-friendly UTF-16. */
     size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, fname, -1, NULL, 0);
     if (size == 0) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
     if ((wfname = (wchar_t *)malloc(sizeof(wchar_t) * size)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
     MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, fname, -1, wfname, size);
 
diff --git a/lib/zip_source_free.c b/lib/zip_source_free.c
index 2f10ef8..1768e61 100644
--- a/lib/zip_source_free.c
+++ b/lib/zip_source_free.c
@@ -40,31 +40,31 @@
 ZIP_EXTERN void
 zip_source_free(zip_source_t *src) {
     if (src == NULL)
-	return;
+        return;
 
     if (src->refcount > 0) {
-	src->refcount--;
+        src->refcount--;
     }
     if (src->refcount > 0) {
-	return;
+        return;
     }
 
     if (ZIP_SOURCE_IS_OPEN_READING(src)) {
-	src->open_count = 1; /* force close */
-	zip_source_close(src);
+        src->open_count = 1; /* force close */
+        zip_source_close(src);
     }
     if (ZIP_SOURCE_IS_OPEN_WRITING(src)) {
-	zip_source_rollback_write(src);
+        zip_source_rollback_write(src);
     }
 
     if (src->source_archive && !src->source_closed) {
-	_zip_deregister_source(src->source_archive, src);
+        _zip_deregister_source(src->source_archive, src);
     }
 
     (void)_zip_source_call(src, NULL, 0, ZIP_SOURCE_FREE);
 
     if (src->src) {
-	zip_source_free(src->src);
+        zip_source_free(src->src);
     }
 
     free(src);
diff --git a/lib/zip_source_function.c b/lib/zip_source_function.c
index 711d1c7..2aed078 100644
--- a/lib/zip_source_function.c
+++ b/lib/zip_source_function.c
@@ -40,7 +40,7 @@
 ZIP_EXTERN zip_source_t *
 zip_source_function(zip_t *za, zip_source_callback zcb, void *ud) {
     if (za == NULL) {
-	return NULL;
+        return NULL;
     }
 
     return zip_source_function_create(zcb, ud, &za->error);
@@ -52,14 +52,14 @@
     zip_source_t *zs;
 
     if ((zs = _zip_source_new(error)) == NULL)
-	return NULL;
+        return NULL;
 
     zs->cb.f = zcb;
     zs->ud = ud;
 
     zs->supports = zcb(ud, NULL, 0, ZIP_SOURCE_SUPPORTS);
     if (zs->supports < 0) {
-	zs->supports = ZIP_SOURCE_SUPPORTS_READABLE;
+        zs->supports = ZIP_SOURCE_SUPPORTS_READABLE;
     }
 
     return zs;
@@ -77,8 +77,8 @@
     zip_source_t *src;
 
     if ((src = (zip_source_t *)malloc(sizeof(*src))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     src->src = NULL;
diff --git a/lib/zip_source_get_file_attributes.c b/lib/zip_source_get_file_attributes.c
index acbede1..ee41544 100644
--- a/lib/zip_source_get_file_attributes.c
+++ b/lib/zip_source_get_file_attributes.c
@@ -42,62 +42,62 @@
 int
 zip_source_get_file_attributes(zip_source_t *src, zip_file_attributes_t *attributes) {
     if (src->source_closed) {
-	return -1;
+        return -1;
     }
     if (attributes == NULL) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     zip_file_attributes_init(attributes);
 
     if (src->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES)) {
-	if (_zip_source_call(src, attributes, sizeof(*attributes), ZIP_SOURCE_GET_FILE_ATTRIBUTES) < 0) {
-	    return -1;
-	}
+        if (_zip_source_call(src, attributes, sizeof(*attributes), ZIP_SOURCE_GET_FILE_ATTRIBUTES) < 0) {
+            return -1;
+        }
     }
 
     if (ZIP_SOURCE_IS_LAYERED(src)) {
-	zip_file_attributes_t lower_attributes;
+        zip_file_attributes_t lower_attributes;
 
-	if (zip_source_get_file_attributes(src->src, &lower_attributes) < 0) {
-	    _zip_error_set_from_source(&src->error, src->src);
-	    return -1;
-	}
+        if (zip_source_get_file_attributes(src->src, &lower_attributes) < 0) {
+            _zip_error_set_from_source(&src->error, src->src);
+            return -1;
+        }
 
-	if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM) && (attributes->valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM) == 0) {
-	    attributes->host_system = lower_attributes.host_system;
-	    attributes->valid |= ZIP_FILE_ATTRIBUTES_HOST_SYSTEM;
-	}
-	if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_ASCII) && (attributes->valid & ZIP_FILE_ATTRIBUTES_ASCII) == 0) {
-	    attributes->ascii = lower_attributes.ascii;
-	    attributes->valid |= ZIP_FILE_ATTRIBUTES_ASCII;
-	}
-	if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED)) {
-	    if (attributes->valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED) {
-		attributes->version_needed = ZIP_MAX(lower_attributes.version_needed, attributes->version_needed);
-	    }
-	    else {
-		attributes->version_needed = lower_attributes.version_needed;
-		attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;
-	    }
-	}
-	if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES) && (attributes->valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES) == 0) {
-	    attributes->external_file_attributes = lower_attributes.external_file_attributes;
-	    attributes->valid |= ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES;
-	}
-	if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS)) {
-	    if (attributes->valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS) {
-		attributes->general_purpose_bit_flags &= ~lower_attributes.general_purpose_bit_mask;
-		attributes->general_purpose_bit_flags |= lower_attributes.general_purpose_bit_flags & lower_attributes.general_purpose_bit_mask;
-		attributes->general_purpose_bit_mask |= lower_attributes.general_purpose_bit_mask;
-	    }
-	    else {
-		attributes->valid |= ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;
-		attributes->general_purpose_bit_flags = lower_attributes.general_purpose_bit_flags;
-		attributes->general_purpose_bit_mask = lower_attributes.general_purpose_bit_mask;
-	    }
-	}
+        if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM) && (attributes->valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM) == 0) {
+            attributes->host_system = lower_attributes.host_system;
+            attributes->valid |= ZIP_FILE_ATTRIBUTES_HOST_SYSTEM;
+        }
+        if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_ASCII) && (attributes->valid & ZIP_FILE_ATTRIBUTES_ASCII) == 0) {
+            attributes->ascii = lower_attributes.ascii;
+            attributes->valid |= ZIP_FILE_ATTRIBUTES_ASCII;
+        }
+        if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED)) {
+            if (attributes->valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED) {
+                attributes->version_needed = ZIP_MAX(lower_attributes.version_needed, attributes->version_needed);
+            }
+            else {
+                attributes->version_needed = lower_attributes.version_needed;
+                attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;
+            }
+        }
+        if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES) && (attributes->valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES) == 0) {
+            attributes->external_file_attributes = lower_attributes.external_file_attributes;
+            attributes->valid |= ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES;
+        }
+        if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS)) {
+            if (attributes->valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS) {
+                attributes->general_purpose_bit_flags &= ~lower_attributes.general_purpose_bit_mask;
+                attributes->general_purpose_bit_flags |= lower_attributes.general_purpose_bit_flags & lower_attributes.general_purpose_bit_mask;
+                attributes->general_purpose_bit_mask |= lower_attributes.general_purpose_bit_mask;
+            }
+            else {
+                attributes->valid |= ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;
+                attributes->general_purpose_bit_flags = lower_attributes.general_purpose_bit_flags;
+                attributes->general_purpose_bit_mask = lower_attributes.general_purpose_bit_mask;
+            }
+        }
     }
 
     return 0;
diff --git a/lib/zip_source_layered.c b/lib/zip_source_layered.c
index d02bc85..1a9683e 100644
--- a/lib/zip_source_layered.c
+++ b/lib/zip_source_layered.c
@@ -40,7 +40,7 @@
 zip_source_t *
 zip_source_layered(zip_t *za, zip_source_t *src, zip_source_layered_callback cb, void *ud) {
     if (za == NULL)
-	return NULL;
+        return NULL;
 
     return zip_source_layered_create(src, cb, ud, &za->error);
 }
@@ -51,7 +51,7 @@
     zip_source_t *zs;
 
     if ((zs = _zip_source_new(error)) == NULL)
-	return NULL;
+        return NULL;
 
     zip_source_keep(src);
     zs->src = src;
@@ -60,7 +60,7 @@
 
     zs->supports = cb(src, ud, NULL, 0, ZIP_SOURCE_SUPPORTS);
     if (zs->supports < 0) {
-	zs->supports = ZIP_SOURCE_SUPPORTS_READABLE;
+        zs->supports = ZIP_SOURCE_SUPPORTS_READABLE;
     }
 
     return zs;
diff --git a/lib/zip_source_open.c b/lib/zip_source_open.c
index e39947d..2e5a32d 100644
--- a/lib/zip_source_open.c
+++ b/lib/zip_source_open.c
@@ -37,33 +37,33 @@
 ZIP_EXTERN int
 zip_source_open(zip_source_t *src) {
     if (src->source_closed) {
-	return -1;
+        return -1;
     }
     if (src->write_state == ZIP_SOURCE_WRITE_REMOVED) {
-	zip_error_set(&src->error, ZIP_ER_DELETED, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_DELETED, 0);
+        return -1;
     }
 
     if (ZIP_SOURCE_IS_OPEN_READING(src)) {
-	if ((zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK)) == 0) {
-	    zip_error_set(&src->error, ZIP_ER_INUSE, 0);
-	    return -1;
-	}
+        if ((zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK)) == 0) {
+            zip_error_set(&src->error, ZIP_ER_INUSE, 0);
+            return -1;
+        }
     }
     else {
-	if (ZIP_SOURCE_IS_LAYERED(src)) {
-	    if (zip_source_open(src->src) < 0) {
-		_zip_error_set_from_source(&src->error, src->src);
-		return -1;
-	    }
-	}
+        if (ZIP_SOURCE_IS_LAYERED(src)) {
+            if (zip_source_open(src->src) < 0) {
+                _zip_error_set_from_source(&src->error, src->src);
+                return -1;
+            }
+        }
 
-	if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_OPEN) < 0) {
-	    if (ZIP_SOURCE_IS_LAYERED(src)) {
-		zip_source_close(src->src);
-	    }
-	    return -1;
-	}
+        if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_OPEN) < 0) {
+            if (ZIP_SOURCE_IS_LAYERED(src)) {
+                zip_source_close(src->src);
+            }
+            return -1;
+        }
     }
 
     src->eof = false;
diff --git a/lib/zip_source_pkware_decode.c b/lib/zip_source_pkware_decode.c
index d5489a5..28a4eed 100644
--- a/lib/zip_source_pkware_decode.c
+++ b/lib/zip_source_pkware_decode.c
@@ -56,21 +56,21 @@
     zip_source_t *s2;
 
     if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
     if (flags & ZIP_CODEC_ENCODE) {
-	zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+        return NULL;
     }
 
     if ((ctx = trad_pkware_new(password, &za->error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     if ((s2 = zip_source_layered(za, src, pkware_decrypt, ctx)) == NULL) {
-	trad_pkware_free(ctx);
-	return NULL;
+        trad_pkware_free(ctx);
+        return NULL;
     }
 
     return s2;
@@ -84,20 +84,20 @@
     zip_int64_t n;
 
     if ((n = zip_source_read(src, header, ZIP_CRYPTO_PKWARE_HEADERLEN)) < 0) {
-	_zip_error_set_from_source(&ctx->error, src);
-	return -1;
+        _zip_error_set_from_source(&ctx->error, src);
+        return -1;
     }
 
     if (n != ZIP_CRYPTO_PKWARE_HEADERLEN) {
-	zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
+        return -1;
     }
 
     _zip_pkware_decrypt(&ctx->keys, header, header, ZIP_CRYPTO_PKWARE_HEADERLEN);
 
     if (zip_source_stat(src, &st)) {
-	/* stat failed, skip password validation */
-	return 0;
+        /* stat failed, skip password validation */
+        return 0;
     }
 
     /* password verification - two ways:
@@ -108,22 +108,22 @@
     bool ok = false;
 
     if (st.valid & ZIP_STAT_MTIME) {
-	unsigned short dostime, dosdate;
-	_zip_u2d_time(st.mtime, &dostime, &dosdate);
-	if (header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == dostime >> 8) {
-	    ok = true;
-	}
+        unsigned short dostime, dosdate;
+        _zip_u2d_time(st.mtime, &dostime, &dosdate);
+        if (header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == dostime >> 8) {
+            ok = true;
+        }
     }
 
     if (st.valid & ZIP_STAT_CRC) {
-	if (header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == st.crc >> 24) {
-	    ok = true;
-	}
+        if (header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == st.crc >> 24) {
+            ok = true;
+        }
     }
 
     if (!ok && ((st.valid & (ZIP_STAT_MTIME | ZIP_STAT_CRC)) != 0)) {
-	zip_error_set(&ctx->error, ZIP_ER_WRONGPASSWD, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_WRONGPASSWD, 0);
+        return -1;
     }
 
     return 0;
@@ -139,52 +139,52 @@
 
     switch (cmd) {
     case ZIP_SOURCE_OPEN:
-	_zip_pkware_keys_reset(&ctx->keys);
-	_zip_pkware_decrypt(&ctx->keys, NULL, (const zip_uint8_t *)ctx->password, strlen(ctx->password));
-	if (decrypt_header(src, ctx) < 0) {
-	    return -1;
-	}
-	return 0;
+        _zip_pkware_keys_reset(&ctx->keys);
+        _zip_pkware_decrypt(&ctx->keys, NULL, (const zip_uint8_t *)ctx->password, strlen(ctx->password));
+        if (decrypt_header(src, ctx) < 0) {
+            return -1;
+        }
+        return 0;
 
     case ZIP_SOURCE_READ:
-	if ((n = zip_source_read(src, data, len)) < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
+        if ((n = zip_source_read(src, data, len)) < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
 
-	_zip_pkware_decrypt(&ctx->keys, (zip_uint8_t *)data, (zip_uint8_t *)data, (zip_uint64_t)n);
-	return n;
+        _zip_pkware_decrypt(&ctx->keys, (zip_uint8_t *)data, (zip_uint8_t *)data, (zip_uint64_t)n);
+        return n;
 
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
+        st = (zip_stat_t *)data;
 
-	st->encryption_method = ZIP_EM_NONE;
-	st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
-	if (st->valid & ZIP_STAT_COMP_SIZE) {
-	    st->comp_size -= ZIP_CRYPTO_PKWARE_HEADERLEN;
-	}
+        st->encryption_method = ZIP_EM_NONE;
+        st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
+        if (st->valid & ZIP_STAT_COMP_SIZE) {
+            st->comp_size -= ZIP_CRYPTO_PKWARE_HEADERLEN;
+        }
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, -1);
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	trad_pkware_free(ctx);
-	return 0;
+        trad_pkware_free(ctx);
+        return 0;
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 }
 
@@ -194,14 +194,14 @@
     struct trad_pkware *ctx;
 
     if ((ctx = (struct trad_pkware *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ctx->password = strdup(password)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	free(ctx);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        free(ctx);
+        return NULL;
     }
 
     zip_error_init(&ctx->error);
@@ -213,7 +213,7 @@
 static void
 trad_pkware_free(struct trad_pkware *ctx) {
     if (ctx == NULL) {
-	return;
+        return;
     }
 
     free(ctx->password);
diff --git a/lib/zip_source_pkware_encode.c b/lib/zip_source_pkware_encode.c
index 1e8f42c..7c77e1e 100644
--- a/lib/zip_source_pkware_encode.c
+++ b/lib/zip_source_pkware_encode.c
@@ -58,21 +58,21 @@
     zip_source_t *s2;
 
     if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
     if (!(flags & ZIP_CODEC_ENCODE)) {
-	zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+        return NULL;
     }
 
     if ((ctx = trad_pkware_new(password, &za->error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     if ((s2 = zip_source_layered(za, src, pkware_encrypt, ctx)) == NULL) {
-	trad_pkware_free(ctx);
-	return NULL;
+        trad_pkware_free(ctx);
+        return NULL;
     }
 
     return s2;
@@ -86,15 +86,15 @@
     zip_uint8_t *header;
 
     if (zip_source_stat(src, &st) != 0) {
-	_zip_error_set_from_source(&ctx->error, src);
-	return -1;
+        _zip_error_set_from_source(&ctx->error, src);
+        return -1;
     }
 
     _zip_u2d_time(st.mtime, &dostime, &dosdate);
 
     if ((ctx->buffer = _zip_buffer_new(NULL, ZIP_CRYPTO_PKWARE_HEADERLEN)) == NULL) {
-	zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     header = _zip_buffer_data(ctx->buffer);
@@ -102,10 +102,10 @@
     /* generate header from random bytes and mtime
        see appnote.iz, XIII. Decryption, Step 2, last paragraph */
     if (!zip_secure_random(header, ZIP_CRYPTO_PKWARE_HEADERLEN - 1)) {
-	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	_zip_buffer_free(ctx->buffer);
-	ctx->buffer = NULL;
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+        _zip_buffer_free(ctx->buffer);
+        ctx->buffer = NULL;
+        return -1;
     }
     header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] = (zip_uint8_t)((dostime >> 8) & 0xff);
 
@@ -125,92 +125,92 @@
 
     switch (cmd) {
     case ZIP_SOURCE_OPEN:
-	ctx->eof = false;
+        ctx->eof = false;
 
-	/* initialize keys */
-	_zip_pkware_keys_reset(&ctx->keys);
-	_zip_pkware_encrypt(&ctx->keys, NULL, (const zip_uint8_t *)ctx->password, strlen(ctx->password));
+        /* initialize keys */
+        _zip_pkware_keys_reset(&ctx->keys);
+        _zip_pkware_encrypt(&ctx->keys, NULL, (const zip_uint8_t *)ctx->password, strlen(ctx->password));
 
-	if (encrypt_header(src, ctx) < 0) {
-	    return -1;
-	}
-	return 0;
+        if (encrypt_header(src, ctx) < 0) {
+            return -1;
+        }
+        return 0;
 
     case ZIP_SOURCE_READ:
-	buffer_n = 0;
+        buffer_n = 0;
 
-	if (ctx->buffer) {
-	    /* write header values to data */
-	    buffer_n = _zip_buffer_read(ctx->buffer, data, length);
-	    data = (zip_uint8_t *)data + buffer_n;
-	    length -= buffer_n;
+        if (ctx->buffer) {
+            /* write header values to data */
+            buffer_n = _zip_buffer_read(ctx->buffer, data, length);
+            data = (zip_uint8_t *)data + buffer_n;
+            length -= buffer_n;
 
-	    if (_zip_buffer_eof(ctx->buffer)) {
-		_zip_buffer_free(ctx->buffer);
-		ctx->buffer = NULL;
-	    }
-	}
+            if (_zip_buffer_eof(ctx->buffer)) {
+                _zip_buffer_free(ctx->buffer);
+                ctx->buffer = NULL;
+            }
+        }
 
-	if (ctx->eof) {
-	    return (zip_int64_t)buffer_n;
-	}
+        if (ctx->eof) {
+            return (zip_int64_t)buffer_n;
+        }
 
-	if ((n = zip_source_read(src, data, length)) < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
+        if ((n = zip_source_read(src, data, length)) < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
 
-	_zip_pkware_encrypt(&ctx->keys, (zip_uint8_t *)data, (zip_uint8_t *)data, (zip_uint64_t)n);
+        _zip_pkware_encrypt(&ctx->keys, (zip_uint8_t *)data, (zip_uint8_t *)data, (zip_uint64_t)n);
 
-	if ((zip_uint64_t)n < length) {
-	    ctx->eof = true;
-	}
+        if ((zip_uint64_t)n < length) {
+            ctx->eof = true;
+        }
 
-	return (zip_int64_t)buffer_n + n;
+        return (zip_int64_t)buffer_n + n;
 
     case ZIP_SOURCE_CLOSE:
-	_zip_buffer_free(ctx->buffer);
-	ctx->buffer = NULL;
-	return 0;
+        _zip_buffer_free(ctx->buffer);
+        ctx->buffer = NULL;
+        return 0;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
-	st->encryption_method = ZIP_EM_TRAD_PKWARE;
-	st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
-	if (st->valid & ZIP_STAT_COMP_SIZE) {
-	    st->comp_size += ZIP_CRYPTO_PKWARE_HEADERLEN;
-	}
+        st = (zip_stat_t *)data;
+        st->encryption_method = ZIP_EM_TRAD_PKWARE;
+        st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
+        if (st->valid & ZIP_STAT_COMP_SIZE) {
+            st->comp_size += ZIP_CRYPTO_PKWARE_HEADERLEN;
+        }
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {
-	zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
-	if (length < sizeof(*attributes)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
-	attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;
-	attributes->version_needed = 20;
+        zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
+        if (length < sizeof(*attributes)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
+        attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;
+        attributes->version_needed = 20;
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, length);
+        return zip_error_to_data(&ctx->error, data, length);
 
     case ZIP_SOURCE_FREE:
-	trad_pkware_free(ctx);
-	return 0;
+        trad_pkware_free(ctx);
+        return 0;
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 }
 
@@ -220,14 +220,14 @@
     struct trad_pkware *ctx;
 
     if ((ctx = (struct trad_pkware *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ctx->password = strdup(password)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	free(ctx);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        free(ctx);
+        return NULL;
     }
     ctx->buffer = NULL;
     zip_error_init(&ctx->error);
@@ -239,7 +239,7 @@
 static void
 trad_pkware_free(struct trad_pkware *ctx) {
     if (ctx == NULL) {
-	return;
+        return;
     }
 
     free(ctx->password);
diff --git a/lib/zip_source_read.c b/lib/zip_source_read.c
index 5da6008..c6fa612 100644
--- a/lib/zip_source_read.c
+++ b/lib/zip_source_read.c
@@ -41,50 +41,50 @@
     zip_int64_t n;
 
     if (src->source_closed) {
-	return -1;
+        return -1;
     }
     if (!ZIP_SOURCE_IS_OPEN_READING(src) || len > ZIP_INT64_MAX || (len > 0 && data == NULL)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (src->had_read_error) {
-	return -1;
+        return -1;
     }
 
     if (_zip_source_eof(src)) {
-	return 0;
+        return 0;
     }
 
     if (len == 0) {
-	return 0;
+        return 0;
     }
 
     bytes_read = 0;
     while (bytes_read < len) {
-	if ((n = _zip_source_call(src, (zip_uint8_t *)data + bytes_read, len - bytes_read, ZIP_SOURCE_READ)) < 0) {
-	    src->had_read_error = true;
-	    if (bytes_read == 0) {
-		return -1;
-	    }
-	    else {
-		return (zip_int64_t)bytes_read;
-	    }
-	}
+        if ((n = _zip_source_call(src, (zip_uint8_t *)data + bytes_read, len - bytes_read, ZIP_SOURCE_READ)) < 0) {
+            src->had_read_error = true;
+            if (bytes_read == 0) {
+                return -1;
+            }
+            else {
+                return (zip_int64_t)bytes_read;
+            }
+        }
 
-	if (n == 0) {
-	    src->eof = 1;
-	    break;
-	}
+        if (n == 0) {
+            src->eof = 1;
+            break;
+        }
 
-	bytes_read += (zip_uint64_t)n;
+        bytes_read += (zip_uint64_t)n;
     }
 
     if (src->bytes_read + bytes_read < src->bytes_read) {
-	src->bytes_read = ZIP_UINT64_MAX;
+        src->bytes_read = ZIP_UINT64_MAX;
     }
     else {
-	src->bytes_read += bytes_read;
+        src->bytes_read += bytes_read;
     }
     return (zip_int64_t)bytes_read;
 }
diff --git a/lib/zip_source_remove.c b/lib/zip_source_remove.c
index 14eddb8..fcfa4db 100644
--- a/lib/zip_source_remove.c
+++ b/lib/zip_source_remove.c
@@ -38,20 +38,20 @@
 int
 zip_source_remove(zip_source_t *src) {
     if (src->write_state == ZIP_SOURCE_WRITE_REMOVED) {
-	return 0;
+        return 0;
     }
 
     if (ZIP_SOURCE_IS_OPEN_READING(src)) {
-	if (zip_source_close(src) < 0) {
-	    return -1;
-	}
+        if (zip_source_close(src) < 0) {
+            return -1;
+        }
     }
     if (src->write_state != ZIP_SOURCE_WRITE_CLOSED) {
-	zip_source_rollback_write(src);
+        zip_source_rollback_write(src);
     }
 
     if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_REMOVE) < 0) {
-	return -1;
+        return -1;
     }
 
     src->write_state = ZIP_SOURCE_WRITE_REMOVED;
diff --git a/lib/zip_source_rollback_write.c b/lib/zip_source_rollback_write.c
index e8259bf..71fdd1d 100644
--- a/lib/zip_source_rollback_write.c
+++ b/lib/zip_source_rollback_write.c
@@ -38,7 +38,7 @@
 ZIP_EXTERN void
 zip_source_rollback_write(zip_source_t *src) {
     if (src->write_state != ZIP_SOURCE_WRITE_OPEN && src->write_state != ZIP_SOURCE_WRITE_FAILED) {
-	return;
+        return;
     }
 
     _zip_source_call(src, NULL, 0, ZIP_SOURCE_ROLLBACK_WRITE);
diff --git a/lib/zip_source_seek.c b/lib/zip_source_seek.c
index 163daf1..d90e4c5 100644
--- a/lib/zip_source_seek.c
+++ b/lib/zip_source_seek.c
@@ -40,18 +40,18 @@
     zip_source_args_seek_t args;
 
     if (src->source_closed) {
-	return -1;
+        return -1;
     }
     if (!ZIP_SOURCE_IS_OPEN_READING(src) || (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     args.offset = offset;
     args.whence = whence;
 
     if (_zip_source_call(src, &args, sizeof(args), ZIP_SOURCE_SEEK) < 0) {
-	return -1;
+        return -1;
     }
 
     src->eof = 0;
@@ -65,30 +65,30 @@
     zip_source_args_seek_t *args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, data_length, error);
 
     if (args == NULL) {
-	return -1;
+        return -1;
     }
 
     switch (args->whence) {
     case SEEK_CUR:
-	new_offset = (zip_int64_t)offset + args->offset;
-	break;
+        new_offset = (zip_int64_t)offset + args->offset;
+        break;
 
     case SEEK_END:
-	new_offset = (zip_int64_t)length + args->offset;
-	break;
+        new_offset = (zip_int64_t)length + args->offset;
+        break;
 
     case SEEK_SET:
-	new_offset = args->offset;
-	break;
+        new_offset = args->offset;
+        break;
 
     default:
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (new_offset < 0 || (zip_uint64_t)new_offset > length) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     return new_offset;
diff --git a/lib/zip_source_seek_write.c b/lib/zip_source_seek_write.c
index 6b0aa78..a561244 100644
--- a/lib/zip_source_seek_write.c
+++ b/lib/zip_source_seek_write.c
@@ -40,8 +40,8 @@
     zip_source_args_seek_t args;
 
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src) || (whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     args.offset = offset;
diff --git a/lib/zip_source_stat.c b/lib/zip_source_stat.c
index 3421d2c..1f78b8f 100644
--- a/lib/zip_source_stat.c
+++ b/lib/zip_source_stat.c
@@ -38,24 +38,24 @@
 ZIP_EXTERN int
 zip_source_stat(zip_source_t *src, zip_stat_t *st) {
     if (src->source_closed) {
-	return -1;
+        return -1;
     }
     if (st == NULL) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     zip_stat_init(st);
 
     if (ZIP_SOURCE_IS_LAYERED(src)) {
-	if (zip_source_stat(src->src, st) < 0) {
-	    _zip_error_set_from_source(&src->error, src->src);
-	    return -1;
-	}
+        if (zip_source_stat(src->src, st) < 0) {
+            _zip_error_set_from_source(&src->error, src->src);
+            return -1;
+        }
     }
 
     if (_zip_source_call(src, st, sizeof(*st), ZIP_SOURCE_STAT) < 0) {
-	return -1;
+        return -1;
     }
 
     return 0;
diff --git a/lib/zip_source_supports.c b/lib/zip_source_supports.c
index 8471559..a4c2959 100644
--- a/lib/zip_source_supports.c
+++ b/lib/zip_source_supports.c
@@ -53,11 +53,11 @@
 
     va_start(ap, cmd0);
     for (;;) {
-	int cmd = va_arg(ap, int);
-	if (cmd < 0) {
-	    break;
-	}
-	bitmap |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(cmd);
+        int cmd = va_arg(ap, int);
+        if (cmd < 0) {
+            break;
+        }
+        bitmap |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(cmd);
     }
     va_end(ap);
 
diff --git a/lib/zip_source_tell.c b/lib/zip_source_tell.c
index 3187d8e..5973f72 100644
--- a/lib/zip_source_tell.c
+++ b/lib/zip_source_tell.c
@@ -38,19 +38,19 @@
 ZIP_EXTERN zip_int64_t
 zip_source_tell(zip_source_t *src) {
     if (src->source_closed) {
-	return -1;
+        return -1;
     }
     if (!ZIP_SOURCE_IS_OPEN_READING(src)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if ((src->supports & (ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_TELL) | ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK))) == 0) {
-	if (src->bytes_read > ZIP_INT64_MAX) {
-	    zip_error_set(&src->error, ZIP_ER_TELL, EOVERFLOW);
-	    return -1;
-	}
-	return (zip_int64_t)src->bytes_read;
+        if (src->bytes_read > ZIP_INT64_MAX) {
+            zip_error_set(&src->error, ZIP_ER_TELL, EOVERFLOW);
+            return -1;
+        }
+        return (zip_int64_t)src->bytes_read;
     }
 
     return _zip_source_call(src, NULL, 0, ZIP_SOURCE_TELL);
diff --git a/lib/zip_source_tell_write.c b/lib/zip_source_tell_write.c
index 96ad7e2..1b59b48 100644
--- a/lib/zip_source_tell_write.c
+++ b/lib/zip_source_tell_write.c
@@ -38,8 +38,8 @@
 ZIP_EXTERN zip_int64_t
 zip_source_tell_write(zip_source_t *src) {
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src)) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     return _zip_source_call(src, NULL, 0, ZIP_SOURCE_TELL_WRITE);
diff --git a/lib/zip_source_window.c b/lib/zip_source_window.c
index d996015..9eab667 100644
--- a/lib/zip_source_window.c
+++ b/lib/zip_source_window.c
@@ -68,23 +68,23 @@
     struct window *ctx;
 
     if (src == NULL || start + length < start || (source_archive == NULL && source_index != 0)) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((ctx = (struct window *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     ctx->start = start;
     ctx->end = start + length;
     zip_stat_init(&ctx->stat);
     if (attributes != NULL) {
-	memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
+        memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
     }
     else {
-	zip_file_attributes_init(&ctx->attributes);
+        zip_file_attributes_init(&ctx->attributes);
     }
     ctx->source_archive = source_archive;
     ctx->source_index = source_index;
@@ -93,10 +93,10 @@
     ctx->needs_seek = (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK)) ? true : false;
 
     if (st) {
-	if (_zip_stat_merge(&ctx->stat, st, error) < 0) {
-	    free(ctx);
-	    return NULL;
-	}
+        if (_zip_stat_merge(&ctx->stat, st, error) < 0) {
+            free(ctx);
+            return NULL;
+        }
     }
 
     return zip_source_layered_create(src, window_read, ctx, error);
@@ -116,7 +116,7 @@
     src->source_closed = 1;
 
     if (zip_error_code_zip(&src->error) == ZIP_ER_OK) {
-	zip_error_set(&src->error, ZIP_ER_ZIPCLOSED, 0);
+        zip_error_set(&src->error, ZIP_ER_ZIPCLOSED, 0);
     }
 }
 
@@ -131,129 +131,129 @@
 
     switch (cmd) {
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	free(ctx);
-	return 0;
+        free(ctx);
+        return 0;
 
     case ZIP_SOURCE_OPEN:
-	if (ctx->source_archive) {
-	    zip_uint64_t offset;
+        if (ctx->source_archive) {
+            zip_uint64_t offset;
 
-	    if ((offset = _zip_file_get_offset(ctx->source_archive, ctx->source_index, &ctx->error)) == 0) {
-		return -1;
-	    }
-	    if (ctx->end + offset < ctx->end) {
-		/* zip archive data claims end of data past zip64 limits */
-		zip_error_set(&ctx->error, ZIP_ER_INCONS, 0);
-		return -1;
-	    }
-	    ctx->start += offset;
-	    ctx->end += offset;
-	    ctx->source_archive = NULL;
-	}
+            if ((offset = _zip_file_get_offset(ctx->source_archive, ctx->source_index, &ctx->error)) == 0) {
+                return -1;
+            }
+            if (ctx->end + offset < ctx->end) {
+                /* zip archive data claims end of data past zip64 limits */
+                zip_error_set(&ctx->error, ZIP_ER_INCONS, 0);
+                return -1;
+            }
+            ctx->start += offset;
+            ctx->end += offset;
+            ctx->source_archive = NULL;
+        }
 
-	if (!ctx->needs_seek) {
-	    DEFINE_BYTE_ARRAY(b, BUFSIZE);
+        if (!ctx->needs_seek) {
+            DEFINE_BYTE_ARRAY(b, BUFSIZE);
 
-	    if (!byte_array_init(b, BUFSIZE)) {
-		zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
+            if (!byte_array_init(b, BUFSIZE)) {
+                zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
 
-	    for (n = 0; n < ctx->start; n += (zip_uint64_t)ret) {
-		i = (ctx->start - n > BUFSIZE ? BUFSIZE : ctx->start - n);
-		if ((ret = zip_source_read(src, b, i)) < 0) {
-		    _zip_error_set_from_source(&ctx->error, src);
-		    byte_array_fini(b);
-		    return -1;
-		}
-		if (ret == 0) {
-		    zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
-		    byte_array_fini(b);
-		    return -1;
-		}
-	    }
+            for (n = 0; n < ctx->start; n += (zip_uint64_t)ret) {
+                i = (ctx->start - n > BUFSIZE ? BUFSIZE : ctx->start - n);
+                if ((ret = zip_source_read(src, b, i)) < 0) {
+                    _zip_error_set_from_source(&ctx->error, src);
+                    byte_array_fini(b);
+                    return -1;
+                }
+                if (ret == 0) {
+                    zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
+                    byte_array_fini(b);
+                    return -1;
+                }
+            }
 
-	    byte_array_fini(b);
-	}
+            byte_array_fini(b);
+        }
 
-	ctx->offset = ctx->start;
-	return 0;
+        ctx->offset = ctx->start;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	if (len > ctx->end - ctx->offset)
-	    len = ctx->end - ctx->offset;
+        if (len > ctx->end - ctx->offset)
+            len = ctx->end - ctx->offset;
 
-	if (len == 0)
-	    return 0;
+        if (len == 0)
+            return 0;
 
-	if (ctx->needs_seek) {
-	    if (zip_source_seek(src, (zip_int64_t)ctx->offset, SEEK_SET) < 0) {
-		_zip_error_set_from_source(&ctx->error, src);
-		return -1;
-	    }
-	}
+        if (ctx->needs_seek) {
+            if (zip_source_seek(src, (zip_int64_t)ctx->offset, SEEK_SET) < 0) {
+                _zip_error_set_from_source(&ctx->error, src);
+                return -1;
+            }
+        }
 
-	if ((ret = zip_source_read(src, data, len)) < 0) {
-	    zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
-	    return -1;
-	}
+        if ((ret = zip_source_read(src, data, len)) < 0) {
+            zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
+            return -1;
+        }
 
-	ctx->offset += (zip_uint64_t)ret;
+        ctx->offset += (zip_uint64_t)ret;
 
-	if (ret == 0) {
-	    if (ctx->offset < ctx->end) {
-		zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
-		return -1;
-	    }
-	}
-	return ret;
+        if (ret == 0) {
+            if (ctx->offset < ctx->end) {
+                zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
+                return -1;
+            }
+        }
+        return ret;
 
     case ZIP_SOURCE_SEEK: {
-	zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset - ctx->start, ctx->end - ctx->start, data, len, &ctx->error);
+        zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset - ctx->start, ctx->end - ctx->start, data, len, &ctx->error);
 
-	if (new_offset < 0) {
-	    return -1;
-	}
+        if (new_offset < 0) {
+            return -1;
+        }
 
-	ctx->offset = (zip_uint64_t)new_offset + ctx->start;
-	return 0;
+        ctx->offset = (zip_uint64_t)new_offset + ctx->start;
+        return 0;
     }
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
+        st = (zip_stat_t *)data;
 
-	if (_zip_stat_merge(st, &ctx->stat, &ctx->error) < 0) {
-	    return -1;
-	}
-	return 0;
+        if (_zip_stat_merge(st, &ctx->stat, &ctx->error) < 0) {
+            return -1;
+        }
+        return 0;
     }
 
     case ZIP_SOURCE_GET_FILE_ATTRIBUTES:
-	if (len < sizeof(ctx->attributes)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
+        if (len < sizeof(ctx->attributes)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
 
-	memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
-	return sizeof(ctx->attributes);
+        memcpy(data, &ctx->attributes, sizeof(ctx->attributes));
+        return sizeof(ctx->attributes);
 
     case ZIP_SOURCE_SUPPORTS:
-	return ctx->supports;
+        return ctx->supports;
 
     case ZIP_SOURCE_TELL:
-	return (zip_int64_t)(ctx->offset - ctx->start);
+        return (zip_int64_t)(ctx->offset - ctx->start);
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 }
 
@@ -263,11 +263,11 @@
     unsigned int i;
 
     for (i = 0; i < za->nopen_source; i++) {
-	if (za->open_source[i] == src) {
-	    za->open_source[i] = za->open_source[za->nopen_source - 1];
-	    za->nopen_source--;
-	    break;
-	}
+        if (za->open_source[i] == src) {
+            za->open_source[i] = za->open_source[za->nopen_source - 1];
+            za->nopen_source--;
+            break;
+        }
     }
 }
 
@@ -277,15 +277,15 @@
     zip_source_t **open_source;
 
     if (za->nopen_source + 1 >= za->nopen_source_alloc) {
-	unsigned int n;
-	n = za->nopen_source_alloc + 10;
-	open_source = (zip_source_t **)realloc(za->open_source, n * sizeof(zip_source_t *));
-	if (open_source == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
-	za->nopen_source_alloc = n;
-	za->open_source = open_source;
+        unsigned int n;
+        n = za->nopen_source_alloc + 10;
+        open_source = (zip_source_t **)realloc(za->open_source, n * sizeof(zip_source_t *));
+        if (open_source == NULL) {
+            zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
+        za->nopen_source_alloc = n;
+        za->open_source = open_source;
     }
 
     za->open_source[za->nopen_source++] = src;
diff --git a/lib/zip_source_winzip_aes_decode.c b/lib/zip_source_winzip_aes_decode.c
index 2ee626a..95a16b7 100644
--- a/lib/zip_source_winzip_aes_decode.c
+++ b/lib/zip_source_winzip_aes_decode.c
@@ -63,35 +63,35 @@
     struct winzip_aes *ctx;
 
     if ((encryption_method != ZIP_EM_AES_128 && encryption_method != ZIP_EM_AES_192 && encryption_method != ZIP_EM_AES_256) || password == NULL || src == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
     if (flags & ZIP_CODEC_ENCODE) {
-	zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+        return NULL;
     }
 
     if (zip_source_stat(src, &st) != 0) {
-	_zip_error_set_from_source(&za->error, src);
-	return NULL;
+        _zip_error_set_from_source(&za->error, src);
+        return NULL;
     }
 
     aux_length = WINZIP_AES_PASSWORD_VERIFY_LENGTH + SALT_LENGTH(encryption_method) + HMAC_LENGTH;
 
     if ((st.valid & ZIP_STAT_COMP_SIZE) == 0 || st.comp_size < aux_length) {
-	zip_error_set(&za->error, ZIP_ER_OPNOTSUPP, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_OPNOTSUPP, 0);
+        return NULL;
     }
 
     if ((ctx = winzip_aes_new(encryption_method, password, &za->error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     ctx->data_length = st.comp_size - aux_length;
 
     if ((s2 = zip_source_layered(za, src, winzip_aes_decrypt, ctx)) == NULL) {
-	winzip_aes_free(ctx);
-	return NULL;
+        winzip_aes_free(ctx);
+        return NULL;
     }
 
     return s2;
@@ -107,23 +107,23 @@
 
     headerlen = WINZIP_AES_PASSWORD_VERIFY_LENGTH + SALT_LENGTH(ctx->encryption_method);
     if ((n = zip_source_read(src, header, headerlen)) < 0) {
-	_zip_error_set_from_source(&ctx->error, src);
-	return -1;
+        _zip_error_set_from_source(&ctx->error, src);
+        return -1;
     }
 
     if (n != headerlen) {
-	zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_EOF, 0);
+        return -1;
     }
 
     if ((ctx->aes_ctx = _zip_winzip_aes_new((zip_uint8_t *)ctx->password, strlen(ctx->password), header, ctx->encryption_method, password_verification, &ctx->error)) == NULL) {
-	return -1;
+        return -1;
     }
     if (memcmp(password_verification, header + SALT_LENGTH(ctx->encryption_method), WINZIP_AES_PASSWORD_VERIFY_LENGTH) != 0) {
-	_zip_winzip_aes_free(ctx->aes_ctx);
-	ctx->aes_ctx = NULL;
-	zip_error_set(&ctx->error, ZIP_ER_WRONGPASSWD, 0);
-	return -1;
+        _zip_winzip_aes_free(ctx->aes_ctx);
+        ctx->aes_ctx = NULL;
+        zip_error_set(&ctx->error, ZIP_ER_WRONGPASSWD, 0);
+        return -1;
     }
     return 0;
 }
@@ -133,20 +133,20 @@
 verify_hmac(zip_source_t *src, struct winzip_aes *ctx) {
     unsigned char computed[SHA1_LENGTH], from_file[HMAC_LENGTH];
     if (zip_source_read(src, from_file, HMAC_LENGTH) < HMAC_LENGTH) {
-	_zip_error_set_from_source(&ctx->error, src);
-	return false;
+        _zip_error_set_from_source(&ctx->error, src);
+        return false;
     }
 
     if (!_zip_winzip_aes_finish(ctx->aes_ctx, computed)) {
-	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+        return false;
     }
     _zip_winzip_aes_free(ctx->aes_ctx);
     ctx->aes_ctx = NULL;
 
     if (memcmp(from_file, computed, HMAC_LENGTH) != 0) {
-	zip_error_set(&ctx->error, ZIP_ER_CRC, 0);
-	return false;
+        zip_error_set(&ctx->error, ZIP_ER_CRC, 0);
+        return false;
     }
 
     return true;
@@ -162,67 +162,67 @@
 
     switch (cmd) {
     case ZIP_SOURCE_OPEN:
-	if (decrypt_header(src, ctx) < 0) {
-	    return -1;
-	}
-	ctx->current_position = 0;
-	return 0;
+        if (decrypt_header(src, ctx) < 0) {
+            return -1;
+        }
+        ctx->current_position = 0;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	if (len > ctx->data_length - ctx->current_position) {
-	    len = ctx->data_length - ctx->current_position;
-	}
+        if (len > ctx->data_length - ctx->current_position) {
+            len = ctx->data_length - ctx->current_position;
+        }
 
-	if (len == 0) {
-	    if (!verify_hmac(src, ctx)) {
-		return -1;
-	    }
-	    return 0;
-	}
+        if (len == 0) {
+            if (!verify_hmac(src, ctx)) {
+                return -1;
+            }
+            return 0;
+        }
 
-	if ((n = zip_source_read(src, data, len)) < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
-	ctx->current_position += (zip_uint64_t)n;
+        if ((n = zip_source_read(src, data, len)) < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
+        ctx->current_position += (zip_uint64_t)n;
 
-	if (!_zip_winzip_aes_decrypt(ctx->aes_ctx, (zip_uint8_t *)data, (zip_uint64_t)n)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	    return -1;
-	}
+        if (!_zip_winzip_aes_decrypt(ctx->aes_ctx, (zip_uint8_t *)data, (zip_uint64_t)n)) {
+            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+            return -1;
+        }
 
-	return n;
+        return n;
 
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
+        st = (zip_stat_t *)data;
 
-	st->encryption_method = ZIP_EM_NONE;
-	st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
-	if (st->valid & ZIP_STAT_COMP_SIZE) {
-	    st->comp_size -= 12 + SALT_LENGTH(ctx->encryption_method);
-	}
+        st->encryption_method = ZIP_EM_NONE;
+        st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
+        if (st->valid & ZIP_STAT_COMP_SIZE) {
+            st->comp_size -= 12 + SALT_LENGTH(ctx->encryption_method);
+        }
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, -1);
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, len);
+        return zip_error_to_data(&ctx->error, data, len);
 
     case ZIP_SOURCE_FREE:
-	winzip_aes_free(ctx);
-	return 0;
+        winzip_aes_free(ctx);
+        return 0;
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 }
 
@@ -230,7 +230,7 @@
 static void
 winzip_aes_free(struct winzip_aes *ctx) {
     if (ctx == NULL) {
-	return;
+        return;
     }
 
     _zip_crypto_clear(ctx->password, strlen(ctx->password));
@@ -246,14 +246,14 @@
     struct winzip_aes *ctx;
 
     if ((ctx = (struct winzip_aes *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ctx->password = strdup(password)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	free(ctx);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        free(ctx);
+        return NULL;
     }
 
     ctx->encryption_method = encryption_method;
diff --git a/lib/zip_source_winzip_aes_encode.c b/lib/zip_source_winzip_aes_encode.c
index f9ae555..88e791f 100644
--- a/lib/zip_source_winzip_aes_encode.c
+++ b/lib/zip_source_winzip_aes_encode.c
@@ -63,17 +63,17 @@
     struct winzip_aes *ctx;
 
     if ((encryption_method != ZIP_EM_AES_128 && encryption_method != ZIP_EM_AES_192 && encryption_method != ZIP_EM_AES_256) || password == NULL || src == NULL) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((ctx = winzip_aes_new(encryption_method, password, &za->error)) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     if ((s2 = zip_source_layered(za, src, winzip_aes_encrypt, ctx)) == NULL) {
-	winzip_aes_free(ctx);
-	return NULL;
+        winzip_aes_free(ctx);
+        return NULL;
     }
 
     return s2;
@@ -84,19 +84,19 @@
 encrypt_header(zip_source_t *src, struct winzip_aes *ctx) {
     zip_uint16_t salt_length = SALT_LENGTH(ctx->encryption_method);
     if (!zip_secure_random(ctx->data, salt_length)) {
-	zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+        return -1;
     }
 
     if ((ctx->aes_ctx = _zip_winzip_aes_new((zip_uint8_t *)ctx->password, strlen(ctx->password), ctx->data, ctx->encryption_method, ctx->data + salt_length, &ctx->error)) == NULL) {
-	return -1;
+        return -1;
     }
 
     if ((ctx->buffer = _zip_buffer_new(ctx->data, salt_length + WINZIP_AES_PASSWORD_VERIFY_LENGTH)) == NULL) {
-	_zip_winzip_aes_free(ctx->aes_ctx);
-	ctx->aes_ctx = NULL;
-	zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-	return -1;
+        _zip_winzip_aes_free(ctx->aes_ctx);
+        ctx->aes_ctx = NULL;
+        zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     return 0;
@@ -113,102 +113,102 @@
 
     switch (cmd) {
     case ZIP_SOURCE_OPEN:
-	ctx->eof = false;
-	if (encrypt_header(src, ctx) < 0) {
-	    return -1;
-	}
-	return 0;
+        ctx->eof = false;
+        if (encrypt_header(src, ctx) < 0) {
+            return -1;
+        }
+        return 0;
 
     case ZIP_SOURCE_READ:
-	buffer_n = 0;
+        buffer_n = 0;
 
-	if (ctx->buffer) {
-	    buffer_n = _zip_buffer_read(ctx->buffer, data, length);
+        if (ctx->buffer) {
+            buffer_n = _zip_buffer_read(ctx->buffer, data, length);
 
-	    data = (zip_uint8_t *)data + buffer_n;
-	    length -= buffer_n;
+            data = (zip_uint8_t *)data + buffer_n;
+            length -= buffer_n;
 
-	    if (_zip_buffer_eof(ctx->buffer)) {
-		_zip_buffer_free(ctx->buffer);
-		ctx->buffer = NULL;
-	    }
-	}
+            if (_zip_buffer_eof(ctx->buffer)) {
+                _zip_buffer_free(ctx->buffer);
+                ctx->buffer = NULL;
+            }
+        }
 
-	if (ctx->eof) {
-	    return (zip_int64_t)buffer_n;
-	}
+        if (ctx->eof) {
+            return (zip_int64_t)buffer_n;
+        }
 
-	if ((ret = zip_source_read(src, data, length)) < 0) {
-	    _zip_error_set_from_source(&ctx->error, src);
-	    return -1;
-	}
+        if ((ret = zip_source_read(src, data, length)) < 0) {
+            _zip_error_set_from_source(&ctx->error, src);
+            return -1;
+        }
 
-	if (!_zip_winzip_aes_encrypt(ctx->aes_ctx, data, (zip_uint64_t)ret)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-	    /* TODO: return partial read? */
-	    return -1;
-	}
+        if (!_zip_winzip_aes_encrypt(ctx->aes_ctx, data, (zip_uint64_t)ret)) {
+            zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+            /* TODO: return partial read? */
+            return -1;
+        }
 
-	if ((zip_uint64_t)ret < length) {
-	    ctx->eof = true;
-	    if (!_zip_winzip_aes_finish(ctx->aes_ctx, ctx->data)) {
-		zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
-		/* TODO: return partial read? */
-		return -1;
-	    }
-	    _zip_winzip_aes_free(ctx->aes_ctx);
-	    ctx->aes_ctx = NULL;
-	    if ((ctx->buffer = _zip_buffer_new(ctx->data, HMAC_LENGTH)) == NULL) {
-		zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
-		/* TODO: return partial read? */
-		return -1;
-	    }
-	    buffer_n += _zip_buffer_read(ctx->buffer, (zip_uint8_t *)data + ret, length - (zip_uint64_t)ret);
-	}
+        if ((zip_uint64_t)ret < length) {
+            ctx->eof = true;
+            if (!_zip_winzip_aes_finish(ctx->aes_ctx, ctx->data)) {
+                zip_error_set(&ctx->error, ZIP_ER_INTERNAL, 0);
+                /* TODO: return partial read? */
+                return -1;
+            }
+            _zip_winzip_aes_free(ctx->aes_ctx);
+            ctx->aes_ctx = NULL;
+            if ((ctx->buffer = _zip_buffer_new(ctx->data, HMAC_LENGTH)) == NULL) {
+                zip_error_set(&ctx->error, ZIP_ER_MEMORY, 0);
+                /* TODO: return partial read? */
+                return -1;
+            }
+            buffer_n += _zip_buffer_read(ctx->buffer, (zip_uint8_t *)data + ret, length - (zip_uint64_t)ret);
+        }
 
-	return (zip_int64_t)(buffer_n + (zip_uint64_t)ret);
+        return (zip_int64_t)(buffer_n + (zip_uint64_t)ret);
 
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st;
+        zip_stat_t *st;
 
-	st = (zip_stat_t *)data;
-	st->encryption_method = ctx->encryption_method;
-	st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
-	if (st->valid & ZIP_STAT_COMP_SIZE) {
-	    st->comp_size += 12 + SALT_LENGTH(ctx->encryption_method);
-	}
+        st = (zip_stat_t *)data;
+        st->encryption_method = ctx->encryption_method;
+        st->valid |= ZIP_STAT_ENCRYPTION_METHOD;
+        if (st->valid & ZIP_STAT_COMP_SIZE) {
+            st->comp_size += 12 + SALT_LENGTH(ctx->encryption_method);
+        }
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {
-	zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
-	if (length < sizeof(*attributes)) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
-	attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;
-	attributes->version_needed = 51;
+        zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;
+        if (length < sizeof(*attributes)) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
+        attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;
+        attributes->version_needed = 51;
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, length);
+        return zip_error_to_data(&ctx->error, data, length);
 
     case ZIP_SOURCE_FREE:
-	winzip_aes_free(ctx);
-	return 0;
+        winzip_aes_free(ctx);
+        return 0;
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 }
 
@@ -216,7 +216,7 @@
 static void
 winzip_aes_free(struct winzip_aes *ctx) {
     if (ctx == NULL) {
-	return;
+        return;
     }
 
     _zip_crypto_clear(ctx->password, strlen(ctx->password));
@@ -233,14 +233,14 @@
     struct winzip_aes *ctx;
 
     if ((ctx = (struct winzip_aes *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ctx->password = strdup(password)) == NULL) {
-	free(ctx);
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        free(ctx);
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     ctx->encryption_method = encryption_method;
diff --git a/lib/zip_source_write.c b/lib/zip_source_write.c
index 73fc3a3..3cac689 100644
--- a/lib/zip_source_write.c
+++ b/lib/zip_source_write.c
@@ -38,8 +38,8 @@
 ZIP_EXTERN zip_int64_t
 zip_source_write(zip_source_t *src, const void *data, zip_uint64_t length) {
     if (!ZIP_SOURCE_IS_OPEN_WRITING(src) || length > ZIP_INT64_MAX) {
-	zip_error_set(&src->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&src->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     return _zip_source_call(src, (void *)data, length, ZIP_SOURCE_WRITE);
diff --git a/lib/zip_source_zip.c b/lib/zip_source_zip.c
index 8a7feaa..075eab1 100644
--- a/lib/zip_source_zip.c
+++ b/lib/zip_source_zip.c
@@ -40,17 +40,17 @@
 ZIP_EXTERN zip_source_t *
 zip_source_zip(zip_t *za, zip_t *srcza, zip_uint64_t srcidx, zip_flags_t flags, zip_uint64_t start, zip_int64_t len) {
     if (len < -1) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if (len == -1)
-	len = 0;
+        len = 0;
 
     if (start == 0 && len == 0)
-	flags |= ZIP_FL_COMPRESSED;
+        flags |= ZIP_FL_COMPRESSED;
     else
-	flags &= ~ZIP_FL_COMPRESSED;
+        flags &= ~ZIP_FL_COMPRESSED;
 
     return _zip_source_zip_new(za, srcza, srcidx, flags, start, (zip_uint64_t)len, NULL);
 }
diff --git a/lib/zip_source_zip_new.c b/lib/zip_source_zip_new.c
index 6d547f0..733d155 100644
--- a/lib/zip_source_zip_new.c
+++ b/lib/zip_source_zip_new.c
@@ -47,41 +47,41 @@
     bool partial_data, needs_crc, needs_decrypt, needs_decompress;
 
     if (za == NULL) {
-	return NULL;
+        return NULL;
     }
 
     if (srcza == NULL || srcidx >= srcza->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((flags & ZIP_FL_UNCHANGED) == 0 && (ZIP_ENTRY_DATA_CHANGED(srcza->entry + srcidx) || srcza->entry[srcidx].deleted)) {
-	zip_error_set(&za->error, ZIP_ER_CHANGED, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_CHANGED, 0);
+        return NULL;
     }
 
     if (zip_stat_index(srcza, srcidx, flags | ZIP_FL_UNCHANGED, &st) < 0) {
-	zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
+        return NULL;
     }
 
     if (flags & ZIP_FL_ENCRYPTED) {
-	flags |= ZIP_FL_COMPRESSED;
+        flags |= ZIP_FL_COMPRESSED;
     }
 
     if ((start > 0 || len > 0) && (flags & ZIP_FL_COMPRESSED)) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     /* overflow or past end of file */
     if ((start > 0 || len > 0) && (start + len < start || start + len > st.size)) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if (len == 0) {
-	len = st.size - start;
+        len = st.size - start;
     }
 
     partial_data = len < st.size;
@@ -91,89 +91,89 @@
     needs_crc = ((flags & ZIP_FL_COMPRESSED) == 0 || st.comp_method == ZIP_CM_STORE) && !partial_data;
 
     if (needs_decrypt) {
-	if (password == NULL) {
-	    password = za->default_password;
-	}
-	if (password == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_NOPASSWD, 0);
-	    return NULL;
-	}
+        if (password == NULL) {
+            password = za->default_password;
+        }
+        if (password == NULL) {
+            zip_error_set(&za->error, ZIP_ER_NOPASSWD, 0);
+            return NULL;
+        }
     }
 
     if ((de = _zip_get_dirent(srcza, srcidx, flags, &za->error)) == NULL) {
-	return NULL;
+        return NULL;
     }
     _zip_file_attributes_from_dirent(&attributes, de);
 
     if (st.comp_size == 0) {
-	return zip_source_buffer_with_attributes(za, NULL, 0, 0, &attributes);
+        return zip_source_buffer_with_attributes(za, NULL, 0, 0, &attributes);
     }
 
     if (partial_data && !needs_decrypt && !needs_decompress) {
-	struct zip_stat st2;
+        struct zip_stat st2;
 
-	st2.size = len;
-	st2.comp_size = len;
-	st2.comp_method = ZIP_CM_STORE;
-	st2.mtime = st.mtime;
-	st2.valid = ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_MTIME;
+        st2.size = len;
+        st2.comp_size = len;
+        st2.comp_method = ZIP_CM_STORE;
+        st2.mtime = st.mtime;
+        st2.valid = ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_MTIME;
 
-	if ((src = _zip_source_window_new(srcza->src, start, len, &st2, &attributes, srcza, srcidx, &za->error)) == NULL) {
-	    return NULL;
-	}
+        if ((src = _zip_source_window_new(srcza->src, start, len, &st2, &attributes, srcza, srcidx, &za->error)) == NULL) {
+            return NULL;
+        }
     }
     else {
-	if ((src = _zip_source_window_new(srcza->src, 0, st.comp_size, &st, &attributes, srcza, srcidx, &za->error)) == NULL) {
-	    return NULL;
-	}
+        if ((src = _zip_source_window_new(srcza->src, 0, st.comp_size, &st, &attributes, srcza, srcidx, &za->error)) == NULL) {
+            return NULL;
+        }
     }
 
     if (_zip_source_set_source_archive(src, srcza) < 0) {
-	zip_source_free(src);
-	return NULL;
+        zip_source_free(src);
+        return NULL;
     }
 
     /* creating a layered source calls zip_keep() on the lower layer, so we free it */
 
     if (needs_decrypt) {
-	zip_encryption_implementation enc_impl;
+        zip_encryption_implementation enc_impl;
 
-	if ((enc_impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
-	    zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
-	    return NULL;
-	}
+        if ((enc_impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
+            zip_error_set(&za->error, ZIP_ER_ENCRNOTSUPP, 0);
+            return NULL;
+        }
 
-	s2 = enc_impl(za, src, st.encryption_method, 0, password);
-	zip_source_free(src);
-	if (s2 == NULL) {
-	    return NULL;
-	}
-	src = s2;
+        s2 = enc_impl(za, src, st.encryption_method, 0, password);
+        zip_source_free(src);
+        if (s2 == NULL) {
+            return NULL;
+        }
+        src = s2;
     }
     if (needs_decompress) {
-	s2 = zip_source_decompress(za, src, st.comp_method);
-	zip_source_free(src);
-	if (s2 == NULL) {
-	    return NULL;
-	}
-	src = s2;
+        s2 = zip_source_decompress(za, src, st.comp_method);
+        zip_source_free(src);
+        if (s2 == NULL) {
+            return NULL;
+        }
+        src = s2;
     }
     if (needs_crc) {
-	s2 = zip_source_crc(za, src, 1);
-	zip_source_free(src);
-	if (s2 == NULL) {
-	    return NULL;
-	}
-	src = s2;
+        s2 = zip_source_crc(za, src, 1);
+        zip_source_free(src);
+        if (s2 == NULL) {
+            return NULL;
+        }
+        src = s2;
     }
 
     if (partial_data && (needs_decrypt || needs_decompress)) {
-	s2 = zip_source_window(za, src, start, len);
-	zip_source_free(src);
-	if (s2 == NULL) {
-	    return NULL;
-	}
-	src = s2;
+        s2 = zip_source_window(za, src, start, len);
+        zip_source_free(src);
+        if (s2 == NULL) {
+            return NULL;
+        }
+        src = s2;
     }
 
     return src;
diff --git a/lib/zip_stat.c b/lib/zip_stat.c
index 341c6f7..dd3ef5c 100644
--- a/lib/zip_stat.c
+++ b/lib/zip_stat.c
@@ -40,7 +40,7 @@
     zip_int64_t idx;
 
     if ((idx = zip_name_locate(za, fname, flags)) < 0)
-	return -1;
+        return -1;
 
     return zip_stat_index(za, (zip_uint64_t)idx, flags, st);
 }
diff --git a/lib/zip_stat_index.c b/lib/zip_stat_index.c
index 7799325..0f8bead 100644
--- a/lib/zip_stat_index.c
+++ b/lib/zip_stat_index.c
@@ -41,35 +41,35 @@
     zip_dirent_t *de;
 
     if ((de = _zip_get_dirent(za, index, flags, NULL)) == NULL)
-	return -1;
+        return -1;
 
     if ((name = zip_get_name(za, index, flags)) == NULL)
-	return -1;
+        return -1;
 
 
     if ((flags & ZIP_FL_UNCHANGED) == 0 && ZIP_ENTRY_DATA_CHANGED(za->entry + index)) {
-	zip_entry_t *entry = za->entry + index;
+        zip_entry_t *entry = za->entry + index;
 
-	if (zip_source_stat(entry->source, st) < 0) {
-	    zip_error_set(&za->error, ZIP_ER_CHANGED, 0);
-	    return -1;
-	}
+        if (zip_source_stat(entry->source, st) < 0) {
+            zip_error_set(&za->error, ZIP_ER_CHANGED, 0);
+            return -1;
+        }
 
-	if (entry->changes->changed & ZIP_DIRENT_LAST_MOD) {
-	    st->mtime = de->last_mod;
-	    st->valid |= ZIP_STAT_MTIME;
-	}
+        if (entry->changes->changed & ZIP_DIRENT_LAST_MOD) {
+            st->mtime = de->last_mod;
+            st->valid |= ZIP_STAT_MTIME;
+        }
     }
     else {
-	zip_stat_init(st);
+        zip_stat_init(st);
 
-	st->crc = de->crc;
-	st->size = de->uncomp_size;
-	st->mtime = de->last_mod;
-	st->comp_size = de->comp_size;
-	st->comp_method = (zip_uint16_t)de->comp_method;
-	st->encryption_method = de->encryption_method;
-	st->valid = (de->crc_valid ? ZIP_STAT_CRC : 0) | ZIP_STAT_SIZE | ZIP_STAT_MTIME | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
+        st->crc = de->crc;
+        st->size = de->uncomp_size;
+        st->mtime = de->last_mod;
+        st->comp_size = de->comp_size;
+        st->comp_method = (zip_uint16_t)de->comp_method;
+        st->encryption_method = de->encryption_method;
+        st->valid = (de->crc_valid ? ZIP_STAT_CRC : 0) | ZIP_STAT_SIZE | ZIP_STAT_MTIME | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_ENCRYPTION_METHOD;
     }
 
     st->index = index;
diff --git a/lib/zip_stat_init.c b/lib/zip_stat_init.c
index 6d0903d..2598794 100644
--- a/lib/zip_stat_init.c
+++ b/lib/zip_stat_init.c
@@ -54,28 +54,28 @@
 _zip_stat_merge(zip_stat_t *dst, const zip_stat_t *src, zip_error_t *error) {
     /* name is not merged, since zip_stat_t doesn't own it, and src may not be valid as long as dst */
     if (src->valid & ZIP_STAT_INDEX) {
-	dst->index = src->index;
+        dst->index = src->index;
     }
     if (src->valid & ZIP_STAT_SIZE) {
-	dst->size = src->size;
+        dst->size = src->size;
     }
     if (src->valid & ZIP_STAT_COMP_SIZE) {
-	dst->comp_size = src->comp_size;
+        dst->comp_size = src->comp_size;
     }
     if (src->valid & ZIP_STAT_MTIME) {
-	dst->mtime = src->mtime;
+        dst->mtime = src->mtime;
     }
     if (src->valid & ZIP_STAT_CRC) {
-	dst->crc = src->crc;
+        dst->crc = src->crc;
     }
     if (src->valid & ZIP_STAT_COMP_METHOD) {
-	dst->comp_method = src->comp_method;
+        dst->comp_method = src->comp_method;
     }
     if (src->valid & ZIP_STAT_ENCRYPTION_METHOD) {
-	dst->encryption_method = src->encryption_method;
+        dst->encryption_method = src->encryption_method;
     }
     if (src->valid & ZIP_STAT_FLAGS) {
-	dst->flags = src->flags;
+        dst->flags = src->flags;
     }
     dst->valid |= src->valid;
 
diff --git a/lib/zip_string.c b/lib/zip_string.c
index 122721d..b8ff74d 100644
--- a/lib/zip_string.c
+++ b/lib/zip_string.c
@@ -45,7 +45,7 @@
     crc = (zip_uint32_t)crc32(0L, Z_NULL, 0);
 
     if (s != NULL)
-	crc = (zip_uint32_t)crc32(crc, s->raw, s->length);
+        crc = (zip_uint32_t)crc32(crc, s->raw, s->length);
 
     return crc;
 }
@@ -54,10 +54,10 @@
 int
 _zip_string_equal(const zip_string_t *a, const zip_string_t *b) {
     if (a == NULL || b == NULL)
-	return a == b;
+        return a == b;
 
     if (a->length != b->length)
-	return 0;
+        return 0;
 
     /* TODO: encoding */
 
@@ -68,7 +68,7 @@
 void
 _zip_string_free(zip_string_t *s) {
     if (s == NULL)
-	return;
+        return;
 
     free(s->raw);
     free(s->converted);
@@ -81,29 +81,29 @@
     static const zip_uint8_t empty[1] = "";
 
     if (string == NULL) {
-	if (lenp)
-	    *lenp = 0;
-	return empty;
+        if (lenp)
+            *lenp = 0;
+        return empty;
     }
 
     if ((flags & ZIP_FL_ENC_RAW) == 0) {
-	/* start guessing */
-	if (string->encoding == ZIP_ENCODING_UNKNOWN)
-	    _zip_guess_encoding(string, ZIP_ENCODING_UNKNOWN);
+        /* start guessing */
+        if (string->encoding == ZIP_ENCODING_UNKNOWN)
+            _zip_guess_encoding(string, ZIP_ENCODING_UNKNOWN);
 
-	if (((flags & ZIP_FL_ENC_STRICT) && string->encoding != ZIP_ENCODING_ASCII && string->encoding != ZIP_ENCODING_UTF8_KNOWN) || (string->encoding == ZIP_ENCODING_CP437)) {
-	    if (string->converted == NULL) {
-		if ((string->converted = _zip_cp437_to_utf8(string->raw, string->length, &string->converted_length, error)) == NULL)
-		    return NULL;
-	    }
-	    if (lenp)
-		*lenp = string->converted_length;
-	    return string->converted;
-	}
+        if (((flags & ZIP_FL_ENC_STRICT) && string->encoding != ZIP_ENCODING_ASCII && string->encoding != ZIP_ENCODING_UTF8_KNOWN) || (string->encoding == ZIP_ENCODING_CP437)) {
+            if (string->converted == NULL) {
+                if ((string->converted = _zip_cp437_to_utf8(string->raw, string->length, &string->converted_length, error)) == NULL)
+                    return NULL;
+            }
+            if (lenp)
+                *lenp = string->converted_length;
+            return string->converted;
+        }
     }
 
     if (lenp)
-	*lenp = string->length;
+        *lenp = string->length;
     return string->raw;
 }
 
@@ -111,7 +111,7 @@
 zip_uint16_t
 _zip_string_length(const zip_string_t *s) {
     if (s == NULL)
-	return 0;
+        return 0;
 
     return s->length;
 }
@@ -123,31 +123,31 @@
     zip_encoding_type_t expected_encoding;
 
     if (length == 0)
-	return NULL;
+        return NULL;
 
     switch (flags & ZIP_FL_ENCODING_ALL) {
     case ZIP_FL_ENC_GUESS:
-	expected_encoding = ZIP_ENCODING_UNKNOWN;
-	break;
+        expected_encoding = ZIP_ENCODING_UNKNOWN;
+        break;
     case ZIP_FL_ENC_UTF_8:
-	expected_encoding = ZIP_ENCODING_UTF8_KNOWN;
-	break;
+        expected_encoding = ZIP_ENCODING_UTF8_KNOWN;
+        break;
     case ZIP_FL_ENC_CP437:
-	expected_encoding = ZIP_ENCODING_CP437;
-	break;
+        expected_encoding = ZIP_ENCODING_CP437;
+        break;
     default:
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     if ((s = (zip_string_t *)malloc(sizeof(*s))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((s->raw = (zip_uint8_t *)malloc((size_t)length + 1)) == NULL) {
-	free(s);
-	return NULL;
+        free(s);
+        return NULL;
     }
 
     memcpy(s->raw, raw, length);
@@ -158,11 +158,11 @@
     s->converted_length = 0;
 
     if (expected_encoding != ZIP_ENCODING_UNKNOWN) {
-	if (_zip_guess_encoding(s, expected_encoding) == ZIP_ENCODING_ERROR) {
-	    _zip_string_free(s);
-	    zip_error_set(error, ZIP_ER_INVAL, 0);
-	    return NULL;
-	}
+        if (_zip_guess_encoding(s, expected_encoding) == ZIP_ENCODING_ERROR) {
+            _zip_string_free(s);
+            zip_error_set(error, ZIP_ER_INVAL, 0);
+            return NULL;
+        }
     }
 
     return s;
@@ -172,7 +172,7 @@
 int
 _zip_string_write(zip_t *za, const zip_string_t *s) {
     if (s == NULL)
-	return 0;
+        return 0;
 
     return _zip_write(za, s->raw, s->length);
 }
diff --git a/lib/zip_unchange.c b/lib/zip_unchange.c
index 1a78e2c..7929505 100644
--- a/lib/zip_unchange.c
+++ b/lib/zip_unchange.c
@@ -49,39 +49,39 @@
     const char *orig_name, *changed_name;
 
     if (idx >= za->nentry) {
-	zip_error_set(&za->error, ZIP_ER_INVAL, 0);
-	return -1;
+        zip_error_set(&za->error, ZIP_ER_INVAL, 0);
+        return -1;
     }
 
     if (!allow_duplicates && za->entry[idx].changes && (za->entry[idx].changes->changed & ZIP_DIRENT_FILENAME)) {
-	if (za->entry[idx].orig != NULL) {
-	    if ((orig_name = _zip_get_name(za, idx, ZIP_FL_UNCHANGED, &za->error)) == NULL) {
-		return -1;
-	    }
+        if (za->entry[idx].orig != NULL) {
+            if ((orig_name = _zip_get_name(za, idx, ZIP_FL_UNCHANGED, &za->error)) == NULL) {
+                return -1;
+            }
 
-	    i = _zip_name_locate(za, orig_name, 0, NULL);
-	    if (i >= 0 && (zip_uint64_t)i != idx) {
-		zip_error_set(&za->error, ZIP_ER_EXISTS, 0);
-		return -1;
-	    }
-	}
-	else {
-	    orig_name = NULL;
-	}
+            i = _zip_name_locate(za, orig_name, 0, NULL);
+            if (i >= 0 && (zip_uint64_t)i != idx) {
+                zip_error_set(&za->error, ZIP_ER_EXISTS, 0);
+                return -1;
+            }
+        }
+        else {
+            orig_name = NULL;
+        }
 
-	if ((changed_name = _zip_get_name(za, idx, 0, &za->error)) == NULL) {
-	    return -1;
-	}
+        if ((changed_name = _zip_get_name(za, idx, 0, &za->error)) == NULL) {
+            return -1;
+        }
 
-	if (orig_name) {
-	    if (_zip_hash_add(za->names, (const zip_uint8_t *)orig_name, idx, 0, &za->error) == false) {
-		return -1;
-	    }
-	}
-	if (_zip_hash_delete(za->names, (const zip_uint8_t *)changed_name, &za->error) == false) {
-	    _zip_hash_delete(za->names, (const zip_uint8_t *)orig_name, NULL);
-	    return -1;
-	}
+        if (orig_name) {
+            if (_zip_hash_add(za->names, (const zip_uint8_t *)orig_name, idx, 0, &za->error) == false) {
+                return -1;
+            }
+        }
+        if (_zip_hash_delete(za->names, (const zip_uint8_t *)changed_name, &za->error) == false) {
+            _zip_hash_delete(za->names, (const zip_uint8_t *)orig_name, NULL);
+            return -1;
+        }
     }
 
     _zip_dirent_free(za->entry[idx].changes);
diff --git a/lib/zip_unchange_all.c b/lib/zip_unchange_all.c
index 2ae742f..317e503 100644
--- a/lib/zip_unchange_all.c
+++ b/lib/zip_unchange_all.c
@@ -41,12 +41,12 @@
     zip_uint64_t i;
 
     if (!_zip_hash_revert(za->names, &za->error)) {
-	return -1;
+        return -1;
     }
 
     ret = 0;
     for (i = 0; i < za->nentry; i++)
-	ret |= _zip_unchange(za, i, 1);
+        ret |= _zip_unchange(za, i, 1);
 
     ret |= zip_unchange_archive(za);
 
diff --git a/lib/zip_unchange_archive.c b/lib/zip_unchange_archive.c
index bd223ef..af9fd16 100644
--- a/lib/zip_unchange_archive.c
+++ b/lib/zip_unchange_archive.c
@@ -40,9 +40,9 @@
 ZIP_EXTERN int
 zip_unchange_archive(zip_t *za) {
     if (za->comment_changed) {
-	_zip_string_free(za->comment_changes);
-	za->comment_changes = NULL;
-	za->comment_changed = 0;
+        _zip_string_free(za->comment_changes);
+        za->comment_changes = NULL;
+        za->comment_changed = 0;
     }
 
     za->ch_flags = za->flags;
diff --git a/lib/zip_unchange_data.c b/lib/zip_unchange_data.c
index 74a429c..7dbd7c5 100644
--- a/lib/zip_unchange_data.c
+++ b/lib/zip_unchange_data.c
@@ -37,16 +37,16 @@
 void
 _zip_unchange_data(zip_entry_t *ze) {
     if (ze->source) {
-	zip_source_free(ze->source);
-	ze->source = NULL;
+        zip_source_free(ze->source);
+        ze->source = NULL;
     }
 
     if (ze->changes != NULL && (ze->changes->changed & ZIP_DIRENT_COMP_METHOD) && ze->changes->comp_method == ZIP_CM_REPLACED_DEFAULT) {
-	ze->changes->changed &= ~ZIP_DIRENT_COMP_METHOD;
-	if (ze->changes->changed == 0) {
-	    _zip_dirent_free(ze->changes);
-	    ze->changes = NULL;
-	}
+        ze->changes->changed &= ~ZIP_DIRENT_COMP_METHOD;
+        if (ze->changes->changed == 0) {
+            _zip_dirent_free(ze->changes);
+            ze->changes = NULL;
+        }
     }
 
     ze->deleted = 0;
diff --git a/lib/zip_utf-8.c b/lib/zip_utf-8.c
index 099db9b..e507f05 100644
--- a/lib/zip_utf-8.c
+++ b/lib/zip_utf-8.c
@@ -103,54 +103,54 @@
     zip_uint32_t i, j, ulen;
 
     if (str == NULL)
-	return ZIP_ENCODING_ASCII;
+        return ZIP_ENCODING_ASCII;
 
     name = str->raw;
 
     if (str->encoding != ZIP_ENCODING_UNKNOWN)
-	enc = str->encoding;
+        enc = str->encoding;
     else {
-	enc = ZIP_ENCODING_ASCII;
-	for (i = 0; i < str->length; i++) {
-	    if ((name[i] > 31 && name[i] < 128) || name[i] == '\r' || name[i] == '\n' || name[i] == '\t')
-		continue;
+        enc = ZIP_ENCODING_ASCII;
+        for (i = 0; i < str->length; i++) {
+            if ((name[i] > 31 && name[i] < 128) || name[i] == '\r' || name[i] == '\n' || name[i] == '\t')
+                continue;
 
-	    enc = ZIP_ENCODING_UTF8_GUESSED;
-	    if ((name[i] & UTF_8_LEN_2_MASK) == UTF_8_LEN_2_MATCH)
-		ulen = 1;
-	    else if ((name[i] & UTF_8_LEN_3_MASK) == UTF_8_LEN_3_MATCH)
-		ulen = 2;
-	    else if ((name[i] & UTF_8_LEN_4_MASK) == UTF_8_LEN_4_MATCH)
-		ulen = 3;
-	    else {
-		enc = ZIP_ENCODING_CP437;
-		break;
-	    }
+            enc = ZIP_ENCODING_UTF8_GUESSED;
+            if ((name[i] & UTF_8_LEN_2_MASK) == UTF_8_LEN_2_MATCH)
+                ulen = 1;
+            else if ((name[i] & UTF_8_LEN_3_MASK) == UTF_8_LEN_3_MATCH)
+                ulen = 2;
+            else if ((name[i] & UTF_8_LEN_4_MASK) == UTF_8_LEN_4_MATCH)
+                ulen = 3;
+            else {
+                enc = ZIP_ENCODING_CP437;
+                break;
+            }
 
-	    if (i + ulen >= str->length) {
-		enc = ZIP_ENCODING_CP437;
-		break;
-	    }
+            if (i + ulen >= str->length) {
+                enc = ZIP_ENCODING_CP437;
+                break;
+            }
 
-	    for (j = 1; j <= ulen; j++) {
-		if ((name[i + j] & UTF_8_CONTINUE_MASK) != UTF_8_CONTINUE_MATCH) {
-		    enc = ZIP_ENCODING_CP437;
-		    goto done;
-		}
-	    }
-	    i += ulen;
-	}
+            for (j = 1; j <= ulen; j++) {
+                if ((name[i + j] & UTF_8_CONTINUE_MASK) != UTF_8_CONTINUE_MATCH) {
+                    enc = ZIP_ENCODING_CP437;
+                    goto done;
+                }
+            }
+            i += ulen;
+        }
     }
 
 done:
     str->encoding = enc;
 
     if (expected_encoding != ZIP_ENCODING_UNKNOWN) {
-	if (expected_encoding == ZIP_ENCODING_UTF8_KNOWN && enc == ZIP_ENCODING_UTF8_GUESSED)
-	    str->encoding = enc = ZIP_ENCODING_UTF8_KNOWN;
+        if (expected_encoding == ZIP_ENCODING_UTF8_KNOWN && enc == ZIP_ENCODING_UTF8_GUESSED)
+            str->encoding = enc = ZIP_ENCODING_UTF8_KNOWN;
 
-	if (expected_encoding != enc && enc != ZIP_ENCODING_ASCII)
-	    return ZIP_ENCODING_ERROR;
+        if (expected_encoding != enc && enc != ZIP_ENCODING_ASCII)
+            return ZIP_ENCODING_ERROR;
     }
 
     return enc;
@@ -160,11 +160,11 @@
 static zip_uint32_t
 _zip_unicode_to_utf8_len(zip_uint32_t codepoint) {
     if (codepoint < 0x0080)
-	return 1;
+        return 1;
     if (codepoint < 0x0800)
-	return 2;
+        return 2;
     if (codepoint < 0x10000)
-	return 3;
+        return 3;
     return 4;
 }
 
@@ -172,19 +172,19 @@
 static zip_uint32_t
 _zip_unicode_to_utf8(zip_uint32_t codepoint, zip_uint8_t *buf) {
     if (codepoint < 0x0080) {
-	buf[0] = codepoint & 0xff;
-	return 1;
+        buf[0] = codepoint & 0xff;
+        return 1;
     }
     if (codepoint < 0x0800) {
-	buf[0] = (zip_uint8_t)(UTF_8_LEN_2_MATCH | ((codepoint >> 6) & 0x1f));
-	buf[1] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | (codepoint & 0x3f));
-	return 2;
+        buf[0] = (zip_uint8_t)(UTF_8_LEN_2_MATCH | ((codepoint >> 6) & 0x1f));
+        buf[1] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | (codepoint & 0x3f));
+        return 2;
     }
     if (codepoint < 0x10000) {
-	buf[0] = (zip_uint8_t)(UTF_8_LEN_3_MATCH | ((codepoint >> 12) & 0x0f));
-	buf[1] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | ((codepoint >> 6) & 0x3f));
-	buf[2] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | (codepoint & 0x3f));
-	return 3;
+        buf[0] = (zip_uint8_t)(UTF_8_LEN_3_MATCH | ((codepoint >> 12) & 0x0f));
+        buf[1] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | ((codepoint >> 6) & 0x3f));
+        buf[2] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | (codepoint & 0x3f));
+        return 3;
     }
     buf[0] = (zip_uint8_t)(UTF_8_LEN_4_MATCH | ((codepoint >> 18) & 0x07));
     buf[1] = (zip_uint8_t)(UTF_8_CONTINUE_MATCH | ((codepoint >> 12) & 0x3f));
@@ -201,26 +201,26 @@
     zip_uint32_t buflen, i, offset;
 
     if (len == 0) {
-	if (utf8_lenp)
-	    *utf8_lenp = 0;
-	return NULL;
+        if (utf8_lenp)
+            *utf8_lenp = 0;
+        return NULL;
     }
 
     buflen = 1;
     for (i = 0; i < len; i++)
-	buflen += _zip_unicode_to_utf8_len(_cp437_to_unicode[cp437buf[i]]);
+        buflen += _zip_unicode_to_utf8_len(_cp437_to_unicode[cp437buf[i]]);
 
     if ((utf8buf = (zip_uint8_t *)malloc(buflen)) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     offset = 0;
     for (i = 0; i < len; i++)
-	offset += _zip_unicode_to_utf8(_cp437_to_unicode[cp437buf[i]], utf8buf + offset);
+        offset += _zip_unicode_to_utf8(_cp437_to_unicode[cp437buf[i]], utf8buf + offset);
 
     utf8buf[buflen - 1] = 0;
     if (utf8_lenp)
-	*utf8_lenp = buflen - 1;
+        *utf8_lenp = buflen - 1;
     return utf8buf;
 }
diff --git a/lib/zip_winzip_aes.c b/lib/zip_winzip_aes.c
index c86ef88..3fc380a 100644
--- a/lib/zip_winzip_aes.c
+++ b/lib/zip_winzip_aes.c
@@ -55,19 +55,19 @@
     zip_uint64_t i, j;
 
     for (i = 0; i < length; i++) {
-	if (ctx->pad_offset == AES_BLOCK_SIZE) {
-	    for (j = 0; j < 8; j++) {
-		ctx->counter[j]++;
-		if (ctx->counter[j] != 0) {
-		    break;
-		}
-	    }
-	    if (!_zip_crypto_aes_encrypt_block(ctx->aes, ctx->counter, ctx->pad)) {
-		return false;
-	    }
-	    ctx->pad_offset = 0;
-	}
-	data[i] ^= ctx->pad[ctx->pad_offset++];
+        if (ctx->pad_offset == AES_BLOCK_SIZE) {
+            for (j = 0; j < 8; j++) {
+                ctx->counter[j]++;
+                if (ctx->counter[j] != 0) {
+                    break;
+                }
+            }
+            if (!_zip_crypto_aes_encrypt_block(ctx->aes, ctx->counter, ctx->pad)) {
+                return false;
+            }
+            ctx->pad_offset = 0;
+        }
+        data[i] ^= ctx->pad[ctx->pad_offset++];
     }
 
     return true;
@@ -83,49 +83,49 @@
 
     switch (encryption_method) {
     case ZIP_EM_AES_128:
-	key_size = 128;
-	break;
+        key_size = 128;
+        break;
     case ZIP_EM_AES_192:
-	key_size = 192;
-	break;
+        key_size = 192;
+        break;
     case ZIP_EM_AES_256:
-	key_size = 256;
-	break;
+        key_size = 256;
+        break;
     }
 
     if (key_size == 0 || salt == NULL || password == NULL || password_length == 0) {
-	zip_error_set(error, ZIP_ER_INVAL, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_INVAL, 0);
+        return NULL;
     }
 
     key_length = key_size / 8;
 
     if ((ctx = (zip_winzip_aes_t *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     memset(ctx->counter, 0, sizeof(ctx->counter));
     ctx->pad_offset = ZIP_CRYPTO_AES_BLOCK_LENGTH;
 
     if (!_zip_crypto_pbkdf2(password, password_length, salt, key_length / 2, PBKDF2_ITERATIONS, buffer, 2 * key_length + WINZIP_AES_PASSWORD_VERIFY_LENGTH)) {
-	free(ctx);
-	return NULL;
+        free(ctx);
+        return NULL;
     }
 
     if ((ctx->aes = _zip_crypto_aes_new(buffer, key_size, error)) == NULL) {
-	_zip_crypto_clear(ctx, sizeof(*ctx));
-	free(ctx);
-	return NULL;
+        _zip_crypto_clear(ctx, sizeof(*ctx));
+        free(ctx);
+        return NULL;
     }
     if ((ctx->hmac = _zip_crypto_hmac_new(buffer + key_length, key_length, error)) == NULL) {
-	_zip_crypto_aes_free(ctx->aes);
-	free(ctx);
-	return NULL;
+        _zip_crypto_aes_free(ctx->aes);
+        free(ctx);
+        return NULL;
     }
 
     if (password_verify) {
-	memcpy(password_verify, buffer + (2 * key_size / 8), WINZIP_AES_PASSWORD_VERIFY_LENGTH);
+        memcpy(password_verify, buffer + (2 * key_size / 8), WINZIP_AES_PASSWORD_VERIFY_LENGTH);
     }
 
     return ctx;
@@ -153,7 +153,7 @@
 void
 _zip_winzip_aes_free(zip_winzip_aes_t *ctx) {
     if (ctx == NULL) {
-	return;
+        return;
     }
 
     _zip_crypto_aes_free(ctx->aes);
diff --git a/lib/zipint.h b/lib/zipint.h
index 703e1b7..88b1e80 100644
--- a/lib/zipint.h
+++ b/lib/zipint.h
@@ -341,8 +341,8 @@
 struct zip_source {
     zip_source_t *src;
     union {
-	zip_source_callback f;
-	zip_source_layered_callback l;
+        zip_source_callback f;
+        zip_source_layered_callback l;
     } cb;
     void *ud;
     zip_error_t error;
diff --git a/regress/add_from_filep.c b/regress/add_from_filep.c
index da0b98c..abfa9b3 100644
--- a/regress/add_from_filep.c
+++ b/regress/add_from_filep.c
@@ -53,43 +53,43 @@
     prg = argv[0];
 
     if (argc != 3) {
-	fprintf(stderr, "usage: %s archive file\n", prg);
-	return 1;
+        fprintf(stderr, "usage: %s archive file\n", prg);
+        return 1;
     }
 
     archive = argv[1];
     file = argv[2];
 
     if ((za = zip_open(archive, ZIP_CREATE, &err)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "%s: can't open zip archive '%s': %s\n", prg, archive, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return 1;
+        zip_error_t error;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "%s: can't open zip archive '%s': %s\n", prg, archive, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return 1;
     }
 
     if ((fp = fopen(file, "rb")) == NULL) {
-	fprintf(stderr, "%s: can't open input file '%s': %s\n", prg, file, strerror(errno));
-	return 1;
+        fprintf(stderr, "%s: can't open input file '%s': %s\n", prg, file, strerror(errno));
+        return 1;
     }
 
     if ((zs = zip_source_filep(za, fp, 0, -1)) == NULL) {
-	fprintf(stderr, "%s: error creating file source for '%s': %s\n", prg, file, zip_strerror(za));
-	return 1;
+        fprintf(stderr, "%s: error creating file source for '%s': %s\n", prg, file, zip_strerror(za));
+        return 1;
     }
 
     if ((name = strrchr(file, '/')) == NULL)
-	name = file;
+        name = file;
 
     if (zip_add(za, name, zs) == -1) {
-	zip_source_free(zs);
-	fprintf(stderr, "%s: can't add file '%s': %s\n", prg, file, zip_strerror(za));
-	return 1;
+        zip_source_free(zs);
+        fprintf(stderr, "%s: can't add file '%s': %s\n", prg, file, zip_strerror(za));
+        return 1;
     }
 
     if (zip_close(za) == -1) {
-	fprintf(stderr, "%s: can't close zip archive '%s': %s\n", prg, archive, zip_strerror(za));
-	return 1;
+        fprintf(stderr, "%s: can't close zip archive '%s': %s\n", prg, archive, zip_strerror(za));
+        return 1;
     }
 
     return 0;
diff --git a/regress/can_clone_file.c b/regress/can_clone_file.c
index b0b375a..0cc9bea 100644
--- a/regress/can_clone_file.c
+++ b/regress/can_clone_file.c
@@ -58,13 +58,13 @@
     struct statfs fs;
     struct attrlist attribute_list;
     struct {
-	uint32_t size;
-	vol_capabilities_attr_t capabilities;
+        uint32_t size;
+        vol_capabilities_attr_t capabilities;
     } volume_attributes;
 
     if (statfs(".", &fs) < 0) {
-	fprintf(stderr, "%s: can't get mount point of current directory: %s\n", argv[0], strerror(errno));
-	exit(1);
+        fprintf(stderr, "%s: can't get mount point of current directory: %s\n", argv[0], strerror(errno));
+        exit(1);
     }
 
     /* Not all volumes support clonefile().  A volume can be tested for
@@ -78,12 +78,12 @@
     memset(&volume_attributes, 0, sizeof(volume_attributes));
 
     if (getattrlist(fs.f_mntonname, &attribute_list, &volume_attributes, sizeof(volume_attributes), 0) < 0) {
-	fprintf(stderr, "%s: can't get volume capabilities of '%s': %s\n", argv[0], fs.f_mntonname, strerror(errno));
-	exit(1);
+        fprintf(stderr, "%s: can't get volume capabilities of '%s': %s\n", argv[0], fs.f_mntonname, strerror(errno));
+        exit(1);
     }
 
     if (volume_attributes.capabilities.capabilities[VOL_CAPABILITIES_INTERFACES] & VOL_CAP_INT_CLONE) {
-	exit(0);
+        exit(0);
     }
 #elif defined(HAVE_FICLONERANGE)
     char namea[32] = "a.fioclone.XXXXXX";
@@ -92,22 +92,22 @@
     struct file_clone_range range;
 
     if ((fda = mkstemp(namea)) < 0) {
-	fprintf(stderr, "can't create temp file a: %s\n", strerror(errno));
-	exit(1);
+        fprintf(stderr, "can't create temp file a: %s\n", strerror(errno));
+        exit(1);
     }
     if ((fdb = mkstemp(nameb)) < 0) {
-	fprintf(stderr, "can't create temp file b: %s\n", strerror(errno));
-	(void)close(fda);
-	(void)remove(namea);
-	exit(1);
+        fprintf(stderr, "can't create temp file b: %s\n", strerror(errno));
+        (void)close(fda);
+        (void)remove(namea);
+        exit(1);
     }
     if (write(fda, "test\n", 5) < 0) {
-	fprintf(stderr, "can't write temp file a: %s\n", strerror(errno));
-	(void)close(fda);
-	(void)remove(namea);
-	close(fdb);
-	(void)remove(nameb);
-	exit(1);
+        fprintf(stderr, "can't write temp file a: %s\n", strerror(errno));
+        (void)close(fda);
+        (void)remove(namea);
+        close(fdb);
+        (void)remove(nameb);
+        exit(1);
     }
     range.src_fd = fda;
     range.src_offset = 0;
@@ -119,7 +119,7 @@
     (void)remove(namea);
     (void)remove(nameb);
     if (ret >= 0) {
-	exit(0);
+        exit(0);
     }
 #endif
 
diff --git a/regress/fopen_unchanged.c b/regress/fopen_unchanged.c
index 3c9da84..c264262 100644
--- a/regress/fopen_unchanged.c
+++ b/regress/fopen_unchanged.c
@@ -49,41 +49,41 @@
     int err;
 
     if (argc != 2) {
-	fprintf(stderr, "usage: %s archive\n", argv[0]);
-	return 1;
+        fprintf(stderr, "usage: %s archive\n", argv[0]);
+        return 1;
     }
 
     archive = argv[1];
 
     if ((za = zip_open(archive, ZIP_CREATE, &err)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "can't open zip archive '%s': %s\n", archive, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return 1;
+        zip_error_t error;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "can't open zip archive '%s': %s\n", archive, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return 1;
     }
 
     if ((zs = zip_source_buffer(za, teststr, strlen(teststr), 0)) == NULL) {
-	fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za));
-	exit(1);
+        fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za));
+        exit(1);
     }
 
     if (zip_add(za, file, zs) == -1) {
-	fprintf(stderr, "can't add file '%s': %s\n", file, zip_strerror(za));
-	(void)zip_source_free(zs);
-	(void)zip_close(za);
-	return 1;
+        fprintf(stderr, "can't add file '%s': %s\n", file, zip_strerror(za));
+        (void)zip_source_free(zs);
+        (void)zip_close(za);
+        return 1;
     }
 
     if (zip_fopen(za, file, ZIP_FL_UNCHANGED) == NULL) {
-	fprintf(stderr, "can't zip_fopen file '%s': %s\n", file, zip_strerror(za));
-	(void)zip_discard(za);
-	return 1;
+        fprintf(stderr, "can't zip_fopen file '%s': %s\n", file, zip_strerror(za));
+        (void)zip_discard(za);
+        return 1;
     }
 
     if (zip_close(za) == -1) {
-	fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
-	return 1;
+        fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
+        return 1;
     }
 
     return 0;
diff --git a/regress/fread.c b/regress/fread.c
index 8545e9e..66b3cbb 100644
--- a/regress/fread.c
+++ b/regress/fread.c
@@ -68,31 +68,31 @@
     progname = argv[0];
 
     while ((c = getopt(argc, argv, "v")) != -1) {
-	switch (c) {
-	case 'v':
-	    verbose = 1;
-	    break;
+        switch (c) {
+        case 'v':
+            verbose = 1;
+            break;
 
-	default:
-	    fprintf(stderr, USAGE, progname);
-	    return 1;
-	}
+        default:
+            fprintf(stderr, USAGE, progname);
+            return 1;
+        }
     }
 
 
     if (argc - optind != 1) {
-	fprintf(stderr, USAGE, progname);
-	return 1;
+        fprintf(stderr, USAGE, progname);
+        return 1;
     }
 
     archive = argv[optind];
 
     if ((z = zip_open(archive, 0, &ze)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, ze);
-	fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, archive, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return 1;
+        zip_error_t error;
+        zip_error_init_with_code(&error, ze);
+        fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, archive, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return 1;
     }
 
     fail += do_read(z, "storedok", 0, WHEN_NEVER, 0, 0);
@@ -118,46 +118,46 @@
 
     zs = zip_source_buffer(z, "asdf", 4, 0);
     if ((idx = zip_name_locate(z, "storedok", 0)) < 0) {
-	fprintf(stderr, "%s: can't locate 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	fail++;
+        fprintf(stderr, "%s: can't locate 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+        fail++;
     }
     else {
-	if (zip_replace(z, (zip_uint64_t)idx, zs) < 0) {
-	    fprintf(stderr, "%s: can't replace 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	    fail++;
-	}
-	else {
-	    fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
-	    fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
-	}
+        if (zip_replace(z, (zip_uint64_t)idx, zs) < 0) {
+            fprintf(stderr, "%s: can't replace 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+            fail++;
+        }
+        else {
+            fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
+            fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
+        }
     }
     if ((idx = zip_name_locate(z, "storedok", 0)) < 0) {
-	fprintf(stderr, "%s: can't locate 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	fail++;
+        fprintf(stderr, "%s: can't locate 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+        fail++;
     }
     else {
-	if (zip_delete(z, (zip_uint64_t)idx) < 0) {
-	    fprintf(stderr, "%s: can't replace 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	    fail++;
-	}
-	else {
-	    fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_NOENT, 0);
-	    fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
-	}
+        if (zip_delete(z, (zip_uint64_t)idx) < 0) {
+            fprintf(stderr, "%s: can't replace 'storedok' in zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+            fail++;
+        }
+        else {
+            fail += do_read(z, "storedok", 0, WHEN_OPEN, ZIP_ER_NOENT, 0);
+            fail += do_read(z, "storedok", ZIP_FL_UNCHANGED, WHEN_NEVER, 0, 0);
+        }
     }
     zs = zip_source_buffer(z, "asdf", 4, 0);
     if (zip_file_add(z, "new_file", zs, 0) < 0) {
-	fprintf(stderr, "%s: can't add file to zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	fail++;
+        fprintf(stderr, "%s: can't add file to zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+        fail++;
     }
     else {
-	fail += do_read(z, "new_file", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
+        fail += do_read(z, "new_file", 0, WHEN_OPEN, ZIP_ER_CHANGED, 0);
     }
 
     zip_unchange_all(z);
     if (zip_close(z) == -1) {
-	fprintf(stderr, "%s: can't close zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	return 1;
+        fprintf(stderr, "%s: can't close zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+        return 1;
     }
 
     exit(fail ? 1 : 0);
@@ -180,33 +180,33 @@
     zip_error_set(&error_ex, ze_ex, se_ex);
 
     if ((zf = zip_fopen(z, name, flags)) == NULL) {
-	when_got = WHEN_OPEN;
-	zf_error = zip_get_error(z);
-	zip_error_set(&error_got, zip_error_code_zip(zf_error), zip_error_code_system(zf_error));
+        when_got = WHEN_OPEN;
+        zf_error = zip_get_error(z);
+        zip_error_set(&error_got, zip_error_code_zip(zf_error), zip_error_code_system(zf_error));
     }
     else {
-	while ((n = zip_fread(zf, b, sizeof(b))) > 0)
-	    ;
-	if (n < 0) {
-	    when_got = WHEN_READ;
-	    zf_error = zip_file_get_error(zf);
-	    zip_error_set(&error_got, zip_error_code_zip(zf_error), zip_error_code_system(zf_error));
-	}
-	err = zip_fclose(zf);
-	if (when_got == WHEN_NEVER && err != 0) {
-	    when_got = WHEN_CLOSE;
-	    zip_error_init_with_code(&error_got, err);
-	}
+        while ((n = zip_fread(zf, b, sizeof(b))) > 0)
+            ;
+        if (n < 0) {
+            when_got = WHEN_READ;
+            zf_error = zip_file_get_error(zf);
+            zip_error_set(&error_got, zip_error_code_zip(zf_error), zip_error_code_system(zf_error));
+        }
+        err = zip_fclose(zf);
+        if (when_got == WHEN_NEVER && err != 0) {
+            when_got = WHEN_CLOSE;
+            zip_error_init_with_code(&error_got, err);
+        }
     }
 
     if (when_got != when_ex || zip_error_code_zip(&error_got) != zip_error_code_zip(&error_ex) || zip_error_code_system(&error_got) != zip_error_code_system(&error_ex)) {
-	printf("%s: %s: got %s error (%s), expected %s error (%s)\n", progname, name, when_name[when_got], zip_error_strerror(&error_got), when_name[when_ex], zip_error_strerror(&error_ex));
-	zip_error_fini(&error_got);
-	zip_error_fini(&error_ex);
-	return 1;
+        printf("%s: %s: got %s error (%s), expected %s error (%s)\n", progname, name, when_name[when_got], zip_error_strerror(&error_got), when_name[when_ex], zip_error_strerror(&error_ex));
+        zip_error_fini(&error_got);
+        zip_error_fini(&error_ex);
+        return 1;
     }
     else if (verbose)
-	printf("%s: %s: passed\n", progname, name);
+        printf("%s: %s: passed\n", progname, name);
 
     return 0;
 }
diff --git a/regress/fseek.c b/regress/fseek.c
index 28474be..007a507 100644
--- a/regress/fseek.c
+++ b/regress/fseek.c
@@ -51,8 +51,8 @@
     progname = argv[0];
 
     if (argc != 4) {
-	fprintf(stderr, USAGE, progname);
-	return 1;
+        fprintf(stderr, USAGE, progname);
+        return 1;
     }
 
     archive = argv[1];
@@ -60,44 +60,44 @@
     offset = (zip_int64_t)strtoull(argv[3], NULL, 10);
 
     if ((z = zip_open(archive, 0, &ze)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, ze);
-	fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, archive, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return 1;
+        zip_error_t error;
+        zip_error_init_with_code(&error, ze);
+        fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, archive, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return 1;
     }
 
     if ((zf = zip_fopen_index(z, index, 0)) == NULL) {
-	fprintf(stderr, "%s: can't open file in archive '%s': %s\n", progname, archive, zip_error_strerror(zip_file_get_error(zf)));
-	zip_close(z);
-	return 1;
+        fprintf(stderr, "%s: can't open file in archive '%s': %s\n", progname, archive, zip_error_strerror(zip_file_get_error(zf)));
+        zip_close(z);
+        return 1;
     }
 
     if (zip_fseek(zf, offset, SEEK_SET) < 0) {
-	fprintf(stderr, "%s: zip_fseek failed: %s\n", progname, zip_error_strerror(zip_file_get_error(zf)));
-	zip_fclose(zf);
-	zip_close(z);
-	return 1;
+        fprintf(stderr, "%s: zip_fseek failed: %s\n", progname, zip_error_strerror(zip_file_get_error(zf)));
+        zip_fclose(zf);
+        zip_close(z);
+        return 1;
     }
 
     while ((n = zip_fread(zf, b, sizeof(b))) > 0) {
-	printf("%.*s", (int)n, b);
+        printf("%.*s", (int)n, b);
     }
     if (n < 0) {
-	fprintf(stderr, "%s: zip_fread failed: %s\n", progname, zip_error_strerror(zip_file_get_error(zf)));
-	zip_fclose(zf);
-	zip_close(z);
-	return 1;
+        fprintf(stderr, "%s: zip_fread failed: %s\n", progname, zip_error_strerror(zip_file_get_error(zf)));
+        zip_fclose(zf);
+        zip_close(z);
+        return 1;
     }
 
     if (zip_fclose(zf) == -1) {
-	fprintf(stderr, "%s: can't close zip archive entry %" PRIu64 " in '%s': %s\n", progname, index, archive, zip_strerror(z));
-	return 1;
+        fprintf(stderr, "%s: can't close zip archive entry %" PRIu64 " in '%s': %s\n", progname, index, archive, zip_strerror(z));
+        return 1;
     }
 
     if (zip_close(z) == -1) {
-	fprintf(stderr, "%s: can't close zip archive '%s': %s\n", progname, archive, zip_strerror(z));
-	return 1;
+        fprintf(stderr, "%s: can't close zip archive '%s': %s\n", progname, archive, zip_strerror(z));
+        return 1;
     }
 
     return 0;
diff --git a/regress/fuzz_main.c b/regress/fuzz_main.c
index 4a12745..0a99d33 100644
--- a/regress/fuzz_main.c
+++ b/regress/fuzz_main.c
@@ -11,14 +11,14 @@
     long siz_buf;
 
     if (argc < 2) {
-	fprintf(stderr, "no input file\n");
-	goto err;
+        fprintf(stderr, "no input file\n");
+        goto err;
     }
 
     f = fopen(argv[1], "rb");
     if (f == NULL) {
-	fprintf(stderr, "error opening input file %s\n", argv[1]);
-	goto err;
+        fprintf(stderr, "error opening input file %s\n", argv[1]);
+        goto err;
     }
 
     fseek(f, 0, SEEK_END);
@@ -27,18 +27,18 @@
     rewind(f);
 
     if (siz_buf < 1) {
-	goto err;
+        goto err;
     }
 
     buf = (char *)malloc(siz_buf);
     if (buf == NULL) {
-	fprintf(stderr, "malloc() failed\n");
-	goto err;
+        fprintf(stderr, "malloc() failed\n");
+        goto err;
     }
 
     if (fread(buf, siz_buf, 1, f) != 1) {
-	fprintf(stderr, "fread() failed\n");
-	goto err;
+        fprintf(stderr, "fread() failed\n");
+        goto err;
     }
 
     (void)LLVMFuzzerTestOneInput((uint8_t *)buf, siz_buf);
diff --git a/regress/hole.c b/regress/hole.c
index 0222bab..861c772 100644
--- a/regress/hole.c
+++ b/regress/hole.c
@@ -55,38 +55,38 @@
     zip_int64_t n;
 
     if (zip_source_open(from) < 0) {
-	fprintf(stderr, "%s: can't open source for reading: %s\n", progname, zip_error_strerror(zip_source_error(from)));
-	return -1;
+        fprintf(stderr, "%s: can't open source for reading: %s\n", progname, zip_error_strerror(zip_source_error(from)));
+        return -1;
     }
 
     if (zip_source_begin_write(to) < 0) {
-	fprintf(stderr, "%s: can't open source for writing: %s\n", progname, zip_error_strerror(zip_source_error(to)));
-	zip_source_close(from);
-	return -1;
+        fprintf(stderr, "%s: can't open source for writing: %s\n", progname, zip_error_strerror(zip_source_error(to)));
+        zip_source_close(from);
+        return -1;
     }
 
     while ((n = zip_source_read(from, buf, sizeof(buf))) > 0) {
-	if (zip_source_write(to, buf, (zip_uint64_t)n) != n) {
-	    fprintf(stderr, "%s: can't write to source: %s\n", progname, zip_error_strerror(zip_source_error(to)));
-	    zip_source_close(from);
-	    zip_source_rollback_write(to);
-	    return -1;
-	}
+        if (zip_source_write(to, buf, (zip_uint64_t)n) != n) {
+            fprintf(stderr, "%s: can't write to source: %s\n", progname, zip_error_strerror(zip_source_error(to)));
+            zip_source_close(from);
+            zip_source_rollback_write(to);
+            return -1;
+        }
     }
 
     if (n < 0) {
-	fprintf(stderr, "%s: can't read from source: %s\n", progname, zip_error_strerror(zip_source_error(from)));
-	zip_source_close(from);
-	zip_source_rollback_write(to);
-	return -1;
+        fprintf(stderr, "%s: can't read from source: %s\n", progname, zip_error_strerror(zip_source_error(from)));
+        zip_source_close(from);
+        zip_source_rollback_write(to);
+        return -1;
     }
 
     zip_source_close(from);
 
     if (zip_source_commit_write(to) < 0) {
-	fprintf(stderr, "%s: can't commit source: %s\n", progname, zip_error_strerror(zip_source_error(to)));
-	zip_source_rollback_write(to);
-	return -1;
+        fprintf(stderr, "%s: can't commit source: %s\n", progname, zip_error_strerror(zip_source_error(to)));
+        zip_source_rollback_write(to);
+        return -1;
     }
 
     return 0;
@@ -101,9 +101,9 @@
     zip_error_init(&error);
 
     if ((src = source_hole_create(fname, flags, &error)) == NULL) {
-	fprintf(stderr, "%s: can't open compressed file %s: %s\n", progname, fname, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	exit(1);
+        fprintf(stderr, "%s: can't open compressed file %s: %s\n", progname, fname, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        exit(1);
     }
 
     return src;
@@ -118,9 +118,9 @@
     zip_error_init(&error);
 
     if ((src = zip_source_file_create(fname, 0, 0, &error)) == NULL) {
-	fprintf(stderr, "%s: can't open file %s: %s\n", progname, fname, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	exit(1);
+        fprintf(stderr, "%s: can't open file %s: %s\n", progname, fname, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        exit(1);
     }
 
     return src;
@@ -146,39 +146,39 @@
     progname = argv[0];
 
     while ((c = getopt(argc, argv, "du")) != -1) {
-	switch (c) {
-	case 'd':
-	    compress = 0;
-	    decompress = 1;
-	    break;
+        switch (c) {
+        case 'd':
+            compress = 0;
+            decompress = 1;
+            break;
 
-	case 'u':
-	    compress = 1;
-	    decompress = 1;
-	    break;
+        case 'u':
+            compress = 1;
+            decompress = 1;
+            break;
 
-	default:
-	    usage();
-	    break;
-	}
+        default:
+            usage();
+            break;
+        }
     }
 
     if (optind + 2 != argc) {
-	usage();
+        usage();
     }
 
     if (decompress) {
-	from = open_compressed(argv[optind], 0);
+        from = open_compressed(argv[optind], 0);
     }
     else {
-	from = open_file(argv[optind]);
+        from = open_file(argv[optind]);
     }
 
     if (compress) {
-	to = open_compressed(argv[optind + 1], ZIP_CREATE);
+        to = open_compressed(argv[optind + 1], ZIP_CREATE);
     }
     else {
-	to = open_file(argv[optind + 1]);
+        to = open_file(argv[optind + 1]);
     }
 
     err = copy_source(from, to);
diff --git a/regress/malloc.c b/regress/malloc.c
index 0032c71..aa151c4 100644
--- a/regress/malloc.c
+++ b/regress/malloc.c
@@ -81,20 +81,20 @@
     char *foo;
     myname = getprogname();
     if (!myname)
-	myname = "(unknown)";
+        myname = "(unknown)";
     if ((foo = getenv("MALLOC_MAX_COUNT")) != NULL)
-	max_count = strtoul(foo, NULL, 0);
+        max_count = strtoul(foo, NULL, 0);
     if ((foo = getenv("MALLOC_MIN_SIZE")) != NULL)
-	min_size = strtoul(foo, NULL, 0);
+        min_size = strtoul(foo, NULL, 0);
     real_calloc = dlsym(RTLD_NEXT, "calloc");
     if (!real_calloc)
-	abort();
+        abort();
     real_malloc = dlsym(RTLD_NEXT, "malloc");
     if (!real_malloc)
-	abort();
+        abort();
     real_realloc = dlsym(RTLD_NEXT, "realloc");
     if (!real_realloc)
-	abort();
+        abort();
     inited = 1;
 }
 
@@ -103,17 +103,17 @@
     void *ret;
 
     if (!inited) {
-	init();
+        init();
     }
 
     if (number >= min_size / size && count >= max_count) {
-	errno = ENOMEM;
-	return NULL;
+        errno = ENOMEM;
+        return NULL;
     }
 
     ret = real_calloc(number, size);
     if (size >= min_size) {
-	count++;
+        count++;
     }
 
     return ret;
@@ -124,17 +124,17 @@
     void *ret;
 
     if (!inited) {
-	init();
+        init();
     }
 
     if (size >= min_size && count >= max_count) {
-	errno = ENOMEM;
-	return NULL;
+        errno = ENOMEM;
+        return NULL;
     }
 
     ret = real_malloc(size);
     if (size >= min_size) {
-	count++;
+        count++;
     }
 
     return ret;
@@ -145,17 +145,17 @@
     void *ret;
 
     if (!inited) {
-	init();
+        init();
     }
 
     if (size >= min_size && count >= max_count) {
-	errno = ENOMEM;
-	return NULL;
+        errno = ENOMEM;
+        return NULL;
     }
 
     ret = real_realloc(ptr, size);
     if (size >= min_size) {
-	count++;
+        count++;
     }
 
     return ret;
diff --git a/regress/nonrandomopentest.c b/regress/nonrandomopentest.c
index be585ee..16d2f1e 100644
--- a/regress/nonrandomopentest.c
+++ b/regress/nonrandomopentest.c
@@ -43,14 +43,14 @@
 
 #ifdef HAVE_CRYPTO
     if (!zip_secure_random(buf, sizeof(buf))) {
-	fprintf(stderr, "zip_secure_random returned false\n");
-	exit(1);
+        fprintf(stderr, "zip_secure_random returned false\n");
+        exit(1);
     }
     for (i = 0; i < sizeof(buf); i++) {
-	if (buf[i] != 0) {
-	    fprintf(stderr, "non-zero byte found\n");
-	    exit(1);
-	}
+        if (buf[i] != 0) {
+            fprintf(stderr, "non-zero byte found\n");
+            exit(1);
+        }
     }
 #endif
     exit(0);
diff --git a/regress/source_hole.c b/regress/source_hole.c
index a4a0ff3..60cfc63 100644
--- a/regress/source_hole.c
+++ b/regress/source_hole.c
@@ -95,7 +95,7 @@
     hole_t *ud = hole_new(fname, flags, error);
 
     if (ud == NULL) {
-	return NULL;
+        return NULL;
     }
     return zip_source_function_create(source_hole_cb, ud, error);
 }
@@ -106,14 +106,14 @@
     zip_uint64_t i;
 
     if (buffer == NULL) {
-	return;
+        return;
     }
 
     if (buffer->fragment) {
-	for (i = 0; i < buffer->nfragments; i++) {
-	    free(buffer->fragment[i]);
-	}
-	free(buffer->fragment);
+        for (i = 0; i < buffer->nfragments; i++) {
+            free(buffer->fragment[i]);
+        }
+        free(buffer->fragment);
     }
     free(buffer);
 }
@@ -125,25 +125,25 @@
     FILE *f;
 
     if ((buffer = buffer_new()) == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((flags & ZIP_TRUNCATE) == 0) {
-	if ((f = fopen(fname, "rb")) == NULL) {
-	    if (!(errno == ENOENT && (flags & ZIP_CREATE))) {
-		buffer_free(buffer);
-		return NULL;
-	    }
-	}
-	else {
-	    if (buffer_read_file(buffer, f, error) < 0) {
-		buffer_free(buffer);
-		fclose(f);
-		return NULL;
-	    }
-	    fclose(f);
-	}
+        if ((f = fopen(fname, "rb")) == NULL) {
+            if (!(errno == ENOENT && (flags & ZIP_CREATE))) {
+                buffer_free(buffer);
+                return NULL;
+            }
+        }
+        else {
+            if (buffer_read_file(buffer, f, error) < 0) {
+                buffer_free(buffer);
+                fclose(f);
+                return NULL;
+            }
+            fclose(f);
+        }
     }
 
     return buffer;
@@ -155,7 +155,7 @@
     buffer_t *buffer;
 
     if ((buffer = (buffer_t *)malloc(sizeof(*buffer))) == NULL) {
-	return NULL;
+        return NULL;
     }
 
     buffer->fragment = NULL;
@@ -175,28 +175,28 @@
     length = MY_MIN(length, buffer->size - buffer->offset);
 
     if (length == 0) {
-	return 0;
+        return 0;
     }
     if (length > ZIP_INT64_MAX) {
-	return -1;
+        return -1;
     }
 
     i = buffer->offset / buffer->fragment_size;
     fragment_offset = buffer->offset % buffer->fragment_size;
     n = 0;
     while (n < length) {
-	zip_uint64_t left = MY_MIN(length - n, buffer->fragment_size - fragment_offset);
+        zip_uint64_t left = MY_MIN(length - n, buffer->fragment_size - fragment_offset);
 
-	if (buffer->fragment[i]) {
-	    memcpy(data + n, buffer->fragment[i] + fragment_offset, left);
-	}
-	else {
-	    memset(data + n, 0, left);
-	}
+        if (buffer->fragment[i]) {
+            memcpy(data + n, buffer->fragment[i] + fragment_offset, left);
+        }
+        else {
+            memset(data + n, 0, left);
+        }
 
-	n += left;
-	i++;
-	fragment_offset = 0;
+        n += left;
+        i++;
+        fragment_offset = 0;
     }
 
     buffer->offset += n;
@@ -210,65 +210,65 @@
     zip_uint64_t i;
 
     if (fread(b, 20, 1, f) != 1) {
-	zip_error_set(error, ZIP_ER_READ, errno);
-	return -1;
+        zip_error_set(error, ZIP_ER_READ, errno);
+        return -1;
     }
 
     if (memcmp(b, MARK_BEGIN, 4) != 0) {
-	zip_error_set(error, ZIP_ER_READ, EFTYPE);
-	return -1;
+        zip_error_set(error, ZIP_ER_READ, EFTYPE);
+        return -1;
     }
 
     buffer->fragment_size = get_u64(b + 4);
     buffer->size = get_u64(b + 12);
 
     if (buffer->size + buffer->fragment_size < buffer->size) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
     buffer->nfragments = (buffer->size + buffer->fragment_size - 1) / buffer->fragment_size;
     if ((buffer->nfragments > SIZE_MAX / sizeof(buffer->fragment[0])) || ((buffer->fragment = (zip_uint8_t **)malloc(sizeof(buffer->fragment[0]) * buffer->nfragments)) == NULL)) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return -1;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return -1;
     }
 
     for (i = 0; i < buffer->nfragments; i++) {
-	buffer->fragment[i] = NULL;
+        buffer->fragment[i] = NULL;
     }
 
     i = 0;
     while (i < buffer->nfragments) {
-	if (fread(b, 4, 1, f) != 1) {
-	    zip_error_set(error, ZIP_ER_READ, errno);
-	    return -1;
-	}
+        if (fread(b, 4, 1, f) != 1) {
+            zip_error_set(error, ZIP_ER_READ, errno);
+            return -1;
+        }
 
-	if (memcmp(b, MARK_DATA, 4) == 0) {
-	    if (buffer->fragment_size > SIZE_MAX) {
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	    if ((buffer->fragment[i] = (zip_uint8_t *)malloc(buffer->fragment_size)) == NULL) {
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return -1;
-	    }
-	    if (fread(buffer->fragment[i], buffer->fragment_size, 1, f) != 1) {
-		zip_error_set(error, ZIP_ER_READ, errno);
-		return -1;
-	    }
-	    i++;
-	}
-	else if (memcmp(b, MARK_NUL, 4) == 0) {
-	    if (fread(b, 8, 1, f) != 1) {
-		zip_error_set(error, ZIP_ER_READ, errno);
-		return -1;
-	    }
-	    i += get_u64(b);
-	}
-	else {
-	    zip_error_set(error, ZIP_ER_READ, EFTYPE);
-	    return -1;
-	}
+        if (memcmp(b, MARK_DATA, 4) == 0) {
+            if (buffer->fragment_size > SIZE_MAX) {
+                zip_error_set(error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+            if ((buffer->fragment[i] = (zip_uint8_t *)malloc(buffer->fragment_size)) == NULL) {
+                zip_error_set(error, ZIP_ER_MEMORY, 0);
+                return -1;
+            }
+            if (fread(buffer->fragment[i], buffer->fragment_size, 1, f) != 1) {
+                zip_error_set(error, ZIP_ER_READ, errno);
+                return -1;
+            }
+            i++;
+        }
+        else if (memcmp(b, MARK_NUL, 4) == 0) {
+            if (fread(b, 8, 1, f) != 1) {
+                zip_error_set(error, ZIP_ER_READ, errno);
+                return -1;
+            }
+            i += get_u64(b);
+        }
+        else {
+            zip_error_set(error, ZIP_ER_READ, EFTYPE);
+            return -1;
+        }
     }
 
     return 0;
@@ -279,7 +279,7 @@
     zip_int64_t new_offset = zip_source_seek_compute_offset(buffer->offset, buffer->size, data, length, error);
 
     if (new_offset < 0) {
-	return -1;
+        return -1;
     }
 
     buffer->offset = (zip_uint64_t)new_offset;
@@ -294,8 +294,8 @@
     zip_uint64_t nul_run;
 
     if (f == NULL) {
-	zip_error_set(error, ZIP_ER_OPEN, errno);
-	return -1;
+        zip_error_set(error, ZIP_ER_OPEN, errno);
+        return -1;
     }
 
     fwrite(MARK_BEGIN, 4, 1, f);
@@ -304,27 +304,27 @@
 
     nul_run = 0;
     for (i = 0; i * buffer->fragment_size < buffer->size; i++) {
-	if (buffer->fragment[i] == NULL || only_nul(buffer->fragment[i], buffer->fragment_size)) {
-	    nul_run++;
-	}
-	else {
-	    if (nul_run > 0) {
-		write_nuls(nul_run, f);
-		nul_run = 0;
-	    }
-	    fwrite(MARK_DATA, 4, 1, f);
+        if (buffer->fragment[i] == NULL || only_nul(buffer->fragment[i], buffer->fragment_size)) {
+            nul_run++;
+        }
+        else {
+            if (nul_run > 0) {
+                write_nuls(nul_run, f);
+                nul_run = 0;
+            }
+            fwrite(MARK_DATA, 4, 1, f);
 
-	    fwrite(buffer->fragment[i], 1, buffer->fragment_size, f);
-	}
+            fwrite(buffer->fragment[i], 1, buffer->fragment_size, f);
+        }
     }
 
     if (nul_run > 0) {
-	write_nuls(nul_run, f);
+        write_nuls(nul_run, f);
     }
 
     if (fclose(f) != 0) {
-	zip_error_set(error, ZIP_ER_WRITE, errno);
-	return -1;
+        zip_error_set(error, ZIP_ER_WRITE, errno);
+        return -1;
     }
 
     return 0;
@@ -335,60 +335,60 @@
 buffer_write(buffer_t *buffer, const zip_uint8_t *data, zip_uint64_t length, zip_error_t *error) {
     zip_uint8_t **fragment;
     if (buffer->offset + length > buffer->nfragments * buffer->fragment_size) {
-	zip_uint64_t needed_fragments = (buffer->offset + length + buffer->fragment_size - 1) / buffer->fragment_size;
-	zip_uint64_t new_capacity = buffer->nfragments;
-	zip_uint64_t i;
+        zip_uint64_t needed_fragments = (buffer->offset + length + buffer->fragment_size - 1) / buffer->fragment_size;
+        zip_uint64_t new_capacity = buffer->nfragments;
+        zip_uint64_t i;
 
-	if (new_capacity == 0) {
-	    new_capacity = 4;
-	}
-	while (new_capacity < needed_fragments) {
-	    new_capacity *= 2;
-	}
+        if (new_capacity == 0) {
+            new_capacity = 4;
+        }
+        while (new_capacity < needed_fragments) {
+            new_capacity *= 2;
+        }
 
-	fragment = realloc(buffer->fragment, new_capacity * sizeof(*fragment));
+        fragment = realloc(buffer->fragment, new_capacity * sizeof(*fragment));
 
-	if (fragment == NULL) {
-	    zip_error_set(error, ZIP_ER_MEMORY, 0);
-	    return -1;
-	}
+        if (fragment == NULL) {
+            zip_error_set(error, ZIP_ER_MEMORY, 0);
+            return -1;
+        }
 
-	for (i = buffer->nfragments; i < new_capacity; i++) {
-	    fragment[i] = NULL;
-	}
+        for (i = buffer->nfragments; i < new_capacity; i++) {
+            fragment[i] = NULL;
+        }
 
-	buffer->fragment = fragment;
-	buffer->nfragments = new_capacity;
+        buffer->fragment = fragment;
+        buffer->nfragments = new_capacity;
     }
 
     if (!only_nul(data, length)) {
-	zip_uint64_t idx, n, fragment_offset;
+        zip_uint64_t idx, n, fragment_offset;
 
-	idx = buffer->offset / buffer->fragment_size;
-	fragment_offset = buffer->offset % buffer->fragment_size;
-	n = 0;
+        idx = buffer->offset / buffer->fragment_size;
+        fragment_offset = buffer->offset % buffer->fragment_size;
+        n = 0;
 
-	while (n < length) {
-	    zip_uint64_t left = MY_MIN(length - n, buffer->fragment_size - fragment_offset);
+        while (n < length) {
+            zip_uint64_t left = MY_MIN(length - n, buffer->fragment_size - fragment_offset);
 
-	    if (buffer->fragment[idx] == NULL) {
-		if ((buffer->fragment[idx] = (zip_uint8_t *)malloc(buffer->fragment_size)) == NULL) {
-		    zip_error_set(error, ZIP_ER_MEMORY, 0);
-		    return -1;
-		}
-		memset(buffer->fragment[idx], 0, buffer->fragment_size);
-	    }
-	    memcpy(buffer->fragment[idx] + fragment_offset, data + n, left);
+            if (buffer->fragment[idx] == NULL) {
+                if ((buffer->fragment[idx] = (zip_uint8_t *)malloc(buffer->fragment_size)) == NULL) {
+                    zip_error_set(error, ZIP_ER_MEMORY, 0);
+                    return -1;
+                }
+                memset(buffer->fragment[idx], 0, buffer->fragment_size);
+            }
+            memcpy(buffer->fragment[idx] + fragment_offset, data + n, left);
 
-	    n += left;
-	    idx++;
-	    fragment_offset = 0;
-	}
+            n += left;
+            idx++;
+            fragment_offset = 0;
+        }
     }
 
     buffer->offset += length;
     if (buffer->offset > buffer->size) {
-	buffer->size = buffer->offset;
+        buffer->size = buffer->offset;
     }
 
     return (zip_int64_t)length;
@@ -410,9 +410,9 @@
     zip_uint64_t i;
 
     for (i = 0; i < length; i++) {
-	if (data[i] != '\0') {
-	    return 0;
-	}
+        if (data[i] != '\0') {
+            return 0;
+        }
     }
 
     return 1;
@@ -422,7 +422,7 @@
 static int
 write_nuls(zip_uint64_t n, FILE *f) {
     if (fwrite(MARK_NUL, 4, 1, f) != 1) {
-	return -1;
+        return -1;
     }
     return write_u64(n, f);
 }
@@ -448,7 +448,7 @@
 static void
 hole_free(hole_t *hole) {
     if (hole == NULL) {
-	return;
+        return;
     }
     zip_error_fini(&hole->error);
     buffer_free(hole->in);
@@ -463,19 +463,19 @@
     hole_t *ctx = (hole_t *)malloc(sizeof(*ctx));
 
     if (ctx == NULL) {
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ctx->fname = strdup(fname)) == NULL) {
-	free(ctx);
-	zip_error_set(error, ZIP_ER_MEMORY, 0);
-	return NULL;
+        free(ctx);
+        zip_error_set(error, ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     if ((ctx->in = buffer_from_file(fname, flags, error)) == NULL) {
-	free(ctx);
-	return NULL;
+        free(ctx);
+        return NULL;
     }
 
     zip_error_init(&ctx->error);
@@ -491,82 +491,82 @@
 
     switch (command) {
     case ZIP_SOURCE_BEGIN_WRITE:
-	ctx->out = buffer_new();
-	return 0;
+        ctx->out = buffer_new();
+        return 0;
 
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_COMMIT_WRITE:
-	if (buffer_to_file(ctx->out, ctx->fname, &ctx->error) < 0) {
-	    return -1;
-	}
-	buffer_free(ctx->in);
-	ctx->in = ctx->out;
-	ctx->out = NULL;
-	return 0;
+        if (buffer_to_file(ctx->out, ctx->fname, &ctx->error) < 0) {
+            return -1;
+        }
+        buffer_free(ctx->in);
+        ctx->in = ctx->out;
+        ctx->out = NULL;
+        return 0;
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, length);
+        return zip_error_to_data(&ctx->error, data, length);
 
     case ZIP_SOURCE_FREE:
-	hole_free(ctx);
-	return 0;
+        hole_free(ctx);
+        return 0;
 
     case ZIP_SOURCE_OPEN:
-	ctx->in->offset = 0;
-	return 0;
+        ctx->in->offset = 0;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	return buffer_read(ctx->in, data, length, &ctx->error);
+        return buffer_read(ctx->in, data, length, &ctx->error);
 
     case ZIP_SOURCE_REMOVE:
-	buffer_free(ctx->in);
-	ctx->in = buffer_new();
-	buffer_free(ctx->out);
-	ctx->out = NULL;
-	(void)remove(ctx->fname);
-	return 0;
+        buffer_free(ctx->in);
+        ctx->in = buffer_new();
+        buffer_free(ctx->out);
+        ctx->out = NULL;
+        (void)remove(ctx->fname);
+        return 0;
 
     case ZIP_SOURCE_ROLLBACK_WRITE:
-	buffer_free(ctx->out);
-	ctx->out = NULL;
-	return 0;
+        buffer_free(ctx->out);
+        ctx->out = NULL;
+        return 0;
 
     case ZIP_SOURCE_SEEK:
-	return buffer_seek(ctx->in, data, length, &ctx->error);
+        return buffer_seek(ctx->in, data, length, &ctx->error);
 
     case ZIP_SOURCE_SEEK_WRITE:
-	return buffer_seek(ctx->out, data, length, &ctx->error);
+        return buffer_seek(ctx->out, data, length, &ctx->error);
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st = ZIP_SOURCE_GET_ARGS(zip_stat_t, data, length, &ctx->error);
+        zip_stat_t *st = ZIP_SOURCE_GET_ARGS(zip_stat_t, data, length, &ctx->error);
 
-	if (st == NULL) {
-	    return -1;
-	}
+        if (st == NULL) {
+            return -1;
+        }
 
-	/* TODO: return ENOENT if fname doesn't exist */
+        /* TODO: return ENOENT if fname doesn't exist */
 
-	st->valid |= ZIP_STAT_SIZE;
-	st->size = ctx->in->size;
-	return 0;
+        st->valid |= ZIP_STAT_SIZE;
+        st->size = ctx->in->size;
+        return 0;
     }
 
     case ZIP_SOURCE_TELL:
-	return (zip_int64_t)ctx->in->offset;
+        return (zip_int64_t)ctx->in->offset;
 
     case ZIP_SOURCE_TELL_WRITE:
-	return (zip_int64_t)ctx->out->offset;
+        return (zip_int64_t)ctx->out->offset;
 
     case ZIP_SOURCE_WRITE:
-	return buffer_write(ctx->out, data, length, &ctx->error);
+        return buffer_write(ctx->out, data, length, &ctx->error);
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_STAT, ZIP_SOURCE_TELL, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_STAT, ZIP_SOURCE_TELL, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, -1);
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 }
diff --git a/regress/tryopen.c b/regress/tryopen.c
index cc5de1e..53c3116 100644
--- a/regress/tryopen.c
+++ b/regress/tryopen.c
@@ -60,47 +60,47 @@
     flags = 0;
 
     while ((c = getopt(argc, argv, "cent")) != -1) {
-	switch (c) {
-	case 'c':
-	    flags |= ZIP_CHECKCONS;
-	    break;
-	case 'e':
-	    flags |= ZIP_EXCL;
-	    break;
-	case 'n':
-	    flags |= ZIP_CREATE;
-	    break;
-	case 't':
-	    flags |= ZIP_TRUNCATE;
-	    break;
+        switch (c) {
+        case 'c':
+            flags |= ZIP_CHECKCONS;
+            break;
+        case 'e':
+            flags |= ZIP_EXCL;
+            break;
+        case 'n':
+            flags |= ZIP_CREATE;
+            break;
+        case 't':
+            flags |= ZIP_TRUNCATE;
+            break;
 
-	default:
-	    fprintf(stderr, TRYOPEN_USAGE, argv[0]);
-	    return 1;
-	}
+        default:
+            fprintf(stderr, TRYOPEN_USAGE, argv[0]);
+            return 1;
+        }
     }
 
     error = 0;
     for (; optind < argc; optind++) {
-	fname = argv[optind];
-	errno = 0;
+        fname = argv[optind];
+        errno = 0;
 
-	if ((z = zip_open(fname, flags, &ze)) != NULL) {
-	    count = zip_get_num_entries(z, 0);
-	    printf("opening '%s' succeeded, %" PRIu64 " entries\n", fname, count);
-	    zip_close(z);
-	    continue;
-	}
+        if ((z = zip_open(fname, flags, &ze)) != NULL) {
+            count = zip_get_num_entries(z, 0);
+            printf("opening '%s' succeeded, %" PRIu64 " entries\n", fname, count);
+            zip_close(z);
+            continue;
+        }
 
-	printf("opening '%s' returned error %d", fname, ze);
-	if (zip_error_get_sys_type(ze) == ZIP_ET_SYS)
-	    printf("/%d", errno);
-	printf("\n");
-	error++;
+        printf("opening '%s' returned error %d", fname, ze);
+        if (zip_error_get_sys_type(ze) == ZIP_ET_SYS)
+            printf("/%d", errno);
+        printf("\n");
+        error++;
     }
 
     if (error > 0)
-	fprintf(stderr, "%d errors\n", error);
+        fprintf(stderr, "%d errors\n", error);
 
     return error ? 1 : 0;
 }
diff --git a/regress/ziptool_regress.c b/regress/ziptool_regress.c
index e98c053..0b7f109 100644
--- a/regress/ziptool_regress.c
+++ b/regress/ziptool_regress.c
@@ -22,14 +22,14 @@
 
 #define GETOPT_REGRESS                              \
     case 'H':                                       \
-	source_type = SOURCE_TYPE_HOLE;             \
-	break;                                      \
+        source_type = SOURCE_TYPE_HOLE;             \
+        break;                                      \
     case 'm':                                       \
-	source_type = SOURCE_TYPE_IN_MEMORY;        \
-	break;                                      \
+        source_type = SOURCE_TYPE_IN_MEMORY;        \
+        break;                                      \
     case 'F':                                       \
-	fragment_size = strtoull(optarg, NULL, 10); \
-	break;
+        fragment_size = strtoull(optarg, NULL, 10); \
+        break;
 
 /* clang-format off */
 
@@ -62,14 +62,14 @@
     zip_uint64_t length = strtoull(argv[1], NULL, 10);
 
     if ((zs = source_nul(za, length)) == NULL) {
-	fprintf(stderr, "can't create zip_source for length: %s\n", zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't create zip_source for length: %s\n", zip_strerror(za));
+        return -1;
     }
 
     if (zip_add(za, argv[0], zs) == -1) {
-	zip_source_free(zs);
-	fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
-	return -1;
+        zip_source_free(zs);
+        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -77,8 +77,8 @@
 static int
 unchange_all(int argc, char *argv[]) {
     if (zip_unchange_all(za) < 0) {
-	fprintf(stderr, "can't revert changes to archive: %s\n", zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't revert changes to archive: %s\n", zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -86,7 +86,7 @@
 static int
 cancel_callback(zip_t *archive, void *ud) {
     if (progress_userdata.percentage >= progress_userdata.limit) {
-	return -1;
+        return -1;
     }
     return 0;
 }
@@ -96,8 +96,8 @@
     zip_int64_t percent;
     percent = strtoll(argv[0], NULL, 10);
     if (percent > 100 || percent < 0) {
-	fprintf(stderr, "invalid percentage '%" PRId64 "' for cancel (valid: 0 <= x <= 100)\n", percent);
-	return -1;
+        fprintf(stderr, "invalid percentage '%" PRId64 "' for cancel (valid: 0 <= x <= 100)\n", percent);
+        return -1;
     }
     progress_userdata.limit = ((double)percent) / 100;
 
@@ -114,12 +114,12 @@
 
     idx = strtoull(argv[0], NULL, 10);
     if (idx >= z_in_count) {
-	fprintf(stderr, "invalid argument '%" PRIu64 "', only %u zip sources open\n", idx, z_in_count);
-	return -1;
+        fprintf(stderr, "invalid argument '%" PRIu64 "', only %u zip sources open\n", idx, z_in_count);
+        return -1;
     }
     if (zip_close(z_in[idx]) < 0) {
-	fprintf(stderr, "can't close source archive: %s\n", zip_strerror(z_in[idx]));
-	return -1;
+        fprintf(stderr, "can't close source archive: %s\n", zip_strerror(z_in[idx]));
+        return -1;
     }
     z_in[idx] = z_in[z_in_count];
     z_in_count--;
@@ -134,12 +134,12 @@
     zip_t *zs = NULL;
 
     if (strcmp(archive, "/dev/stdin") == 0) {
-	zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
+        return NULL;
     }
 
     if ((src = source_hole_create(archive, flags, error)) == NULL || (zs = zip_open_from_source(src, flags, error)) == NULL) {
-	zip_source_free(src);
+        zip_source_free(src);
     }
 
     return zs;
@@ -153,103 +153,103 @@
     FILE *fp;
 
     if (strcmp(archive, "/dev/stdin") == 0) {
-	zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
-	return NULL;
+        zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
+        return NULL;
     }
 
     if ((fp = fopen(archive, "rb")) == NULL) {
-	if (errno == ENOENT) {
-	    src = zip_source_buffer_create(NULL, 0, 0, error);
-	}
-	else {
-	    zip_error_set(error, ZIP_ER_OPEN, errno);
-	    return NULL;
-	}
+        if (errno == ENOENT) {
+            src = zip_source_buffer_create(NULL, 0, 0, error);
+        }
+        else {
+            zip_error_set(error, ZIP_ER_OPEN, errno);
+            return NULL;
+        }
     }
     else {
-	struct stat st;
+        struct stat st;
 
-	if (fstat(fileno(fp), &st) < 0) {
-	    fclose(fp);
-	    zip_error_set(error, ZIP_ER_OPEN, errno);
-	    return NULL;
-	}
-	if (fragment_size == 0) {
-	    char *buf;
-	    if ((buf = malloc((size_t)st.st_size)) == NULL) {
-		fclose(fp);
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return NULL;
-	    }
-	    if (fread(buf, (size_t)st.st_size, 1, fp) < 1) {
-		free(buf);
-		fclose(fp);
-		zip_error_set(error, ZIP_ER_READ, errno);
-		return NULL;
-	    }
-	    src = zip_source_buffer_create(buf, (zip_uint64_t)st.st_size, 1, error);
-	    if (src == NULL) {
-		free(buf);
-	    }
-	}
-	else {
-	    zip_uint64_t nfragments, i, left;
-	    zip_buffer_fragment_t *fragments;
+        if (fstat(fileno(fp), &st) < 0) {
+            fclose(fp);
+            zip_error_set(error, ZIP_ER_OPEN, errno);
+            return NULL;
+        }
+        if (fragment_size == 0) {
+            char *buf;
+            if ((buf = malloc((size_t)st.st_size)) == NULL) {
+                fclose(fp);
+                zip_error_set(error, ZIP_ER_MEMORY, 0);
+                return NULL;
+            }
+            if (fread(buf, (size_t)st.st_size, 1, fp) < 1) {
+                free(buf);
+                fclose(fp);
+                zip_error_set(error, ZIP_ER_READ, errno);
+                return NULL;
+            }
+            src = zip_source_buffer_create(buf, (zip_uint64_t)st.st_size, 1, error);
+            if (src == NULL) {
+                free(buf);
+            }
+        }
+        else {
+            zip_uint64_t nfragments, i, left;
+            zip_buffer_fragment_t *fragments;
 
-	    nfragments = ((size_t)st.st_size + fragment_size - 1) / fragment_size;
-	    if ((fragments = malloc(sizeof(fragments[0]) * nfragments)) == NULL) {
-		fclose(fp);
-		zip_error_set(error, ZIP_ER_MEMORY, 0);
-		return NULL;
-	    }
-	    for (i = 0; i < nfragments; i++) {
-		left = ZIP_MIN(fragment_size, (size_t)st.st_size - i * fragment_size);
-		if ((fragments[i].data = malloc(left)) == NULL) {
+            nfragments = ((size_t)st.st_size + fragment_size - 1) / fragment_size;
+            if ((fragments = malloc(sizeof(fragments[0]) * nfragments)) == NULL) {
+                fclose(fp);
+                zip_error_set(error, ZIP_ER_MEMORY, 0);
+                return NULL;
+            }
+            for (i = 0; i < nfragments; i++) {
+                left = ZIP_MIN(fragment_size, (size_t)st.st_size - i * fragment_size);
+                if ((fragments[i].data = malloc(left)) == NULL) {
 #ifndef __clang_analyzer__
-		    /* fragments is initialized up to i - 1*/
-		    while (--i > 0) {
-			free(fragments[i].data);
-		    }
+                    /* fragments is initialized up to i - 1*/
+                    while (--i > 0) {
+                        free(fragments[i].data);
+                    }
 #endif
-		    free(fragments);
-		    fclose(fp);
-		    zip_error_set(error, ZIP_ER_MEMORY, 0);
-		    return NULL;
-		}
-		fragments[i].length = left;
-		if (fread(fragments[i].data, left, 1, fp) < 1) {
+                    free(fragments);
+                    fclose(fp);
+                    zip_error_set(error, ZIP_ER_MEMORY, 0);
+                    return NULL;
+                }
+                fragments[i].length = left;
+                if (fread(fragments[i].data, left, 1, fp) < 1) {
 #ifndef __clang_analyzer__
-		    /* fragments is initialized up to i - 1*/
-		    while (--i > 0) {
-			free(fragments[i].data);
-		    }
+                    /* fragments is initialized up to i - 1*/
+                    while (--i > 0) {
+                        free(fragments[i].data);
+                    }
 #endif
-		    free(fragments);
-		    fclose(fp);
-		    zip_error_set(error, ZIP_ER_READ, errno);
-		    return NULL;
-		}
-	    }
-	    src = zip_source_buffer_fragment_create(fragments, nfragments, 1, error);
-	    if (src == NULL) {
-		for (i = 0; i < nfragments; i++) {
-		    free(fragments[i].data);
-		}
-		free(fragments);
-		fclose(fp);
-		return NULL;
-	    }
-	    free(fragments);
-	}
-	fclose(fp);
+                    free(fragments);
+                    fclose(fp);
+                    zip_error_set(error, ZIP_ER_READ, errno);
+                    return NULL;
+                }
+            }
+            src = zip_source_buffer_fragment_create(fragments, nfragments, 1, error);
+            if (src == NULL) {
+                for (i = 0; i < nfragments; i++) {
+                    free(fragments[i].data);
+                }
+                free(fragments);
+                fclose(fp);
+                return NULL;
+            }
+            free(fragments);
+        }
+        fclose(fp);
     }
     if (src == NULL) {
-	return NULL;
+        return NULL;
     }
     zb = zip_open_from_source(src, flags, error);
     if (zb == NULL) {
-	zip_source_free(src);
-	return NULL;
+        zip_source_free(src);
+        return NULL;
     }
     zip_source_keep(src);
     *srcp = src;
@@ -269,52 +269,52 @@
 
     switch (command) {
     case ZIP_SOURCE_CLOSE:
-	return 0;
+        return 0;
 
     case ZIP_SOURCE_ERROR:
-	return zip_error_to_data(&ctx->error, data, length);
+        return zip_error_to_data(&ctx->error, data, length);
 
     case ZIP_SOURCE_FREE:
-	free(ctx);
-	return 0;
+        free(ctx);
+        return 0;
 
     case ZIP_SOURCE_OPEN:
-	ctx->offset = 0;
-	return 0;
+        ctx->offset = 0;
+        return 0;
 
     case ZIP_SOURCE_READ:
-	if (length > ZIP_INT64_MAX) {
-	    zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
-	    return -1;
-	}
+        if (length > ZIP_INT64_MAX) {
+            zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);
+            return -1;
+        }
 
-	if (length > ctx->length - ctx->offset) {
-	    length = ctx->length - ctx->offset;
-	}
+        if (length > ctx->length - ctx->offset) {
+            length = ctx->length - ctx->offset;
+        }
 
-	memset(data, 0, length);
-	ctx->offset += length;
-	return (zip_int64_t)length;
+        memset(data, 0, length);
+        ctx->offset += length;
+        return (zip_int64_t)length;
 
     case ZIP_SOURCE_STAT: {
-	zip_stat_t *st = ZIP_SOURCE_GET_ARGS(zip_stat_t, data, length, &ctx->error);
+        zip_stat_t *st = ZIP_SOURCE_GET_ARGS(zip_stat_t, data, length, &ctx->error);
 
-	if (st == NULL) {
-	    return -1;
-	}
+        if (st == NULL) {
+            return -1;
+        }
 
-	st->valid |= ZIP_STAT_SIZE;
-	st->size = ctx->length;
+        st->valid |= ZIP_STAT_SIZE;
+        st->size = ctx->length;
 
-	return 0;
+        return 0;
     }
 
     case ZIP_SOURCE_SUPPORTS:
-	return zip_source_make_command_bitmap(ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_STAT, -1);
+        return zip_source_make_command_bitmap(ZIP_SOURCE_CLOSE, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_STAT, -1);
 
     default:
-	zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
-	return -1;
+        zip_error_set(&ctx->error, ZIP_ER_OPNOTSUPP, 0);
+        return -1;
     }
 }
 
@@ -324,8 +324,8 @@
     zip_source_t *src;
 
     if ((ctx = (source_nul_t *)malloc(sizeof(*ctx))) == NULL) {
-	zip_error_set(zip_get_error(zs), ZIP_ER_MEMORY, 0);
-	return NULL;
+        zip_error_set(zip_get_error(zs), ZIP_ER_MEMORY, 0);
+        return NULL;
     }
 
     zip_error_init(&ctx->error);
@@ -333,8 +333,8 @@
     ctx->offset = 0;
 
     if ((src = zip_source_function(zs, source_nul_cb, ctx)) == NULL) {
-	free(ctx);
-	return NULL;
+        free(ctx);
+        return NULL;
     }
 
     return src;
@@ -348,47 +348,47 @@
     FILE *fp;
 
     if (zip_source_stat(src, &zst) < 0) {
-	fprintf(stderr, "zip_source_stat on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
-	return -1;
+        fprintf(stderr, "zip_source_stat on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
+        return -1;
     }
     if (zip_source_open(src) < 0) {
-	if (zip_error_code_zip(zip_source_error(src)) == ZIP_ER_DELETED) {
-	    if (unlink(archive) < 0 && errno != ENOENT) {
-		fprintf(stderr, "unlink failed: %s\n", strerror(errno));
-		return -1;
-	    }
-	    return 0;
-	}
-	fprintf(stderr, "zip_source_open on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
-	return -1;
+        if (zip_error_code_zip(zip_source_error(src)) == ZIP_ER_DELETED) {
+            if (unlink(archive) < 0 && errno != ENOENT) {
+                fprintf(stderr, "unlink failed: %s\n", strerror(errno));
+                return -1;
+            }
+            return 0;
+        }
+        fprintf(stderr, "zip_source_open on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
+        return -1;
     }
     if ((buf = malloc(zst.size)) == NULL) {
-	fprintf(stderr, "malloc failed: %s\n", strerror(errno));
-	zip_source_close(src);
-	return -1;
+        fprintf(stderr, "malloc failed: %s\n", strerror(errno));
+        zip_source_close(src);
+        return -1;
     }
     if (zip_source_read(src, buf, zst.size) < (zip_int64_t)zst.size) {
-	fprintf(stderr, "zip_source_read on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
-	zip_source_close(src);
-	free(buf);
-	return -1;
+        fprintf(stderr, "zip_source_read on buffer failed: %s\n", zip_error_strerror(zip_source_error(src)));
+        zip_source_close(src);
+        free(buf);
+        return -1;
     }
     zip_source_close(src);
     if ((fp = fopen(archive, "wb")) == NULL) {
-	fprintf(stderr, "fopen failed: %s\n", strerror(errno));
-	free(buf);
-	return -1;
+        fprintf(stderr, "fopen failed: %s\n", strerror(errno));
+        free(buf);
+        return -1;
     }
     if (fwrite(buf, zst.size, 1, fp) < 1) {
-	fprintf(stderr, "fwrite failed: %s\n", strerror(errno));
-	free(buf);
-	fclose(fp);
-	return -1;
+        fprintf(stderr, "fwrite failed: %s\n", strerror(errno));
+        free(buf);
+        fclose(fp);
+        return -1;
     }
     free(buf);
     if (fclose(fp) != 0) {
-	fprintf(stderr, "fclose failed: %s\n", strerror(errno));
-	return -1;
+        fprintf(stderr, "fclose failed: %s\n", strerror(errno));
+        return -1;
     }
     return 0;
 }
@@ -398,16 +398,16 @@
 ziptool_open(const char *archive, int flags, zip_error_t *error, zip_uint64_t offset, zip_uint64_t len) {
     switch (source_type) {
     case SOURCE_TYPE_NONE:
-	za = read_from_file(archive, flags, error, offset, len);
-	break;
+        za = read_from_file(archive, flags, error, offset, len);
+        break;
 
     case SOURCE_TYPE_IN_MEMORY:
-	za = read_to_memory(archive, flags, error, &memory_src);
-	break;
+        za = read_to_memory(archive, flags, error, &memory_src);
+        break;
 
     case SOURCE_TYPE_HOLE:
-	za = read_hole(archive, flags, error);
-	break;
+        za = read_hole(archive, flags, error);
+        break;
     }
 
     return za;
@@ -417,10 +417,10 @@
 int
 ziptool_post_close(const char *archive) {
     if (source_type == SOURCE_TYPE_IN_MEMORY) {
-	if (write_memory_src_to_file(archive, memory_src) < 0) {
-	    return -1;
-	}
-	zip_source_free(memory_src);
+        if (write_memory_src_to_file(archive, memory_src) < 0) {
+            return -1;
+        }
+        zip_source_free(memory_src);
     }
 
     return 0;
diff --git a/src/getopt.c b/src/getopt.c
index befd672..a9879c4 100644
--- a/src/getopt.c
+++ b/src/getopt.c
@@ -61,50 +61,50 @@
     char *oli;                 /* option letter list index */
 
     if (optreset || !*place) { /* update scanning pointer */
-	optreset = 0;
-	if (optind >= nargc || *(place = nargv[optind]) != '-') {
-	    place = EMSG;
-	    return (EOF);
-	}
-	if (place[1] && *++place == '-') { /* found "--" */
-	    ++optind;
-	    place = EMSG;
-	    return (EOF);
-	}
+        optreset = 0;
+        if (optind >= nargc || *(place = nargv[optind]) != '-') {
+            place = EMSG;
+            return (EOF);
+        }
+        if (place[1] && *++place == '-') { /* found "--" */
+            ++optind;
+            place = EMSG;
+            return (EOF);
+        }
     } /* option letter okay? */
     if ((optopt = (int)*place++) == (int)':' || !(oli = (char *)strchr(ostr, optopt))) {
-	/*
-	 * if the user didn't specify '-' as an option,
-	 * assume it means EOF.
-	 */
-	if (optopt == (int)'-')
-	    return (EOF);
-	if (!*place)
-	    ++optind;
-	if (opterr && *ostr != ':')
-	    (void)fprintf(stderr, "illegal option -- %c\n", optopt);
-	return (BADCH);
+        /*
+         * if the user didn't specify '-' as an option,
+         * assume it means EOF.
+         */
+        if (optopt == (int)'-')
+            return (EOF);
+        if (!*place)
+            ++optind;
+        if (opterr && *ostr != ':')
+            (void)fprintf(stderr, "illegal option -- %c\n", optopt);
+        return (BADCH);
     }
     if (*++oli != ':') { /* don't need argument */
-	optarg = NULL;
-	if (!*place)
-	    ++optind;
+        optarg = NULL;
+        if (!*place)
+            ++optind;
     }
     else {          /* need an argument */
-	if (*place) /* no white space */
-	    optarg = place;
-	else if (nargc <= ++optind) { /* no arg */
-	    place = EMSG;
-	    if (*ostr == ':')
-		return (BADARG);
-	    if (opterr)
-		(void)fprintf(stderr, "option requires an argument -- %c\n", optopt);
-	    return (BADCH);
-	}
-	else /* white space */
-	    optarg = nargv[optind];
-	place = EMSG;
-	++optind;
+        if (*place) /* no white space */
+            optarg = place;
+        else if (nargc <= ++optind) { /* no arg */
+            place = EMSG;
+            if (*ostr == ':')
+                return (BADARG);
+            if (opterr)
+                (void)fprintf(stderr, "option requires an argument -- %c\n", optopt);
+            return (BADCH);
+        }
+        else /* white space */
+            optarg = nargv[optind];
+        place = EMSG;
+        ++optind;
     }
     return (optopt); /* dump back option letter */
 }
diff --git a/src/zipcmp.c b/src/zipcmp.c
index 83b70fd..815eda9 100644
--- a/src/zipcmp.c
+++ b/src/zipcmp.c
@@ -145,41 +145,41 @@
     verbose = 1;
 
     while ((c = getopt(argc, argv, OPTIONS)) != -1) {
-	switch (c) {
-	case 'i':
-	    ignore_case = 1;
-	    break;
-	case 'p':
-	    paranoid = 1;
-	    break;
-	case 'q':
-	    verbose = 0;
-	    break;
-	case 't':
-	    test_files = 1;
-	    break;
-	case 'v':
-	    verbose = 1;
-	    break;
+        switch (c) {
+        case 'i':
+            ignore_case = 1;
+            break;
+        case 'p':
+            paranoid = 1;
+            break;
+        case 'q':
+            verbose = 0;
+            break;
+        case 't':
+            test_files = 1;
+            break;
+        case 'v':
+            verbose = 1;
+            break;
 
-	case 'h':
-	    fputs(help_head, stdout);
-	    printf(USAGE, progname);
-	    fputs(help, stdout);
-	    exit(0);
-	case 'V':
-	    fputs(version_string, stdout);
-	    exit(0);
+        case 'h':
+            fputs(help_head, stdout);
+            printf(USAGE, progname);
+            fputs(help, stdout);
+            exit(0);
+        case 'V':
+            fputs(version_string, stdout);
+            exit(0);
 
-	default:
-	    fprintf(stderr, USAGE, progname);
-	    exit(2);
-	}
+        default:
+            fprintf(stderr, USAGE, progname);
+            exit(2);
+        }
     }
 
     if (argc != optind + 2) {
-	fprintf(stderr, USAGE, progname);
-	exit(2);
+        fprintf(stderr, USAGE, progname);
+        exit(2);
     }
 
     exit((compare_zip(argv + optind) == 0) ? 0 : 1);
@@ -195,29 +195,29 @@
     int res;
 
     for (i = 0; i < 2; i++) {
-	a[i].name = zn[i];
-	a[i].entry = NULL;
-	a[i].nentry = 0;
-	a[i].za = NULL;
-	a[i].comment = NULL;
-	a[i].comment_length = 0;
+        a[i].name = zn[i];
+        a[i].entry = NULL;
+        a[i].nentry = 0;
+        a[i].za = NULL;
+        a[i].comment = NULL;
+        a[i].comment_length = 0;
 
-	if (is_directory(zn[i])) {
+        if (is_directory(zn[i])) {
 #ifndef HAVE_FTS_H
-	    fprintf(stderr, "%s: reading directories not supported\n", progname);
-	    exit(2);
+            fprintf(stderr, "%s: reading directories not supported\n", progname);
+            exit(2);
 #else
-	    if (list_directory(zn[i], a + i) < 0)
-		exit(2);
-	    paranoid = 0; /* paranoid checks make no sense for directories, since they compare zip metadata */
+            if (list_directory(zn[i], a + i) < 0)
+                exit(2);
+            paranoid = 0; /* paranoid checks make no sense for directories, since they compare zip metadata */
 #endif
-	}
-	else {
-	    if (list_zip(zn[i], a + i) < 0)
-		exit(2);
-	}
-	if (a[i].nentry > 0)
-	    qsort(a[i].entry, a[i].nentry, sizeof(a[i].entry[0]), entry_cmp);
+        }
+        else {
+            if (list_zip(zn[i], a + i) < 0)
+                exit(2);
+        }
+        if (a[i].nentry > 0)
+            qsort(a[i].entry, a[i].nentry, sizeof(a[i].entry[0]), entry_cmp);
     }
 
     header_done = 0;
@@ -229,36 +229,36 @@
     res = compare_list(zn, (const void **)e, n, sizeof(e[i][0]), entry_cmp, paranoid ? entry_paranoia_checks : NULL, entry_print);
 
     if (paranoid) {
-	if (comment_compare(a[0].comment, a[0].comment_length, a[1].comment, a[1].comment_length) != 0) {
-	    if (verbose) {
-		printf("--- archive comment (%zu)\n", a[0].comment_length);
-		printf("+++ archive comment (%zu)\n", a[1].comment_length);
-	    }
-	    res = 1;
-	}
+        if (comment_compare(a[0].comment, a[0].comment_length, a[1].comment, a[1].comment_length) != 0) {
+            if (verbose) {
+                printf("--- archive comment (%zu)\n", a[0].comment_length);
+                printf("+++ archive comment (%zu)\n", a[1].comment_length);
+            }
+            res = 1;
+        }
     }
 
     for (i = 0; i < 2; i++) {
-	zip_uint64_t j;
+        zip_uint64_t j;
 
-	if (a[i].za) {
-	    zip_close(a[i].za);
-	}
-	for (j = 0; j < a[i].nentry; j++) {
-	    free(a[i].entry[j].name);
-	}
-	free(a[i].entry);
+        if (a[i].za) {
+            zip_close(a[i].za);
+        }
+        for (j = 0; j < a[i].nentry; j++) {
+            free(a[i].entry[j].name);
+        }
+        free(a[i].entry);
     }
 
     switch (res) {
     case 0:
-	exit(0);
+        exit(0);
 
     case 1:
-	exit(1);
+        exit(1);
 
     default:
-	exit(2);
+        exit(2);
     }
 }
 
@@ -272,18 +272,18 @@
 
 
     if ((f = fopen(fname, "rb")) == NULL) {
-	fprintf(stderr, "%s: can't open %s: %s\n", progname, fname, strerror(errno));
-	return -1;
+        fprintf(stderr, "%s: can't open %s: %s\n", progname, fname, strerror(errno));
+        return -1;
     }
 
     while ((n = fread(buffer, 1, sizeof(buffer), f)) > 0) {
-	crc = crc32(crc, buffer, (unsigned int)n);
+        crc = crc32(crc, buffer, (unsigned int)n);
     }
 
     if (ferror(f)) {
-	fprintf(stderr, "%s: read error on %s: %s\n", progname, fname, strerror(errno));
-	fclose(f);
-	return -1;
+        fprintf(stderr, "%s: read error on %s: %s\n", progname, fname, strerror(errno));
+        fclose(f);
+        return -1;
     }
 
     fclose(f);
@@ -298,7 +298,7 @@
     struct stat st;
 
     if (stat(name, &st) < 0)
-	return 0;
+        return 0;
 
     return S_ISDIR(st.st_mode);
 }
@@ -316,64 +316,64 @@
 
 
     if ((fts = fts_open(names, FTS_NOCHDIR | FTS_LOGICAL, NULL)) == NULL) {
-	fprintf(stderr, "%s: can't open directory '%s': %s\n", progname, name, strerror(errno));
-	return -1;
+        fprintf(stderr, "%s: can't open directory '%s': %s\n", progname, name, strerror(errno));
+        return -1;
     }
     prefix_length = strlen(name) + 1;
 
     nalloc = 0;
 
     while ((ent = fts_read(fts))) {
-	zip_int64_t crc;
+        zip_int64_t crc;
 
-	switch (ent->fts_info) {
-	case FTS_D:
-	case FTS_DOT:
-	case FTS_DP:
-	case FTS_DEFAULT:
-	case FTS_SL:
-	case FTS_NSOK:
-	    break;
+        switch (ent->fts_info) {
+        case FTS_D:
+        case FTS_DOT:
+        case FTS_DP:
+        case FTS_DEFAULT:
+        case FTS_SL:
+        case FTS_NSOK:
+            break;
 
-	case FTS_DC:
-	case FTS_DNR:
-	case FTS_ERR:
-	case FTS_NS:
-	case FTS_SLNONE:
-	    /* TODO: error */
-	    fts_close(fts);
-	    return -1;
+        case FTS_DC:
+        case FTS_DNR:
+        case FTS_ERR:
+        case FTS_NS:
+        case FTS_SLNONE:
+            /* TODO: error */
+            fts_close(fts);
+            return -1;
 
-	case FTS_F:
-	    if (a->nentry >= nalloc) {
-		nalloc += 16;
-		if (nalloc > SIZE_MAX / sizeof(a->entry[0])) {
-		    fprintf(stderr, "%s: malloc failure\n", progname);
-		    exit(1);
-		}
-		a->entry = realloc(a->entry, sizeof(a->entry[0]) * nalloc);
-		if (a->entry == NULL) {
-		    fprintf(stderr, "%s: malloc failure\n", progname);
-		    exit(1);
-		}
-	    }
+        case FTS_F:
+            if (a->nentry >= nalloc) {
+                nalloc += 16;
+                if (nalloc > SIZE_MAX / sizeof(a->entry[0])) {
+                    fprintf(stderr, "%s: malloc failure\n", progname);
+                    exit(1);
+                }
+                a->entry = realloc(a->entry, sizeof(a->entry[0]) * nalloc);
+                if (a->entry == NULL) {
+                    fprintf(stderr, "%s: malloc failure\n", progname);
+                    exit(1);
+                }
+            }
 
-	    a->entry[a->nentry].name = strdup(ent->fts_path + prefix_length);
-	    a->entry[a->nentry].size = (zip_uint64_t)ent->fts_statp->st_size;
-	    if ((crc = compute_crc(ent->fts_accpath)) < 0) {
-		fts_close(fts);
-		return -1;
-	    }
+            a->entry[a->nentry].name = strdup(ent->fts_path + prefix_length);
+            a->entry[a->nentry].size = (zip_uint64_t)ent->fts_statp->st_size;
+            if ((crc = compute_crc(ent->fts_accpath)) < 0) {
+                fts_close(fts);
+                return -1;
+            }
 
-	    a->entry[a->nentry].crc = (zip_uint32_t)crc;
-	    a->nentry++;
-	    break;
-	}
+            a->entry[a->nentry].crc = (zip_uint32_t)crc;
+            a->nentry++;
+            break;
+        }
     }
 
     if (fts_close(fts)) {
-	fprintf(stderr, "%s: error closing directory '%s': %s\n", progname, a->name, strerror(errno));
-	return -1;
+        fprintf(stderr, "%s: error closing directory '%s': %s\n", progname, a->name, strerror(errno));
+        return -1;
     }
 
     return 0;
@@ -389,51 +389,51 @@
     unsigned int i;
 
     if ((za = zip_open(name, paranoid ? ZIP_CHECKCONS : 0, &err)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "%s: cannot open zip archive '%s': %s\n", progname, name, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return -1;
+        zip_error_t error;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "%s: cannot open zip archive '%s': %s\n", progname, name, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return -1;
     }
 
     a->za = za;
     a->nentry = (zip_uint64_t)zip_get_num_entries(za, 0);
 
     if (a->nentry == 0)
-	a->entry = NULL;
+        a->entry = NULL;
     else {
-	if ((a->nentry > SIZE_MAX / sizeof(a->entry[0])) || (a->entry = (struct entry *)malloc(sizeof(a->entry[0]) * a->nentry)) == NULL) {
-	    fprintf(stderr, "%s: malloc failure\n", progname);
-	    exit(1);
-	}
+        if ((a->nentry > SIZE_MAX / sizeof(a->entry[0])) || (a->entry = (struct entry *)malloc(sizeof(a->entry[0]) * a->nentry)) == NULL) {
+            fprintf(stderr, "%s: malloc failure\n", progname);
+            exit(1);
+        }
 
-	for (i = 0; i < a->nentry; i++) {
-	    zip_stat_index(za, i, 0, &st);
-	    a->entry[i].name = strdup(st.name);
-	    a->entry[i].size = st.size;
-	    a->entry[i].crc = st.crc;
-	    if (test_files)
-		test_file(za, i, st.size, st.crc);
-	    if (paranoid) {
-		a->entry[i].comp_method = st.comp_method;
-		ef_read(za, i, a->entry + i);
-		a->entry[i].comment = zip_file_get_comment(za, i, &a->entry[i].comment_length, 0);
-	    }
-	    else {
-		a->entry[i].comp_method = 0;
-		a->entry[i].n_extra_fields = 0;
-	    }
-	}
+        for (i = 0; i < a->nentry; i++) {
+            zip_stat_index(za, i, 0, &st);
+            a->entry[i].name = strdup(st.name);
+            a->entry[i].size = st.size;
+            a->entry[i].crc = st.crc;
+            if (test_files)
+                test_file(za, i, st.size, st.crc);
+            if (paranoid) {
+                a->entry[i].comp_method = st.comp_method;
+                ef_read(za, i, a->entry + i);
+                a->entry[i].comment = zip_file_get_comment(za, i, &a->entry[i].comment_length, 0);
+            }
+            else {
+                a->entry[i].comp_method = 0;
+                a->entry[i].n_extra_fields = 0;
+            }
+        }
 
-	if (paranoid) {
-	    int length;
-	    a->comment = zip_get_archive_comment(za, &length, 0);
-	    a->comment_length = (size_t)length;
-	}
-	else {
-	    a->comment = NULL;
-	    a->comment_length = 0;
-	}
+        if (paranoid) {
+            int length;
+            a->comment = zip_get_archive_comment(za, &length, 0);
+            a->comment_length = (size_t)length;
+        }
+        else {
+            a->comment = NULL;
+            a->comment_length = 0;
+        }
     }
 
     return 0;
@@ -443,13 +443,13 @@
 static int
 comment_compare(const char *c1, size_t l1, const char *c2, size_t l2) {
     if (l1 != l2)
-	return 1;
+        return 1;
 
     if (l1 == 0)
-	return 0;
+        return 0;
 
     if (c1 == NULL || c2 == NULL)
-	return c1 == c2;
+        return c1 == c2;
 
     return memcmp(c1, c2, (size_t)l2);
 }
@@ -464,43 +464,43 @@
 #define INC(k) (i[k]++, l[k] = ((const char *)l[k]) + size)
 #define PRINT(k)                                          \
     do {                                                  \
-	if (header_done == 0 && verbose) {                \
-	    printf("--- %s\n+++ %s\n", name[0], name[1]); \
-	    header_done = 1;                              \
-	}                                                 \
-	if (verbose) {                                    \
-	    printf("%c ", (k) ? '+' : '-');               \
-	    print(l[k]);                                  \
-	}                                                 \
-	diff = 1;                                         \
+        if (header_done == 0 && verbose) {                \
+            printf("--- %s\n+++ %s\n", name[0], name[1]); \
+            header_done = 1;                              \
+        }                                                 \
+        if (verbose) {                                    \
+            printf("%c ", (k) ? '+' : '-');               \
+            print(l[k]);                                  \
+        }                                                 \
+        diff = 1;                                         \
     } while (0)
 
     i[0] = i[1] = 0;
     diff = 0;
     while (i[0] < n[0] && i[1] < n[1]) {
-	c = cmp(l[0], l[1]);
+        c = cmp(l[0], l[1]);
 
-	if (c == 0) {
-	    if (check)
-		diff |= check(name, l[0], l[1]);
-	    INC(0);
-	    INC(1);
-	}
-	else if (c < 0) {
-	    PRINT(0);
-	    INC(0);
-	}
-	else {
-	    PRINT(1);
-	    INC(1);
-	}
+        if (c == 0) {
+            if (check)
+                diff |= check(name, l[0], l[1]);
+            INC(0);
+            INC(1);
+        }
+        else if (c < 0) {
+            PRINT(0);
+            INC(0);
+        }
+        else {
+            PRINT(1);
+            INC(1);
+        }
     }
 
     for (j = 0; j < 2; j++) {
-	while (i[j] < n[j]) {
-	    PRINT(j);
-	    INC(j);
-	}
+        while (i[j] < n[j]) {
+            PRINT(j);
+            INC(j);
+        }
     }
 
     return diff;
@@ -513,27 +513,27 @@
     zip_uint16_t i;
 
     if ((n_local = zip_file_extra_fields_count(za, idx, ZIP_FL_LOCAL)) < 0 || (n_central = zip_file_extra_fields_count(za, idx, ZIP_FL_CENTRAL)) < 0) {
-	return -1;
+        return -1;
     }
 
     e->n_extra_fields = (zip_uint16_t)(n_local + n_central);
 
     if ((e->extra_fields = (struct ef *)malloc(sizeof(e->extra_fields[0]) * e->n_extra_fields)) == NULL)
-	return -1;
+        return -1;
 
     for (i = 0; i < n_local; i++) {
-	e->extra_fields[i].name = e->name;
-	e->extra_fields[i].data = zip_file_extra_field_get(za, idx, i, &e->extra_fields[i].id, &e->extra_fields[i].size, ZIP_FL_LOCAL);
-	if (e->extra_fields[i].data == NULL)
-	    return -1;
-	e->extra_fields[i].flags = ZIP_FL_LOCAL;
+        e->extra_fields[i].name = e->name;
+        e->extra_fields[i].data = zip_file_extra_field_get(za, idx, i, &e->extra_fields[i].id, &e->extra_fields[i].size, ZIP_FL_LOCAL);
+        if (e->extra_fields[i].data == NULL)
+            return -1;
+        e->extra_fields[i].flags = ZIP_FL_LOCAL;
     }
     for (; i < e->n_extra_fields; i++) {
-	e->extra_fields[i].name = e->name;
-	e->extra_fields[i].data = zip_file_extra_field_get(za, idx, (zip_uint16_t)(i - n_local), &e->extra_fields[i].id, &e->extra_fields[i].size, ZIP_FL_CENTRAL);
-	if (e->extra_fields[i].data == NULL)
-	    return -1;
-	e->extra_fields[i].flags = ZIP_FL_CENTRAL;
+        e->extra_fields[i].name = e->name;
+        e->extra_fields[i].data = zip_file_extra_field_get(za, idx, (zip_uint16_t)(i - n_local), &e->extra_fields[i].id, &e->extra_fields[i].size, ZIP_FL_CENTRAL);
+        if (e->extra_fields[i].data == NULL)
+            return -1;
+        e->extra_fields[i].flags = ZIP_FL_CENTRAL;
     }
 
     qsort(e->extra_fields, e->n_extra_fields, sizeof(e->extra_fields[0]), ef_order);
@@ -564,11 +564,11 @@
     b = (struct ef *)bp;
 
     if (a->flags != b->flags)
-	return a->flags - b->flags;
+        return a->flags - b->flags;
     if (a->id != b->id)
-	return a->id - b->id;
+        return a->id - b->id;
     if (a->size != b->size)
-	return a->size - b->size;
+        return a->size - b->size;
     return memcmp(a->data, b->data, a->size);
 }
 
@@ -581,7 +581,7 @@
     printf("                    %s  ", ef->name);
     printf("%04x %c <", ef->id, ef->flags == ZIP_FL_LOCAL ? 'l' : 'c');
     for (i = 0; i < ef->size; i++)
-	printf("%s%02x", i ? " " : "", ef->data[i]);
+        printf("%s%02x", i ? " " : "", ef->data[i]);
     printf(">\n");
 }
 
@@ -595,15 +595,15 @@
     e2 = (struct entry *)p2;
 
     if ((c = (ignore_case ? strcasecmp : strcmp)(e1->name, e2->name)) != 0)
-	return c;
+        return c;
     if (e1->size != e2->size) {
-	if (e1->size > e2->size)
-	    return 1;
-	else
-	    return -1;
+        if (e1->size > e2->size)
+            return 1;
+        else
+            return -1;
     }
     if (e1->crc != e2->crc)
-	return (int)e1->crc - (int)e2->crc;
+        return (int)e1->crc - (int)e2->crc;
 
     return 0;
 }
@@ -620,33 +620,33 @@
     ret = 0;
 
     if (ef_compare(name, e1, e2) != 0)
-	ret = 1;
+        ret = 1;
 
     if (e1->comp_method != e2->comp_method) {
-	if (verbose) {
-	    if (header_done == 0) {
-		printf("--- %s\n+++ %s\n", name[0], name[1]);
-		header_done = 1;
-	    }
-	    printf("---                     %s  ", e1->name);
-	    printf("method %u\n", e1->comp_method);
-	    printf("+++                     %s  ", e1->name);
-	    printf("method %u\n", e2->comp_method);
-	}
-	ret = 1;
+        if (verbose) {
+            if (header_done == 0) {
+                printf("--- %s\n+++ %s\n", name[0], name[1]);
+                header_done = 1;
+            }
+            printf("---                     %s  ", e1->name);
+            printf("method %u\n", e1->comp_method);
+            printf("+++                     %s  ", e1->name);
+            printf("method %u\n", e2->comp_method);
+        }
+        ret = 1;
     }
     if (comment_compare(e1->comment, e1->comment_length, e2->comment, e2->comment_length) != 0) {
-	if (verbose) {
-	    if (header_done == 0) {
-		printf("--- %s\n+++ %s\n", name[0], name[1]);
-		header_done = 1;
-	    }
-	    printf("---                     %s  ", e1->name);
-	    printf("comment %" PRIu32 "\n", e1->comment_length);
-	    printf("+++                     %s  ", e1->name);
-	    printf("comment %" PRIu32 "\n", e2->comment_length);
-	}
-	ret = 1;
+        if (verbose) {
+            if (header_done == 0) {
+                printf("--- %s\n+++ %s\n", name[0], name[1]);
+                header_done = 1;
+            }
+            printf("---                     %s  ", e1->name);
+            printf("comment %" PRIu32 "\n", e1->comment_length);
+            printf("+++                     %s  ", e1->name);
+            printf("comment %" PRIu32 "\n", e2->comment_length);
+        }
+        ret = 1;
     }
 
     return ret;
@@ -673,33 +673,33 @@
     zip_uint32_t ncrc;
 
     if ((zf = zip_fopen_index(za, idx, 0)) == NULL) {
-	fprintf(stderr, "%s: cannot open file %" PRIu64 " in archive: %s\n", progname, idx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "%s: cannot open file %" PRIu64 " in archive: %s\n", progname, idx, zip_strerror(za));
+        return -1;
     }
 
     ncrc = (zip_uint32_t)crc32(0, NULL, 0);
     nsize = 0;
 
     while ((n = zip_fread(zf, buf, sizeof(buf))) > 0) {
-	nsize += (zip_uint64_t)n;
-	ncrc = (zip_uint32_t)crc32(ncrc, (const Bytef *)buf, (unsigned int)n);
+        nsize += (zip_uint64_t)n;
+        ncrc = (zip_uint32_t)crc32(ncrc, (const Bytef *)buf, (unsigned int)n);
     }
 
     if (n < 0) {
-	fprintf(stderr, "%s: error reading file %" PRIu64 " in archive: %s\n", progname, idx, zip_file_strerror(zf));
-	zip_fclose(zf);
-	return -1;
+        fprintf(stderr, "%s: error reading file %" PRIu64 " in archive: %s\n", progname, idx, zip_file_strerror(zf));
+        zip_fclose(zf);
+        return -1;
     }
 
     zip_fclose(zf);
 
     if (nsize != size) {
-	fprintf(stderr, "%s: file %" PRIu64 ": unexpected length %" PRId64 " (should be %" PRId64 ")\n", progname, idx, nsize, size);
-	return -2;
+        fprintf(stderr, "%s: file %" PRIu64 ": unexpected length %" PRId64 " (should be %" PRId64 ")\n", progname, idx, nsize, size);
+        return -2;
     }
     if (ncrc != crc) {
-	fprintf(stderr, "%s: file %" PRIu64 ": unexpected length %x (should be %x)\n", progname, idx, ncrc, crc);
-	return -2;
+        fprintf(stderr, "%s: file %" PRIu64 ": unexpected length %x (should be %x)\n", progname, idx, ncrc, crc);
+        return -2;
     }
 
     return 0;
diff --git a/src/zipmerge.c b/src/zipmerge.c
index cb3247a..7ffb470 100644
--- a/src/zipmerge.c
+++ b/src/zipmerge.c
@@ -97,43 +97,43 @@
     name_flags = 0;
 
     while ((c = getopt(argc, argv, OPTIONS)) != -1) {
-	switch (c) {
-	case 'D':
-	    name_flags |= ZIP_FL_NODIR;
-	    break;
-	case 'i':
-	    confirm &= ~CONFIRM_ALL_YES;
-	    break;
-	case 'I':
-	    name_flags |= ZIP_FL_NOCASE;
-	    break;
-	case 's':
-	    confirm &= ~CONFIRM_SAME_NO;
-	    confirm |= CONFIRM_SAME_YES;
-	    break;
-	case 'S':
-	    confirm &= ~CONFIRM_SAME_YES;
-	    confirm |= CONFIRM_SAME_NO;
-	    break;
+        switch (c) {
+        case 'D':
+            name_flags |= ZIP_FL_NODIR;
+            break;
+        case 'i':
+            confirm &= ~CONFIRM_ALL_YES;
+            break;
+        case 'I':
+            name_flags |= ZIP_FL_NOCASE;
+            break;
+        case 's':
+            confirm &= ~CONFIRM_SAME_NO;
+            confirm |= CONFIRM_SAME_YES;
+            break;
+        case 'S':
+            confirm &= ~CONFIRM_SAME_YES;
+            confirm |= CONFIRM_SAME_NO;
+            break;
 
-	case 'h':
-	    fputs(help_head, stdout);
-	    printf(USAGE, progname);
-	    fputs(help, stdout);
-	    exit(0);
-	case 'V':
-	    fputs(version_string, stdout);
-	    exit(0);
+        case 'h':
+            fputs(help_head, stdout);
+            printf(USAGE, progname);
+            fputs(help, stdout);
+            exit(0);
+        case 'V':
+            fputs(version_string, stdout);
+            exit(0);
 
-	default:
-	    fprintf(stderr, USAGE, progname);
-	    exit(2);
-	}
+        default:
+            fprintf(stderr, USAGE, progname);
+            exit(2);
+        }
     }
 
     if (argc < optind + 2) {
-	fprintf(stderr, USAGE, progname);
-	exit(2);
+        fprintf(stderr, USAGE, progname);
+        exit(2);
     }
 
     tname = argv[optind++];
@@ -141,30 +141,30 @@
 
     n = (unsigned int)(argc - optind);
     if ((zs = (zip_t **)malloc(sizeof(zs[0]) * n)) == NULL) {
-	fprintf(stderr, "%s: out of memory\n", progname);
-	exit(1);
+        fprintf(stderr, "%s: out of memory\n", progname);
+        exit(1);
     }
 
     if ((za = zip_open(tname, ZIP_CREATE, &err)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, tname, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	exit(1);
+        zip_error_t error;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, tname, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        exit(1);
     }
 
     for (i = 0; i < n; i++) {
-	if ((zs[i] = merge_zip(za, tname, argv[i])) == NULL)
-	    exit(1);
+        if ((zs[i] = merge_zip(za, tname, argv[i])) == NULL)
+            exit(1);
     }
 
     if (zip_close(za) < 0) {
-	fprintf(stderr, "%s: cannot write zip archive '%s': %s\n", progname, tname, zip_strerror(za));
-	exit(1);
+        fprintf(stderr, "%s: cannot write zip archive '%s': %s\n", progname, tname, zip_strerror(za));
+        exit(1);
     }
 
     for (i = 0; i < n; i++)
-	zip_close(zs[i]);
+        zip_close(zs[i]);
 
     exit(0);
 }
@@ -176,38 +176,38 @@
     struct zip_stat st, ss;
 
     if (confirm & CONFIRM_ALL_YES)
-	return 1;
+        return 1;
     else if (confirm & CONFIRM_ALL_NO)
-	return 0;
+        return 0;
 
     if (zip_stat_index(za, it, ZIP_FL_UNCHANGED, &st) < 0) {
-	fprintf(stderr, "%s: cannot stat file %" PRIu64 " in '%s': %s\n", progname, it, tname, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "%s: cannot stat file %" PRIu64 " in '%s': %s\n", progname, it, tname, zip_strerror(za));
+        return -1;
     }
     if (zip_stat_index(zs, is, 0, &ss) < 0) {
-	fprintf(stderr, "%s: cannot stat file %" PRIu64 " in '%s': %s\n", progname, is, sname, zip_strerror(zs));
-	return -1;
+        fprintf(stderr, "%s: cannot stat file %" PRIu64 " in '%s': %s\n", progname, is, sname, zip_strerror(zs));
+        return -1;
     }
 
     if (st.size == ss.size && st.crc == ss.crc) {
-	if (confirm & CONFIRM_SAME_YES)
-	    return 1;
-	else if (confirm & CONFIRM_SAME_NO)
-	    return 0;
+        if (confirm & CONFIRM_SAME_YES)
+            return 1;
+        else if (confirm & CONFIRM_SAME_NO)
+            return 0;
     }
 
     printf("replace '%s' (%" PRIu64 " / %08x) in `%s'\n"
-	   "   with '%s' (%" PRIu64 " / %08x) from `%s'? ",
-	   st.name, st.size, st.crc, tname, ss.name, ss.size, ss.crc, sname);
+           "   with '%s' (%" PRIu64 " / %08x) from `%s'? ",
+           st.name, st.size, st.crc, tname, ss.name, ss.size, ss.crc, sname);
     fflush(stdout);
 
     if (fgets(line, sizeof(line), stdin) == NULL) {
-	fprintf(stderr, "%s: read error from stdin: %s\n", progname, strerror(errno));
-	return -1;
+        fprintf(stderr, "%s: read error from stdin: %s\n", progname, strerror(errno));
+        return -1;
     }
 
     if (tolower((unsigned char)line[0]) == 'y')
-	return 1;
+        return 1;
 
     return 0;
 }
@@ -223,56 +223,56 @@
     const char *fname;
 
     if ((zs = zip_open(sname, 0, &err)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, sname, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return NULL;
+        zip_error_t error;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "%s: can't open zip archive '%s': %s\n", progname, sname, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return NULL;
     }
 
     ret = zip_get_num_entries(zs, 0);
     if (ret < 0) {
-	fprintf(stderr, "%s: cannot get number of entries for '%s': %s\n", progname, sname, zip_strerror(za));
-	return NULL;
+        fprintf(stderr, "%s: cannot get number of entries for '%s': %s\n", progname, sname, zip_strerror(za));
+        return NULL;
     }
     for (i = 0; i < (zip_uint64_t)ret; i++) {
-	fname = zip_get_name(zs, i, 0);
+        fname = zip_get_name(zs, i, 0);
 
-	if ((idx = zip_name_locate(za, fname, name_flags)) >= 0) {
-	    switch (confirm_replace(za, tname, (zip_uint64_t)idx, zs, sname, i)) {
-	    case 0:
-		break;
+        if ((idx = zip_name_locate(za, fname, name_flags)) >= 0) {
+            switch (confirm_replace(za, tname, (zip_uint64_t)idx, zs, sname, i)) {
+            case 0:
+                break;
 
-	    case 1:
-		if ((source = zip_source_zip(za, zs, i, 0, 0, 0)) == NULL || zip_replace(za, (zip_uint64_t)idx, source) < 0) {
-		    zip_source_free(source);
-		    fprintf(stderr, "%s: cannot replace '%s' in `%s': %s\n", progname, fname, tname, zip_strerror(za));
-		    zip_close(zs);
-		    return NULL;
-		}
-		break;
+            case 1:
+                if ((source = zip_source_zip(za, zs, i, 0, 0, 0)) == NULL || zip_replace(za, (zip_uint64_t)idx, source) < 0) {
+                    zip_source_free(source);
+                    fprintf(stderr, "%s: cannot replace '%s' in `%s': %s\n", progname, fname, tname, zip_strerror(za));
+                    zip_close(zs);
+                    return NULL;
+                }
+                break;
 
-	    case -1:
-		zip_close(zs);
-		return NULL;
+            case -1:
+                zip_close(zs);
+                return NULL;
 
-	    default:
-		fprintf(stderr,
-			"%s: internal error: "
-			"unexpected return code from confirm (%d)\n",
-			progname, err);
-		zip_close(zs);
-		return NULL;
-	    }
-	}
-	else {
-	    if ((source = zip_source_zip(za, zs, i, 0, 0, 0)) == NULL || zip_add(za, fname, source) < 0) {
-		zip_source_free(source);
-		fprintf(stderr, "%s: cannot add '%s' to `%s': %s\n", progname, fname, tname, zip_strerror(za));
-		zip_close(zs);
-		return NULL;
-	    }
-	}
+            default:
+                fprintf(stderr,
+                        "%s: internal error: "
+                        "unexpected return code from confirm (%d)\n",
+                        progname, err);
+                zip_close(zs);
+                return NULL;
+            }
+        }
+        else {
+            if ((source = zip_source_zip(za, zs, i, 0, 0, 0)) == NULL || zip_add(za, fname, source) < 0) {
+                zip_source_free(source);
+                fprintf(stderr, "%s: cannot add '%s' to `%s': %s\n", progname, fname, tname, zip_strerror(za));
+                zip_close(zs);
+                return NULL;
+            }
+        }
     }
 
     return zs;
diff --git a/src/ziptool.c b/src/ziptool.c
index c946987..c6681cf 100644
--- a/src/ziptool.c
+++ b/src/ziptool.c
@@ -85,14 +85,14 @@
     zip_source_t *zs;
 
     if ((zs = zip_source_buffer(za, argv[1], strlen(argv[1]), 0)) == NULL) {
-	fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't create zip_source from buffer: %s\n", zip_strerror(za));
+        return -1;
     }
 
     if (zip_add(za, argv[0], zs) == -1) {
-	zip_source_free(zs);
-	fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
-	return -1;
+        zip_source_free(zs);
+        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -101,8 +101,8 @@
 add_dir(int argc, char *argv[]) {
     /* add directory */
     if (zip_add_dir(za, argv[0]) < 0) {
-	fprintf(stderr, "can't add directory '%s': %s\n", argv[0], zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't add directory '%s': %s\n", argv[0], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -114,22 +114,22 @@
     zip_int64_t len = strtoll(argv[3], NULL, 10);
 
     if (strcmp(argv[1], "/dev/stdin") == 0) {
-	if ((zs = zip_source_filep(za, stdin, start, len)) == NULL) {
-	    fprintf(stderr, "can't create zip_source from stdin: %s\n", zip_strerror(za));
-	    return -1;
-	}
+        if ((zs = zip_source_filep(za, stdin, start, len)) == NULL) {
+            fprintf(stderr, "can't create zip_source from stdin: %s\n", zip_strerror(za));
+            return -1;
+        }
     }
     else {
-	if ((zs = zip_source_file(za, argv[1], start, len)) == NULL) {
-	    fprintf(stderr, "can't create zip_source from file: %s\n", zip_strerror(za));
-	    return -1;
-	}
+        if ((zs = zip_source_file(za, argv[1], start, len)) == NULL) {
+            fprintf(stderr, "can't create zip_source from file: %s\n", zip_strerror(za));
+            return -1;
+        }
     }
 
     if (zip_add(za, argv[0], zs) == -1) {
-	zip_source_free(zs);
-	fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
-	return -1;
+        zip_source_free(zs);
+        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -145,22 +145,22 @@
     start = strtoull(argv[3], NULL, 10);
     len = strtoll(argv[4], NULL, 10);
     if ((z_in[z_in_count] = zip_open(argv[1], ZIP_CHECKCONS, &err)) == NULL) {
-	zip_error_t error;
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "can't open zip archive '%s': %s\n", argv[1], zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return -1;
+        zip_error_t error;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "can't open zip archive '%s': %s\n", argv[1], zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return -1;
     }
     if ((zs = zip_source_zip(za, z_in[z_in_count], idx, 0, start, len)) == NULL) {
-	fprintf(stderr, "error creating file source from '%s' index '%" PRIu64 "': %s\n", argv[1], idx, zip_strerror(za));
-	zip_close(z_in[z_in_count]);
-	return -1;
+        fprintf(stderr, "error creating file source from '%s' index '%" PRIu64 "': %s\n", argv[1], idx, zip_strerror(za));
+        zip_close(z_in[z_in_count]);
+        return -1;
     }
     if (zip_add(za, argv[0], zs) == -1) {
-	fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
-	zip_source_free(zs);
-	zip_close(z_in[z_in_count]);
-	return -1;
+        fprintf(stderr, "can't add file '%s': %s\n", argv[0], zip_strerror(za));
+        zip_source_free(zs);
+        zip_close(z_in[z_in_count]);
+        return -1;
     }
     z_in_count++;
     return 0;
@@ -181,27 +181,27 @@
     setmode(fileno(stdout), _O_BINARY);
 #endif
     if ((zf = zip_fopen_index(za, idx, 0)) == NULL) {
-	fprintf(stderr, "can't open file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't open file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
+        return -1;
     }
     while ((n = zip_fread(zf, buf, sizeof(buf))) > 0) {
-	if (fwrite(buf, (size_t)n, 1, stdout) != 1) {
-	    zip_fclose(zf);
-	    fprintf(stderr, "can't write file contents to stdout: %s\n", strerror(errno));
-	    return -1;
-	}
+        if (fwrite(buf, (size_t)n, 1, stdout) != 1) {
+            zip_fclose(zf);
+            fprintf(stderr, "can't write file contents to stdout: %s\n", strerror(errno));
+            return -1;
+        }
     }
     if (n == -1) {
-	fprintf(stderr, "can't read file at index '%" PRIu64 "': %s\n", idx, zip_file_strerror(zf));
-	zip_fclose(zf);
-	return -1;
+        fprintf(stderr, "can't read file at index '%" PRIu64 "': %s\n", idx, zip_file_strerror(zf));
+        zip_fclose(zf);
+        return -1;
     }
     if ((err = zip_fclose(zf)) != 0) {
-	zip_error_t error;
+        zip_error_t error;
 
-	zip_error_init_with_code(&error, err);
-	fprintf(stderr, "can't close file at index '%" PRIu64 "': %s\n", idx, zip_error_strerror(&error));
-	return -1;
+        zip_error_init_with_code(&error, err);
+        fprintf(stderr, "can't close file at index '%" PRIu64 "': %s\n", idx, zip_error_strerror(&error));
+        return -1;
     }
 
     return 0;
@@ -215,11 +215,11 @@
     idx = strtoull(argv[0], NULL, 10);
     ceflags = get_flags(argv[1]);
     if ((count = zip_file_extra_fields_count(za, idx, ceflags)) < 0) {
-	fprintf(stderr, "can't get extra field count for file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't get extra field count for file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
+        return -1;
     }
     else {
-	printf("Extra field count: %d\n", count);
+        printf("Extra field count: %d\n", count);
     }
     return 0;
 }
@@ -234,11 +234,11 @@
     eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
     ceflags = get_flags(argv[2]);
     if ((count = zip_file_extra_fields_count_by_id(za, idx, eid, ceflags)) < 0) {
-	fprintf(stderr, "can't get extra field count for file at index '%" PRIu64 "' and for id '%d': %s\n", idx, eid, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't get extra field count for file at index '%" PRIu64 "' and for id '%d': %s\n", idx, eid, zip_strerror(za));
+        return -1;
     }
     else {
-	printf("Extra field count: %d\n", count);
+        printf("Extra field count: %d\n", count);
     }
     return 0;
 }
@@ -247,8 +247,8 @@
     zip_uint64_t idx;
     idx = strtoull(argv[0], NULL, 10);
     if (zip_delete(za, idx) < 0) {
-	fprintf(stderr, "can't delete file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't delete file at index '%" PRIu64 "': %s\n", idx, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -262,8 +262,8 @@
     eid = (zip_uint16_t)strtoull(argv[1], NULL, 10);
     geflags = get_flags(argv[2]);
     if ((zip_file_extra_field_delete(za, idx, eid, geflags)) < 0) {
-	fprintf(stderr, "can't delete extra field data for file at index '%" PRIu64 "', extra field id '%d': %s\n", idx, eid, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't delete extra field data for file at index '%" PRIu64 "', extra field id '%d': %s\n", idx, eid, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -278,8 +278,8 @@
     eidx = (zip_uint16_t)strtoull(argv[2], NULL, 10);
     geflags = get_flags(argv[3]);
     if ((zip_file_extra_field_delete_by_id(za, idx, eid, eidx, geflags)) < 0) {
-	fprintf(stderr, "can't delete extra field data for file at index '%" PRIu64 "', extra field id '%d', extra field idx '%d': %s\n", idx, eid, eidx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't delete extra field data for file at index '%" PRIu64 "', extra field id '%d', extra field idx '%d': %s\n", idx, eid, eidx, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -290,9 +290,9 @@
     int len;
     /* get archive comment */
     if ((comment = zip_get_archive_comment(za, &len, 0)) == NULL)
-	printf("No archive comment\n");
+        printf("No archive comment\n");
     else
-	printf("Archive comment: %.*s\n", len, comment);
+        printf("Archive comment: %.*s\n", len, comment);
     return 0;
 }
 
@@ -307,13 +307,13 @@
     eidx = (zip_uint16_t)strtoull(argv[1], NULL, 10);
     geflags = get_flags(argv[2]);
     if ((efdata = zip_file_extra_field_get(za, idx, eidx, &id, &eflen, geflags)) == NULL) {
-	fprintf(stderr, "can't get extra field data for file at index %" PRIu64 ", extra field %d, flags %u: %s\n", idx, eidx, geflags, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't get extra field data for file at index %" PRIu64 ", extra field %d, flags %u: %s\n", idx, eidx, geflags, zip_strerror(za));
+        return -1;
     }
     printf("Extra field 0x%04x: len %d", id, eflen);
     if (eflen > 0) {
-	printf(", data ");
-	hexdump(efdata, eflen);
+        printf(", data ");
+        hexdump(efdata, eflen);
     }
     printf("\n");
     return 0;
@@ -330,13 +330,13 @@
     eidx = (zip_uint16_t)strtoull(argv[2], NULL, 10);
     geflags = get_flags(argv[3]);
     if ((efdata = zip_file_extra_field_get_by_id(za, idx, eid, eidx, &eflen, geflags)) == NULL) {
-	fprintf(stderr, "can't get extra field data for file at index %" PRIu64 ", extra field id %d, ef index %d, flags %u: %s\n", idx, eid, eidx, geflags, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't get extra field data for file at index %" PRIu64 ", extra field id %d, ef index %d, flags %u: %s\n", idx, eid, eidx, geflags, zip_strerror(za));
+        return -1;
     }
     printf("Extra field 0x%04x: len %d", eid, eflen);
     if (eflen > 0) {
-	printf(", data ");
-	hexdump(efdata, eflen);
+        printf(", data ");
+        hexdump(efdata, eflen);
     }
     printf("\n");
     return 0;
@@ -350,13 +350,13 @@
     /* get file comment */
     idx = strtoull(argv[0], NULL, 10);
     if ((comment = zip_get_file_comment(za, idx, &len, 0)) == NULL) {
-	fprintf(stderr, "can't get comment for '%s': %s\n", zip_get_name(za, idx, 0), zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't get comment for '%s': %s\n", zip_get_name(za, idx, 0), zip_strerror(za));
+        return -1;
     }
     else if (len == 0)
-	printf("No comment for '%s'\n", zip_get_name(za, idx, 0));
+        printf("No comment for '%s'\n", zip_get_name(za, idx, 0));
     else
-	printf("File comment for '%s': %.*s\n", zip_get_name(za, idx, 0), len, comment);
+        printf("File comment for '%s': %.*s\n", zip_get_name(za, idx, 0), len, comment);
     return 0;
 }
 
@@ -378,10 +378,10 @@
     flags = get_flags(argv[1]);
 
     if ((idx = zip_name_locate(za, argv[0], flags)) < 0) {
-	fprintf(stderr, "can't find entry with name '%s' using flags '%s'\n", argv[0], argv[1]);
+        fprintf(stderr, "can't find entry with name '%s' using flags '%s'\n", argv[0], argv[1]);
     }
     else {
-	printf("name '%s' using flags '%s' found at index %" PRId64 "\n", argv[0], argv[1], idx);
+        printf("name '%s' using flags '%s' found at index %" PRId64 "\n", argv[0], argv[1], idx);
     }
 
     return 0;
@@ -411,8 +411,8 @@
     zip_uint64_t idx;
     idx = strtoull(argv[0], NULL, 10);
     if (zip_rename(za, idx, argv[1]) < 0) {
-	fprintf(stderr, "can't rename file at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't rename file at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -426,9 +426,9 @@
     idx = strtoull(argv[0], NULL, 10);
     content = argv[1];
     if ((s = zip_source_buffer(za, content, strlen(content), 0)) == NULL || zip_file_replace(za, idx, s, 0) < 0) {
-	zip_source_free(s);
-	fprintf(stderr, "error replacing file data: %s\n", zip_strerror(za));
-	return -1;
+        zip_source_free(s);
+        fprintf(stderr, "error replacing file data: %s\n", zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -445,8 +445,8 @@
     geflags = get_flags(argv[3]);
     efdata = (zip_uint8_t *)argv[4];
     if ((zip_file_extra_field_set(za, idx, eid, eidx, efdata, (zip_uint16_t)strlen((const char *)efdata), geflags)) < 0) {
-	fprintf(stderr, "can't set extra field data for file at index '%" PRIu64 "', extra field id '%d', index '%d': %s\n", idx, eid, eidx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set extra field data for file at index '%" PRIu64 "', extra field id '%d', index '%d': %s\n", idx, eid, eidx, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -454,8 +454,8 @@
 static int
 set_archive_comment(int argc, char *argv[]) {
     if (zip_set_archive_comment(za, argv[0], (zip_uint16_t)strlen(argv[0])) < 0) {
-	fprintf(stderr, "can't set archive comment to '%s': %s\n", argv[0], zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set archive comment to '%s': %s\n", argv[0], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -465,8 +465,8 @@
     zip_uint64_t idx;
     idx = strtoull(argv[0], NULL, 10);
     if (zip_file_set_comment(za, idx, argv[1], (zip_uint16_t)strlen(argv[1]), 0) < 0) {
-	fprintf(stderr, "can't set file comment at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set file comment at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -480,8 +480,8 @@
     method = get_compression_method(argv[1]);
     flags = (zip_uint32_t)strtoull(argv[2], NULL, 10);
     if (zip_set_file_compression(za, idx, method, flags) < 0) {
-	fprintf(stderr, "can't set file compression method at index '%" PRIu64 "' to '%s', flags '%" PRIu32 "': %s\n", idx, argv[1], flags, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set file compression method at index '%" PRIu64 "' to '%s', flags '%" PRIu32 "': %s\n", idx, argv[1], flags, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -495,11 +495,11 @@
     method = get_encryption_method(argv[1]);
     password = argv[2];
     if (strlen(password) == 0) {
-	password = NULL;
+        password = NULL;
     }
     if (zip_file_set_encryption(za, idx, method, password) < 0) {
-	fprintf(stderr, "can't set file encryption method at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set file encryption method at index '%" PRIu64 "' to '%s': %s\n", idx, argv[1], zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -513,8 +513,8 @@
     dostime = (zip_uint16_t)strtoull(argv[1], NULL, 10);
     dosdate = (zip_uint16_t)strtoull(argv[2], NULL, 10);
     if (zip_file_set_dostime(za, idx, dostime, dosdate, 0) < 0) {
-	fprintf(stderr, "can't set file dostime at index '%" PRIu64 "' to '%d'/'%d': %s\n", idx, (int)dostime, (int)dosdate, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set file dostime at index '%" PRIu64 "' to '%d'/'%d': %s\n", idx, (int)dostime, (int)dosdate, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -527,8 +527,8 @@
     idx = strtoull(argv[0], NULL, 10);
     mtime = (time_t)strtoull(argv[1], NULL, 10);
     if (zip_file_set_mtime(za, idx, mtime, 0) < 0) {
-	fprintf(stderr, "can't set file mtime at index '%" PRIu64 "' to '%lld': %s\n", idx, (long long)mtime, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't set file mtime at index '%" PRIu64 "' to '%lld': %s\n", idx, (long long)mtime, zip_strerror(za));
+        return -1;
     }
     return 0;
 }
@@ -542,14 +542,14 @@
     mtime = (time_t)strtoull(argv[0], NULL, 10);
 
     if ((num_entries = zip_get_num_entries(za, 0)) < 0) {
-	fprintf(stderr, "can't get number of entries: %s\n", zip_strerror(za));
-	return -1;
+        fprintf(stderr, "can't get number of entries: %s\n", zip_strerror(za));
+        return -1;
     }
     for (idx = 0; idx < (zip_uint64_t)num_entries; idx++) {
-	if (zip_file_set_mtime(za, idx, mtime, 0) < 0) {
-	    fprintf(stderr, "can't set file mtime at index '%" PRIu64 "' to '%lld': %s\n", idx, (long long)mtime, zip_strerror(za));
-	    return -1;
-	}
+        if (zip_file_set_mtime(za, idx, mtime, 0) < 0) {
+            fprintf(stderr, "can't set file mtime at index '%" PRIu64 "' to '%lld': %s\n", idx, (long long)mtime, zip_strerror(za));
+            return -1;
+        }
     }
     return 0;
 }
@@ -558,8 +558,8 @@
 set_password(int argc, char *argv[]) {
     /* set default password */
     if (zip_set_default_password(za, argv[0]) < 0) {
-	fprintf(stderr, "can't set default password to '%s'\n", argv[0]);
-	return -1;
+        fprintf(stderr, "can't set default password to '%s'\n", argv[0]);
+        return -1;
     }
     return 0;
 }
@@ -572,42 +572,42 @@
     idx = strtoull(argv[0], NULL, 10);
 
     if (zip_stat_index(za, idx, stat_flags, &sb) < 0) {
-	fprintf(stderr, "zip_stat_index failed on '%" PRIu64 "' failed: %s\n", idx, zip_strerror(za));
-	return -1;
+        fprintf(stderr, "zip_stat_index failed on '%" PRIu64 "' failed: %s\n", idx, zip_strerror(za));
+        return -1;
     }
 
     if (sb.valid & ZIP_STAT_NAME)
-	printf("name: '%s'\n", sb.name);
+        printf("name: '%s'\n", sb.name);
     if (sb.valid & ZIP_STAT_INDEX)
-	printf("index: '%" PRIu64 "'\n", sb.index);
+        printf("index: '%" PRIu64 "'\n", sb.index);
     if (sb.valid & ZIP_STAT_SIZE)
-	printf("size: '%" PRIu64 "'\n", sb.size);
+        printf("size: '%" PRIu64 "'\n", sb.size);
     if (sb.valid & ZIP_STAT_COMP_SIZE)
-	printf("compressed size: '%" PRIu64 "'\n", sb.comp_size);
+        printf("compressed size: '%" PRIu64 "'\n", sb.comp_size);
     if (sb.valid & ZIP_STAT_MTIME) {
-	struct tm *tpm;
+        struct tm *tpm;
 #ifdef HAVE_LOCALTIME_R
-	struct tm tm;
-	tpm = localtime_r(&sb.mtime, &tm);
+        struct tm tm;
+        tpm = localtime_r(&sb.mtime, &tm);
 #else
-	tpm = localtime(&sb.mtime);
+        tpm = localtime(&sb.mtime);
 #endif
-	if (tpm == NULL) {
-	    printf("mtime: <not valid>\n");
-	}
-	else {
-	    strftime(buf, sizeof(buf), "%a %b %d %Y %H:%M:%S", tpm);
-	    printf("mtime: '%s'\n", buf);
-	}
+        if (tpm == NULL) {
+            printf("mtime: <not valid>\n");
+        }
+        else {
+            strftime(buf, sizeof(buf), "%a %b %d %Y %H:%M:%S", tpm);
+            printf("mtime: '%s'\n", buf);
+        }
     }
     if (sb.valid & ZIP_STAT_CRC)
-	printf("crc: '%0x'\n", sb.crc);
+        printf("crc: '%0x'\n", sb.crc);
     if (sb.valid & ZIP_STAT_COMP_METHOD)
-	printf("compression method: '%d'\n", sb.comp_method);
+        printf("compression method: '%d'\n", sb.comp_method);
     if (sb.valid & ZIP_STAT_ENCRYPTION_METHOD)
-	printf("encryption method: '%d'\n", sb.encryption_method);
+        printf("encryption method: '%d'\n", sb.encryption_method);
     if (sb.valid & ZIP_STAT_FLAGS)
-	printf("flags: '%ld'\n", (long)sb.flags);
+        printf("flags: '%ld'\n", (long)sb.flags);
     printf("\n");
 
     return 0;
@@ -617,67 +617,67 @@
 get_flags(const char *arg) {
     zip_flags_t flags = 0;
     if (strchr(arg, 'C') != NULL)
-	flags |= ZIP_FL_NOCASE;
+        flags |= ZIP_FL_NOCASE;
     if (strchr(arg, 'c') != NULL)
-	flags |= ZIP_FL_CENTRAL;
+        flags |= ZIP_FL_CENTRAL;
     if (strchr(arg, 'd') != NULL)
-	flags |= ZIP_FL_NODIR;
+        flags |= ZIP_FL_NODIR;
     if (strchr(arg, 'l') != NULL)
-	flags |= ZIP_FL_LOCAL;
+        flags |= ZIP_FL_LOCAL;
     if (strchr(arg, 'u') != NULL)
-	flags |= ZIP_FL_UNCHANGED;
+        flags |= ZIP_FL_UNCHANGED;
     return flags;
 }
 
 static zip_int32_t
 get_compression_method(const char *arg) {
     if (strcasecmp(arg, "default") == 0)
-	return ZIP_CM_DEFAULT;
+        return ZIP_CM_DEFAULT;
     else if (strcasecmp(arg, "store") == 0)
-	return ZIP_CM_STORE;
+        return ZIP_CM_STORE;
     else if (strcasecmp(arg, "deflate") == 0)
-	return ZIP_CM_DEFLATE;
+        return ZIP_CM_DEFLATE;
 #if defined(HAVE_LIBBZ2)
     else if (strcasecmp(arg, "bzip2") == 0)
-	return ZIP_CM_BZIP2;
+        return ZIP_CM_BZIP2;
 #endif
 #if defined(HAVE_LIBLZMA)
     /*  Disabled - because 7z isn't able to unpack ZIP+LZMA ZIP+LZMA2
-	archives made this way - and vice versa.
+        archives made this way - and vice versa.
 
-	else if (strcasecmp(arg, "lzma") == 0)
-	  return ZIP_CM_LZMA;
-	else if (strcasecmp(arg, "lzma2") == 0)
-	  return ZIP_CM_LZMA2;
+        else if (strcasecmp(arg, "lzma") == 0)
+          return ZIP_CM_LZMA;
+        else if (strcasecmp(arg, "lzma2") == 0)
+          return ZIP_CM_LZMA2;
     */
     else if (strcasecmp(arg, "xz") == 0)
-	return ZIP_CM_XZ;
+        return ZIP_CM_XZ;
 
 #endif
 #if defined(HAVE_LIBZSTD)
     else if (strcasecmp(arg, "zstd") == 0)
-	return ZIP_CM_ZSTD;
+        return ZIP_CM_ZSTD;
 
 #endif
     else if (strcasecmp(arg, "unknown") == 0)
-	return 100;
+        return 100;
     return 0; /* TODO: error handling */
 }
 
 static zip_uint16_t
 get_encryption_method(const char *arg) {
     if (strcasecmp(arg, "none") == 0)
-	return ZIP_EM_NONE;
+        return ZIP_EM_NONE;
     else if (strcasecmp(arg, "PKWARE") == 0)
-	return ZIP_EM_TRAD_PKWARE;
+        return ZIP_EM_TRAD_PKWARE;
     else if (strcasecmp(arg, "AES-128") == 0)
-	return ZIP_EM_AES_128;
+        return ZIP_EM_AES_128;
     else if (strcasecmp(arg, "AES-192") == 0)
-	return ZIP_EM_AES_192;
+        return ZIP_EM_AES_192;
     else if (strcasecmp(arg, "AES-256") == 0)
-	return ZIP_EM_AES_256;
+        return ZIP_EM_AES_256;
     else if (strcasecmp(arg, "unknown") == 0)
-	return 100;
+        return 100;
     return (zip_uint16_t)-1; /* TODO: error handling */
 }
 
@@ -686,12 +686,12 @@
     zip_uint16_t i;
 
     if (len <= 0)
-	return;
+        return;
 
     printf("0x");
 
     for (i = 0; i < len; i++)
-	printf("%02x", data[i]);
+        printf("%02x", data[i]);
 
     return;
 }
@@ -704,63 +704,63 @@
     int err;
 
     if (offset == 0 && length == 0) {
-	if (strcmp(archive, "/dev/stdin") == 0) {
-	    zaa = zip_fdopen(STDIN_FILENO, flags & ~ZIP_CREATE, &err);
-	}
-	else {
-	    zaa = zip_open(archive, flags, &err);
-	}
-	if (zaa == NULL) {
-	    zip_error_set(error, err, errno);
-	    return NULL;
-	}
+        if (strcmp(archive, "/dev/stdin") == 0) {
+            zaa = zip_fdopen(STDIN_FILENO, flags & ~ZIP_CREATE, &err);
+        }
+        else {
+            zaa = zip_open(archive, flags, &err);
+        }
+        if (zaa == NULL) {
+            zip_error_set(error, err, errno);
+            return NULL;
+        }
     }
     else {
-	if (length > ZIP_INT64_MAX) {
-	    zip_error_set(error, ZIP_ER_INVAL, 0);
-	    return NULL;
-	}
-	if ((source = zip_source_file_create(archive, offset, (zip_int64_t)length, error)) == NULL || (zaa = zip_open_from_source(source, flags, error)) == NULL) {
-	    zip_source_free(source);
-	    return NULL;
-	}
+        if (length > ZIP_INT64_MAX) {
+            zip_error_set(error, ZIP_ER_INVAL, 0);
+            return NULL;
+        }
+        if ((source = zip_source_file_create(archive, offset, (zip_int64_t)length, error)) == NULL || (zaa = zip_open_from_source(source, flags, error)) == NULL) {
+            zip_source_free(source);
+            return NULL;
+        }
     }
 
     return zaa;
 }
 
 dispatch_table_t dispatch_table[] = {{"add", 2, "name content", "add file called name using content", add},
-				     {"add_dir", 1, "name", "add directory", add_dir},
-				     {"add_file", 4, "name file_to_add offset len", "add file to archive, len bytes starting from offset", add_file},
-				     {"add_from_zip", 5, "name archivename index offset len", "add file from another archive, len bytes starting from offset", add_from_zip},
-				     {"cat", 1, "index", "output file contents to stdout", cat},
-				     {"count_extra", 2, "index flags", "show number of extra fields for archive entry", count_extra},
-				     {"count_extra_by_id", 3, "index extra_id flags", "show number of extra fields of type extra_id for archive entry", count_extra_by_id},
-				     {"delete", 1, "index", "remove entry", delete},
-				     {"delete_extra", 3, "index extra_idx flags", "remove extra field", delete_extra},
-				     {"delete_extra_by_id", 4, "index extra_id extra_index flags", "remove extra field of type extra_id", delete_extra_by_id},
-				     {"get_archive_comment", 0, "", "show archive comment", get_archive_comment},
-				     {"get_extra", 3, "index extra_index flags", "show extra field", get_extra},
-				     {"get_extra_by_id", 4, "index extra_id extra_index flags", "show extra field of type extra_id", get_extra_by_id},
-				     {"get_file_comment", 1, "index", "get file comment", get_file_comment},
-				     {"get_num_entries", 1, "flags", "get number of entries in archive", get_num_entries},
-				     {"name_locate", 2, "name flags", "find entry in archive", name_locate},
-				     {"print_progress", 0, "", "print progress during zip_close()", print_progress},
-				     {"rename", 2, "index name", "rename entry", zrename},
-				     {"replace_file_contents", 2, "index data", "replace entry with data", replace_file_contents},
-				     {"set_archive_comment", 1, "comment", "set archive comment", set_archive_comment},
-				     {"set_extra", 5, "index extra_id extra_index flags value", "set extra field", set_extra},
-				     {"set_file_comment", 2, "index comment", "set file comment", set_file_comment},
-				     {"set_file_compression", 3, "index method compression_flags", "set file compression method", set_file_compression},
-				     {"set_file_dostime", 3, "index time date", "set file modification time and date (DOS format)", set_file_dostime},
-				     {"set_file_encryption", 3, "index method password", "set file encryption method", set_file_encryption},
-				     {"set_file_mtime", 2, "index timestamp", "set file modification time", set_file_mtime},
-				     {"set_file_mtime_all", 1, "timestamp", "set file modification time for all files", set_file_mtime_all},
-				     {"set_password", 1, "password", "set default password for encryption", set_password},
-				     {"stat", 1, "index", "print information about entry", zstat}
+                                     {"add_dir", 1, "name", "add directory", add_dir},
+                                     {"add_file", 4, "name file_to_add offset len", "add file to archive, len bytes starting from offset", add_file},
+                                     {"add_from_zip", 5, "name archivename index offset len", "add file from another archive, len bytes starting from offset", add_from_zip},
+                                     {"cat", 1, "index", "output file contents to stdout", cat},
+                                     {"count_extra", 2, "index flags", "show number of extra fields for archive entry", count_extra},
+                                     {"count_extra_by_id", 3, "index extra_id flags", "show number of extra fields of type extra_id for archive entry", count_extra_by_id},
+                                     {"delete", 1, "index", "remove entry", delete},
+                                     {"delete_extra", 3, "index extra_idx flags", "remove extra field", delete_extra},
+                                     {"delete_extra_by_id", 4, "index extra_id extra_index flags", "remove extra field of type extra_id", delete_extra_by_id},
+                                     {"get_archive_comment", 0, "", "show archive comment", get_archive_comment},
+                                     {"get_extra", 3, "index extra_index flags", "show extra field", get_extra},
+                                     {"get_extra_by_id", 4, "index extra_id extra_index flags", "show extra field of type extra_id", get_extra_by_id},
+                                     {"get_file_comment", 1, "index", "get file comment", get_file_comment},
+                                     {"get_num_entries", 1, "flags", "get number of entries in archive", get_num_entries},
+                                     {"name_locate", 2, "name flags", "find entry in archive", name_locate},
+                                     {"print_progress", 0, "", "print progress during zip_close()", print_progress},
+                                     {"rename", 2, "index name", "rename entry", zrename},
+                                     {"replace_file_contents", 2, "index data", "replace entry with data", replace_file_contents},
+                                     {"set_archive_comment", 1, "comment", "set archive comment", set_archive_comment},
+                                     {"set_extra", 5, "index extra_id extra_index flags value", "set extra field", set_extra},
+                                     {"set_file_comment", 2, "index comment", "set file comment", set_file_comment},
+                                     {"set_file_compression", 3, "index method compression_flags", "set file compression method", set_file_compression},
+                                     {"set_file_dostime", 3, "index time date", "set file modification time and date (DOS format)", set_file_dostime},
+                                     {"set_file_encryption", 3, "index method password", "set file encryption method", set_file_encryption},
+                                     {"set_file_mtime", 2, "index timestamp", "set file modification time", set_file_mtime},
+                                     {"set_file_mtime_all", 1, "timestamp", "set file modification time for all files", set_file_mtime_all},
+                                     {"set_password", 1, "password", "set default password for encryption", set_password},
+                                     {"stat", 1, "index", "print information about entry", zstat}
 #ifdef DISPATCH_REGRESS
-				     ,
-				     DISPATCH_REGRESS
+                                     ,
+                                     DISPATCH_REGRESS
 #endif
 };
 
@@ -768,18 +768,18 @@
 dispatch(int argc, char *argv[]) {
     unsigned int i;
     for (i = 0; i < sizeof(dispatch_table) / sizeof(dispatch_table_t); i++) {
-	if (strcmp(dispatch_table[i].cmdline_name, argv[0]) == 0) {
-	    argc--;
-	    argv++;
-	    /* 1 for the command, argument_count for the arguments */
-	    if (argc < dispatch_table[i].argument_count) {
-		fprintf(stderr, "not enough arguments for command '%s': %d available, %d needed\n", dispatch_table[i].cmdline_name, argc, dispatch_table[i].argument_count);
-		return -1;
-	    }
-	    if (dispatch_table[i].function(argc, argv) == 0)
-		return 1 + dispatch_table[i].argument_count;
-	    return -1;
-	}
+        if (strcmp(dispatch_table[i].cmdline_name, argv[0]) == 0) {
+            argc--;
+            argv++;
+            /* 1 for the command, argument_count for the arguments */
+            if (argc < dispatch_table[i].argument_count) {
+                fprintf(stderr, "not enough arguments for command '%s': %d available, %d needed\n", dispatch_table[i].cmdline_name, argc, dispatch_table[i].argument_count);
+                return -1;
+            }
+            if (dispatch_table[i].function(argc, argv) == 0)
+                return 1 + dispatch_table[i].argument_count;
+            return -1;
+        }
     }
 
     fprintf(stderr, "unknown command '%s'\n", argv[0]);
@@ -792,69 +792,69 @@
     unsigned int i;
     FILE *out;
     if (reason == NULL)
-	out = stdout;
+        out = stdout;
     else
-	out = stderr;
+        out = stderr;
     fprintf(out, "usage: %s [-ceghnrst]" USAGE_REGRESS " [-l len] [-o offset] archive command1 [args] [command2 [args] ...]\n", progname);
     if (reason != NULL) {
-	fprintf(out, "%s\n", reason);
-	exit(1);
+        fprintf(out, "%s\n", reason);
+        exit(1);
     }
 
     fprintf(out, "\nSupported options are:\n"
-		 "\t-c\t\tcheck consistency\n"
-		 "\t-e\t\terror if archive already exists (only useful with -n)\n"
+                 "\t-c\t\tcheck consistency\n"
+                 "\t-e\t\terror if archive already exists (only useful with -n)\n"
 #ifdef FOR_REGRESS
-		 "\t-F size\t\tfragment size for in memory archive\n"
+                 "\t-F size\t\tfragment size for in memory archive\n"
 #endif
-		 "\t-g\t\tguess file name encoding (for stat)\n"
+                 "\t-g\t\tguess file name encoding (for stat)\n"
 #ifdef FOR_REGRESS
-		 "\t-H\t\twrite files with holes compactly\n"
+                 "\t-H\t\twrite files with holes compactly\n"
 #endif
-		 "\t-h\t\tdisplay this usage\n"
-		 "\t-l len\t\tonly use len bytes of file\n"
+                 "\t-h\t\tdisplay this usage\n"
+                 "\t-l len\t\tonly use len bytes of file\n"
 #ifdef FOR_REGRESS
-		 "\t-m\t\tread archive into memory, and modify there; write out at end\n"
+                 "\t-m\t\tread archive into memory, and modify there; write out at end\n"
 #endif
-		 "\t-n\t\tcreate archive if it doesn't exist\n"
-		 "\t-o offset\tstart reading file at offset\n"
-		 "\t-r\t\tprint raw file name encoding without translation (for stat)\n"
-		 "\t-s\t\tfollow file name convention strictly (for stat)\n"
-		 "\t-t\t\tdisregard current archive contents, if any\n");
+                 "\t-n\t\tcreate archive if it doesn't exist\n"
+                 "\t-o offset\tstart reading file at offset\n"
+                 "\t-r\t\tprint raw file name encoding without translation (for stat)\n"
+                 "\t-s\t\tfollow file name convention strictly (for stat)\n"
+                 "\t-t\t\tdisregard current archive contents, if any\n");
     fprintf(out, "\nSupported commands and arguments are:\n");
     for (i = 0; i < sizeof(dispatch_table) / sizeof(dispatch_table_t); i++) {
-	fprintf(out, "\t%s %s\n\t    %s\n\n", dispatch_table[i].cmdline_name, dispatch_table[i].arg_names, dispatch_table[i].description);
+        fprintf(out, "\t%s %s\n\t    %s\n\n", dispatch_table[i].cmdline_name, dispatch_table[i].arg_names, dispatch_table[i].description);
     }
     fprintf(out, "\nSupported flags are:\n"
-		 "\t0\t(no flags)\n"
-		 "\tC\tZIP_FL_NOCASE\n"
-		 "\tc\tZIP_FL_CENTRAL\n"
-		 "\td\tZIP_FL_NODIR\n"
-		 "\tl\tZIP_FL_LOCAL\n"
-		 "\tu\tZIP_FL_UNCHANGED\n");
+                 "\t0\t(no flags)\n"
+                 "\tC\tZIP_FL_NOCASE\n"
+                 "\tc\tZIP_FL_CENTRAL\n"
+                 "\td\tZIP_FL_NODIR\n"
+                 "\tl\tZIP_FL_LOCAL\n"
+                 "\tu\tZIP_FL_UNCHANGED\n");
     fprintf(out, "\nSupported compression methods are:\n"
-		 "\tdefault\n");
+                 "\tdefault\n");
     if (zip_compression_method_supported(ZIP_CM_BZIP2, 1)) {
-	fprintf(out, "\tbzip2\n");
+        fprintf(out, "\tbzip2\n");
     }
     fprintf(out, "\tdeflate\n"
-		 "\tstore\n");
+                 "\tstore\n");
     if (zip_compression_method_supported(ZIP_CM_XZ, 1)) {
-	fprintf(out, "\txz\n");
+        fprintf(out, "\txz\n");
     }
     if (zip_compression_method_supported(ZIP_CM_ZSTD, 1)) {
-	fprintf(out, "\tzstd\n");
+        fprintf(out, "\tzstd\n");
     }
     fprintf(out, "\nSupported encryption methods are:\n"
-		 "\tnone\n");
+                 "\tnone\n");
     if (zip_encryption_method_supported(ZIP_EM_AES_128, 1)) {
-	fprintf(out, "\tAES-128\n");
+        fprintf(out, "\tAES-128\n");
     }
     if (zip_encryption_method_supported(ZIP_EM_AES_192, 1)) {
-	fprintf(out, "\tAES-192\n");
+        fprintf(out, "\tAES-192\n");
     }
     if (zip_encryption_method_supported(ZIP_EM_AES_256, 1)) {
-	fprintf(out, "\tAES-256\n");
+        fprintf(out, "\tAES-256\n");
     }
     fprintf(out, "\tPKWARE\n");
     fprintf(out, "\nThe index is zero-based.\n");
@@ -882,93 +882,93 @@
     prg = argv[0];
 
     while ((c = getopt(argc, argv, "ceghl:no:rst" OPTIONS_REGRESS)) != -1) {
-	switch (c) {
-	case 'c':
-	    flags |= ZIP_CHECKCONS;
-	    break;
-	case 'e':
-	    flags |= ZIP_EXCL;
-	    break;
-	case 'g':
-	    stat_flags = ZIP_FL_ENC_GUESS;
-	    break;
-	case 'h':
-	    usage(prg, NULL);
-	    break;
-	case 'l':
-	    len = strtoull(optarg, NULL, 10);
-	    break;
-	case 'n':
-	    flags |= ZIP_CREATE;
-	    break;
-	case 'o':
-	    offset = strtoull(optarg, NULL, 10);
-	    break;
-	case 'r':
-	    stat_flags = ZIP_FL_ENC_RAW;
-	    break;
-	case 's':
-	    stat_flags = ZIP_FL_ENC_STRICT;
-	    break;
-	case 't':
-	    flags |= ZIP_TRUNCATE;
-	    break;
+        switch (c) {
+        case 'c':
+            flags |= ZIP_CHECKCONS;
+            break;
+        case 'e':
+            flags |= ZIP_EXCL;
+            break;
+        case 'g':
+            stat_flags = ZIP_FL_ENC_GUESS;
+            break;
+        case 'h':
+            usage(prg, NULL);
+            break;
+        case 'l':
+            len = strtoull(optarg, NULL, 10);
+            break;
+        case 'n':
+            flags |= ZIP_CREATE;
+            break;
+        case 'o':
+            offset = strtoull(optarg, NULL, 10);
+            break;
+        case 'r':
+            stat_flags = ZIP_FL_ENC_RAW;
+            break;
+        case 's':
+            stat_flags = ZIP_FL_ENC_STRICT;
+            break;
+        case 't':
+            flags |= ZIP_TRUNCATE;
+            break;
 #ifdef GETOPT_REGRESS
-	    GETOPT_REGRESS
+            GETOPT_REGRESS
 #endif
 
-	default: {
-	    char reason[128];
-	    snprintf(reason, sizeof(reason), "invalid option -%c", optopt);
-	    usage(prg, reason);
-	}
-	}
+        default: {
+            char reason[128];
+            snprintf(reason, sizeof(reason), "invalid option -%c", optopt);
+            usage(prg, reason);
+        }
+        }
     }
 
     if (optind >= argc - 1)
-	usage(prg, "too few arguments");
+        usage(prg, "too few arguments");
 
     arg = optind;
 
     archive = argv[arg++];
 
     if (flags == 0)
-	flags = ZIP_CREATE;
+        flags = ZIP_CREATE;
 
     zip_error_init(&error);
     za = ziptool_open(archive, flags, &error, offset, len);
     if (za == NULL) {
-	fprintf(stderr, "can't open zip archive '%s': %s\n", archive, zip_error_strerror(&error));
-	zip_error_fini(&error);
-	return 1;
+        fprintf(stderr, "can't open zip archive '%s': %s\n", archive, zip_error_strerror(&error));
+        zip_error_fini(&error);
+        return 1;
     }
     zip_error_fini(&error);
 
     err = 0;
     while (arg < argc) {
-	int ret;
-	ret = dispatch(argc - arg, argv + arg);
-	if (ret > 0) {
-	    arg += ret;
-	}
-	else {
-	    err = 1;
-	    break;
-	}
+        int ret;
+        ret = dispatch(argc - arg, argv + arg);
+        if (ret > 0) {
+            arg += ret;
+        }
+        else {
+            err = 1;
+            break;
+        }
     }
 
     if (zip_close(za) == -1) {
-	fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
-	return 1;
+        fprintf(stderr, "can't close zip archive '%s': %s\n", archive, zip_strerror(za));
+        return 1;
     }
     if (ziptool_post_close(archive) < 0) {
-	err = 1;
+        err = 1;
     }
 
     for (i = 0; i < z_in_count; i++) {
-	if (zip_close(z_in[i]) < 0) {
-	    err = 1;
-	}
+        if (zip_close(z_in[i]) < 0) {
+            err = 1;
+        }
     }
 
     return err;