Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/archival/dpkg.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/archival/dpkg.c (modified) (52 diffs)

branches/2.2.9/mindi-busybox/archival/dpkg.c

@@ -7 +7 @@
  *  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.
  */
 
@@ -26 +30 @@
 
 #include "libbb.h"
-#include "unarchive.h"
+#include <fnmatch.h>
+#include "archive.h"
 
 /* note: if you vary hash_prime sizes be aware,
@@ -76 +81 @@
 } 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 */
@@ -124 +140 @@
          * 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;
@@ -134 +150 @@
 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);
@@ -156 +172 @@
 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);
@@ -172 +188 @@
 }
 
-/* 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)
-{
-    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;
-        }
-
-        /* 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) {
+static int order(char x)
+{
+    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++;
+        }
+
+        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 (isdigit(*val))
+            return 1;
+        if (isdigit(*ref))
             return -1;
-        }
-        if (ver_num1 > ver_num2) {
-            return 1;
-        }
+        if (first_diff)
+            return first_diff;
     }
     return 0;
@@ -238 +246 @@
     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;
@@ -247 +254 @@
 
     /* Compare epoch */
-    if (ch_ver1[1] == ':') {
-        epoch1 = ch_ver1[0];
-        ver1_ptr = strchr(ch_ver1, ':') + 1;
-    } else {
-        epoch1 = '0';
-        ver1_ptr = ch_ver1;
-    }
-    if (ch_ver2[1] == ':') {
-        epoch2 = ch_ver2[0];
-        ver2_ptr = strchr(ch_ver2, ':') + 1;
-    } else {
-        epoch2 = '0';
-        ver2_ptr = ch_ver2;
+    colon = strchr(ch_ver1, ':');
+    if (colon) {
+        epoch1 = atoi(ch_ver1);
+        ch_ver1 = colon + 1;
+    }
+    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 */
@@ -276 +279 @@
     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);
@@ -313 +315 @@
 }
 
-
 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);
@@ -373 +374 @@
 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;
 }
 
@@ -411 +411 @@
          && (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 alternatives
+            //or_edge->version = 0; // tracks the number of alternatives
             add_edge_to_node(parent_node, or_edge);
         }
@@ -440 +440 @@
                     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 {
@@ -497 +493 @@
 
 /*
- * 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
  */
@@ -603 +599 @@
 
         if (field_name == NULL) {
-            goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement! */
+            goto fill_package_struct_cleanup;
         }
 
@@ -736 +732 @@
 }
 
-
 static void index_status_file(const char *filename)
 {
@@ -745 +740 @@
     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) {
@@ -787 +782 @@
 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;
@@ -799 +794 @@
 
     /* Update previously known packages */
-    while ((control_buffer = xmalloc_fgets_str(old_status_file, "\n\n")) != NULL) {
+    while ((control_buffer = xmalloc_fgetline_str(old_status_file, "\n\n")) != NULL) {
         tmp_string = strstr(control_buffer, "Package:");
         if (tmp_string == NULL) {
@@ -811 +806 @@
         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");
@@ -863 +858 @@
                             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);
                         }
@@ -871 +867 @@
                     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) {
@@ -914 +910 @@
     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 */
@@ -924 +919 @@
     }
 
-    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");
 }
 
@@ -948 +940 @@
 
     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;
@@ -972 +964 @@
     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(
@@ -989 +981 @@
                     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++;
@@ -1076 +1068 @@
             if (package_edge->type == EDGE_OR_PRE_DEPENDS
              || package_edge->type == EDGE_OR_DEPENDS
-            ) { /* start an EDGE_OR_ list */
+            ) {
+                /* start an EDGE_OR_ list */
                 number_of_alternatives = package_edge->version;
                 root_of_alternatives = package_edge;
                 continue;
             }
-            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;
@@ -1088 +1081 @@
             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;
@@ -1157 +1151 @@
 {
     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;
-    }
-    file_list[count] = NULL;
     return file_list;
 }
@@ -1214 +1206 @@
 }
 
-static int run_package_script(const char *package_name, const char *script_type)
-{
-    struct stat path_stat;
+static void run_package_script_or_die(const char *package_name, const char *script_type)
+{
     char *script_path;
     int result;
@@ -1222 +1213 @@
     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);
+}
+
+/*
+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", NULL
+    "config", "templates"
 };
 
@@ -1240 +1262 @@
 
     /* 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++;
     }
@@ -1265 +1288 @@
  * scanning the status file. The resulting list, however, is unsorted.
  */
-static void list_packages(void)
+static void list_packages(const char *pattern)
 {
     int i;
@@ -1286 +1309 @@
             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';
@@ -1315 +1341 @@
         printf("Removing %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, 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 */
@@ -1344 +1369 @@
     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);
 
@@ -1362 +1389 @@
     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(exclude_files);
+
+    /* Run and remove postrm script */
+    run_package_script_or_die(package_name, "postrm");
+    remove_file_array(remove_files, NULL);
+
     free_array(remove_files);
-    free(exclude_files);
-
-    /* run postrm script */
-    if (run_package_script(package_name, "postrm") != 0) {
-        bb_error_msg_and_die("postrm failure.. set status to what?");
-    }
 
     /* Change package status */
@@ -1413 +1441 @@
 
     /* We don't care about data.tar.* or debian-binary, just control.tar.* */
-#if ENABLE_FEATURE_DEB_TAR_GZ
+#if ENABLE_FEATURE_SEAMLESS_GZ
     llist_add_to(&(ar_handle->accept), (char*)"control.tar.gz");
 #endif
-#if ENABLE_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;
 }
 
@@ -1433 +1461 @@
 
     /* We don't care about control.tar.* or debian-binary, just data.tar.* */
-#if ENABLE_FEATURE_DEB_TAR_GZ
+#if ENABLE_FEATURE_SEAMLESS_GZ
     llist_add_to(&(ar_handle->accept), (char*)"data.tar.gz");
 #endif
-#if ENABLE_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;
-}
-
-static void data_extract_all_prefix(archive_handle_t *archive_handle)
+    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 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)
@@ -1476 +1595 @@
     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 */
@@ -1485 +1606 @@
             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 {
@@ -1491 +1617 @@
 
     /* 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);
@@ -1549 +1680 @@
 
     /* Run the postinst script */
-    if (run_package_script(package_name, "postinst") != 0) {
-        /* TODO: handle failure gracefully */
-        bb_error_msg_and_die("postinst 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);
@@ -1558 +1688 @@
 }
 
-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;
@@ -1570 +1700 @@
     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(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
@@ -1591 +1739 @@
     //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.)"); */
@@ -1606 +1750 @@
     /* 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;
     }
@@ -1613 +1757 @@
     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)) {
@@ -1626 +1770 @@
             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]);
@@ -1694 +1838 @@
     /* 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");
         }