X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Fdpkg.c;h=1280ca03d8d00c189e57ab9f38974c0e80d6f82d;hb=05efca90d22184a5c2fd1f1d61da9afe2f0ae2af;hp=ac4683398d1670580ca7114b08f759ef15ed309f;hpb=1da6a2166621d26f84cfb9b8711ded657fdf8d37;p=oweals%2Fbusybox.git

diff --git a/archival/dpkg.c b/archival/dpkg.c
index ac4683398..1280ca03d 100644
--- a/archival/dpkg.c
+++ b/archival/dpkg.c
@@ -24,7 +24,7 @@
  *
  */
 
-#include "busybox.h"
+#include "libbb.h"
 #include "unarchive.h"
 
 /* note: if you vary hash_prime sizes be aware,
@@ -34,7 +34,7 @@
  * 3) all _hash_prime's must be a prime number or chaos is assured, if your looking
  *    for a prime, try http://www.utm.edu/research/primes/lists/small/10000.txt
  * 4) if you go bigger than 15 bits you may get into trouble (untested) as its
- *    sometimes cast to an unsigned int, if you go to 16 bit you will overlap
+ *    sometimes cast to an unsigned, if you go to 16 bit you will overlap
  *    int's and chaos is assured, 16381 is the max prime for 14 bit field
  */
 
@@ -42,7 +42,6 @@
  * I estimate it should be at least 50% bigger than PACKAGE_HASH_PRIME,
  * as there a lot of duplicate version numbers */
 #define NAME_HASH_PRIME 16381
-static char *name_hashtable[NAME_HASH_PRIME + 1];
 
 /* PACKAGE_HASH_PRIME, Maximum number of unique packages,
  * It must not be smaller than STATUS_HASH_PRIME,
@@ -54,29 +53,32 @@ static char *name_hashtable[NAME_HASH_PRIME + 1];
  *      and available file */
 #define PACKAGE_HASH_PRIME 10007
 typedef struct edge_s {
-	unsigned int operator:3;
-	unsigned int type:4;
-	unsigned int name:14;
-	unsigned int version:14;
+	unsigned operator:4; /* was:3 */
+	unsigned type:4;
+	unsigned name:16; /* was:14 */
+	unsigned version:16; /* was:14 */
 } edge_t;
 
 typedef struct common_node_s {
-	unsigned int name:14;
-	unsigned int version:14;
-	unsigned int num_of_edges:14;
+	unsigned name:16; /* was:14 */
+	unsigned version:16; /* was:14 */
+	unsigned num_of_edges:16; /* was:14 */
 	edge_t **edge;
 } common_node_t;
-static common_node_t *package_hashtable[PACKAGE_HASH_PRIME + 1];
 
 /* Currently it doesnt store packages that have state-status of not-installed
  * So it only really has to be the size of the maximum number of packages
  * likely to be installed at any one time, so there is a bit of leeway here */
 #define STATUS_HASH_PRIME 8191
 typedef struct status_node_s {
-	unsigned int package:14;	/* has to fit PACKAGE_HASH_PRIME */
-	unsigned int status:14;		/* has to fit STATUS_HASH_PRIME */
+	unsigned package:16; /* was:14 */       /* has to fit PACKAGE_HASH_PRIME */
+	unsigned status:16; /* was:14 */        /* has to fit STATUS_HASH_PRIME */
 } status_node_t;
-static status_node_t *status_hashtable[STATUS_HASH_PRIME + 1];
+
+/* Were statically declared here, but such a big bss is nommu-unfriendly */
+static char **name_hashtable;             /* [NAME_HASH_PRIME + 1] */
+static common_node_t **package_hashtable; /* [PACKAGE_HASH_PRIME + 1] */
+static status_node_t **status_hashtable;  /* [STATUS_HASH_PRIME + 1] */
 
 /* Even numbers are for 'extras', like ored dependencies or null */
 enum edge_type_e {
@@ -102,86 +104,71 @@ enum operator_e {
 	VER_ANY = 6
 };
 
-enum dpkg_opt_e {
-	dpkg_opt_purge = 1,
-	dpkg_opt_remove = 2,
-	dpkg_opt_unpack = 4,
-	dpkg_opt_configure = 8,
-	dpkg_opt_install = 16,
-	dpkg_opt_package_name = 32,
-	dpkg_opt_filename = 64,
-	dpkg_opt_list_installed = 128,
-	dpkg_opt_force_ignore_depends = 256
-};
-
 typedef struct deb_file_s {
 	char *control_file;
 	char *filename;
-	unsigned int package:14;
+	unsigned package:16; /* was:14 */
 } deb_file_t;
 
 
-static void make_hash(const char *key, unsigned int *start, unsigned int *decrement, const int hash_prime)
+static void make_hash(const char *key, unsigned *start, unsigned *decrement, const int hash_prime)
 {
-	unsigned long int hash_num = key[0];
+	unsigned long hash_num = key[0];
 	int len = strlen(key);
 	int i;
 
 	/* Maybe i should have uses a "proper" hashing algorithm here instead
 	 * of making one up myself, seems to be working ok though. */
-	for(i = 1; i < len; i++) {
+	for (i = 1; i < len; i++) {
 		/* shifts the ascii based value and adds it to previous value
 		 * shift amount is mod 24 because long int is 32 bit and data
 		 * to be shifted is 8, don't want to shift data to where it has
 		 * no effect*/
 		hash_num += ((key[i] + key[i-1]) << ((key[i] * i) % 24));
 	}
-	*start = (unsigned int) hash_num % hash_prime;
-	*decrement = (unsigned int) 1 + (hash_num % (hash_prime - 1));
+	*start = (unsigned) hash_num % hash_prime;
+	*decrement = (unsigned) 1 + (hash_num % (hash_prime - 1));
 }
 
 /* this adds the key to the hash table */
 static int search_name_hashtable(const char *key)
 {
-	unsigned int probe_address = 0;
-	unsigned int probe_decrement = 0;
-//	char *temp;
+	unsigned probe_address = 0;
+	unsigned probe_decrement = 0;
 
 	make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME);
-	while(name_hashtable[probe_address] != NULL) {
+	while (name_hashtable[probe_address] != NULL) {
 		if (strcmp(name_hashtable[probe_address], key) == 0) {
-			return(probe_address);
-		} else {
-			probe_address -= probe_decrement;
-			if ((int)probe_address < 0) {
-				probe_address += NAME_HASH_PRIME;
-			}
+			return probe_address;
+		}
+		probe_address -= probe_decrement;
+		if ((int)probe_address < 0) {
+			probe_address += NAME_HASH_PRIME;
 		}
 	}
 	name_hashtable[probe_address] = xstrdup(key);
-	return(probe_address);
+	return probe_address;
 }
 
 /* this DOESNT add the key to the hashtable
  * TODO make it consistent with search_name_hashtable
  */
-static unsigned int search_status_hashtable(const char *key)
+static unsigned search_status_hashtable(const char *key)
 {
-	unsigned int probe_address = 0;
-	unsigned int probe_decrement = 0;
+	unsigned probe_address = 0;
+	unsigned probe_decrement = 0;
 
 	make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME);
-	while(status_hashtable[probe_address] != NULL) {
+	while (status_hashtable[probe_address] != NULL) {
 		if (strcmp(key, name_hashtable[package_hashtable[status_hashtable[probe_address]->package]->name]) == 0) {
 			break;
-		} else {
-			probe_address -= probe_decrement;
-			if ((int)probe_address < 0) {
-				probe_address += STATUS_HASH_PRIME;
-			}
+		}
+		probe_address -= probe_decrement;
+		if ((int)probe_address < 0) {
+			probe_address += STATUS_HASH_PRIME;
 		}
 	}
-	return(probe_address);
+	return probe_address;
 }
 
 /* Need to rethink version comparison, maybe the official dpkg has something i can use ? */
@@ -196,7 +183,6 @@ static int version_compare_part(const char *version1, const char *version2)
 	int tmp_int;
 	int ver_num1;
 	int ver_num2;
-	int ret;
 
 	if (version1 == NULL) {
 		version1 = xstrdup("");
@@ -219,8 +205,7 @@ static int version_compare_part(const char *version1, const char *version2)
 		free(name1_char);
 		free(name2_char);
 		if (tmp_int != 0) {
-			ret = tmp_int;
-			goto cleanup_version_compare_part;
+			return tmp_int;
 		}
 
 		/* Compare digits */
@@ -235,24 +220,20 @@ static int version_compare_part(const char *version1, const char *version2)
 		free(name1_char);
 		free(name2_char);
 		if (ver_num1 < ver_num2) {
-			ret = -1;
-			goto cleanup_version_compare_part;
+			return -1;
 		}
-		else if (ver_num1 > ver_num2) {
-			ret = 1;
-			goto cleanup_version_compare_part;
+		if (ver_num1 > ver_num2) {
+			return 1;
 		}
 	}
-	ret = 0;
-cleanup_version_compare_part:
-	return(ret);
+	return 0;
 }
 
 /* if ver1 < ver2 return -1,
  * if ver1 = ver2 return 0,
  * if ver1 > ver2 return 1,
  */
-static int version_compare(const unsigned int ver1, const unsigned int ver2)
+static int version_compare(const unsigned ver1, const unsigned ver2)
 {
 	char *ch_ver1 = name_hashtable[ver1];
 	char *ch_ver2 = name_hashtable[ver2];
@@ -280,10 +261,10 @@ static int version_compare(const unsigned int ver1, const unsigned int ver2)
 		ver2_ptr = ch_ver2;
 	}
 	if (epoch1 < epoch2) {
-		return(-1);
+		return -1;
 	}
 	else if (epoch1 > epoch2) {
-		return(1);
+		return 1;
 	}
 
 	/* Compare upstream version */
@@ -302,67 +283,49 @@ static int version_compare(const unsigned int ver1, const unsigned int ver2)
 		deb_ver2++;
 	}
 	result = version_compare_part(upstream_ver1, upstream_ver2);
+	if (!result)
+		/* Compare debian versions */
+		result = version_compare_part(deb_ver1, deb_ver2);
 
 	free(upstream_ver1);
 	free(upstream_ver2);
-
-	if (result != 0) {
-		return(result);
-	}
-
-	/* Compare debian versions */
-	return(version_compare_part(deb_ver1, deb_ver2));
+	return result;
 }
 
