Fix spaces, indentation and some const char* warnings in ab filterandroid_adb

Add TODOs for AES-256

2 files changed, 81 insertions, 51 deletions

diff --git a/libarchive/archive_read_support_filter_ab.c b/libarchive/archive_read_support_filter_ab.c
index a885519a..fa90ada2 100644
--- a/libarchive/archive_read_support_filter_ab.c
+++ b/libarchive/archive_read_support_filter_ab.c
@@ -76,7 +76,8 @@ static inline char* getnextline(const char* str)
 	return (nline == NULL) ? NULL : (nline + 1);
 }
 
-static int read_str_ahead(struct archive_read_filter* readfilter, char* buffer, size_t len)
+static int read_str_ahead(struct archive_read_filter* readfilter, char* buffer,
+    size_t len)
 {
 	const void* ptr = __archive_read_filter_ahead(readfilter, len, NULL);
 	if(ptr == NULL)
@@ -88,9 +89,10 @@ static int read_str_ahead(struct archive_read_filter* readfilter, char* buffer,
 	return 0;
 }
 
-static char* parse_ab_header(const char* header, enum AB_HEADER_FIELD field)
+static const char* parse_ab_header(const char* header,
+    enum AB_HEADER_FIELD field)
 {
-	char* l = (char*)header;
+	const char* l = header;
 	enum AB_HEADER_FIELD curfield = AB_HEADER_MAGIC;
 
 	do
@@ -102,7 +104,8 @@ static char* parse_ab_header(const char* header, enum AB_HEADER_FIELD field)
 	return NULL;
 }
 
-static int ab_reader_bid(struct archive_read_filter_bidder* self, struct archive_read_filter* filter)
+static int ab_reader_bid(struct archive_read_filter_bidder* self,
+    struct archive_read_filter* filter)
 {
 	char h[64];
 	char* l = h;
@@ -113,12 +116,13 @@ static int ab_reader_bid(struct archive_read_filter_bidder* self, struct archive
 	if(read_str_ahead(filter, h, 64) != 0)
 		return 0;
 
-	if(memcmp(AB_MAGIC, h, strlen(AB_MAGIC)) != 0)
+	if(strcmp(AB_MAGIC, h) != 0)
 		return 0;
 
 	if((l = getnextline(h)) == NULL)
 		return 0;
 
+	/* TODO: version 4+ */
 	/* version 1 to 3 supported */
 	if(l[0] < '1' || l[0] > '3')
 		return 0;
@@ -133,8 +137,8 @@ static int ab_reader_bid(struct archive_read_filter_bidder* self, struct archive
 	if((l = getnextline(l)) == NULL)
 		return 0;
 
-	/* encryption method none or AES-256 (not supported) */
-	if(memcmp(l, "none", 4) != 0)
+	/* TODO: AES-256 */
+	if(strcmp(l, "none") != 0)
 		return 0;
 
 	if((l = getnextline(l)) == NULL)
@@ -143,7 +147,8 @@ static int ab_reader_bid(struct archive_read_filter_bidder* self, struct archive
 	return ((l - h) << 3);
 }
 
-static inline ssize_t ab_filter_read_raw(struct archive_read_filter* self, const void** p)
+static inline ssize_t ab_filter_read_raw(struct archive_read_filter* self,
+    const void** p)
 {
 	const void* data;
 	ssize_t datalen;
@@ -166,7 +171,8 @@ static inline int ab_zlib_init(struct archive_read_filter* self)
 	state = (struct private_data*)self->data;
 	ssize_t avail = 0;
 
-	state->stream.next_in = (Bytef*)__archive_read_filter_ahead(self->upstream, 1, &avail);
+	state->stream.next_in = (Bytef*)__archive_read_filter_ahead(
+	    self->upstream, 1, &avail);
 	state->stream.avail_in = (uInt)avail;
 	ret = inflateInit2(&(state->stream), 0);
 
@@ -229,7 +235,8 @@ static inline int ab_zlib_destroy(struct archive_read_filter* self)
 }
 
 /* based on gzip_filter_read */
-static inline ssize_t ab_filter_read_deflate(struct archive_read_filter* self, const void** p)
+static inline ssize_t ab_filter_read_deflate(struct archive_read_filter* self,
+    const void** p)
 {
 #if HAVE_ZLIB_H
 	struct private_data* state;
@@ -247,7 +254,8 @@ static inline ssize_t ab_filter_read_deflate(struct archive_read_filter* self, c
 	while (state->stream.avail_out > 0 && !state->eof)
 	{
 		/* Peek at the next available data. */
-		state->stream.next_in = (Bytef*)__archive_read_filter_ahead(self->upstream, 1, &avail_in);
+		state->stream.next_in = (Bytef*)__archive_read_filter_ahead(
+		    self->upstream, 1, &avail_in);
 		if (state->stream.next_in == NULL) {
 			archive_set_error(&self->archive->archive,
 			    ARCHIVE_ERRNO_MISC,
@@ -299,13 +307,14 @@ static inline ssize_t ab_filter_read_deflate(struct archive_read_filter* self, c
 static inline int consume_header(struct archive_read_filter* self)
 {
 	char h[64];
-	char* l = h;
+	const char* l = h;
 
 	/* determine header length */
-	if(read_str_ahead(self->upstream, h, 64) != 0 || (l = parse_ab_header(h, AB_HEADER_END)) == NULL)
+	if(read_str_ahead(self->upstream, h, 64) != 0 || (l = parse_ab_header(
+	    h, AB_HEADER_END)) == NULL)
 	{
 		archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
-			"ab: reading failed");
+		    "ab: reading failed");
 		return ARCHIVE_FATAL;
 	}
 
@@ -388,7 +397,7 @@ static int ab_reader_init(struct archive_read_filter* self)
 	state = (struct private_data*)calloc(1, sizeof(*state));
 #if HAVE_ZLIB_H
 	out_block = malloc(out_block_size);
-	if (state == NULL || out_block == NULL) 
+	if (state == NULL || out_block == NULL)
 	{
 		free(out_block);
 #else
@@ -410,8 +419,8 @@ static int ab_reader_init(struct archive_read_filter* self)
 
 	self->data = state;
 	{
-		char* ver = parse_ab_header(h, AB_HEADER_VERSION);
-		char* comp = parse_ab_header(h, AB_HEADER_COMPRESSION);
+		const char* ver = parse_ab_header(h, AB_HEADER_VERSION);
+		const char* comp = parse_ab_header(h, AB_HEADER_COMPRESSION);
 		if(!ver || !comp)
 		{
 			archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC,
diff --git a/libarchive/archive_write_add_filter_ab.c b/libarchive/archive_write_add_filter_ab.c
index 83d5d7bb..ba422cc6 100644
--- a/libarchive/archive_write_add_filter_ab.c
+++ b/libarchive/archive_write_add_filter_ab.c
@@ -73,7 +73,8 @@ static inline int write_ab_header(struct archive_write_filter* f)
 	size_t bw;
 	int ret;
 
-	bw = snprintf(buffer, sizeof(buffer), "%s\n%d\n%d\n%s\n", AB_MAGIC, data->version, (data->compression_level ? 1 : 0), "none");
+	bw = snprintf(buffer, sizeof(buffer), "%s\n%d\n%d\n%s\n", AB_MAGIC,
+	    data->version, (data->compression_level ? 1 : 0), "none");
 	if(bw > sizeof(buffer) - 1)
 		bw = sizeof(buffer) - 1;
 
@@ -85,20 +86,24 @@ static inline int write_ab_header(struct archive_write_filter* f)
 	return ARCHIVE_OK;
 }
 
-static int archive_write_ab_options(struct archive_write_filter* f, const char* key, const char* value)
+static int archive_write_ab_options(struct archive_write_filter* f,
+    const char* key, const char* value)
 {
 	struct private_data* data = (struct private_data*)f->data;
 	int val = 0;
 
 	if (strcmp(key, "compression-level") == 0)
 	{
-		if (value == NULL || !((val = value[0] - '0') >= 0 && val <= 9) || value[1] != '\0')
+		if (value == NULL || !((val = value[0] - '0') >= 0 && val <= 9)
+		    || value[1] != '\0') {
 			return ARCHIVE_WARN;
+		}
 
 #if !(HAVE_ZLIB_H)
 		if(val != 0)
 		{
-			archive_set_error(f->archive, ARCHIVE_ERRNO_PROGRAMMER, "ab: DEFLATE compression not supported in this build");
+			archive_set_error(f->archive, ARCHIVE_ERRNO_PROGRAMMER,
+			    "ab: DEFLATE compression is not supported");
 			return ARCHIVE_FATAL;
 		}
 #endif
@@ -107,10 +112,12 @@ static int archive_write_ab_options(struct archive_write_filter* f, const char*
 		return ARCHIVE_OK;
 	}
 
-	if (strcmp(key, "version") == 0) 
+	if (strcmp(key, "version") == 0)
 	{
-		if (value == NULL || !((val = value[0] - '0') >= 1 && val <= 3) || value[1] != '\0')
+		if (value == NULL || !((val = value[0] - '0') >= 1 && val <= 3)
+		    || value[1] != '\0') {
 			return ARCHIVE_WARN;
+		}
 
 		data->version = val;
 		return ARCHIVE_OK;
@@ -124,15 +131,17 @@ static int archive_write_ab_options(struct archive_write_filter* f, const char*
 
 #if HAVE_ZLIB_H
 /* based on drive_compressor from archive_write_add_filter_gzip.c */
-static int drive_compressor(struct archive_write_filter* f, struct private_data* data, int finishing)
+static int drive_compressor(struct archive_write_filter* f,
+    struct private_data* data, int finishing)
 {
 	int ret;
 
-	for (;;) 
+	for (;;)
 	{
-		if (data->stream.avail_out == 0) 
+		if (data->stream.avail_out == 0)
 		{
-			ret = __archive_write_filter(f->next_filter, data->out_block, data->out_block_size);
+			ret = __archive_write_filter(f->next_filter,
+			    data->out_block, data->out_block_size);
 			if (ret != ARCHIVE_OK)
 				return ARCHIVE_FATAL;
 			data->stream.next_out = data->out_block;
@@ -146,7 +155,7 @@ static int drive_compressor(struct archive_write_filter* f, struct private_data*
 		ret = deflate(&(data->stream),
 		    finishing ? Z_FINISH : Z_NO_FLUSH );
 
-		switch (ret) 
+		switch (ret)
 		{
 		case Z_OK:
 			/* In non-finishing case, check if compressor
@@ -162,15 +171,16 @@ static int drive_compressor(struct archive_write_filter* f, struct private_data*
 		default:
 			/* Any other return value indicates an error. */
 			archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
-			    "DEFLATE compression failed: deflate() call returned status %d",
-			    ret);
+			    "DEFLATE compression failed: "
+			    "deflate() call returned status %d", ret);
 			return ARCHIVE_FATAL;
 		}
 	}
 }
 #endif
 
-static inline int archive_write_ab_write_deflate(struct archive_write_filter* f, const void* buff, size_t length)
+static inline int archive_write_ab_write_deflate(
+    struct archive_write_filter* f, const void* buff, size_t length)
 {
 #if HAVE_ZLIB_H
 	struct private_data* data = (struct private_data*)f->data;
@@ -192,12 +202,14 @@ static inline int archive_write_ab_write_deflate(struct archive_write_filter* f,
 #endif
 }
 
-static inline int archive_write_ab_write_raw(struct archive_write_filter* f, const void* buff, size_t length)
+static inline int archive_write_ab_write_raw(struct archive_write_filter* f,
+    const void* buff, size_t length)
 {
 	return __archive_write_filter(f->next_filter, buff, length);
 }
 
-static int archive_write_ab_write(struct archive_write_filter* f, const void* buff, size_t length)
+static int archive_write_ab_write(struct archive_write_filter* f,
+    const void* buff, size_t length)
 {
 	struct private_data* data = (struct private_data*)f->data;
 
@@ -224,14 +236,15 @@ static int archive_write_ab_open(struct archive_write_filter* f)
 #if HAVE_ZLIB_H
 	if(data->compression_level)
 	{
-		if (data->out_block == NULL) 
+		if (data->out_block == NULL)
 		{
 			size_t bs = 65536, bpb;
-			if (f->archive->magic == ARCHIVE_WRITE_MAGIC) 
+			if (f->archive->magic == ARCHIVE_WRITE_MAGIC)
 			{
 				/* Buffer size should be a multiple number of
 				 * the of bytes per block for performance. */
-				bpb = archive_write_get_bytes_per_block(f->archive);
+				bpb = archive_write_get_bytes_per_block(
+				    f->archive);
 				if (bpb > bs)
 					bs = bpb;
 				else if (bpb != 0)
@@ -243,7 +256,8 @@ static int archive_write_ab_open(struct archive_write_filter* f)
 			if (data->out_block == NULL)
 			{
 				archive_set_error(f->archive, ENOMEM,
-					"Can't allocate data for compression buffer");
+				    "Can't allocate data "
+				    "for compression buffer");
 				return ARCHIVE_FATAL;
 			}
 		}
@@ -253,32 +267,39 @@ static int archive_write_ab_open(struct archive_write_filter* f)
 
 		/* Initialize compression library. */
 		ret = deflateInit2(&(data->stream),
-			((data->compression_level == (char)Z_DEFAULT_COMPRESSION) ? Z_DEFAULT_COMPRESSION : data->compression_level),
-			Z_DEFLATED,
-			15,
-			8,
-			Z_DEFAULT_STRATEGY);
+		    ((data->compression_level ==
+		    (char)Z_DEFAULT_COMPRESSION) ? Z_DEFAULT_COMPRESSION :
+		    data->compression_level),
+		    Z_DEFLATED,
+		    15,
+		    8,
+		    Z_DEFAULT_STRATEGY);
 
 		if (ret == Z_OK)
 			goto End;
 
 		/* Library setup failed: clean up. */
-		archive_set_error(f->archive, ARCHIVE_ERRNO_MISC, "Internal error initializing zlib compression library");
+		archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
+		    "Internal error initializing zlib compression library");
 
-		/* Override the error message if we know what really went wrong. */
+		/* Override the error message if we know what really went
+		 * wrong. */
 		switch (ret)
 		{
 		case Z_STREAM_ERROR:
 			archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
-				"Internal error initializing zlib compression library: invalid setup parameter");
+			    "Internal error initializing zlib compression "
+			    "library: invalid setup parameter");
 			break;
 		case Z_MEM_ERROR:
 			archive_set_error(f->archive, ENOMEM,
-				"Internal error initializing zlib compression library");
+			    "Internal error initializing zlib compression "
+			    "library");
 			break;
 		case Z_VERSION_ERROR:
 			archive_set_error(f->archive, ARCHIVE_ERRNO_MISC,
-				"Internal error initializing zlib compression library: invalid library version");
+			    "Internal error initializing zlib compression "
+			    "library: invalid library version");
 			break;
 		}
 
@@ -302,12 +323,12 @@ static int archive_write_ab_close(struct archive_write_filter* f)
 	{
 		/* Finish compression cycle */
 		ret = drive_compressor(f, data, 1);
-		if (ret == ARCHIVE_OK) 
+		if (ret == ARCHIVE_OK)
 		{
 			/* Write the last compressed data. */
 			ret = __archive_write_filter(f->next_filter,
-				data->out_block,
-				data->out_block_size - data->stream.avail_out);
+			    data->out_block,
+			    data->out_block_size - data->stream.avail_out);
 		}
 
 		switch (deflateEnd(&(data->stream)))
@@ -322,7 +343,7 @@ static int archive_write_ab_close(struct archive_write_filter* f)
 	}
 #endif
 	r1 = __archive_write_close_filter(f->next_filter);
-		return (r1 < ret ? r1 : ret);
+	return (r1 < ret ? r1 : ret);
 }
 
 static int archive_write_ab_free(struct archive_write_filter* f)