X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=archival%2Fdpkg.c;h=3288f7e636fe4d9def4f541d6cb7441d5fe94d57;hb=b79db92a21aee4c003f49eb21f1447b79e0e0c1e;hp=189b0a89870d4d22f9f111baf26494e1c4faa46b;hpb=58a5bd187dd69ed9ba761e8ea755fd9ff4e97ce6;p=oweals%2Fbusybox.git diff --git a/archival/dpkg.c b/archival/dpkg.c index 189b0a898..3288f7e63 100644 --- a/archival/dpkg.c +++ b/archival/dpkg.c @@ -2,6 +2,7 @@ * Mini dpkg implementation for busybox. * This is not meant as a replacemnt for dpkg * + * Written By Glenn McGrath with the help of others * Copyright (C) 2001 by Glenn McGrath * * Started life as a busybox implementation of udpkg @@ -37,10 +38,12 @@ * */ +#include #include #include #include #include +#include "unarchive.h" #include "busybox.h" /* NOTE: If you vary HASH_PRIME sizes be aware, @@ -161,6 +164,7 @@ int search_name_hashtable(const char *key) { unsigned int probe_address = 0; unsigned int probe_decrement = 0; +// char *temp; make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME); while(name_hashtable[probe_address] != NULL) { @@ -173,8 +177,7 @@ int search_name_hashtable(const char *key) } } } - name_hashtable[probe_address] = xstrdup(key); - + name_hashtable[probe_address] = bb_xstrdup(key); return(probe_address); } @@ -212,12 +215,13 @@ 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(""); + version1 = bb_xstrdup(""); } - if (version2 != NULL) { - version2 = xstrdup(""); + if (version2 == NULL) { + version2 = bb_xstrdup(""); } upstream_len1 = strlen(version1); upstream_len2 = strlen(version2); @@ -225,37 +229,42 @@ int version_compare_part(const char *version1, const char *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); + name1_char = bb_xstrndup(&version1[len1], tmp_int); len1 += tmp_int; tmp_int = strcspn(&version2[len2], "0123456789"); - name2_char = xstrndup(&version2[len2], tmp_int); + name2_char = bb_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); + ret = tmp_int; + goto cleanup_version_compare_part; } /* Compare digits */ tmp_int = strspn(&version1[len1], "0123456789"); - name1_char = xstrndup(&version1[len1], tmp_int); + name1_char = bb_xstrndup(&version1[len1], tmp_int); len1 += tmp_int; tmp_int = strspn(&version2[len2], "0123456789"); - name2_char = xstrndup(&version2[len2], tmp_int); + name2_char = bb_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); + ret = -1; + goto cleanup_version_compare_part; } else if (ver_num1 > ver_num2) { - return(1); + ret = 1; + goto cleanup_version_compare_part; } } - return(0); + ret = 0; +cleanup_version_compare_part: + return(ret); } /* if ver1 < ver2 return -1, @@ -297,8 +306,8 @@ int version_compare(const unsigned int ver1, const unsigned int ver2) } /* Compare upstream version */ - upstream_ver1 = xstrdup(ver1_ptr); - upstream_ver2 = xstrdup(ver2_ptr); + upstream_ver1 = bb_xstrdup(ver1_ptr); + upstream_ver2 = bb_xstrdup(ver2_ptr); /* Chop off debian version, and store for later use */ deb_ver1 = strrchr(upstream_ver1, '-'); @@ -388,7 +397,7 @@ int search_package_hashtable(const unsigned int name, const unsigned int version */ void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned int edge_type) { - char *line = xstrdup(whole_line); + char *line = bb_xstrdup(whole_line); char *line2; char *line_ptr1 = NULL; char *line_ptr2 = NULL; @@ -401,7 +410,7 @@ void add_split_dependencies(common_node_t *parent_node, const char *whole_line, field = strtok_r(line, ",", &line_ptr1); do { - line2 = xstrdup(field); + line2 = bb_xstrdup(field); field2 = strtok_r(line2, "|", &line_ptr2); if ((edge_type == EDGE_DEPENDS) && (strcmp(field, field2) != 0)) { type = EDGE_OR_DEPENDS; @@ -448,7 +457,7 @@ void add_split_dependencies(common_node_t *parent_node, const char *whole_line, else if (strncmp(version, ">=", offset_ch) == 0) { edge->operator = VER_MORE_EQUAL; } else { - error_msg_and_die("Illegal operator\n"); + bb_error_msg_and_die("Illegal operator\n"); } } /* skip to start of version numbers */ @@ -479,91 +488,76 @@ void add_split_dependencies(common_node_t *parent_node, const char *whole_line, void free_package(common_node_t *node) { - int i; - if (node != NULL) { + unsigned short i; + if (node) { for (i = 0; i < node->num_of_edges; i++) { - if (node->edge[i] != NULL) { - free(node->edge[i]); - } - } - if (node->edge != NULL) { - free(node->edge); - } - if (node != NULL) { - free(node); + free(node->edge[i]); } + free(node->edge); + free(node); } } unsigned int fill_package_struct(char *control_buffer) { common_node_t *new_node = (common_node_t *) xcalloc(1, sizeof(common_node_t)); - - char *field; + const char *field_names[] = { "Package", "Version", "Pre-Depends", "Depends", + "Replaces", "Provides", "Conflicts", "Suggests", "Recommends", "Enhances", 0}; char *field_name; char *field_value; int field_start = 0; - int field_length; - int seperator_offset; int num = -1; int buffer_length = strlen(control_buffer); new_node->version = search_name_hashtable("unknown"); while (field_start < buffer_length) { - field = read_package_field(&control_buffer[field_start]); + unsigned short field_num; - /* Setup start point for next field */ - field_length = strlen(field); - field_start += (field_length + 1); + field_start += read_package_field(&control_buffer[field_start], + &field_name, &field_value); - seperator_offset = strcspn(field, ":"); - if (seperator_offset == 0) { - free(field); - continue; + if (field_name == NULL) { + goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement ! */ } - field_name = xstrndup(field, seperator_offset); - field_value = field + seperator_offset + 1; - field_value += strspn(field_value, " \n\t"); - /* Should be able to replace this strlen with pointer arithmatic */ - if (strlen(field_value) == 0) { - goto fill_package_struct_cleanup; // Oh no, the dreaded goto statement !! - } - - if (strcmp(field_name, "Package") == 0) { - new_node->name = search_name_hashtable(field_value); - } - else if (strcmp(field_name, "Version") == 0) { - new_node->version = search_name_hashtable(field_value); - } - else if (strcmp(field_name, "Pre-Depends") == 0) { - add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS); - } - else if (strcmp(field_name, "Depends") == 0) { - add_split_dependencies(new_node, field_value, EDGE_DEPENDS); - } - else if (strcmp(field_name, "Replaces") == 0) { - add_split_dependencies(new_node, field_value, EDGE_REPLACES); - } - else if (strcmp(field_name, "Provides") == 0) { - add_split_dependencies(new_node, field_value, EDGE_PROVIDES); - } - else if (strcmp(field_name, "Conflicts") == 0) { - add_split_dependencies(new_node, field_value, EDGE_CONFLICTS); - } - else if (strcmp(field_name, "Suggests") == 0) { - add_split_dependencies(new_node, field_value, EDGE_SUGGESTS); - } - else if (strcmp(field_name, "Recommends") == 0) { - add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS); - } - else if (strcmp(field_name, "Enhances") == 0) { - add_split_dependencies(new_node, field_value, EDGE_ENHANCES); + 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; } fill_package_struct_cleanup: free(field_name); - free(field); + free(field_value); } + if (new_node->version == search_name_hashtable("unknown")) { free_package(new_node); return(-1); @@ -594,7 +588,7 @@ unsigned int get_status(const unsigned int status_node, const int num) status_string += strspn(status_string, " "); } len = strcspn(status_string, " \n\0"); - state_sub_string = xstrndup(status_string, len); + state_sub_string = bb_xstrndup(status_string, len); state_sub_num = search_name_hashtable(state_sub_string); free(state_sub_string); return(state_sub_num); @@ -626,12 +620,13 @@ void set_status(const unsigned int status_node_num, const char *new_value, const status_len = new_value_len; break; default: - error_msg_and_die("DEBUG ONLY: this shouldnt happen"); + bb_error_msg_and_die("DEBUG ONLY: this shouldnt happen"); } new_status = (char *) xmalloc(want_len + flag_len + status_len + 3); sprintf(new_status, "%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; } @@ -643,7 +638,7 @@ void index_status_file(const char *filename) status_node_t *status_node = NULL; unsigned int status_num; - status_file = fopen(filename, "r"); + status_file = bb_xfopen(filename, "r"); while ((control_buffer = fgets_str(status_file, "\n\n")) != NULL) { const unsigned int package_num = fill_package_struct(control_buffer); if (package_num != -1) { @@ -653,7 +648,7 @@ 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 = bb_xstrndup(status_line, strcspn(status_line, "\n\0")); status_node->status = search_name_hashtable(status_line); free(status_line); } @@ -739,36 +734,53 @@ char *get_depends_field(common_node_t *package, const int depends_type) return(depends); } +void write_buffer_no_status(FILE *new_status_file, const char *control_buffer) +{ + char *name; + char *value; + int start = 0; + while (1) { + start += read_package_field(&control_buffer[start], &name, &value); + if (name == NULL) { + break; + } + if (strcmp(name, "Status") != 0) { + fprintf(new_status_file, "%s: %s\n", name, value); + } + } + return; +} + /* This could do with a cleanup */ 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 = bb_xfopen("/var/lib/dpkg/status", "r"); + FILE *new_status_file = bb_xfopen("/var/lib/dpkg/status.udeb", "w"); char *package_name; char *status_from_file; char *control_buffer = NULL; char *tmp_string; - char *field; int status_num; - int field_length; int field_start = 0; - int buffer_length; int write_flag; int i = 0; /* Update previously known packages */ while ((control_buffer = fgets_str(old_status_file, "\n\n")) != NULL) { - tmp_string = strstr(control_buffer, "Package:") + 8; + if ((tmp_string = strstr(control_buffer, "Package:")) == NULL) { + continue; + } + + tmp_string += 8; tmp_string += strspn(tmp_string, " \n\t"); - package_name = xstrndup(tmp_string, strcspn(tmp_string, "\n\0")); + package_name = bb_xstrndup(tmp_string, strcspn(tmp_string, "\n\0")); write_flag = FALSE; - tmp_string = strstr(control_buffer, "Status:"); if (tmp_string != NULL) { /* Seperate 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")); + status_from_file = bb_xstrndup(tmp_string, strcspn(tmp_string, "\n")); } else { status_from_file = NULL; } @@ -786,20 +798,11 @@ void write_status_file(deb_file_t **deb_file) i = 0; while(deb_file[i] != NULL) { if (strcmp(package_name, name_hashtable[package_hashtable[deb_file[i]->package]->name]) == 0) { - char *last_char; /* Write a status file entry with a modified status */ /* remove trailing \n's */ - while(1) { - last_char = last_char_is(deb_file[i]->control_file, '\n'); - if (last_char) { - *last_char = '\0'; - } else { - break; - } - } - fputs(deb_file[i]->control_file, new_status_file); + write_buffer_no_status(new_status_file, deb_file[i]->control_file); set_status(status_num, "ok", 2); - fprintf(new_status_file, "\nStatus: %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; } @@ -807,23 +810,24 @@ void write_status_file(deb_file_t **deb_file) } /* This is temperary, debugging only */ if (deb_file[i] == NULL) { - 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: Couldnt 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) { /* Only write the Package, Status, Priority and Section lines */ fprintf(new_status_file, "Package: %s\n", package_name); fprintf(new_status_file, "Status: %s\n", status_from_hashtable); - buffer_length = strlen(control_buffer); - while (field_start < buffer_length) { - field = read_package_field(&control_buffer[field_start]); - field_length = strlen(field); - field_start += (field_length + 1); - if (strncmp(field, "Priority:", 9) == 0) { - fprintf(new_status_file, "Priority:%s\n", field + 9); + + while (1) { + char *field_name; + char *field_value; + field_start += read_package_field(&control_buffer[field_start], &field_name, &field_value); + if (field_name == NULL) { + break; } - if (strncmp(field, "Section:", 8) == 0) { - fprintf(new_status_file, "Section:%s\n", field + 8); + 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; @@ -831,54 +835,42 @@ void write_status_file(deb_file_t **deb_file) } else if (strcmp("config-files", name_hashtable[state_status]) == 0) { /* only change the status line */ - buffer_length = strlen(control_buffer); - while (field_start < buffer_length) { - field = read_package_field(&control_buffer[field_start]); + while (1) { + char *field_name; + char *field_value; + field_start += read_package_field(&control_buffer[field_start], &field_name, &field_value); + if (field_name == NULL) { + break; + } /* Setup start point for next field */ - field_length = strlen(field); - field_start += (field_length + 1); - if (strncmp(field, "Status:", 7) == 0) { + if (strcmp(field_name, "Status") == 0) { fprintf(new_status_file, "Status: %s\n", status_from_hashtable); } else { - fprintf(new_status_file, "%s\n", field); + fprintf(new_status_file, "%s: %s\n", field_name, field_value); } - free(field); } write_flag = TRUE; fputs("\n", new_status_file); } } } - /* If the package from the status file wasnt handle above, do it now*/ - if (write_flag == FALSE) { + if (! write_flag) { fprintf(new_status_file, "%s\n\n", control_buffer); } - if (status_from_file != NULL) { - free(status_from_file); - } + free(status_from_file); free(package_name); free(control_buffer); } + /* Write any new packages */ 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) { - char *last_char; - /* remove trailing \n's */ - while(1) { - last_char = last_char_is(deb_file[i]->control_file, '\n'); - if (last_char) { - *last_char = '\0'; - } else { - break; - } - } - - fputs(deb_file[i]->control_file, new_status_file); + write_buffer_no_status(new_status_file, deb_file[i]->control_file); set_status(status_num, "ok", 2); - fprintf(new_status_file, "\nStatus: %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]); } } fclose(old_status_file); @@ -889,15 +881,15 @@ void write_status_file(deb_file_t **deb_file) if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) { struct stat stat_buf; if (stat("/var/lib/dpkg/status", &stat_buf) == 0) { - error_msg_and_die("Couldnt create backup status file"); + bb_error_msg_and_die("Couldnt create backup status file"); } /* Its ok if renaming the status file fails becasue status * file doesnt exist, maybe we are starting from scratch */ - 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) { - error_msg_and_die("DANGER: Couldnt create status file, you need to manually repair your status file"); + bb_error_msg_and_die("DANGER: Couldnt create status file, you need to manually repair your status file"); } } @@ -908,9 +900,8 @@ int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count) int state_status; int state_flag; int state_want; - unsigned int status_package_num; int i = deb_start; - int j, k; + int j; /* Check for conflicts * TODO: TEST if conflicts with other packages to be installed @@ -951,38 +942,49 @@ int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count) } /* Check conflicts */ - for (i = 0; i < conflicts_num; i++) { - /* Check for conflicts */ - for (j = 0; j < STATUS_HASH_PRIME; j++) { - if (status_hashtable[j] == NULL) { - continue; - } - state_flag = get_status(j, 2); - state_status = get_status(j, 3); - if ((state_status != search_name_hashtable("installed")) - && (state_flag != search_name_hashtable("want-install"))) { - continue; - } - status_package_num = status_hashtable[j]->package; - for (k = 0; k < package_hashtable[status_package_num]->num_of_edges; k++) { - const edge_t *package_edge = package_hashtable[status_package_num]->edge[k]; - if (package_edge->type != EDGE_CONFLICTS) { - continue; - } - if (package_edge->name != package_hashtable[conflicts[i]]->name) { - continue; + i = 0; + while (deb_file[i] != NULL) { + const common_node_t *package_node = package_hashtable[deb_file[i]->package]; + int status_num = 0; + status_num = search_status_hashtable(name_hashtable[package_node->name]); + + if (get_status(status_num, 3) == search_name_hashtable("installed")) { + i++; + continue; + } + + for (j = 0; j < package_node->num_of_edges; j++) { + const edge_t *package_edge = package_node->edge[j]; + const unsigned int package_num = + search_package_hashtable(package_edge->name, + package_edge->version, package_edge->operator); + + if (package_edge->type == EDGE_CONFLICTS) { + int result = 0; + if (package_hashtable[package_num] != NULL) { + status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]); + state_status = get_status(status_num, 3); + state_flag = get_status(status_num, 1); + + result = (state_status == search_name_hashtable("installed")) || + (state_flag == search_name_hashtable("want-install")); + + if (result) { + result = test_version(package_hashtable[deb_file[i]->package]->version, + package_edge->version, package_edge->operator); + } } - /* There is a conflict against the package name - * check if version conflict as well */ - if (test_version(package_hashtable[deb_file[i]->package]->version, - package_edge->version, package_edge->operator)) { - error_msg_and_die("Package %s conflict with %s", - name_hashtable[package_hashtable[deb_file[i]->package]->name], - name_hashtable[package_hashtable[status_package_num]->name]); + + if (result) { + bb_error_msg_and_die("Package %s conflicts with %s", + name_hashtable[package_node->name], + name_hashtable[package_edge->name]); } } } - } + i++; + } + /* Check dependendcies */ i = 0; @@ -990,68 +992,86 @@ int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count) const common_node_t *package_node = package_hashtable[deb_file[i]->package]; int status_num = 0; + status_num = search_status_hashtable(name_hashtable[package_node->name]); + state_status = get_status(status_num, 3); + state_want = get_status(status_num, 1); + + if (state_status == search_name_hashtable("installed")) { + i++; + continue; + } + for (j = 0; j < package_hashtable[deb_file[i]->package]->num_of_edges; j++) { const edge_t *package_edge = package_node->edge[j]; - const unsigned int package_num = search_package_hashtable(package_edge->name, - package_edge->version, package_edge->operator); + unsigned int package_num; + + package_num = search_package_hashtable(package_edge->name, package_edge->version, package_edge->operator); - status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]); - state_status = get_status(status_num, 3); - state_want = get_status(status_num, 1); switch (package_edge->type) { case(EDGE_PRE_DEPENDS): - case(EDGE_OR_PRE_DEPENDS): + case(EDGE_OR_PRE_DEPENDS): { + int result=1; /* It must be already installed */ /* NOTE: This is untested, nothing apropriate in my status file */ - if ((package_hashtable[package_num] == NULL) || (state_status != search_name_hashtable("installed"))) { - error_msg_and_die("Package %s pre-depends on %s, but it is not installed", + if (package_hashtable[package_num] != NULL) { + status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]); + state_status = get_status(status_num, 3); + state_want = get_status(status_num, 1); + result = (state_status != search_name_hashtable("installed")); + } + + if (result) { + bb_error_msg_and_die("Package %s pre-depends on %s, but it is not installed", name_hashtable[package_node->name], name_hashtable[package_edge->name]); } break; + } case(EDGE_DEPENDS): - case(EDGE_OR_DEPENDS): + case(EDGE_OR_DEPENDS): { + int result=1; + if (package_hashtable[package_num] != NULL) { + status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]); + state_status = get_status(status_num, 3); + state_want = get_status(status_num, 1); + result=(state_status != search_name_hashtable("installed")) && (state_want != search_name_hashtable("want-install")); + } /* It must be already installed, or to be installed */ - if ((package_hashtable[package_num] == NULL) || - ((state_status != search_name_hashtable("installed")) && - (state_want != search_name_hashtable("want_install")))) { - error_msg_and_die("Package %s depends on %s, but it is not installed, or flaged to be installed", + if (result) { + bb_error_msg_and_die("Package %s depends on %s, but it is not installed, or flaged to be installed", name_hashtable[package_node->name], name_hashtable[package_edge->name]); } break; + } } } i++; } + free(conflicts); return(TRUE); } char **create_list(const char *filename) { FILE *list_stream; - char **file_list = xmalloc(sizeof(char *)); + char **file_list = NULL; char *line = NULL; - char *last_char; - int length = 0; int count = 0; + /* dont use [xw]fopen here, handle error ourself */ list_stream = fopen(filename, "r"); if (list_stream == NULL) { return(NULL); } - while (getline(&line, &length, list_stream) != -1) { - file_list = xrealloc(file_list, sizeof(char *) * (length + 1)); - last_char = last_char_is(line, '\n'); - if (last_char) { - *last_char = '\0'; - } - file_list[count] = xstrdup(line); - free(line); + + while ((line = bb_get_chomped_line_from_file(list_stream)) != NULL) { + file_list = xrealloc(file_list, sizeof(char *) * (count + 2)); + file_list[count] = line; count++; - length = 0; } fclose(list_stream); + if (count == 0) { return(NULL); } else { @@ -1103,30 +1123,92 @@ int run_package_script(const char *package_name, const char *script_type) { struct stat path_stat; char *script_path; + int result; script_path = xmalloc(strlen(package_name) + strlen(script_type) + 21); sprintf(script_path, "/var/lib/dpkg/info/%s.%s", package_name, script_type); /* If the file doesnt exist is isnt a fatal */ if (lstat(script_path, &path_stat) < 0) { - return(EXIT_SUCCESS); + result = EXIT_SUCCESS; } else { - return(system(script_path)); + result = system(script_path); } + free(script_path); + return(result); } -void all_control_list(char **remove_files, const char *package_name) +char **all_control_list(const char *package_name) { - const char *all_extensions[11] = {"preinst", "postinst", "prerm", "postrm", + const char *extensions[11] = {"preinst", "postinst", "prerm", "postrm", "list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL }; - int i; + unsigned short i = 0; + char **remove_files; /* Create a list of all /var/lib/dpkg/info/ files */ - for(i = 0; i < 10; i++) { - remove_files[i] = xmalloc(strlen(package_name) + strlen(all_extensions[i]) + 21); - sprintf(remove_files[i], "/var/lib/dpkg/info/%s.%s", package_name, all_extensions[i]); + remove_files = malloc(sizeof(char *) * 11); + while (extensions[i]) { + remove_files[i] = xmalloc(strlen(package_name) + strlen(extensions[i]) + 21); + sprintf(remove_files[i], "/var/lib/dpkg/info/%s.%s", package_name, extensions[i]); + i++; } remove_files[10] = NULL; + + return(remove_files); +} + +void free_array(char **array) +{ + + if (array) { + unsigned short i = 0; + while (array[i]) { + free(array[i]); + i++; + } + free(array); + } +} + +/* This function lists information on the installed packages. It loops through + * the status_hashtable to retrieve the info. This results in smaller code than + * scanning the status file. The resulting list, however, is unsorted. + */ +void list_packages(void) +{ + int i; + + printf(" Name Version\n"); + printf("+++-==============-==============\n"); + + /* go through status hash, dereference package hash and finally strings */ + for (i=0; istatus]; + name_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->name]; + vers_str = name_hashtable[package_hashtable[status_hashtable[i]->package]->version]; + + /* 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++) { + 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); + } + } } void remove_package(const unsigned int package_num) @@ -1140,10 +1222,12 @@ void remove_package(const unsigned int package_num) char conffile_name[package_name_length + 30]; int return_value; + printf("Removing %s ...\n", package_name); + /* run prerm script */ - return_value = run_package_script(package_name, "prem"); + return_value = run_package_script(package_name, "prerm"); if (return_value == -1) { - error_msg_and_die("script failed, prerm failure"); + bb_error_msg_and_die("script failed, prerm failure"); } /* Create a list of files to remove, and a seperate list of those to keep */ @@ -1154,20 +1238,23 @@ void remove_package(const unsigned int package_num) 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) == TRUE); - - /* Create a list of all /var/lib/dpkg/info/ files */ - remove_files = xmalloc(11); - all_control_list(remove_files, package_name); + while (remove_file_array(remove_files, exclude_files)); + free_array(exclude_files); + free_array(remove_files); /* Create a list of files in /var/lib/dpkg/info/.* to keep */ exclude_files = xmalloc(sizeof(char*) * 3); - exclude_files[0] = xstrdup(conffile_name); + exclude_files[0] = bb_xstrdup(conffile_name); exclude_files[1] = xmalloc(package_name_length + 27); sprintf(exclude_files[1], "/var/lib/dpkg/info/%s.postrm", package_name); exclude_files[2] = NULL; + /* Create a list of all /var/lib/dpkg/info/ files */ + remove_files = all_control_list(package_name); + remove_file_array(remove_files, exclude_files); + free_array(remove_files); + free_array(exclude_files); /* rename .conffile to .list */ rename(conffile_name, list_name); @@ -1186,43 +1273,128 @@ void purge_package(const unsigned int package_num) char list_name[strlen(package_name) + 25]; /* run prerm script */ - if (run_package_script(package_name, "prerm") == -1) { - error_msg_and_die("script failed, prerm failure"); + if (run_package_script(package_name, "prerm") != 0) { + bb_error_msg_and_die("script failed, prerm failure"); } /* Create a list of files to remove */ sprintf(list_name, "/var/lib/dpkg/info/%s.list", package_name); remove_files = create_list(list_name); - exclude_files = xmalloc(1); + exclude_files = xmalloc(sizeof(char*)); exclude_files[0] = NULL; /* Some directories cant be removed straight away, so do multiple passes */ - while (remove_file_array(remove_files, exclude_files) == TRUE); + while (remove_file_array(remove_files, exclude_files)); + free_array(remove_files); /* Create a list of all /var/lib/dpkg/info/ files */ - remove_files = xmalloc(11); - all_control_list(remove_files, package_name); + remove_files = all_control_list(package_name); remove_file_array(remove_files, exclude_files); + free_array(remove_files); + free(exclude_files); /* run postrm script */ if (run_package_script(package_name, "postrm") == -1) { - error_msg_and_die("postrm fialure.. set status to what?"); + bb_error_msg_and_die("postrm fialure.. set status to what?"); } + /* Change package status */ set_status(status_num, "purge", 1); set_status(status_num, "not-installed", 3); } -void unpack_package(deb_file_t *deb_file) +static archive_handle_t *init_archive_deb_ar(const char *filename) { - const unsigned int package_name_num = package_hashtable[deb_file->package]->name; - const char *package_name = name_hashtable[package_name_num]; - const unsigned int status_num = search_status_hashtable(package_name); - unsigned int status_package_num; + archive_handle_t *ar_handle; - FILE *out_stream; + /* Setup an ar archive handle that refers to the gzip sub archive */ + ar_handle = init_handle(); + ar_handle->filter = filter_accept_list_reassign; + ar_handle->src_fd = bb_xopen(filename, O_RDONLY); + + return(ar_handle); +} + +static void init_archive_deb_control(archive_handle_t *ar_handle) +{ + archive_handle_t *tar_handle; + + /* Setup the tar archive handle */ + tar_handle = init_handle(); + tar_handle->filter = filter_accept_list; + tar_handle->src_fd = ar_handle->src_fd; + + /* We dont care about data.tar.* or debian-binary, just control.tar.* */ +#ifdef CONFIG_FEATURE_DEB_TAR_GZ + ar_handle->accept = llist_add_to(NULL, "control.tar.gz"); +#endif +#ifdef CONFIG_FEATURE_DEB_TAR_BZ2 + ar_handle->accept = llist_add_to(ar_handle->accept, "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) +{ + archive_handle_t *tar_handle; + + /* Setup the tar archive handle */ + tar_handle = init_handle(); + tar_handle->filter = filter_accept_all; + tar_handle->src_fd = ar_handle->src_fd; + + /* We dont care about data.tar.* or debian-binary, just control.tar.* */ +#ifdef CONFIG_FEATURE_DEB_TAR_GZ + tar_handle->accept = llist_add_to(NULL, "data.tar.gz"); +#endif +#ifdef CONFIG_FEATURE_DEB_TAR_BZ2 + tar_handle->accept = llist_add_to(ar_handle->accept, "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 *accept) +{ + ar_handle->sub_archive->action_data = data_extract_to_buffer; + ar_handle->sub_archive->accept = accept; + + 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) +{ + char *name_ptr = archive_handle->file_header->name; + + name_ptr += strspn(name_ptr, "./"); + if (name_ptr[0] != '\0') { + archive_handle->file_header->name = xmalloc(strlen(archive_handle->buffer) + 2 + strlen(name_ptr)); + strcpy(archive_handle->file_header->name, archive_handle->buffer); + strcat(archive_handle->file_header->name, 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; char *info_prefix; + archive_handle_t *archive_handle; + FILE *out_stream; /* If existing version, remove it first */ if (strcmp(name_hashtable[get_status(status_num, 3)], "installed") == 0) { @@ -1236,48 +1408,66 @@ void unpack_package(deb_file_t *deb_file) } /* Extract control.tar.gz to /var/lib/dpkg/info/.filename */ - info_prefix = (char *) xmalloc(sizeof(package_name) + 20 + 4 + 1); + info_prefix = (char *) xmalloc(strlen(package_name) + 20 + 4 + 2); sprintf(info_prefix, "/var/lib/dpkg/info/%s.", package_name); - deb_extract(deb_file->filename, stdout, (extract_quiet | extract_control_tar_gz | extract_all_to_fs), info_prefix, NULL); + archive_handle = init_archive_deb_ar(deb_file->filename); + init_archive_deb_control(archive_handle); + archive_handle->sub_archive->action_data = data_extract_all_prefix; + archive_handle->sub_archive->buffer = info_prefix; + 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."); + } /* Extract data.tar.gz to the root directory */ - deb_extract(deb_file->filename, stdout, (extract_quiet | extract_data_tar_gz | extract_all_to_fs), "/", NULL); + archive_handle = init_archive_deb_ar(deb_file->filename); + init_archive_deb_data(archive_handle); + unpack_ar_archive(archive_handle); /* Create the list file */ strcat(info_prefix, "list"); - - out_stream = wfopen(info_prefix, "w"); - deb_extract(deb_file->filename, out_stream, (extract_quiet | extract_data_tar_gz | extract_list), NULL, NULL); + out_stream = bb_xfopen(info_prefix, "w"); + while (archive_handle->passed) { + /* blindly skip over the leading '.' */ + fputs(archive_handle->passed->data + 1, out_stream); + fputc('\n', out_stream); + archive_handle->passed = archive_handle->passed->link; + } fclose(out_stream); /* change status */ set_status(status_num, "install", 1); set_status(status_num, "unpacked", 3); + + free(info_prefix); } void configure_package(deb_file_t *deb_file) { - int return_value; - int status_num; + const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name]; + const char *package_version = name_hashtable[package_hashtable[deb_file->package]->version]; + const int status_num = search_status_hashtable(package_name); - /* Run the preinst prior to extracting */ - return_value = run_package_script(name_hashtable[package_hashtable[deb_file->package]->name], "postinst"); - if (return_value == -1) { + 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 */ - error_msg_and_die("postrm fialure.. set status to what?"); + bb_error_msg_and_die("postrm failure.. set status to what?"); } - /* Change status to reflect success */ - status_num = search_status_hashtable(name_hashtable[package_hashtable[deb_file->package]->name]); set_status(status_num, "install", 1); set_status(status_num, "installed", 3); } -extern int dpkg_main(int argc, char **argv) +int dpkg_main(int argc, char **argv) { deb_file_t **deb_file = NULL; status_node_t *status_node; - char opt = 0; + int opt; int package_num; int dpkg_opt = 0; int deb_count = 0; @@ -1285,9 +1475,9 @@ extern int dpkg_main(int argc, char **argv) int status_num; int i; - while ((opt = getopt(argc, argv, "cF:ilPru")) != -1) { + while ((opt = getopt(argc, argv, "CF:ilPru")) != -1) { switch (opt) { - case 'c': + case 'C': // equivalent to --configure in official dpkg dpkg_opt |= dpkg_opt_configure; dpkg_opt |= dpkg_opt_package_name; break; @@ -1301,6 +1491,7 @@ extern int dpkg_main(int argc, char **argv) break; case 'l': dpkg_opt |= dpkg_opt_list_installed; + break; case 'P': dpkg_opt |= dpkg_opt_purge; dpkg_opt |= dpkg_opt_package_name; @@ -1314,44 +1505,65 @@ extern int dpkg_main(int argc, char **argv) dpkg_opt |= dpkg_opt_filename; break; default: - show_usage(); + bb_show_usage(); } } + /* check for non-otion argument if expected */ + if ((dpkg_opt == 0) || ((argc == optind) && !(dpkg_opt && dpkg_opt_list_installed))) { + bb_show_usage(); + } - if ((argc == optind) || (dpkg_opt == 0)) { - show_usage(); - } - - puts("(Reading database ... xxxxx files and directories installed.)"); +/* 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) { + list_packages(); + return(EXIT_SUCCESS); + } + /* Read arguments and store relevant info in structs */ - deb_file = xmalloc(sizeof(deb_file_t)); while (optind < argc) { + /* 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 *) xmalloc(sizeof(deb_file_t)); if (dpkg_opt & dpkg_opt_filename) { - deb_file[deb_count]->filename = xstrdup(argv[optind]); - deb_file[deb_count]->control_file = deb_extract(argv[optind], stdout, (extract_control_tar_gz | extract_one_to_buffer), NULL, "./control"); + archive_handle_t *archive_handle; + llist_t *control_list = NULL; + + /* Extract the control file */ + control_list = llist_add_to(NULL, "./control"); + archive_handle = init_archive_deb_ar(argv[optind]); + 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) { - error_msg_and_die("Couldnt extract control file"); + bb_error_msg_and_die("Couldnt extract control file"); } + deb_file[deb_count]->filename = bb_xstrdup(argv[optind]); package_num = fill_package_struct(deb_file[deb_count]->control_file); if (package_num == -1) { - error_msg("Invalid control file in %s", argv[optind]); + bb_error_msg("Invalid control file in %s", argv[optind]); continue; } deb_file[deb_count]->package = (unsigned int) package_num; + /* Add the package to the status hashtable */ if ((dpkg_opt & dpkg_opt_unpack) || (dpkg_opt & dpkg_opt_install)) { status_node = (status_node_t *) xmalloc(sizeof(status_node_t)); status_node->package = deb_file[deb_count]->package; - /* use reinstreq isnt changed to "ok" until the package control info - * is written to the status file*/ - status_node->status = search_name_hashtable("install reinstreq not-installed"); - + /* 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]); - status_hashtable[status_num] = status_node; + /* If no previous entry was found initialise a new entry */ + if ((status_hashtable[status_num] == NULL) || + (status_hashtable[status_num]->status == 0)) { + /* reinstreq isnt changed to "ok" until the package control info + * is written to the status file*/ + status_node->status = search_name_hashtable("want-install reinstreq not-installed"); + status_hashtable[status_num] = status_node; + } else { + status_hashtable[status_num]->status = search_name_hashtable("want-install reinstreq not-installed"); + } } } else if (dpkg_opt & dpkg_opt_package_name) { @@ -1361,7 +1573,7 @@ extern int dpkg_main(int argc, char **argv) search_name_hashtable(argv[optind]), search_name_hashtable("ANY"), VER_ANY); if (package_hashtable[deb_file[deb_count]->package] == NULL) { - error_msg_and_die("unknown package, %s\n", argv[optind]); + bb_error_msg_and_die("Package %s is uninstalled or unknown\n", argv[optind]); } state_status = get_status(search_status_hashtable(name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]), 3); @@ -1369,13 +1581,13 @@ extern int dpkg_main(int argc, char **argv) if (dpkg_opt & dpkg_opt_remove) { if ((strcmp(name_hashtable[state_status], "not-installed") == 0) || (strcmp(name_hashtable[state_status], "config-files") == 0)) { - error_msg_and_die("%s is already removed.", name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]); + bb_error_msg_and_die("%s is already removed.", name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]); } } else if (dpkg_opt & dpkg_opt_purge) { /* if package status is "conf-files" then its ok */ if (strcmp(name_hashtable[state_status], "not-installed") == 0) { - error_msg_and_die("%s is already purged.", name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]); + bb_error_msg_and_die("%s is already purged.", name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]); } } } @@ -1388,7 +1600,7 @@ extern int dpkg_main(int argc, char **argv) /* TODO: check dependencies before removing */ if ((dpkg_opt & dpkg_opt_force_ignore_depends) != dpkg_opt_force_ignore_depends) { if (!check_deps(deb_file, 0, deb_count)) { - error_msg_and_die("Dependency check fialed"); + bb_error_msg_and_die("Dependency check failed"); } } @@ -1414,20 +1626,28 @@ extern int dpkg_main(int argc, char **argv) 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]); + } + + free(deb_file); + for (i = 0; i < NAME_HASH_PRIME; i++) { - if (name_hashtable[i] != NULL) { - free(name_hashtable[i]); - } + free(name_hashtable[i]); } + for (i = 0; i < PACKAGE_HASH_PRIME; i++) { - free_package(package_hashtable[i]); + if (package_hashtable[i] != NULL) { + free_package(package_hashtable[i]); + } } + for (i = 0; i < STATUS_HASH_PRIME; i++) { - if (status_hashtable[i] != NULL) { - free(status_hashtable[i]); - } + free(status_hashtable[i]); } - return(EXIT_FAILURE); + return(EXIT_SUCCESS); }