-static int test_version(const unsigned int version1, const unsigned int version2, const unsigned int operator)
+static int test_version(const unsigned version1, const unsigned version2, const unsigned operator)
 {
 	const int version_result = version_compare(version1, version2);
-	switch(operator) {
-		case (VER_ANY):
-			return(TRUE);
-		case (VER_EQUAL):
-			if (version_result == 0) {
-				return(TRUE);
-			}
-			break;
-		case (VER_LESS):
-			if (version_result < 0) {
-				return(TRUE);
-			}
-			break;
-		case (VER_LESS_EQUAL):
-			if (version_result <= 0) {
-				return(TRUE);
-			}
-			break;
-		case (VER_MORE):
-			if (version_result > 0) {
-				return(TRUE);
-			}
-			break;
-		case (VER_MORE_EQUAL):
-			if (version_result >= 0) {
-				return(TRUE);
-			}
-			break;
-	}
-	return(FALSE);
+	switch (operator) {
+	case VER_ANY:
+		return TRUE;
+	case VER_EQUAL:
+		return (version_result == 0);
+	case VER_LESS:
+		return (version_result < 0);
+	case VER_LESS_EQUAL:
+		return (version_result <= 0);
+	case VER_MORE:
+		return (version_result > 0);
+	case VER_MORE_EQUAL:
+		return (version_result >= 0);
+	}
+	return FALSE;
 }
 
 
-static int search_package_hashtable(const unsigned int name, const unsigned int version, const unsigned int operator)
+static int search_package_hashtable(const unsigned name, const unsigned version, const unsigned operator)
 {
-	unsigned int probe_address = 0;
-	unsigned int probe_decrement = 0;
+	unsigned probe_address = 0;
+	unsigned probe_decrement = 0;
 
 	make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME);
-	while(package_hashtable[probe_address] != NULL) {
+	while (package_hashtable[probe_address] != NULL) {
 		if (package_hashtable[probe_address]->name == name) {
 			if (operator == VER_ANY) {
-				return(probe_address);
+				return probe_address;
 			}
 			if (test_version(package_hashtable[probe_address]->version, version, operator)) {
-				return(probe_address);
+				return probe_address;
 			}
 		}
 		probe_address -= probe_decrement;
@@ -370,7 +333,7 @@ static int search_package_hashtable(const unsigned int name, const unsigned int
 			probe_address += PACKAGE_HASH_PRIME;
 		}
 	}
-	return(probe_address);
+	return probe_address;
 }
 
 /*
@@ -389,14 +352,16 @@ static int search_package_hashtable(const unsigned int name, const unsigned int
  * FIXME: I don't think this is very efficient, but I thought I'd keep
  * it simple for now until it proves to be a problem.
  */
-static int search_for_provides(int needle, int start_at) {
+static int search_for_provides(int needle, int start_at)
+{
 	int i, j;
 	common_node_t *p;
 	for (i = start_at + 1; i < PACKAGE_HASH_PRIME; i++) {
 		p = package_hashtable[i];
-		if ( p == NULL ) continue;
-		for(j = 0; j < p->num_of_edges; j++)
-			if ( p->edge[j]->type == EDGE_PROVIDES && p->edge[j]->name == needle )
+		if (p == NULL)
+			continue;
+		for (j = 0; j < p->num_of_edges; j++)
+			if (p->edge[j]->type == EDGE_PROVIDES && p->edge[j]->name == needle)
 				return i;
 	}
 	return -1;
@@ -422,7 +387,7 @@ static void add_edge_to_node(common_node_t *node, edge_t *edge)
  * field contains the number of EDGE nodes which follow as part of
  * this alternative.
  */
-static void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned int edge_type)
+static void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned edge_type)
 {
 	char *line = xstrdup(whole_line);
 	char *line2;
@@ -441,23 +406,19 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
 		field += strspn(field, " ");
 		line2 = xstrdup(field);
 		field2 = strtok_r(line2, "|", &line_ptr2);
-		if ( (edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS) &&
-		     (strcmp(field, field2) != 0)) {
-			or_edge = (edge_t *)xmalloc(sizeof(edge_t));
+		or_edge = NULL;
+		if ((edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS)
+		 && (strcmp(field, field2) != 0)
+		) {
+			or_edge = xmalloc(sizeof(edge_t));
 			or_edge->type = edge_type + 1;
-		} else {
-			or_edge = NULL;
-		}
-
-		if ( or_edge ) {
 			or_edge->name = search_name_hashtable(field);
-			or_edge->version = 0; // tracks the number of altenatives
-
+			or_edge->version = 0; // tracks the number of alternatives
 			add_edge_to_node(parent_node, or_edge);
 		}
 
 		do {
-			edge = (edge_t *) xmalloc(sizeof(edge_t));
+			edge = xmalloc(sizeof(edge_t));
 			edge->type = edge_type;
 
 			/* Skip any extra leading spaces */
@@ -471,8 +432,7 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
 				edge->version = search_name_hashtable("ANY");
 			} else {
 				/* Skip leading ' ' or '(' */
-				version += strspn(field2, " ");
-				version += strspn(version, "(");
+				version += strspn(version, " (");
 				/* Calculate length of any operator characters */
 				offset_ch = strspn(version, "<=>");
 				/* Determine operator */
@@ -492,7 +452,7 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
 					else if (strncmp(version, ">=", offset_ch) == 0) {
 						edge->operator = VER_MORE_EQUAL;
 					} else {
-						bb_error_msg_and_die("Illegal operator\n");
+						bb_error_msg_and_die("illegal operator");
 					}
 				}
 				/* skip to start of version numbers */
@@ -509,21 +469,23 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
 			field2[strcspn(field2, " (")] = '\0';
 			edge->name = search_name_hashtable(field2);
 
-			if ( or_edge )
+			if (or_edge)
 				or_edge->version++;
 
 			add_edge_to_node(parent_node, edge);
-		} while ((field2 = strtok_r(NULL, "|", &line_ptr2)) != NULL);
+			field2 = strtok_r(NULL, "|", &line_ptr2);
+		} while (field2 != NULL);
+
 		free(line2);
-	} while ((field = strtok_r(NULL, ",", &line_ptr1)) != NULL);
-	free(line);
+		field = strtok_r(NULL, ",", &line_ptr1);
+	} while (field != NULL);
 
