X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Fdpkg.c;h=c37ae334903d7505648d08a3403e9e52faccb6ca;hb=b9f2d9f7d9b4a9b6fbb6a28a8c0bcf8e0e3b1704;hp=ebdf6c68a1ceab8d163c8782490603e519932ada;hpb=de8a6a01d84ebb09a333104bf0fd5f6e251d9eb7;p=oweals%2Fbusybox.git

diff --git a/archival/dpkg.c b/archival/dpkg.c
index ebdf6c68a..c37ae3349 100644
--- a/archival/dpkg.c
+++ b/archival/dpkg.c
@@ -6,9 +6,13 @@
  *  written by glenn mcgrath with the help of others
  *  copyright (c) 2001 by glenn mcgrath
  *
+ *  parts of the version comparison code is plucked from the real dpkg
+ *  application which is licensed GPLv2 and
+ *  copyright (c) 1995 Ian Jackson <ian@chiark.greenend.org.uk>
+ *
  *  started life as a busybox implementation of udpkg
  *
- * licensed under gplv2 or later, see file license in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
 /*
@@ -24,8 +28,9 @@
  *
  */
 
-#include "busybox.h"
-#include "unarchive.h"
+#include "libbb.h"
+#include <fnmatch.h>
+#include "archive.h"
 
 /* note: if you vary hash_prime sizes be aware,
  * 1) tweaking these will have a big effect on how much memory this program uses.
@@ -53,16 +58,16 @@
  *      and available file */
 #define PACKAGE_HASH_PRIME 10007
 typedef struct edge_s {
-	unsigned operator:3;
+	unsigned operator:4; /* was:3 */
 	unsigned type:4;
-	unsigned name:14;
-	unsigned version:14;
+	unsigned name:16; /* was:14 */
+	unsigned version:16; /* was:14 */
 } edge_t;
 
 typedef struct common_node_s {
-	unsigned name:14;
-	unsigned version:14;
-	unsigned 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;
 
@@ -71,14 +76,25 @@ typedef struct common_node_s {
  * 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 package:14;	/* has to fit PACKAGE_HASH_PRIME */
-	unsigned 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;
 
-/* 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] */
+
+/* Globals */
+struct globals {
+	char          *name_hashtable[NAME_HASH_PRIME + 1];
+	common_node_t *package_hashtable[PACKAGE_HASH_PRIME + 1];
+	status_node_t *status_hashtable[STATUS_HASH_PRIME + 1];
+};
+#define G (*ptr_to_globals)
+#define name_hashtable    (G.name_hashtable   )
+#define package_hashtable (G.package_hashtable)
+#define status_hashtable  (G.status_hashtable )
+#define INIT_G() do { \
+	SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
+} while (0)
+
 
 /* Even numbers are for 'extras', like ored dependencies or null */
 enum edge_type_e {
@@ -107,13 +123,13 @@ enum operator_e {
 typedef struct deb_file_s {
 	char *control_file;
 	char *filename;
-	unsigned package:14;
+	unsigned package:16; /* was:14 */
 } deb_file_t;
 
 
 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;
 
@@ -123,8 +139,8 @@ static void make_hash(const char *key, unsigned *start, unsigned *decrement, con
 		/* 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));
+		 * no effect */
+		hash_num += (key[i] + key[i-1]) << ((key[i] * i) % 24);
 	}
 	*start = (unsigned) hash_num % hash_prime;
 	*decrement = (unsigned) 1 + (hash_num % (hash_prime - 1));
@@ -133,8 +149,8 @@ static void make_hash(const char *key, unsigned *start, unsigned *decrement, con
 /* this adds the key to the hash table */
 static int search_name_hashtable(const char *key)
 {
-	unsigned probe_address = 0;
-	unsigned probe_decrement = 0;
+	unsigned probe_address;
+	unsigned probe_decrement;
 
 	make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME);
 	while (name_hashtable[probe_address] != NULL) {
@@ -155,8 +171,8 @@ static int search_name_hashtable(const char *key)
  */
 static unsigned search_status_hashtable(const char *key)
 {
-	unsigned probe_address = 0;
-	unsigned probe_decrement = 0;
+	unsigned probe_address;
+	unsigned probe_decrement;
 
 	make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME);
 	while (status_hashtable[probe_address] != NULL) {
@@ -171,60 +187,52 @@ static unsigned search_status_hashtable(const char *key)
 	return probe_address;
 }
 
-/* Need to rethink version comparison, maybe the official dpkg has something i can use ? */
-static int version_compare_part(const char *version1, const char *version2)
+static int order(char x)
 {
-	int upstream_len1 = 0;
-	int upstream_len2 = 0;
-	char *name1_char;
-	char *name2_char;
-	int len1 = 0;
-	int len2 = 0;
-	int tmp_int;
-	int ver_num1;
-	int ver_num2;
-
-	if (version1 == NULL) {
-		version1 = xstrdup("");
-	}
-	if (version2 == NULL) {
-		version2 = xstrdup("");
-	}
-	upstream_len1 = strlen(version1);
-	upstream_len2 = strlen(version2);
-
-	while ((len1 < upstream_len1) || (len2 < upstream_len2)) {
-		/* Compare non-digit section */
-		tmp_int = strcspn(&version1[len1], "0123456789");
-		name1_char = xstrndup(&version1[len1], tmp_int);
-		len1 += tmp_int;
-		tmp_int = strcspn(&version2[len2], "0123456789");
-		name2_char = xstrndup(&version2[len2], tmp_int);
-		len2 += tmp_int;
-		tmp_int = strcmp(name1_char, name2_char);
-		free(name1_char);
-		free(name2_char);
-		if (tmp_int != 0) {
-			return tmp_int;
+	return (x == '~' ? -1
+		: x == '\0' ? 0
+		: isdigit(x) ? 0
+		: isalpha(x) ? x
+		: (unsigned char)x + 256
+	);
+}
+
+/* This code is taken from dpkg and modified slightly to work with busybox */
+static int version_compare_part(const char *val, const char *ref)
+{
+	if (!val) val = "";
+	if (!ref) ref = "";
+
+	while (*val || *ref) {
+		int first_diff;
+
+		while ((*val && !isdigit(*val)) || (*ref && !isdigit(*ref))) {
+			int vc = order(*val);
+			int rc = order(*ref);
+			if (vc != rc)
+				return vc - rc;
+			val++;
+			ref++;
 		}
 
-		/* Compare digits */
-		tmp_int = strspn(&version1[len1], "0123456789");
-		name1_char = xstrndup(&version1[len1], tmp_int);
-		len1 += tmp_int;
-		tmp_int = strspn(&version2[len2], "0123456789");
-		name2_char = xstrndup(&version2[len2], tmp_int);
-		len2 += tmp_int;
-		ver_num1 = atoi(name1_char);
-		ver_num2 = atoi(name2_char);
-		free(name1_char);
-		free(name2_char);
-		if (ver_num1 < ver_num2) {
-			return -1;
+		while (*val == '0')
+			val++;
+		while (*ref == '0')
+			ref++;
+
+		first_diff = 0;
+		while (isdigit(*val) && isdigit(*ref)) {
+			if (first_diff == 0)
+				first_diff = *val - *ref;
+			val++;
+			ref++;
 		}
-		if (ver_num1 > ver_num2) {
+		if (isdigit(*val))
 			return 1;
-		}
+		if (isdigit(*ref))
+			return -1;
+		if (first_diff)
+			return first_diff;
 	}
 	return 0;
 }
@@ -237,55 +245,49 @@ static int version_compare(const unsigned ver1, const unsigned ver2)
 {
 	char *ch_ver1 = name_hashtable[ver1];
 	char *ch_ver2 = name_hashtable[ver2];
-
-	char epoch1, epoch2;
+	unsigned epoch1 = 0, epoch2 = 0;
+	char *colon;
 	char *deb_ver1, *deb_ver2;
-	char *ver1_ptr, *ver2_ptr;
 	char *upstream_ver1;
 	char *upstream_ver2;
 	int result;
 
 	/* Compare epoch */
-	if (ch_ver1[1] == ':') {
-		epoch1 = ch_ver1[0];
-		ver1_ptr = strchr(ch_ver1, ':') + 1;
-	} else {
-		epoch1 = '0';
-		ver1_ptr = ch_ver1;
+	colon = strchr(ch_ver1, ':');
+	if (colon) {
+		epoch1 = atoi(ch_ver1);
+		ch_ver1 = colon + 1;
 	}
-	if (ch_ver2[1] == ':') {
-		epoch2 = ch_ver2[0];
-		ver2_ptr = strchr(ch_ver2, ':') + 1;
-	} else {
-		epoch2 = '0';
-		ver2_ptr = ch_ver2;
+	colon = strchr(ch_ver2, ':');
+	if (colon) {
+		epoch2 = atoi(ch_ver2);
+		ch_ver2 = colon + 1;
 	}
 	if (epoch1 < epoch2) {
 		return -1;
 	}
-	else if (epoch1 > epoch2) {
+	if (epoch1 > epoch2) {
 		return 1;
 	}
 
 	/* Compare upstream version */
-	upstream_ver1 = xstrdup(ver1_ptr);
-	upstream_ver2 = xstrdup(ver2_ptr);
+	upstream_ver1 = xstrdup(ch_ver1);
+	upstream_ver2 = xstrdup(ch_ver2);
 
 	/* Chop off debian version, and store for later use */
 	deb_ver1 = strrchr(upstream_ver1, '-');
 	deb_ver2 = strrchr(upstream_ver2, '-');
 	if (deb_ver1) {
-		deb_ver1[0] = '\0';
-		deb_ver1++;
+		*deb_ver1++ = '\0';
 	}
 	if (deb_ver2) {
-		deb_ver2[0] = '\0';
-		deb_ver2++;
+		*deb_ver2++ = '\0';
 	}
 	result = version_compare_part(upstream_ver1, upstream_ver2);
-	if (!result)
+	if (result == 0) {
 		/* Compare debian versions */
 		result = version_compare_part(deb_ver1, deb_ver2);
+	}
 
 	free(upstream_ver1);
 	free(upstream_ver2);
@@ -312,11 +314,10 @@ static int test_version(const unsigned version1, const unsigned version2, const
 	return FALSE;
 }
 
-
 static int search_package_hashtable(const unsigned name, const unsigned version, const unsigned operator)
 {
-	unsigned probe_address = 0;
-	unsigned probe_decrement = 0;
+	unsigned probe_address;
+	unsigned probe_decrement;
 
 	make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME);
 	while (package_hashtable[probe_address] != NULL) {
@@ -352,7 +353,8 @@ static int search_package_hashtable(const unsigned name, const unsigned version,
  * 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++) {
@@ -371,9 +373,8 @@ static int search_for_provides(int needle, int start_at) {
  */
 static void add_edge_to_node(common_node_t *node, edge_t *edge)
 {
-	node->num_of_edges++;
-	node->edge = xrealloc(node->edge, sizeof(edge_t) * (node->num_of_edges + 1));
-	node->edge[node->num_of_edges - 1] = edge;
+	node->edge = xrealloc_vector(node->edge, 2, node->num_of_edges);
+	node->edge[node->num_of_edges++] = edge;
 }
 
 /*
@@ -409,10 +410,10 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
 		if ((edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS)
 		 && (strcmp(field, field2) != 0)
 		) {
-			or_edge = xmalloc(sizeof(edge_t));
+			or_edge = xzalloc(sizeof(edge_t));
 			or_edge->type = edge_type + 1;
 			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);
 		}
 
@@ -431,24 +432,20 @@ 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, " (");
 				/* Calculate length of any operator characters */
 				offset_ch = strspn(version, "<=>");
 				/* Determine operator */
 				if (offset_ch > 0) {
 					if (strncmp(version, "=", offset_ch) == 0) {
 						edge->operator = VER_EQUAL;
-					}
-					else if (strncmp(version, "<<", offset_ch) == 0) {
+					} else if (strncmp(version, "<<", offset_ch) == 0) {
 						edge->operator = VER_LESS;
-					}
-					else if (strncmp(version, "<=", offset_ch) == 0) {
+					} else if (strncmp(version, "<=", offset_ch) == 0) {
 						edge->operator = VER_LESS_EQUAL;
-					}
-					else if (strncmp(version, ">>", offset_ch) == 0) {
+					} else if (strncmp(version, ">>", offset_ch) == 0) {
 						edge->operator = VER_MORE;
-					}
-					else if (strncmp(version, ">=", offset_ch) == 0) {
+					} else if (strncmp(version, ">=", offset_ch) == 0) {
 						edge->operator = VER_MORE_EQUAL;
 					} else {
 						bb_error_msg_and_die("illegal operator");
@@ -472,9 +469,13 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
 				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);
+		field = strtok_r(NULL, ",", &line_ptr1);
+	} while (field != NULL);
+
 	free(line);
 }
 
@@ -491,7 +492,7 @@ static void free_package(common_node_t *node)
 }
 
 /*
- * Gets the next package field from package_buffer, seperated into the field name
+ * Gets the next package field from package_buffer, separated into the field name
  * and field value, it returns the int offset to the first character of the next field
  */
 static int read_package_field(const char *package_buffer, char **field_name, char **field_value)
@@ -577,10 +578,10 @@ static int read_package_field(const char *package_buffer, char **field_name, cha
 
 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 = xzalloc(sizeof(common_node_t));
 	char *field_name;
@@ -597,10 +598,10 @@ static unsigned fill_package_struct(char *control_buffer)
 				&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 = index_in_str_array(field_names, field_name);
+		field_num = index_in_strings(field_names, field_name);
 		switch (field_num) {
 		case 0: /* Package */
 			new_node->name = search_name_hashtable(field_value);
@@ -643,8 +644,7 @@ static unsigned fill_package_struct(char *control_buffer)
 		return -1;
 	}
 	num = search_package_hashtable(new_node->name, new_node->version, VER_EQUAL);
-	if (package_hashtable[num] != NULL)
-		free_package(package_hashtable[num]);
+	free_package(package_hashtable[num]);
 	package_hashtable[num] = new_node;
 	return num;
 }
@@ -706,10 +706,11 @@ static void set_status(const unsigned status_node_num, const char *new_value, co
 	free(new_status);
 }
 
-static const char *describe_status(int status_num) {
-	int status_want, status_state ;
+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";
+		return "is not installed or flagged to be installed";
 
 	status_want = get_status(status_num, 1);
 	status_state = get_status(status_num, 3);
@@ -722,7 +723,7 @@ static const char *describe_status(int status_num) {
 		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"))
 		return "is marked to be installed";
@@ -730,7 +731,6 @@ static const char *describe_status(int status_num) {
 	return "is not installed or flagged to be installed";
 }
 
-
 static void index_status_file(const char *filename)
 {
 	FILE *status_file;
@@ -739,8 +739,8 @@ static void index_status_file(const char *filename)
 	status_node_t *status_node = NULL;
 	unsigned status_num;
 
-	status_file = xfopen(filename, "r");
-	while ((control_buffer = xmalloc_fgets_str(status_file, "\n\n")) != NULL) {
+	status_file = xfopen_for_read(filename);
+	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));
@@ -781,8 +781,8 @@ static void write_buffer_no_status(FILE *new_status_file, const char *control_bu
 /* This could do with a cleanup */
 static void write_status_file(deb_file_t **deb_file)
 {
-	FILE *old_status_file = xfopen("/var/lib/dpkg/status", "r");
-	FILE *new_status_file = xfopen("/var/lib/dpkg/status.udeb", "w");
+	FILE *old_status_file = xfopen_for_read("/var/lib/dpkg/status");
+	FILE *new_status_file = xfopen_for_write("/var/lib/dpkg/status.udeb");
 	char *package_name;
 	char *status_from_file;
 	char *control_buffer = NULL;
@@ -793,8 +793,9 @@ static void write_status_file(deb_file_t **deb_file)
 	int i = 0;
 
 	/* Update previously known packages */
-	while ((control_buffer = xmalloc_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;
 		}
 
@@ -804,7 +805,7 @@ static void write_status_file(deb_file_t **deb_file)
 		write_flag = FALSE;
 		tmp_string = strstr(control_buffer, "Status:");
 		if (tmp_string != NULL) {
-			/* Seperate the status value from the control buffer */
+			/* Separate the status value from the control buffer */
 			tmp_string += 7;
 			tmp_string += strspn(tmp_string, " \n\t");
 			status_from_file = xstrndup(tmp_string, strcspn(tmp_string, "\n"));
@@ -819,8 +820,9 @@ 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) {
@@ -855,15 +857,16 @@ static void write_status_file(deb_file_t **deb_file)
 						if (field_name == NULL) {
 							break;
 						}
-						if ((strcmp(field_name, "Priority") == 0) ||
-							(strcmp(field_name, "Section") == 0)) {
+						if ((strcmp(field_name, "Priority") == 0)
+						 || (strcmp(field_name, "Section") == 0)
+						) {
 							fprintf(new_status_file, "%s: %s\n", field_name, field_value);
 						}
 					}
 					write_flag = TRUE;
 					fputs("\n", new_status_file);
 				}
-				else if	(strcmp("config-files", name_hashtable[state_status]) == 0) {
+				else if (strcmp("config-files", name_hashtable[state_status]) == 0) {
 					/* only change the status line */
 					while (1) {
 						char *field_name;
@@ -885,7 +888,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);
 		}
 
@@ -906,20 +909,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("can't 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");
 	}
 
-	if (rename("/var/lib/dpkg/status.udeb", "/var/lib/dpkg/status") == -1) {
-		bb_error_msg_and_die("DANGER: cannot 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
@@ -940,13 +939,13 @@ static int package_satisfies_dependency(int package, int depend_type)
 		return 0;
 
 	switch (depend_type) {
-	case EDGE_PRE_DEPENDS:	return get_status(status_num, 3) == search_name_hashtable("installed");
-	case EDGE_DEPENDS:	return get_status(status_num, 1) == search_name_hashtable("install");
+	case EDGE_PRE_DEPENDS: return get_status(status_num, 3) == search_name_hashtable("installed");
+	case EDGE_DEPENDS:     return get_status(status_num, 1) == search_name_hashtable("install");
 	}
 	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;
@@ -964,11 +963,11 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 	 * installed package for conflicts*/
 	while (deb_file[i] != NULL) {
 		const unsigned package_num = deb_file[i]->package;
-		conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
+		conflicts = xrealloc_vector(conflicts, 2, conflicts_num);
 		conflicts[conflicts_num] = package_num;
 		conflicts_num++;
 		/* add provides to conflicts list */
-		for (j = 0; j <	package_hashtable[package_num]->num_of_edges; j++) {
+		for (j = 0; j < package_hashtable[package_num]->num_of_edges; j++) {
 			if (package_hashtable[package_num]->edge[j]->type == EDGE_PROVIDES) {
 				const int conflicts_package_num = search_package_hashtable(
 					package_hashtable[package_num]->edge[j]->name,
@@ -981,7 +980,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 					new_node->version = package_hashtable[package_num]->edge[j]->version;
 					package_hashtable[conflicts_package_num] = new_node;
 				}
-				conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
+				conflicts = xrealloc_vector(conflicts, 2, conflicts_num);
 				conflicts[conflicts_num] = conflicts_package_num;
 				conflicts_num++;
 			}
@@ -1066,20 +1065,24 @@ 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];
 			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;
 			}
 
 			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) {
+			if (package_edge->type == EDGE_PRE_DEPENDS
+			 || package_edge->type == EDGE_DEPENDS
+			) {
 				int result=1;
 				status_num = 0;
 
@@ -1121,14 +1124,14 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 							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
@@ -1147,86 +1150,110 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
 static char **create_list(const char *filename)
 {
 	FILE *list_stream;
-	char **file_list = NULL;
-	char *line = NULL;
-	int count = 0;
+	char **file_list;
+	char *line;
+	int count;
 
 	/* don't use [xw]fopen here, handle error ourself */
-	list_stream = fopen(filename, "r");
+	list_stream = fopen_for_read(filename);
 	if (list_stream == NULL) {
 		return NULL;
 	}
 
-	while ((line = xmalloc_getline(list_stream)) != NULL) {
-		file_list = xrealloc(file_list, sizeof(char *) * (count + 2));
-		file_list[count] = line;
-		count++;
+	file_list = NULL;
+	count = 0;
+	while ((line = xmalloc_fgetline(list_stream)) != NULL) {
+		file_list = xrealloc_vector(file_list, 2, count);
+		file_list[count++] = line;
+		/*file_list[count] = NULL; - xrealloc_vector did it */
 	}
 	fclose(list_stream);
 
-	if (count == 0) {
-		return NULL;
-	} else {
-		file_list[count] = NULL;
-		return file_list;
-	}
+	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)
+static void run_package_script_or_die(const char *package_name, const char *script_type)
 {
-	struct stat path_stat;
 	char *script_path;
 	int result;
 
 	script_path = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, script_type);
 
-	/* If the file doesnt exist is isnt a fatal */
-	result = lstat(script_path, &path_stat) < 0 ? EXIT_SUCCESS : system(script_path);
+	/* If the file doesnt exist is isnt fatal */
+	result = access(script_path, F_OK) ? EXIT_SUCCESS : system(script_path);
 	free(script_path);
-	return result;
+	if (result)
+		bb_error_msg_and_die("%s failed, exit code %d", script_type, result);
 }
 
-static const char *all_control_files[] = {"preinst", "postinst", "prerm", "postrm",
-	"list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL };
+/*
+The policy manual defines what scripts get called when and with
+what arguments. I realize that busybox does not support all of
+these scenarios, but it does support some of them; it does not,
+however, run them with any parameters in run_package_script_or_die().
+Here are the scripts:
+
+preinst install
+preinst install <old_version>
+preinst upgrade <old_version>
+preinst abort_upgrade <new_version>
+postinst configure <most_recent_version>
+postinst abort-upgade <new_version>
+postinst abort-remove
+postinst abort-remove in-favour <package> <version>
+postinst abort-deconfigure in-favor <failed_install_package> removing <conflicting_package> <version>
+prerm remove
+prerm upgrade <new_version>
+prerm failed-upgrade <old_version>
+prerm remove in-favor <package> <new_version>
+prerm deconfigure in-favour <package> <version> removing <package> <version>
+postrm remove
+postrm purge
+postrm upgrade <new_version>
+postrm failed-upgrade <old_version>
+postrm abort-install
+postrm abort-install <old_version>
+postrm abort-upgrade <old_version>
+postrm disappear <overwriter> <version>
+*/
+static const char *const all_control_files[] = {
+	"preinst", "postinst", "prerm", "postrm",
+	"list", "md5sums", "shlibs", "conffiles",
+	"config", "templates"
+};
 
 static char **all_control_list(const char *package_name)
 {
@@ -1234,9 +1261,10 @@ static char **all_control_list(const char *package_name)
 	char **remove_files;
 
 	/* Create a list of all /var/lib/dpkg/info/<package> files */
-	remove_files = xzalloc(sizeof(all_control_files));
-	while (all_control_files[i]) {
-		remove_files[i] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, all_control_files[i]);
+	remove_files = xzalloc(sizeof(all_control_files) + sizeof(char*));
+	while (i < ARRAY_SIZE(all_control_files)) {
+		remove_files[i] = xasprintf("/var/lib/dpkg/info/%s.%s",
+				package_name, all_control_files[i]);
 		i++;
 	}
 
@@ -1245,7 +1273,6 @@ static char **all_control_list(const char *package_name)
 
 static void free_array(char **array)
 {
-
 	if (array) {
 		unsigned i = 0;
 		while (array[i]) {
@@ -1260,7 +1287,7 @@ static void free_array(char **array)
  * the status_hashtable to retrieve the info. This results in smaller code than
  * scanning the status file. The resulting list, however, is unsorted.
  */
-static void list_packages(void)
+static void list_packages(const char *pattern)
 {
 	int i;
 
@@ -1268,8 +1295,7 @@ static void list_packages(void)
 	puts("+++-==============-==============");
 
 	/* go through status hash, dereference package hash and finally strings */
-	for (i=0; i<STATUS_HASH_PRIME+1; i++) {
-
+	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 */
@@ -1282,11 +1308,14 @@ static void list_packages(void)
 			name_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->name];
 			vers_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->version];
 
+			if (pattern && fnmatch(pattern, name_str, 0) != 0)
+				continue;
+
 			/* get abbreviation for status field 1 */
 			s1 = stat_str[0] == 'i' ? 'i' : 'r';
 
 			/* get abbreviation for status field 2 */
-			for (j=0, spccnt=0; stat_str[j] && spccnt<2; j++) {
+			for (j = 0, spccnt = 0; stat_str[j] && spccnt < 2; j++) {
 				if (stat_str[j] == ' ') spccnt++;
 			}
 			s2 = stat_str[j];
@@ -1294,7 +1323,7 @@ static void list_packages(void)
 			/* 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 package_num, int noisy)
@@ -1307,33 +1336,30 @@ static void remove_package(const unsigned package_num, int noisy)
 	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);
 
-	/* run prerm script */
-	return_value = run_package_script(package_name, "prerm");
-	if (return_value == -1) {
-		bb_error_msg_and_die("script failed, prerm failure");
-	}
+	/* Run prerm script */
+	run_package_script_or_die(package_name, "prerm");
 
 	/* Create a list of files to remove, and a separate list of those to keep */
-	sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name);
+	sprintf(list_name, "/var/lib/dpkg/info/%s.%s", package_name, "list");
 	remove_files = create_list(list_name);
 
-	sprintf(conffile_name, "/var/lib/dpkg/info/%s.conffiles", package_name);
+	sprintf(conffile_name, "/var/lib/dpkg/info/%s.%s", package_name, "conffiles");
 	exclude_files = create_list(conffile_name);
 
 	/* Some directories can't be removed straight away, so do multiple passes */
-	while (remove_file_array(remove_files, exclude_files)) /*repeat */;
+	while (remove_file_array(remove_files, exclude_files))
+		continue;
 	free_array(exclude_files);
 	free_array(remove_files);
 
-	/* Create a list of files in /var/lib/dpkg/info/<package>.* to keep  */
-	exclude_files = xzalloc(sizeof(char*) * 3);
+	/* Create a list of files in /var/lib/dpkg/info/<package>.* to keep */
+	exclude_files = xzalloc(sizeof(exclude_files[0]) * 3);
 	exclude_files[0] = xstrdup(conffile_name);
-	exclude_files[1] = xasprintf("/var/lib/dpkg/info/%s.postrm", package_name);
+	exclude_files[1] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "postrm");
 
 	/* Create a list of all /var/lib/dpkg/info/<package> files */
 	remove_files = all_control_list(package_name);
@@ -1342,7 +1368,9 @@ static void remove_package(const unsigned package_num, int noisy)
 	free_array(remove_files);
 	free_array(exclude_files);
 
-	/* rename <package>.conffile to <package>.list */
+	/* rename <package>.conffiles to <package>.list
+	 * The conffiles control file isn't required in Debian packages, so don't
+	 * error out if it's missing.  */
 	rename(conffile_name, list_name);
 
 	/* Change package status */
@@ -1360,31 +1388,32 @@ static void purge_package(const unsigned package_num)
 
 	printf("Purging %s (%s)...\n", package_name, package_version);
 
-	/* run prerm script */
-	if (run_package_script(package_name, "prerm") != 0) {
-		bb_error_msg_and_die("script failed, prerm failure");
-	}
+	/* Run prerm script */
+	run_package_script_or_die(package_name, "prerm");
 
 	/* Create a list of files to remove */
-	sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name);
+	sprintf(list_name, "/var/lib/dpkg/info/%s.%s", package_name, "list");
 	remove_files = create_list(list_name);
 
-	exclude_files = xzalloc(sizeof(char*));
-
 	/* Some directories cant be removed straight away, so do multiple passes */
-	while (remove_file_array(remove_files, exclude_files)) /* repeat */;
+	while (remove_file_array(remove_files, NULL))
+		continue;
 	free_array(remove_files);
 
 	/* Create a list of all /var/lib/dpkg/info/<package> files */
 	remove_files = all_control_list(package_name);
+
+	/* Delete all of them except the postrm script */
+	exclude_files = xzalloc(sizeof(exclude_files[0]) * 2);
+	exclude_files[0] = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "postrm");
 	remove_file_array(remove_files, exclude_files);
-	free_array(remove_files);
-	free(exclude_files);
+	free_array(exclude_files);
 
-	/* run postrm script */
-	if (run_package_script(package_name, "postrm") == -1) {
-		bb_error_msg_and_die("postrm fialure.. set status to what?");
-	}
+	/* Run and remove postrm script */
+	run_package_script_or_die(package_name, "postrm");
+	remove_file_array(remove_files, NULL);
+
+	free_array(remove_files);
 
 	/* Change package status */
 	set_status(status_num, "not-installed", 3);
@@ -1411,15 +1440,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
+#if ENABLE_FEATURE_SEAMLESS_GZ
 	llist_add_to(&(ar_handle->accept), (char*)"control.tar.gz");
 #endif
-#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+#if ENABLE_FEATURE_SEAMLESS_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;
+	ar_handle->dpkg__sub_archive = tar_handle;
 }
 
 static void init_archive_deb_data(archive_handle_t *ar_handle)
@@ -1431,40 +1460,131 @@ 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
+#if ENABLE_FEATURE_SEAMLESS_GZ
 	llist_add_to(&(ar_handle->accept), (char*)"data.tar.gz");
 #endif
-#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
+#if ENABLE_FEATURE_SEAMLESS_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;
+	ar_handle->dpkg__sub_archive = tar_handle;
+}
+
+static void FAST_FUNC data_extract_to_buffer(archive_handle_t *archive_handle)
+{
+	unsigned size = archive_handle->file_header->size;
+
+	archive_handle->dpkg__buffer = xzalloc(size + 1);
+	xread(archive_handle->src_fd, archive_handle->dpkg__buffer, size);
 }
 
 static char *deb_extract_control_file_to_buffer(archive_handle_t *ar_handle, llist_t *myaccept)
 {
-	ar_handle->sub_archive->action_data = data_extract_to_buffer;
-	ar_handle->sub_archive->accept = myaccept;
-	ar_handle->sub_archive->filter = filter_accept_list;
+	ar_handle->dpkg__sub_archive->action_data = data_extract_to_buffer;
+	ar_handle->dpkg__sub_archive->accept = myaccept;
+	ar_handle->dpkg__sub_archive->filter = filter_accept_list;
 
 	unpack_ar_archive(ar_handle);
 	close(ar_handle->src_fd);
 
-	return ar_handle->sub_archive->buffer;
+	return ar_handle->dpkg__sub_archive->dpkg__buffer;
+}
+
+static void append_control_file_to_llist(const char *package_name, const char *control_name, llist_t **ll)
+{
+	FILE *fp;
+	char *filename, *line;
+
+	filename = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, control_name);
+	fp = fopen_for_read(filename);
+	free(filename);
+	if (fp != NULL) {
+		while ((line = xmalloc_fgetline(fp)) != NULL)
+			llist_add_to(ll, line);
+		fclose(fp);
+	}
+}
+
+static char FAST_FUNC filter_rename_config(archive_handle_t *archive_handle)
+{
+	int fd;
+	char *name_ptr = archive_handle->file_header->name + 1;
+
+	/* Is this file marked as config file? */
+	if (!find_list_entry(archive_handle->accept, name_ptr))
+		return EXIT_SUCCESS; /* no */
+
+	fd = open(name_ptr, O_RDONLY);
+	if (fd >= 0) {
+		md5_ctx_t md5;
+		char *md5line, *buf;
+		int count;
+
+		/* Calculate MD5 of existing file */
+		buf = xmalloc(4096);
+		md5_begin(&md5);
+		while ((count = safe_read(fd, buf, 4096)) > 0)
+			md5_hash(&md5, buf, count);
+		md5_end(&md5, buf); /* using buf as result storage */
+		close(fd);
+
+		md5line = xmalloc(16 * 2 + 2 + strlen(name_ptr) + 1);
+		sprintf(bin2hex(md5line, buf, 16), "  %s", name_ptr);
+		free(buf);
+
+		/* Is it changed after install? */
+		if (find_list_entry(archive_handle->accept, md5line) == NULL) {
+			printf("Warning: Creating %s as %s.dpkg-new\n", name_ptr, name_ptr);
+			archive_handle->file_header->name = xasprintf("%s.dpkg-new", archive_handle->file_header->name);
+		}
+		free(md5line);
+	}
+	return EXIT_SUCCESS;
 }
 
-static void data_extract_all_prefix(archive_handle_t *archive_handle)
+static void FAST_FUNC data_extract_all_prefix(archive_handle_t *archive_handle)
 {
 	char *name_ptr = archive_handle->file_header->name;
 
-	name_ptr += strspn(name_ptr, "./");
+	/* Skip all leading "/" */
+	while (*name_ptr == '/')
+		name_ptr++;
+	/* Skip all leading "./" and "../" */
+	while (name_ptr[0] == '.') {
+		if (name_ptr[1] == '.')
+			name_ptr++;
+		if (name_ptr[1] != '/')
+			break;
+		name_ptr += 2;
+	}
+
 	if (name_ptr[0] != '\0') {
-		archive_handle->file_header->name = xasprintf("%s%s", archive_handle->buffer, name_ptr);
+		archive_handle->file_header->name = xasprintf("%s%s", archive_handle->dpkg__buffer, name_ptr);
 		data_extract_all(archive_handle);
+		if (fnmatch("*.dpkg-new", archive_handle->file_header->name, 0) == 0) {
+			/* remove .dpkg-new suffix */
+			archive_handle->file_header->name[strlen(archive_handle->file_header->name) - 9] = '\0';
+		}
 	}
 }
 
+enum {
+	/* Commands */
+	OPT_configure            = (1 << 0),
+	OPT_install              = (1 << 1),
+	OPT_list_installed       = (1 << 2),
+	OPT_purge                = (1 << 3),
+	OPT_remove               = (1 << 4),
+	OPT_unpack               = (1 << 5),
+	OPTMASK_cmd              = (1 << 6) - 1,
+	/* Options */
+	OPT_force                = (1 << 6),
+	OPT_force_ignore_depends = (1 << 7),
+	OPT_force_confnew        = (1 << 8),
+	OPT_force_confold        = (1 << 9),
+};
+
 static void unpack_package(deb_file_t *deb_file)
 {
 	const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
@@ -1474,59 +1594,71 @@ static void unpack_package(deb_file_t *deb_file)
 	char *list_filename;
 	archive_handle_t *archive_handle;
 	FILE *out_stream;
-	llist_t *accept_list = NULL;
-	int i = 0;
+	llist_t *accept_list;
+	llist_t *conffile_list;
+	int i;
 
 	/* If existing version, remove it first */
+	conffile_list = NULL;
 	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,
 			name_hashtable[package_hashtable[status_package_num]->version],
 			deb_file->filename);
+
+		/* Read md5sums from old package */
+		if (!(option_mask32 & OPT_force_confold))
+			append_control_file_to_llist(package_name, "md5sums", &conffile_list);
+
 		remove_package(status_package_num, 0);
 	} else {
 		printf("Unpacking %s (from %s)...\n", package_name, deb_file->filename);
 	}
 
 	/* Extract control.tar.gz to /var/lib/dpkg/info/<package>.filename */
-	info_prefix = xasprintf("/var/lib/dpkg/info/%s.", package_name);
+	info_prefix = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "");
 	archive_handle = init_archive_deb_ar(deb_file->filename);
 	init_archive_deb_control(archive_handle);
 
-	while (all_control_files[i]) {
+	accept_list = NULL;
+	i = 0;
+	while (i < ARRAY_SIZE(all_control_files)) {
 		char *c = xasprintf("./%s", all_control_files[i]);
 		llist_add_to(&accept_list, c);
 		i++;
 	}
-	archive_handle->sub_archive->accept = accept_list;
-	archive_handle->sub_archive->filter = filter_accept_list;
-	archive_handle->sub_archive->action_data = data_extract_all_prefix;
-	archive_handle->sub_archive->buffer = info_prefix;
-	archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+	archive_handle->dpkg__sub_archive->accept = accept_list;
+	archive_handle->dpkg__sub_archive->filter = filter_accept_list;
+	archive_handle->dpkg__sub_archive->action_data = data_extract_all_prefix;
+	archive_handle->dpkg__sub_archive->dpkg__buffer = info_prefix;
+	archive_handle->dpkg__sub_archive->ah_flags |= ARCHIVE_UNLINK_OLD;
 	unpack_ar_archive(archive_handle);
 
 	/* 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");
-	}
+	run_package_script_or_die(package_name, "preinst");
+
+	/* Don't overwrite existing config files */
+	if (!(option_mask32 & OPT_force_confnew))
+		append_control_file_to_llist(package_name, "conffiles", &conffile_list);
 
 	/* 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 = (char*)"/"; /* huh? */
-	archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
+	archive_handle->dpkg__sub_archive->accept = conffile_list;
+	archive_handle->dpkg__sub_archive->filter = filter_rename_config;
+	archive_handle->dpkg__sub_archive->action_data = data_extract_all_prefix;
+	archive_handle->dpkg__sub_archive->dpkg__buffer = (char*)"/"; /* huh? */
+	archive_handle->dpkg__sub_archive->ah_flags |= ARCHIVE_UNLINK_OLD;
 	unpack_ar_archive(archive_handle);
 
 	/* Create the list file */
-	list_filename = xasprintf("/var/lib/dpkg/info/%s.list", package_name);
-	out_stream = xfopen(list_filename, "w");
-	while (archive_handle->sub_archive->passed) {
+	list_filename = xasprintf("/var/lib/dpkg/info/%s.%s", package_name, "list");
+	out_stream = xfopen_for_write(list_filename);
+	while (archive_handle->dpkg__sub_archive->passed) {
 		/* the leading . has been stripped by data_extract_all_prefix already */
-		fputs(archive_handle->sub_archive->passed->data, out_stream);
+		fputs(archive_handle->dpkg__sub_archive->passed->data, out_stream);
 		fputc('\n', out_stream);
-		archive_handle->sub_archive->passed = archive_handle->sub_archive->passed->link;
+		archive_handle->dpkg__sub_archive->passed = archive_handle->dpkg__sub_archive->passed->link;
 	}
 	fclose(out_stream);
 
@@ -1547,17 +1679,16 @@ static void configure_package(deb_file_t *deb_file)
 	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?");
-	}
+	/* TODO: handle failure gracefully */
+	run_package_script_or_die(package_name, "postinst");
+
 	/* Change status to reflect success */
 	set_status(status_num, "install", 1);
 	set_status(status_num, "installed", 3);
 }
 
-int dpkg_main(int argc, char **argv);
-int dpkg_main(int argc, char **argv)
+int dpkg_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int dpkg_main(int argc UNUSED_PARAM, char **argv)
 {
 	deb_file_t **deb_file = NULL;
 	status_node_t *status_node;
@@ -1568,50 +1699,64 @@ int dpkg_main(int argc, char **argv)
 	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,
-	};
-
-	opt = getopt32(argc, argv, "CF:ilPru", &str_f);
+#if ENABLE_LONG_OPTS
+	static const char dpkg_longopts[] ALIGN1 =
+// FIXME: we use -C non-compatibly, should be:
+// "-C|--audit Check for broken package(s)"
+		"configure\0"      No_argument        "C"
+		"force\0"          Required_argument  "F"
+		"install\0"        No_argument        "i"
+		"list\0"           No_argument        "l"
+		"purge\0"          No_argument        "P"
+		"remove\0"         No_argument        "r"
+		"unpack\0"         No_argument        "u"
+		"force-depends\0"  No_argument        "\xff"
+		"force-confnew\0"  No_argument        "\xfe"
+		"force-confold\0"  No_argument        "\xfd"
+		;
+#endif
+
+	INIT_G();
+
+	IF_LONG_OPTS(applet_long_options = dpkg_longopts);
+	opt = getopt32(argv, "CilPruF:", &str_f);
+	argv += optind;
 	//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_force) { // -F (--force in official dpkg)
+		if (strcmp(str_f, "depends") == 0)
+			opt |= OPT_force_ignore_depends;
+		else if (strcmp(str_f, "confnew") == 0)
+			opt |= OPT_force_confnew;
+		else if (strcmp(str_f, "confold") == 0)
+			opt |= OPT_force_confold;
+		else
+			bb_show_usage();
+		option_mask32 = opt;
 	}
 	//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)))
+	if (!(opt & OPTMASK_cmd) /* no cmd */
+	 || ((opt & OPTMASK_cmd) & ((opt & OPTMASK_cmd)-1)) /* more than one cmd */
+	) {
 		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 (opt & OPT_list_installed) {
-		list_packages();
+		list_packages(argv[0]); /* param can be NULL */
 		return EXIT_SUCCESS;
 	}
 
 	/* Read arguments and store relevant info in structs */
 	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[0]) * (deb_count + 2));
+		deb_file = xrealloc_vector(deb_file, 2, deb_count);
 		deb_file[deb_count] = xzalloc(sizeof(deb_file[0][0]));
 		if (opt & (OPT_install | OPT_unpack)) {
 			/* -i/-u: require filename */
@@ -1624,7 +1769,7 @@ int dpkg_main(int argc, char **argv)
 			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("cannot extract control file");
+				bb_error_msg_and_die("can't extract control file");
 			}
 			deb_file[deb_count]->filename = xstrdup(argv[0]);
 			package_num = fill_package_struct(deb_file[deb_count]->control_file);
@@ -1692,7 +1837,7 @@ int dpkg_main(int argc, char **argv)
 
 	/* Check that the deb file arguments are installable */
 	if (!(opt & OPT_force_ignore_depends)) {
-		if (!check_deps(deb_file, 0, deb_count)) {
+		if (!check_deps(deb_file, 0 /*, deb_count*/)) {
 			bb_error_msg_and_die("dependency check failed");
 		}
 	}
@@ -1739,9 +1884,7 @@ int dpkg_main(int argc, char **argv)
 		}
 
 		for (i = 0; i < PACKAGE_HASH_PRIME; i++) {
-			if (package_hashtable[i] != NULL) {
-				free_package(package_hashtable[i]);
-			}
+			free_package(package_hashtable[i]);
 		}
 
 		for (i = 0; i < STATUS_HASH_PRIME; i++) {