-	return;
+	free(line);
 }
 
 static void free_package(common_node_t *node)
 {
-	unsigned short i;
+	unsigned i;
 	if (node) {
 		for (i = 0; i < node->num_of_edges; i++) {
 			free(node->edge[i]);
@@ -552,15 +514,15 @@ static int read_package_field(const char *package_buffer, char **field_name, cha
 	if (package_buffer == NULL) {
 		*field_name = NULL;
 		*field_value = NULL;
-		return(-1);
+		return -1;
 	}
 	while (1) {
 		next_offset = offset + 1;
 		switch (package_buffer[offset]) {
-			case('\0'):
+			case '\0':
 				exit_flag = TRUE;
 				break;
-			case(':'):
+			case ':':
 				if (offset_name_end == 0) {
 					offset_name_end = offset;
 					offset_value_start = next_offset;
@@ -568,14 +530,14 @@ static int read_package_field(const char *package_buffer, char **field_name, cha
 				/* TODO: Name might still have trailing spaces if ':' isnt
 				 * immediately after name */
 				break;
-			case('\n'):
+			case '\n':
 				/* TODO: The char next_offset may be out of bounds */
 				if (package_buffer[next_offset] != ' ') {
 					exit_flag = TRUE;
 					break;
 				}
-			case('\t'):
-			case(' '):
+			case '\t':
+			case ' ':
 				/* increment the value start point if its a just filler */
 				if (offset_name_start == offset) {
 					offset_name_start++;
@@ -607,27 +569,25 @@ static int read_package_field(const char *package_buffer, char **field_name, cha
 		}
 		offset++;
 	}
-	if (name_length == 0) {
-		*field_name = NULL;
-	} else {
+	*field_name = NULL;
+	if (name_length) {
 		*field_name = xstrndup(&package_buffer[offset_name_start], name_length);
 	}
+	*field_value = NULL;
 	if (value_length > 0) {
 		*field_value = xstrndup(&package_buffer[offset_value_start], value_length);
-	} else {
-		*field_value = NULL;
 	}
-	return(next_offset);
+	return next_offset;
 }
 
-static unsigned int fill_package_struct(char *control_buffer)
+static unsigned fill_package_struct(char *control_buffer)
 {
-	static const char *const field_names[] = { "Package", "Version",
-		"Pre-Depends", "Depends","Replaces", "Provides",
-		"Conflicts", "Suggests", "Recommends", "Enhances", 0
-	};
+	static const char field_names[] ALIGN1 =
+		"Package\0""Version\0"
+		"Pre-Depends\0""Depends\0""Replaces\0""Provides\0"
+		"Conflicts\0""Suggests\0""Recommends\0""Enhances\0";
 
-	common_node_t *new_node = (common_node_t *) xzalloc(sizeof(common_node_t));
+	common_node_t *new_node = xzalloc(sizeof(common_node_t));
 	char *field_name;
 	char *field_value;
 	int field_start = 0;
@@ -636,72 +596,69 @@ static unsigned int fill_package_struct(char *control_buffer)
 
 	new_node->version = search_name_hashtable("unknown");
 	while (field_start < buffer_length) {
-		unsigned short field_num;
+		unsigned field_num;
 
 		field_start += read_package_field(&control_buffer[field_start],
 				&field_name, &field_value);
 
 		if (field_name == NULL) {
-			goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement ! */
+			goto fill_package_struct_cleanup;
 		}
 
-		field_num = compare_string_array(field_names, field_name);
-		switch(field_num) {
-			case 0: /* Package */
-				new_node->name = search_name_hashtable(field_value);
-				break;
-			case 1: /* Version */
-				new_node->version = search_name_hashtable(field_value);
-				break;
-			case 2: /* Pre-Depends */
-				add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS);
-				break;
-			case 3: /* Depends */
-				add_split_dependencies(new_node, field_value, EDGE_DEPENDS);
-				break;
-			case 4: /* Replaces */
-				add_split_dependencies(new_node, field_value, EDGE_REPLACES);
-				break;
-			case 5: /* Provides */
-				add_split_dependencies(new_node, field_value, EDGE_PROVIDES);
-				break;
-			case 6: /* Conflicts */
-				add_split_dependencies(new_node, field_value, EDGE_CONFLICTS);
-				break;
-			case 7: /* Suggests */
-				add_split_dependencies(new_node, field_value, EDGE_SUGGESTS);
-				break;
-			case 8: /* Recommends */
-				add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS);
-				break;
-			case 9: /* Enhances */
-				add_split_dependencies(new_node, field_value, EDGE_ENHANCES);
-				break;
+		field_num = index_in_strings(field_names, field_name);
+		switch (field_num) {
+		case 0: /* Package */
+			new_node->name = search_name_hashtable(field_value);
+			break;
+		case 1: /* Version */
+			new_node->version = search_name_hashtable(field_value);
+			break;
+		case 2: /* Pre-Depends */
+			add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS);
+			break;
+		case 3: /* Depends */
+			add_split_dependencies(new_node, field_value, EDGE_DEPENDS);
+			break;
+		case 4: /* Replaces */
+			add_split_dependencies(new_node, field_value, EDGE_REPLACES);
+			break;
+		case 5: /* Provides */
+			add_split_dependencies(new_node, field_value, EDGE_PROVIDES);
+			break;
+		case 6: /* Conflicts */
+			add_split_dependencies(new_node, field_value, EDGE_CONFLICTS);
+			break;
+		case 7: /* Suggests */
+			add_split_dependencies(new_node, field_value, EDGE_SUGGESTS);
+			break;
+		case 8: /* Recommends */
+			add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS);
+			break;
+		case 9: /* Enhances */
+			add_split_dependencies(new_node, field_value, EDGE_ENHANCES);
+			break;
 		}
-fill_package_struct_cleanup:
+ fill_package_struct_cleanup:
 		free(field_name);
 		free(field_value);
 	}
 
 	if (new_node->version == search_name_hashtable("unknown")) {
 		free_package(new_node);
-		return(-1);
+		return -1;
 	}
 	num = search_package_hashtable(new_node->name, new_node->version, VER_EQUAL);
-	if (package_hashtable[num] == NULL) {
-		package_hashtable[num] = new_node;
-	} else {
-		free_package(new_node);
-	}
-	return(num);
+	free_package(package_hashtable[num]);
+	package_hashtable[num] = new_node;
+	return num;
 }
 
 /* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
-static unsigned int get_status(const unsigned int status_node, const int num)
+static unsigned get_status(const unsigned status_node, const int num)
 {
 	char *status_string = name_hashtable[status_hashtable[status_node]->status];
 	char *state_sub_string;
-	unsigned int state_sub_num;
+	unsigned state_sub_num;
 	int len;
 	int i;
 
@@ -712,35 +669,35 @@ static unsigned int get_status(const unsigned int status_node, const int num)
 		/* skip past the separating spaces */
 		status_string += strspn(status_string, " ");
 	}
-	len = strcspn(status_string, " \n\0");
+	len = strcspn(status_string, " \n");
 	state_sub_string = xstrndup(status_string, len);
 	state_sub_num = search_name_hashtable(state_sub_string);
 	free(state_sub_string);
-	return(state_sub_num);
+	return state_sub_num;
 }
 
-static void set_status(const unsigned int status_node_num, const char *new_value, const int position)
+static void set_status(const unsigned status_node_num, const char *new_value, const int position)
 {
-	const unsigned int new_value_len = strlen(new_value);
-	const unsigned int new_value_num = search_name_hashtable(new_value);
-	unsigned int want = get_status(status_node_num, 1);
-	unsigned int flag = get_status(status_node_num, 2);
-	unsigned int status = get_status(status_node_num, 3);
+	const unsigned new_value_len = strlen(new_value);
+	const unsigned new_value_num = search_name_hashtable(new_value);
+	unsigned want = get_status(status_node_num, 1);
+	unsigned flag = get_status(status_node_num, 2);
+	unsigned status = get_status(status_node_num, 3);
 	int want_len = strlen(name_hashtable[want]);
 	int flag_len = strlen(name_hashtable[flag]);
 	int status_len = strlen(name_hashtable[status]);
 	char *new_status;
 
 	switch (position) {
-		case (1):
+		case 1:
 			want = new_value_num;
 			want_len = new_value_len;
 			break;
-		case (2):
+		case 2:
 			flag = new_value_num;
 			flag_len = new_value_len;
 			break;
-		case (3):
+		case 3:
 			status = new_value_num;
 			status_len = new_value_len;
 			break;
@@ -751,28 +708,28 @@ static void set_status(const unsigned int status_node_num, const char *new_value
 	new_status = xasprintf("%s %s %s", name_hashtable[want], name_hashtable[flag], name_hashtable[status]);
 	status_hashtable[status_node_num]->status = search_name_hashtable(new_status);
 	free(new_status);
-	return;
 }
 
-static const char *describe_status(int status_num) {
-	int status_want, status_state ;
-	if ( status_hashtable[status_num] == NULL || status_hashtable[status_num]->status == 0 )
-		return "is not installed or flagged to be installed\n";
+static const char *describe_status(int status_num)
+{
+	int status_want, status_state;
+	if (status_hashtable[status_num] == NULL || status_hashtable[status_num]->status == 0)
+		return "is not installed or flagged to be installed";
 
 	status_want = get_status(status_num, 1);
 	status_state = get_status(status_num, 3);
 
-	if ( status_state == search_name_hashtable("installed") ) {
-		if ( status_want == search_name_hashtable("install") )
+	if (status_state == search_name_hashtable("installed")) {
+		if (status_want == search_name_hashtable("install"))
 			return "is installed";
-		if ( status_want == search_name_hashtable("deinstall") )
+		if (status_want == search_name_hashtable("deinstall"))
 			return "is marked to be removed";
-		if ( status_want == search_name_hashtable("purge") )
+		if (status_want == search_name_hashtable("purge"))
 			return "is marked to be purged";
 	}
-	if ( status_want ==  search_name_hashtable("unknown") )
+	if (status_want == search_name_hashtable("unknown"))
 		return "is in an indeterminate state";
-	if ( status_want == search_name_hashtable("install") )
+	if (status_want == search_name_hashtable("install"))
 		return "is marked to be installed";
 
 	return "is not installed or flagged to be installed";
@@ -785,11 +742,11 @@ static void index_status_file(const char *filename)
 	char *control_buffer;
 	char *status_line;
 	status_node_t *status_node = NULL;
-	unsigned int status_num;
+	unsigned status_num;
 
 	status_file = xfopen(filename, "r");
-	while ((control_buffer = fgets_str(status_file, "\n\n")) != NULL) {
-		const unsigned int package_num = fill_package_struct(control_buffer);
+	while ((control_buffer = xmalloc_fgetline_str(status_file, "\n\n")) != NULL) {
+		const unsigned package_num = fill_package_struct(control_buffer);
 		if (package_num != -1) {
 			status_node = xmalloc(sizeof(status_node_t));
 			/* fill_package_struct doesnt handle the status field */
@@ -797,7 +754,7 @@ static void index_status_file(const char *filename)
 			if (status_line != NULL) {
 				status_line += 7;
 				status_line += strspn(status_line, " \n\t");
-				status_line = xstrndup(status_line, strcspn(status_line, "\n\0"));
+				status_line = xstrndup(status_line, strcspn(status_line, "\n"));
 				status_node->status = search_name_hashtable(status_line);
 				free(status_line);
 			}
@@ -808,7 +765,6 @@ static void index_status_file(const char *filename)
 		free(control_buffer);
 	}
 	fclose(status_file);
-	return;
 }
 
 static void write_buffer_no_status(FILE *new_status_file, const char *control_buffer)
@@ -825,7 +781,6 @@ static void write_buffer_no_status(FILE *new_status_file, const char *control_bu
 			fprintf(new_status_file, "%s: %s\n", name, value);
 		}
 	}
-	return;
 }
 
 /* This could do with a cleanup */
@@ -843,14 +798,15 @@ static void write_status_file(deb_file_t **deb_file)
 	int i = 0;
 
 	/* Update previously known packages */
-	while ((control_buffer = fgets_str(old_status_file, "\n\n")) != NULL) {
-		if ((tmp_string = strstr(control_buffer, "Package:")) == NULL) {
+	while ((control_buffer = xmalloc_fgetline_str(old_status_file, "\n\n")) != NULL) {
+		tmp_string = strstr(control_buffer, "Package:");
+		if (tmp_string == NULL) {
 			continue;
 		}
 
 		tmp_string += 8;
 		tmp_string += strspn(tmp_string, " \n\t");
-		package_name = xstrndup(tmp_string, strcspn(tmp_string, "\n\0"));
+		package_name = xstrndup(tmp_string, strcspn(tmp_string, "\n"));
 		write_flag = FALSE;
 		tmp_string = strstr(control_buffer, "Status:");
 		if (tmp_string != NULL) {
@@ -869,17 +825,19 @@ static void write_status_file(deb_file_t **deb_file)
 			if (strcmp(status_from_file, status_from_hashtable) != 0) {
 				/* New status isnt exactly the same as old status */
 				const int state_status = get_status(status_num, 3);
-				if ((strcmp("installed", name_hashtable[state_status]) == 0) ||
-					(strcmp("unpacked", name_hashtable[state_status]) == 0)) {
+				if ((strcmp("installed", name_hashtable[state_status]) == 0)
+				 || (strcmp("unpacked", name_hashtable[state_status]) == 0)
+				) {
 					/* We need to add the control file from the package */
 					i = 0;
-					while(deb_file[i] != NULL) {
+					while (deb_file[i] != NULL) {
 						if (strcmp(package_name, name_hashtable[package_hashtable[deb_file[i]->package]->name]) == 0) {
 							/* Write a status file entry with a modified status */
 							/* remove trailing \n's */
 							write_buffer_no_status(new_status_file, deb_file[i]->control_file);
 							set_status(status_num, "ok", 2);
-							fprintf(new_status_file, "Status: %s\n\n", name_hashtable[status_hashtable[status_num]->status]);
+							fprintf(new_status_file, "Status: %s\n\n",
+									name_hashtable[status_hashtable[status_num]->status]);
 							write_flag = TRUE;
 							break;
 						}
@@ -887,7 +845,9 @@ static void write_status_file(deb_file_t **deb_file)
 					}
 					/* This is temperary, debugging only */
 					if (deb_file[i] == NULL) {
-						bb_error_msg_and_die("ALERT: Couldnt find a control file, your status file may be broken, status may be incorrect for %s", package_name);
+						bb_error_msg_and_die("ALERT: cannot find a control file, "
+							"your status file may be broken, status may be "
+							"incorrect for %s", package_name);
 					}
 				}
 				else if (strcmp("not-installed", name_hashtable[state_status]) == 0) {
@@ -932,7 +892,7 @@ static void write_status_file(deb_file_t **deb_file)
 			}
 		}
 		/* If the package from the status file wasnt handle above, do it now*/
-		if (! write_flag) {
+		if (!write_flag) {
 			fprintf(new_status_file, "%s\n\n", control_buffer);
 		}
 
@@ -942,7 +902,7 @@ static void write_status_file(deb_file_t **deb_file)
 	}
 
 	/* Write any new packages */
-	for(i = 0; deb_file[i] != NULL; i++) {
+	for (i = 0; deb_file[i] != NULL; i++) {
 		status_num = search_status_hashtable(name_hashtable[package_hashtable[deb_file[i]->package]->name]);
 		if (strcmp("reinstreq", name_hashtable[get_status(status_num, 2)]) == 0) {
 			write_buffer_no_status(new_status_file, deb_file[i]->control_file);
@@ -953,19 +913,16 @@ static void write_status_file(deb_file_t **deb_file)
 	fclose(old_status_file);
 	fclose(new_status_file);
 
-
 	/* Create a separate backfile to dpkg */
 	if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
-		struct stat stat_buf;
-		xstat("/var/lib/dpkg/status", &stat_buf);
+		if (errno != ENOENT)
+			bb_error_msg_and_die("cannot create backup status file");
 		/* Its ok if renaming the status file fails because status
 		 * file doesnt exist, maybe we are starting from scratch */
-		bb_error_msg("No status file found, creating new one");
+		bb_error_msg("no status file found, creating new one");
 	}
 
-	if (rename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status") == -1) {
-		bb_error_msg_and_die("DANGER: Couldnt create status file, you need to manually repair your status file");
-	}
+	xrename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status");
 }
 
 /* This function returns TRUE if the given package can satisfy a
@@ -982,7 +939,7 @@ static int package_satisfies_dependency(int package, int depend_type)
 	/* status could be unknown if package is a pure virtual
 	 * provides which cannot satisfy any dependency by itself.
 	 */
-	if ( status_hashtable[status_num] == NULL )
+	if (status_hashtable[status_num] == NULL)
 		return 0;
 
 	switch (depend_type) {
@@ -992,7 +949,7 @@ static int package_satisfies_dependency(int package, int depend_type)
 	return 0;
 }
 
-static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
+static int check_deps(deb_file_t **deb_file, int deb_start /*, int dep_max_count - ?? */)
 {
 	int *conflicts = NULL;
 	int conflicts_num = 0;
@@ -1009,7 +966,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 	/* Create array of package numbers to check against
 	 * installed package for conflicts*/
 	while (deb_file[i] != NULL) {
-		const unsigned int package_num = deb_file[i]->package;
+		const unsigned package_num = deb_file[i]->package;
 		conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
 		conflicts[conflicts_num] = package_num;
 		conflicts_num++;
@@ -1022,7 +979,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 					package_hashtable[package_num]->edge[j]->operator);
 				if (package_hashtable[conflicts_package_num] == NULL) {
 					/* create a new package */
-					common_node_t *new_node = (common_node_t *) xzalloc(sizeof(common_node_t));
+					common_node_t *new_node = xzalloc(sizeof(common_node_t));
 					new_node->name = package_hashtable[package_num]->edge[j]->name;
 					new_node->version = package_hashtable[package_num]->edge[j]->version;
 					package_hashtable[conflicts_package_num] = new_node;
@@ -1051,7 +1008,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 			const edge_t *package_edge = package_node->edge[j];
 
 			if (package_edge->type == EDGE_CONFLICTS) {
-				const unsigned int package_num =
+				const unsigned package_num =
 					search_package_hashtable(package_edge->name,
 								 package_edge->version,
 								 package_edge->operator);
@@ -1066,7 +1023,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 				}
 
 				if (result) {
-					bb_error_msg_and_die("Package %s conflicts with %s",
+					bb_error_msg_and_die("package %s conflicts with %s",
 						name_hashtable[package_node->name],
 						name_hashtable[package_edge->name]);
 				}
@@ -1087,7 +1044,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 		 * package is a virtual one. In which case there are
 		 * no dependencies to check.
 		 */
-		if ( package_node == NULL ) continue;
+		if (package_node == NULL) continue;
 
 		status_num = search_status_hashtable(name_hashtable[package_node->name]);
 
@@ -1095,7 +1052,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 		 * virtual one provided by something else. In which
 		 * case there are no dependencies to check.
 		 */
-		if ( status_hashtable[status_num] == NULL ) continue;
+		if (status_hashtable[status_num] == NULL) continue;
 
 		/* If we don't want this package installed then we may
 		 * as well ignore it's dependencies.
@@ -1110,14 +1067,16 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 		 */
 		for (j = 0; j < package_node->num_of_edges; j++) {
 			const edge_t *package_edge = package_node->edge[j];
-			unsigned int package_num;
+			unsigned package_num;
 
-			if ( package_edge->type == EDGE_OR_PRE_DEPENDS ||
-			     package_edge->type == EDGE_OR_DEPENDS ) {	/* start an EDGE_OR_ list */
+			if (package_edge->type == EDGE_OR_PRE_DEPENDS
+			 || package_edge->type == EDGE_OR_DEPENDS
+			) {	/* start an EDGE_OR_ list */
 				number_of_alternatives = package_edge->version;
 				root_of_alternatives = package_edge;
 				continue;
-			} else if ( number_of_alternatives == 0 ) {	/* not in the middle of an EDGE_OR_ list */
+			}
+			if (number_of_alternatives == 0) {	/* not in the middle of an EDGE_OR_ list */
 				number_of_alternatives = 1;
 				root_of_alternatives = NULL;
 			}
@@ -1125,7 +1084,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 			package_num = search_package_hashtable(package_edge->name, package_edge->version, package_edge->operator);
 
 			if (package_edge->type == EDGE_PRE_DEPENDS ||
-			    package_edge->type == EDGE_DEPENDS ) {
+			    package_edge->type == EDGE_DEPENDS) {
 				int result=1;
 				status_num = 0;
 
@@ -1135,8 +1094,8 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 				 * EDGE_DEPENDS == OR_DEPENDS -1
 				 * EDGE_PRE_DEPENDS == OR_PRE_DEPENDS -1
 				 */
-				if ( root_of_alternatives && package_edge->type != root_of_alternatives->type - 1)
-					bb_error_msg_and_die("Fatal error. Package dependencies corrupt: %d != %d - 1 \n",
+				if (root_of_alternatives && package_edge->type != root_of_alternatives->type - 1)
+					bb_error_msg_and_die("fatal error, package dependencies corrupt: %d != %d - 1",
 							     package_edge->type, root_of_alternatives->type);
 
 				if (package_hashtable[package_num] != NULL)
@@ -1145,14 +1104,14 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 				if (result) { /* check for other package which provide what we are looking for */
 					int provider = -1;
 
-					while ( (provider = search_for_provides(package_edge->name, provider) ) > -1 ) {
-						if ( package_hashtable[provider] == NULL ) {
-							printf("Have a provider but no package information for it\n");
+					while ((provider = search_for_provides(package_edge->name, provider)) > -1) {
+						if (package_hashtable[provider] == NULL) {
+							puts("Have a provider but no package information for it");
 							continue;
 						}
 						result = !package_satisfies_dependency(provider, package_edge->type);
 
-						if ( result == 0 )
+						if (result == 0)
 							break;
 					}
 				}
@@ -1160,21 +1119,21 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 				/* It must be already installed, or to be installed */
 				number_of_alternatives--;
 				if (result && number_of_alternatives == 0) {
-					if ( root_of_alternatives )
+					if (root_of_alternatives)
 						bb_error_msg_and_die(
-							"Package %s %sdepends on %s, "
+							"package %s %sdepends on %s, "
 							"which cannot be satisfied",
 							name_hashtable[package_node->name],
 							package_edge->type == EDGE_PRE_DEPENDS ? "pre-" : "",
 							name_hashtable[root_of_alternatives->name]);
-					else
-						bb_error_msg_and_die(
-							"Package %s %sdepends on %s, which %s\n",
-							name_hashtable[package_node->name],
-							package_edge->type == EDGE_PRE_DEPENDS ? "pre-" : "",
-							name_hashtable[package_edge->name],
-							describe_status(status_num));
-				} else if ( result == 0 && number_of_alternatives ) {
+					bb_error_msg_and_die(
+						"package %s %sdepends on %s, which %s\n",
+						name_hashtable[package_node->name],
+						package_edge->type == EDGE_PRE_DEPENDS ? "pre-" : "",
+						name_hashtable[package_edge->name],
+						describe_status(status_num));
+				}
+				if (result == 0 && number_of_alternatives) {
 					/* we've found a package which
 					 * satisfies the dependency,
 					 * so skip over the rest of
@@ -1187,7 +1146,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 		}
 	}
 	free(conflicts);
-	return(TRUE);
+	return TRUE;
 }
 
 static char **create_list(const char *filename)
@@ -1200,10 +1159,10 @@ static char **create_list(const char *filename)
 	/* don't use [xw]fopen here, handle error ourself */
 	list_stream = fopen(filename, "r");
 	if (list_stream == NULL) {
-		return(NULL);
+		return NULL;
 	}
 
-	while ((line = bb_get_chomped_line_from_file(list_stream)) != NULL) {
+	while ((line = xmalloc_fgetline(list_stream)) != NULL) {
 		file_list = xrealloc(file_list, sizeof(char *) * (count + 2));
 		file_list[count] = line;
 		count++;
@@ -1211,50 +1170,43 @@ static char **create_list(const char *filename)
 	fclose(list_stream);
 
 	if (count == 0) {
-		return(NULL);
-	} else {
-		file_list[count] = NULL;
-		return(file_list);
+		return NULL;
 	}
+	file_list[count] = NULL;
+	return file_list;
 }
 
 /* maybe i should try and hook this into remove_file.c somehow */
 static int remove_file_array(char **remove_names, char **exclude_names)
 {
 	struct stat path_stat;
-	int match_flag;
-	int remove_flag = FALSE;
-	int i,j;
+	int remove_flag = 1; /* not removed anything yet */
+	int i, j;
 
 	if (remove_names == NULL) {
-		return(FALSE);
+		return 0;
 	}
 	for (i = 0; remove_names[i] != NULL; i++) {
-		match_flag = FALSE;
 		if (exclude_names != NULL) {
-			for (j = 0; exclude_names[j] != 0; j++) {
+			for (j = 0; exclude_names[j] != NULL; j++) {
 				if (strcmp(remove_names[i], exclude_names[j]) == 0) {
-					match_flag = TRUE;
-					break;
+					goto skip;
 				}
 			}
 		}
-		if (!match_flag) {
-			if (lstat(remove_names[i], &path_stat) < 0) {
-				continue;
-			}
-			if (S_ISDIR(path_stat.st_mode)) {
-				if (rmdir(remove_names[i]) != -1) {
-					remove_flag = TRUE;
-				}
-			} else {
-				if (unlink(remove_names[i]) != -1) {
-					remove_flag = TRUE;
-				}
-			}
+		/* TODO: why we are checking lstat? we can just try rm/rmdir */
+		if (lstat(remove_names[i], &path_stat) < 0) {
+			continue;
 		}
+		if (S_ISDIR(path_stat.st_mode)) {
+			remove_flag &= rmdir(remove_names[i]); /* 0 if no error */
+		} else {
+			remove_flag &= unlink(remove_names[i]); /* 0 if no error */
+		}
+ skip:
+		continue;
 	}
-	return(remove_flag);
+	return (remove_flag == 0);
 }
 
 static int run_package_script(const char *package_name, const char *script_type)
@@ -1268,15 +1220,18 @@ static int run_package_script(const char *package_name, const char *script_type)
 	/* If the file doesnt exist is isnt a fatal */
 	result = lstat(script_path, &path_stat) < 0 ? EXIT_SUCCESS : system(script_path);
 	free(script_path);
-	return(result);
+	return result;
 }
 
-static const char *all_control_files[] = {"preinst", "postinst", "prerm", "postrm",
-	"list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL };
+static const char *const all_control_files[] = {
+	"preinst", "postinst", "prerm", "postrm",
+	"list", "md5sums", "shlibs", "conffiles",
+	"config", "templates", NULL
+};
 
 static char **all_control_list(const char *package_name)
 {
-	unsigned short i = 0;
+	unsigned i = 0;
 	char **remove_files;
 
 	/* Create a list of all /var/lib/dpkg/info/<package> files */
@@ -1286,14 +1241,13 @@ static char **all_control_list(const char *package_name)
 		i++;
 	}
 
-	return(remove_files);
+	return remove_files;
 }
 
 static void free_array(char **array)
 {
-
 	if (array) {
-		unsigned short i = 0;
+		unsigned i = 0;
 		while (array[i]) {
 			free(array[i]);
 			i++;
@@ -1310,14 +1264,13 @@ static void list_packages(void)
 {
 	int i;
 
-	printf("    Name           Version\n");
-	printf("+++-==============-==============\n");
+	puts("    Name           Version");
+	puts("+++-==============-==============");
 
 	/* go through status hash, dereference package hash and finally strings */
-	for (i=0; i<STATUS_HASH_PRIME+1; i++) {
-
-	        if (status_hashtable[i]) {
-		        const char *stat_str;  /* status string */
+	for (i = 0; i < STATUS_HASH_PRIME+1; i++) {
+		if (status_hashtable[i]) {
+			const char *stat_str;  /* status string */
 			const char *name_str;  /* package name */
 			const char *vers_str;  /* version */
 			char  s1, s2;          /* status abbreviations */
@@ -1332,35 +1285,33 @@ static void list_packages(void)
 			s1 = stat_str[0] == 'i' ? 'i' : 'r';
 
 			/* get abbreviation for status field 2 */
-			for (j=0, spccnt=0; stat_str[j] && spccnt<2; j++) {
-			        if (stat_str[j] == ' ') spccnt++;
+			for (j = 0, spccnt = 0; stat_str[j] && spccnt < 2; j++) {
+				if (stat_str[j] == ' ') spccnt++;
 			}
 			s2 = stat_str[j];
 
 			/* print out the line formatted like Debian dpkg */
 			printf("%c%c  %-14s %s\n", s1, s2, name_str, vers_str);
 		}
-    }
+	}
 }
 
-static void remove_package(const unsigned int package_num, int noisy)
+static void remove_package(const unsigned package_num, int noisy)
 {
 	const char *package_name = name_hashtable[package_hashtable[package_num]->name];
 	const char *package_version = name_hashtable[package_hashtable[package_num]->version];
-	const unsigned int status_num = search_status_hashtable(package_name);
+	const unsigned status_num = search_status_hashtable(package_name);
 	const int package_name_length = strlen(package_name);
 	char **remove_files;
 	char **exclude_files;
 	char list_name[package_name_length + 25];
 	char conffile_name[package_name_length + 30];
-	int return_value;
 
-	if ( noisy )
-		printf("Removing %s (%s) ...\n", package_name, package_version);
+	if (noisy)
+		printf("Removing %s (%s)...\n", package_name, package_version);
 
 	/* run prerm script */
-	return_value = run_package_script(package_name, "prerm");
-	if (return_value == -1) {
+	if (run_package_script(package_name, "prerm") != 0) {
 		bb_error_msg_and_die("script failed, prerm failure");
 	}
 
@@ -1371,8 +1322,8 @@ static void remove_package(const unsigned int package_num, int noisy)
 	sprintf(conffile_name, "/var/lib/dpkg/info/%s.conffiles", package_name);
 	exclude_files = create_list(conffile_name);
 
-	/* Some directories cant be removed straight away, so do multiple passes */
-	while (remove_file_array(remove_files, exclude_files));
+	/* Some directories can't be removed straight away, so do multiple passes */
+	while (remove_file_array(remove_files, exclude_files)) /*repeat */;
 	free_array(exclude_files);
 	free_array(remove_files);
 
@@ -1389,22 +1340,22 @@ static void remove_package(const unsigned int package_num, int noisy)
 	free_array(exclude_files);
 
 	/* rename <package>.conffile to <package>.list */
-	rename(conffile_name, list_name);
+	xrename(conffile_name, list_name);
 
 	/* Change package status */
 	set_status(status_num, "config-files", 3);
 }
 
-static void purge_package(const unsigned int package_num)
+static void purge_package(const unsigned package_num)
 {
 	const char *package_name = name_hashtable[package_hashtable[package_num]->name];
 	const char *package_version = name_hashtable[package_hashtable[package_num]->version];
-	const unsigned int status_num = search_status_hashtable(package_name);
+	const unsigned status_num = search_status_hashtable(package_name);
 	char **remove_files;
 	char **exclude_files;
 	char list_name[strlen(package_name) + 25];
 
-	printf("Purging %s (%s) ...\n", package_name, package_version);
+	printf("Purging %s (%s)...\n", package_name, package_version);
 
 	/* run prerm script */
 	if (run_package_script(package_name, "prerm") != 0) {
@@ -1418,7 +1369,7 @@ static void purge_package(const unsigned int package_num)
 	exclude_files = xzalloc(sizeof(char*));
 
 	/* Some directories cant be removed straight away, so do multiple passes */
-	while (remove_file_array(remove_files, exclude_files));
+	while (remove_file_array(remove_files, exclude_files)) /* repeat */;
 	free_array(remove_files);
 
 	/* Create a list of all /var/lib/dpkg/info/<package> files */
@@ -1428,8 +1379,8 @@ static void purge_package(const unsigned int package_num)
 	free(exclude_files);
 
 	/* run postrm script */
-	if (run_package_script(package_name, "postrm") == -1) {
-		bb_error_msg_and_die("postrm fialure.. set status to what?");
+	if (run_package_script(package_name, "postrm") != 0) {
+		bb_error_msg_and_die("postrm failure.. set status to what?");
 	}
 
 	/* Change package status */
@@ -1445,7 +1396,7 @@ static archive_handle_t *init_archive_deb_ar(const char *filename)
 	ar_handle->filter = filter_accept_list_reassign;
 	ar_handle->src_fd = xopen(filename, O_RDONLY);
 
-	return(ar_handle);
+	return ar_handle;
 }
 
 static void init_archive_deb_control(archive_handle_t *ar_handle)
@@ -1457,17 +1408,15 @@ static void init_archive_deb_control(archive_handle_t *ar_handle)
 	tar_handle->src_fd = ar_handle->src_fd;
 
 	/* We don't care about data.tar.* or debian-binary, just control.tar.* */
-#ifdef CONFIG_FEATURE_DEB_TAR_GZ
-	llist_add_to(&(ar_handle->accept), "control.tar.gz");
+#if ENABLE_FEATURE_DEB_TAR_GZ
+	llist_add_to(&(ar_handle->accept), (char*)"control.tar.gz");
 #endif
-#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
-	llist_add_to(&(ar_handle->accept), "control.tar.bz2");
+#if ENABLE_FEATURE_DEB_TAR_BZ2
+	llist_add_to(&(ar_handle->accept), (char*)"control.tar.bz2");
 #endif
 
 	/* Assign the tar handle as a subarchive of the ar handle */
 	ar_handle->sub_archive = tar_handle;
-
-	return;
 }
 
 static void init_archive_deb_data(archive_handle_t *ar_handle)
@@ -1479,17 +1428,15 @@ static void init_archive_deb_data(archive_handle_t *ar_handle)
 	tar_handle->src_fd = ar_handle->src_fd;
 
 	/* We don't care about control.tar.* or debian-binary, just data.tar.* */
-#ifdef CONFIG_FEATURE_DEB_TAR_GZ
-	llist_add_to(&(ar_handle->accept), "data.tar.gz");
+#if ENABLE_FEATURE_DEB_TAR_GZ
+	llist_add_to(&(ar_handle->accept), (char*)"data.tar.gz");
 #endif
-#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
-	llist_add_to(&(ar_handle->accept), "data.tar.bz2");
+#if ENABLE_FEATURE_DEB_TAR_BZ2
+	llist_add_to(&(ar_handle->accept), (char*)"data.tar.bz2");
 #endif
 
 	/* Assign the tar handle as a subarchive of the ar handle */
 	ar_handle->sub_archive = tar_handle;
-
-	return;
 }
 
 static char *deb_extract_control_file_to_buffer(archive_handle_t *ar_handle, llist_t *myaccept)
@@ -1501,7 +1448,7 @@ static char *deb_extract_control_file_to_buffer(archive_handle_t *ar_handle, lli
 	unpack_ar_archive(ar_handle);
 	close(ar_handle->src_fd);
 
-	return(ar_handle->sub_archive->buffer);
+	return ar_handle->sub_archive->buffer;
 }
 
 static void data_extract_all_prefix(archive_handle_t *archive_handle)
@@ -1513,14 +1460,13 @@ static void data_extract_all_prefix(archive_handle_t *archive_handle)
 		archive_handle->file_header->name = xasprintf("%s%s", archive_handle->buffer, name_ptr);
 		data_extract_all(archive_handle);
 	}
-	return;
 }
 
 static void unpack_package(deb_file_t *deb_file)
 {
 	const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
-	const unsigned int status_num = search_status_hashtable(package_name);
-	const unsigned int status_package_num = status_hashtable[status_num]->package;
+	const unsigned status_num = search_status_hashtable(package_name);
+	const unsigned status_package_num = status_hashtable[status_num]->package;
 	char *info_prefix;
 	char *list_filename;
 	archive_handle_t *archive_handle;
@@ -1531,12 +1477,12 @@ static void unpack_package(deb_file_t *deb_file)
 	/* If existing version, remove it first */
 	if (strcmp(name_hashtable[get_status(status_num, 3)], "installed") == 0) {
 		/* Package is already installed, remove old version first */
-		printf("Preparing to replace %s %s (using %s) ...\n", package_name,
+		printf("Preparing to replace %s %s (using %s)...\n", package_name,
 			name_hashtable[package_hashtable[status_package_num]->version],
 			deb_file->filename);
 		remove_package(status_package_num, 0);
 	} else {
-		printf("Unpacking %s (from %s) ...\n", package_name, deb_file->filename);
+		printf("Unpacking %s (from %s)...\n", package_name, deb_file->filename);
 	}
 
 	/* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
@@ -1544,7 +1490,7 @@ static void unpack_package(deb_file_t *deb_file)
 	archive_handle = init_archive_deb_ar(deb_file->filename);
 	init_archive_deb_control(archive_handle);
 
-	while(all_control_files[i]) {
+	while (all_control_files[i]) {
 		char *c = xasprintf("./%s", all_control_files[i]);
 		llist_add_to(&accept_list, c);
 		i++;
@@ -1559,20 +1505,20 @@ static void unpack_package(deb_file_t *deb_file)
 	/* Run the preinst prior to extracting */
 	if (run_package_script(package_name, "preinst") != 0) {
 		/* when preinst returns exit code != 0 then quit installation process */
-		bb_error_msg_and_die("subprocess pre-installation script returned error.");
+		bb_error_msg_and_die("subprocess pre-installation script returned error");
 	}
 
 	/* Extract data.tar.gz to the root directory */
 	archive_handle = init_archive_deb_ar(deb_file->filename);
 	init_archive_deb_data(archive_handle);
 	archive_handle->sub_archive->action_data = data_extract_all_prefix;
-	archive_handle->sub_archive->buffer = "/";
+	archive_handle->sub_archive->buffer = (char*)"/"; /* huh? */
 	archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
 	unpack_ar_archive(archive_handle);
 
 	/* Create the list file */
-	list_filename = bb_xasprintf("/var/lib/dpkg/info/%s.list", package_name);
-	out_stream = bb_xfopen(list_filename, "w");
+	list_filename = xasprintf("/var/lib/dpkg/info/%s.list", package_name);
+	out_stream = xfopen(list_filename, "w");
 	while (archive_handle->sub_archive->passed) {
 		/* the leading . has been stripped by data_extract_all_prefix already */
 		fputs(archive_handle->sub_archive->passed->data, out_stream);
@@ -1595,113 +1541,107 @@ static void configure_package(deb_file_t *deb_file)
 	const char *package_version = name_hashtable[package_hashtable[deb_file->package]->version];
 	const int status_num = search_status_hashtable(package_name);
 
-	printf("Setting up %s (%s) ...\n", package_name, package_version);
+	printf("Setting up %s (%s)...\n", package_name, package_version);
 
 	/* Run the postinst script */
 	if (run_package_script(package_name, "postinst") != 0) {
 		/* TODO: handle failure gracefully */
-		bb_error_msg_and_die("postrm failure.. set status to what?");
+		bb_error_msg_and_die("postinst failure.. set status to what?");
 	}
 	/* Change status to reflect success */
 	set_status(status_num, "install", 1);
 	set_status(status_num, "installed", 3);
 }
 
+int dpkg_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 int dpkg_main(int argc, char **argv)
 {
 	deb_file_t **deb_file = NULL;
 	status_node_t *status_node;
+	char *str_f;
 	int opt;
 	int package_num;
-	int dpkg_opt = 0;
 	int deb_count = 0;
 	int state_status;
 	int status_num;
 	int i;
+	enum {
+		OPT_configure = 0x1,
+		OPT_force_ignore_depends = 0x2,
+		OPT_install = 0x4,
+		OPT_list_installed = 0x8,
+		OPT_purge = 0x10,
+		OPT_remove = 0x20,
+		OPT_unpack = 0x40,
+	};
 
-	while ((opt = getopt(argc, argv, "CF:ilPru")) != -1) {
-		switch (opt) {
-			case 'C': // equivalent to --configure in official dpkg
-				dpkg_opt |= dpkg_opt_configure;
-				dpkg_opt |= dpkg_opt_package_name;
-				break;
-			case 'F': // equivalent to --force in official dpkg
-				if (strcmp(optarg, "depends") == 0) {
-					dpkg_opt |= dpkg_opt_force_ignore_depends;
-				}
-				break;
-			case 'i':
-				dpkg_opt |= dpkg_opt_install;
-				dpkg_opt |= dpkg_opt_filename;
-				break;
-			case 'l':
-				dpkg_opt |= dpkg_opt_list_installed;
-				break;
-			case 'P':
-				dpkg_opt |= dpkg_opt_purge;
-				dpkg_opt |= dpkg_opt_package_name;
-				break;
-			case 'r':
-				dpkg_opt |= dpkg_opt_remove;
-				dpkg_opt |= dpkg_opt_package_name;
-				break;
-			case 'u':	/* Equivalent to --unpack in official dpkg */
-				dpkg_opt |= dpkg_opt_unpack;
-				dpkg_opt |= dpkg_opt_filename;
-				break;
-			default:
-				bb_show_usage();
-		}
-	}
-	/* check for non-otion argument if expected  */
-	if ((dpkg_opt == 0) || ((argc == optind) && !(dpkg_opt && dpkg_opt_list_installed))) {
+	opt = getopt32(argv, "CF:ilPru", &str_f);
+	//if (opt & OPT_configure) ... // -C
+	if (opt & OPT_force_ignore_depends) { // -F (--force in official dpkg)
+		if (strcmp(str_f, "depends"))
+			opt &= ~OPT_force_ignore_depends;
+	}
+	//if (opt & OPT_install) ... // -i
+	//if (opt & OPT_list_installed) ... // -l
+	//if (opt & OPT_purge) ... // -P
+	//if (opt & OPT_remove) ... // -r
+	//if (opt & OPT_unpack) ... // -u (--unpack in official dpkg)
+	argc -= optind;
+	argv += optind;
+	/* check for non-option argument if expected  */
+	if (!opt || (!argc && !(opt && OPT_list_installed)))
 		bb_show_usage();
-	}
+
+	name_hashtable = xzalloc(sizeof(name_hashtable[0]) * (NAME_HASH_PRIME + 1));
+	package_hashtable = xzalloc(sizeof(package_hashtable[0]) * (PACKAGE_HASH_PRIME + 1));
+	status_hashtable = xzalloc(sizeof(status_hashtable[0]) * (STATUS_HASH_PRIME + 1));
 
 /*	puts("(Reading database ... xxxxx files and directories installed.)"); */
 	index_status_file("/var/lib/dpkg/status");
 
 	/* if the list action was given print the installed packages and exit */
-	if (dpkg_opt & dpkg_opt_list_installed) {
+	if (opt & OPT_list_installed) {
 		list_packages();
-		return(EXIT_SUCCESS);
+		return EXIT_SUCCESS;
 	}
 
 	/* Read arguments and store relevant info in structs */
-	while (optind < argc) {
+	while (*argv) {
 		/* deb_count = nb_elem - 1 and we need nb_elem + 1 to allocate terminal node [NULL pointer] */
-		deb_file = xrealloc(deb_file, sizeof(deb_file_t *) * (deb_count + 2));
-		deb_file[deb_count] = (deb_file_t *) xzalloc(sizeof(deb_file_t));
-		if (dpkg_opt & dpkg_opt_filename) {
+		deb_file = xrealloc(deb_file, sizeof(deb_file[0]) * (deb_count + 2));
+		deb_file[deb_count] = xzalloc(sizeof(deb_file[0][0]));
+		if (opt & (OPT_install | OPT_unpack)) {
+			/* -i/-u: require filename */
 			archive_handle_t *archive_handle;
 			llist_t *control_list = NULL;
 
 			/* Extract the control file */
-			llist_add_to(&control_list, "./control");
-			archive_handle = init_archive_deb_ar(argv[optind]);
+			llist_add_to(&control_list, (char*)"./control");
+			archive_handle = init_archive_deb_ar(argv[0]);
 			init_archive_deb_control(archive_handle);
 			deb_file[deb_count]->control_file = deb_extract_control_file_to_buffer(archive_handle, control_list);
 			if (deb_file[deb_count]->control_file == NULL) {
-				bb_error_msg_and_die("Couldnt extract control file");
+				bb_error_msg_and_die("cannot extract control file");
 			}
-			deb_file[deb_count]->filename = xstrdup(argv[optind]);
+			deb_file[deb_count]->filename = xstrdup(argv[0]);
 			package_num = fill_package_struct(deb_file[deb_count]->control_file);
 
 			if (package_num == -1) {
-				bb_error_msg("Invalid control file in %s", argv[optind]);
-				optind++;
+				bb_error_msg("invalid control file in %s", argv[0]);
+				argv++;
 				continue;
 			}
-			deb_file[deb_count]->package = (unsigned int) package_num;
+			deb_file[deb_count]->package = (unsigned) package_num;
 
 			/* Add the package to the status hashtable */
-			if ((dpkg_opt & dpkg_opt_unpack) || (dpkg_opt & dpkg_opt_install)) {
+			if (opt & (OPT_unpack | OPT_install)) {
 				/* Try and find a currently installed version of this package */
 				status_num = search_status_hashtable(name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]);
 				/* If no previous entry was found initialise a new entry */
-				if ((status_hashtable[status_num] == NULL) ||
-					(status_hashtable[status_num]->status == 0)) {
-					status_node = (status_node_t *) xmalloc(sizeof(status_node_t));
+				if (status_hashtable[status_num] == NULL
+				 || status_hashtable[status_num]->status == 0
+				) {
+					status_node = xmalloc(sizeof(status_node_t));
 					status_node->package = deb_file[deb_count]->package;
 					/* reinstreq isnt changed to "ok" until the package control info
 					 * is written to the status file*/
@@ -1712,96 +1652,101 @@ int dpkg_main(int argc, char **argv)
 					set_status(status_num, "reinstreq", 2);
 				}
 			}
-		}
-		else if (dpkg_opt & dpkg_opt_package_name) {
+		} else if (opt & (OPT_configure | OPT_purge | OPT_remove)) {
+			/* -C/-p/-r: require package name */
 			deb_file[deb_count]->package = search_package_hashtable(
-				search_name_hashtable(argv[optind]),
-				search_name_hashtable("ANY"), VER_ANY);
+					search_name_hashtable(argv[0]),
+					search_name_hashtable("ANY"), VER_ANY);
 			if (package_hashtable[deb_file[deb_count]->package] == NULL) {
-				bb_error_msg_and_die("Package %s is uninstalled or unknown\n", argv[optind]);
+				bb_error_msg_and_die("package %s is uninstalled or unknown", argv[0]);
 			}
 			package_num = deb_file[deb_count]->package;
 			status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
 			state_status = get_status(status_num, 3);
 
 			/* check package status is "installed" */
-			if (dpkg_opt & dpkg_opt_remove) {
-				if ((strcmp(name_hashtable[state_status], "not-installed") == 0) ||
-					(strcmp(name_hashtable[state_status], "config-files") == 0)) {
-					bb_error_msg_and_die("%s is already removed.", name_hashtable[package_hashtable[package_num]->name]);
+			if (opt & OPT_remove) {
+				if (strcmp(name_hashtable[state_status], "not-installed") == 0
+				 || strcmp(name_hashtable[state_status], "config-files") == 0
+				) {
+					bb_error_msg_and_die("%s is already removed", name_hashtable[package_hashtable[package_num]->name]);
 				}
 				set_status(status_num, "deinstall", 1);
-			}
-			else if (dpkg_opt & dpkg_opt_purge) {
+			} else if (opt & OPT_purge) {
 				/* if package status is "conf-files" then its ok */
 				if (strcmp(name_hashtable[state_status], "not-installed") == 0) {
-					bb_error_msg_and_die("%s is already purged.", name_hashtable[package_hashtable[package_num]->name]);
+					bb_error_msg_and_die("%s is already purged", name_hashtable[package_hashtable[package_num]->name]);
 				}
 				set_status(status_num, "purge", 1);
 			}
 		}
 		deb_count++;
-		optind++;
+		argv++;
 	}
+	if (!deb_count)
+		bb_error_msg_and_die("no package files specified");
 	deb_file[deb_count] = NULL;
 
 	/* Check that the deb file arguments are installable */
-	if ((dpkg_opt & dpkg_opt_force_ignore_depends) != dpkg_opt_force_ignore_depends) {
-		if (!check_deps(deb_file, 0, deb_count)) {
-			bb_error_msg_and_die("Dependency check failed");
+	if (!(opt & OPT_force_ignore_depends)) {
+		if (!check_deps(deb_file, 0 /*, deb_count*/)) {
+			bb_error_msg_and_die("dependency check failed");
 		}
 	}
 
 	/* TODO: install or remove packages in the correct dependency order */
 	for (i = 0; i < deb_count; i++) {
 		/* Remove or purge packages */
-		if (dpkg_opt & dpkg_opt_remove) {
+		if (opt & OPT_remove) {
 			remove_package(deb_file[i]->package, 1);
 		}
-		else if (dpkg_opt & dpkg_opt_purge) {
+		else if (opt & OPT_purge) {
 			purge_package(deb_file[i]->package);
 		}
-		else if (dpkg_opt & dpkg_opt_unpack) {
+		else if (opt & OPT_unpack) {
 			unpack_package(deb_file[i]);
 		}
-		else if (dpkg_opt & dpkg_opt_install) {
+		else if (opt & OPT_install) {
 			unpack_package(deb_file[i]);
 			/* package is configured in second pass below */
 		}
-		else if (dpkg_opt & dpkg_opt_configure) {
+		else if (opt & OPT_configure) {
 			configure_package(deb_file[i]);
 		}
 	}
 	/* configure installed packages */
-	if (dpkg_opt & dpkg_opt_install) {
+	if (opt & OPT_install) {
 		for (i = 0; i < deb_count; i++)
 			configure_package(deb_file[i]);
 	}
 
 	write_status_file(deb_file);
 
-	for (i = 0; i < deb_count; i++) {
-		free(deb_file[i]->control_file);
-		free(deb_file[i]->filename);
-		free(deb_file[i]);
-	}
+	if (ENABLE_FEATURE_CLEAN_UP) {
+		for (i = 0; i < deb_count; i++) {
+			free(deb_file[i]->control_file);
+			free(deb_file[i]->filename);
+			free(deb_file[i]);
+		}
 
-	free(deb_file);
+		free(deb_file);
 
-	for (i = 0; i < NAME_HASH_PRIME; i++) {
-		free(name_hashtable[i]);
-	}
+		for (i = 0; i < NAME_HASH_PRIME; i++) {
+			free(name_hashtable[i]);
+		}
 
-	for (i = 0; i < PACKAGE_HASH_PRIME; i++) {
-		if (package_hashtable[i] != NULL) {
+		for (i = 0; i < PACKAGE_HASH_PRIME; i++) {
 			free_package(package_hashtable[i]);
 		}
-	}
 
-	for (i = 0; i < STATUS_HASH_PRIME; i++) {
-		free(status_hashtable[i]);
+		for (i = 0; i < STATUS_HASH_PRIME; i++) {
+			free(status_hashtable[i]);
+		}
+
+		free(status_hashtable);
+		free(package_hashtable);
+		free(name_hashtable);
 	}
 
-	return(EXIT_SUCCESS);
+	return EXIT_SUCCESS;
 }
-