*
*/
-#include "busybox.h"
+#include "libbb.h"
#include "unarchive.h"
/* note: if you vary hash_prime sizes be aware,
* 3) all _hash_prime's must be a prime number or chaos is assured, if your looking
* for a prime, try http://www.utm.edu/research/primes/lists/small/10000.txt
* 4) if you go bigger than 15 bits you may get into trouble (untested) as its
- * sometimes cast to an unsigned int, if you go to 16 bit you will overlap
+ * sometimes cast to an unsigned, if you go to 16 bit you will overlap
* int's and chaos is assured, 16381 is the max prime for 14 bit field
*/
* and available file */
#define PACKAGE_HASH_PRIME 10007
typedef struct edge_s {
- unsigned int operator:3;
- unsigned int type:4;
- unsigned int name:14;
- unsigned int version:14;
+ unsigned operator:4; /* was:3 */
+ unsigned type:4;
+ unsigned name:16; /* was:14 */
+ unsigned version:16; /* was:14 */
} edge_t;
typedef struct common_node_s {
- unsigned int name:14;
- unsigned int version:14;
- unsigned int num_of_edges:14;
+ unsigned name:16; /* was:14 */
+ unsigned version:16; /* was:14 */
+ unsigned num_of_edges:16; /* was:14 */
edge_t **edge;
} common_node_t;
* likely to be installed at any one time, so there is a bit of leeway here */
#define STATUS_HASH_PRIME 8191
typedef struct status_node_s {
- unsigned int package:14; /* has to fit PACKAGE_HASH_PRIME */
- unsigned int status:14; /* has to fit STATUS_HASH_PRIME */
+ unsigned package:16; /* was:14 */ /* has to fit PACKAGE_HASH_PRIME */
+ unsigned status:16; /* was:14 */ /* has to fit STATUS_HASH_PRIME */
} status_node_t;
/* Were statically declared here, but such a big bss is nommu-unfriendly */
VER_ANY = 6
};
-enum dpkg_opt_e {
- dpkg_opt_purge = 1,
- dpkg_opt_remove = 2,
- dpkg_opt_unpack = 4,
- dpkg_opt_configure = 8,
- dpkg_opt_install = 16,
- dpkg_opt_package_name = 32,
- dpkg_opt_filename = 64,
- dpkg_opt_list_installed = 128,
- dpkg_opt_force_ignore_depends = 256
-};
-
typedef struct deb_file_s {
char *control_file;
char *filename;
- unsigned int package:14;
+ unsigned package:16; /* was:14 */
} deb_file_t;
-static void make_hash(const char *key, unsigned int *start, unsigned int *decrement, const int hash_prime)
+static void make_hash(const char *key, unsigned *start, unsigned *decrement, const int hash_prime)
{
- unsigned long int hash_num = key[0];
+ unsigned long hash_num = key[0];
int len = strlen(key);
int i;
* no effect*/
hash_num += ((key[i] + key[i-1]) << ((key[i] * i) % 24));
}
- *start = (unsigned int) hash_num % hash_prime;
- *decrement = (unsigned int) 1 + (hash_num % (hash_prime - 1));
+ *start = (unsigned) hash_num % hash_prime;
+ *decrement = (unsigned) 1 + (hash_num % (hash_prime - 1));
}
/* this adds the key to the hash table */
static int search_name_hashtable(const char *key)
{
- unsigned int probe_address = 0;
- unsigned int probe_decrement = 0;
-// char *temp;
+ unsigned probe_address = 0;
+ unsigned probe_decrement = 0;
make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME);
while (name_hashtable[probe_address] != NULL) {
if (strcmp(name_hashtable[probe_address], key) == 0) {
return probe_address;
- } else {
- probe_address -= probe_decrement;
- if ((int)probe_address < 0) {
- probe_address += NAME_HASH_PRIME;
- }
+ }
+ probe_address -= probe_decrement;
+ if ((int)probe_address < 0) {
+ probe_address += NAME_HASH_PRIME;
}
}
name_hashtable[probe_address] = xstrdup(key);
/* this DOESNT add the key to the hashtable
* TODO make it consistent with search_name_hashtable
*/
-static unsigned int search_status_hashtable(const char *key)
+static unsigned search_status_hashtable(const char *key)
{
- unsigned int probe_address = 0;
- unsigned int probe_decrement = 0;
+ unsigned probe_address = 0;
+ unsigned probe_decrement = 0;
make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME);
while (status_hashtable[probe_address] != NULL) {
if (strcmp(key, name_hashtable[package_hashtable[status_hashtable[probe_address]->package]->name]) == 0) {
break;
- } else {
- probe_address -= probe_decrement;
- if ((int)probe_address < 0) {
- probe_address += STATUS_HASH_PRIME;
- }
+ }
+ probe_address -= probe_decrement;
+ if ((int)probe_address < 0) {
+ probe_address += STATUS_HASH_PRIME;
}
}
return probe_address;
int tmp_int;
int ver_num1;
int ver_num2;
- int ret;
if (version1 == NULL) {
version1 = xstrdup("");
free(name1_char);
free(name2_char);
if (tmp_int != 0) {
- ret = tmp_int;
- goto cleanup_version_compare_part;
+ return tmp_int;
}
/* Compare digits */
free(name1_char);
free(name2_char);
if (ver_num1 < ver_num2) {
- ret = -1;
- goto cleanup_version_compare_part;
+ return -1;
}
- else if (ver_num1 > ver_num2) {
- ret = 1;
- goto cleanup_version_compare_part;
+ if (ver_num1 > ver_num2) {
+ return 1;
}
}
- ret = 0;
-cleanup_version_compare_part:
- return ret;
+ return 0;
}
/* if ver1 < ver2 return -1,
* if ver1 = ver2 return 0,
* if ver1 > ver2 return 1,
*/
-static int version_compare(const unsigned int ver1, const unsigned int ver2)
+static int version_compare(const unsigned ver1, const unsigned ver2)
{
char *ch_ver1 = name_hashtable[ver1];
char *ch_ver2 = name_hashtable[ver2];
return result;
}
-static int test_version(const unsigned int version1, const unsigned int version2, const unsigned int operator)
+static int test_version(const unsigned version1, const unsigned version2, const unsigned operator)
{
const int version_result = version_compare(version1, version2);
switch (operator) {
- case VER_ANY:
- return TRUE;
- case VER_EQUAL:
- if (version_result == 0) {
- return TRUE;
- }
- break;
- case VER_LESS:
- if (version_result < 0) {
- return TRUE;
- }
- break;
- case VER_LESS_EQUAL:
- if (version_result <= 0) {
- return TRUE;
- }
- break;
- case VER_MORE:
- if (version_result > 0) {
- return TRUE;
- }
- break;
- case VER_MORE_EQUAL:
- if (version_result >= 0) {
- return TRUE;
- }
- break;
+ case VER_ANY:
+ return TRUE;
+ case VER_EQUAL:
+ return (version_result == 0);
+ case VER_LESS:
+ return (version_result < 0);
+ case VER_LESS_EQUAL:
+ return (version_result <= 0);
+ case VER_MORE:
+ return (version_result > 0);
+ case VER_MORE_EQUAL:
+ return (version_result >= 0);
}
return FALSE;
}
-static int search_package_hashtable(const unsigned int name, const unsigned int version, const unsigned int operator)
+static int search_package_hashtable(const unsigned name, const unsigned version, const unsigned operator)
{
- unsigned int probe_address = 0;
- unsigned int probe_decrement = 0;
+ unsigned probe_address = 0;
+ unsigned probe_decrement = 0;
make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME);
while (package_hashtable[probe_address] != NULL) {
* FIXME: I don't think this is very efficient, but I thought I'd keep
* it simple for now until it proves to be a problem.
*/
-static int search_for_provides(int needle, int start_at) {
+static int search_for_provides(int needle, int start_at)
+{
int i, j;
common_node_t *p;
for (i = start_at + 1; i < PACKAGE_HASH_PRIME; i++) {
p = package_hashtable[i];
- if (p == NULL) continue;
+ if (p == NULL)
+ continue;
for (j = 0; j < p->num_of_edges; j++)
if (p->edge[j]->type == EDGE_PROVIDES && p->edge[j]->name == needle)
return i;
* field contains the number of EDGE nodes which follow as part of
* this alternative.
*/
-static void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned int edge_type)
+static void add_split_dependencies(common_node_t *parent_node, const char *whole_line, unsigned edge_type)
{
char *line = xstrdup(whole_line);
char *line2;
field += strspn(field, " ");
line2 = xstrdup(field);
field2 = strtok_r(line2, "|", &line_ptr2);
- if ((edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS) &&
- (strcmp(field, field2) != 0)) {
- or_edge = (edge_t *)xmalloc(sizeof(edge_t));
+ or_edge = NULL;
+ if ((edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS)
+ && (strcmp(field, field2) != 0)
+ ) {
+ or_edge = xmalloc(sizeof(edge_t));
or_edge->type = edge_type + 1;
- } else {
- or_edge = NULL;
- }
-
- if (or_edge) {
or_edge->name = search_name_hashtable(field);
- or_edge->version = 0; // tracks the number of altenatives
-
+ or_edge->version = 0; // tracks the number of alternatives
add_edge_to_node(parent_node, or_edge);
}
do {
- edge = (edge_t *) xmalloc(sizeof(edge_t));
+ edge = xmalloc(sizeof(edge_t));
edge->type = edge_type;
/* Skip any extra leading spaces */
edge->version = search_name_hashtable("ANY");
} else {
/* Skip leading ' ' or '(' */
- version += strspn(field2, " ");
- version += strspn(version, "(");
+ version += strspn(version, " (");
/* Calculate length of any operator characters */
offset_ch = strspn(version, "<=>");
/* Determine operator */
or_edge->version++;
add_edge_to_node(parent_node, edge);
- } while ((field2 = strtok_r(NULL, "|", &line_ptr2)) != NULL);
+ field2 = strtok_r(NULL, "|", &line_ptr2);
+ } while (field2 != NULL);
+
free(line2);
- } while ((field = strtok_r(NULL, ",", &line_ptr1)) != NULL);
- free(line);
+ field = strtok_r(NULL, ",", &line_ptr1);
+ } while (field != NULL);
- return;
+ free(line);
}
static void free_package(common_node_t *node)
}
offset++;
}
- if (name_length == 0) {
- *field_name = NULL;
- } else {
+ *field_name = NULL;
+ if (name_length) {
*field_name = xstrndup(&package_buffer[offset_name_start], name_length);
}
+ *field_value = NULL;
if (value_length > 0) {
*field_value = xstrndup(&package_buffer[offset_value_start], value_length);
- } else {
- *field_value = NULL;
}
return next_offset;
}
-static unsigned int fill_package_struct(char *control_buffer)
+static unsigned fill_package_struct(char *control_buffer)
{
- static const char *const field_names[] = { "Package", "Version",
- "Pre-Depends", "Depends","Replaces", "Provides",
- "Conflicts", "Suggests", "Recommends", "Enhances", 0
- };
+ static const char field_names[] ALIGN1 =
+ "Package\0""Version\0"
+ "Pre-Depends\0""Depends\0""Replaces\0""Provides\0"
+ "Conflicts\0""Suggests\0""Recommends\0""Enhances\0";
- common_node_t *new_node = (common_node_t *) xzalloc(sizeof(common_node_t));
+ common_node_t *new_node = xzalloc(sizeof(common_node_t));
char *field_name;
char *field_value;
int field_start = 0;
&field_name, &field_value);
if (field_name == NULL) {
- goto fill_package_struct_cleanup; /* Oh no, the dreaded goto statement ! */
+ goto fill_package_struct_cleanup;
}
- field_num = compare_string_array(field_names, field_name);
+ field_num = index_in_strings(field_names, field_name);
switch (field_num) {
- case 0: /* Package */
- new_node->name = search_name_hashtable(field_value);
- break;
- case 1: /* Version */
- new_node->version = search_name_hashtable(field_value);
- break;
- case 2: /* Pre-Depends */
- add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS);
- break;
- case 3: /* Depends */
- add_split_dependencies(new_node, field_value, EDGE_DEPENDS);
- break;
- case 4: /* Replaces */
- add_split_dependencies(new_node, field_value, EDGE_REPLACES);
- break;
- case 5: /* Provides */
- add_split_dependencies(new_node, field_value, EDGE_PROVIDES);
- break;
- case 6: /* Conflicts */
- add_split_dependencies(new_node, field_value, EDGE_CONFLICTS);
- break;
- case 7: /* Suggests */
- add_split_dependencies(new_node, field_value, EDGE_SUGGESTS);
- break;
- case 8: /* Recommends */
- add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS);
- break;
- case 9: /* Enhances */
- add_split_dependencies(new_node, field_value, EDGE_ENHANCES);
- break;
+ case 0: /* Package */
+ new_node->name = search_name_hashtable(field_value);
+ break;
+ case 1: /* Version */
+ new_node->version = search_name_hashtable(field_value);
+ break;
+ case 2: /* Pre-Depends */
+ add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS);
+ break;
+ case 3: /* Depends */
+ add_split_dependencies(new_node, field_value, EDGE_DEPENDS);
+ break;
+ case 4: /* Replaces */
+ add_split_dependencies(new_node, field_value, EDGE_REPLACES);
+ break;
+ case 5: /* Provides */
+ add_split_dependencies(new_node, field_value, EDGE_PROVIDES);
+ break;
+ case 6: /* Conflicts */
+ add_split_dependencies(new_node, field_value, EDGE_CONFLICTS);
+ break;
+ case 7: /* Suggests */
+ add_split_dependencies(new_node, field_value, EDGE_SUGGESTS);
+ break;
+ case 8: /* Recommends */
+ add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS);
+ break;
+ case 9: /* Enhances */
+ add_split_dependencies(new_node, field_value, EDGE_ENHANCES);
+ break;
}
-fill_package_struct_cleanup:
+ fill_package_struct_cleanup:
free(field_name);
free(field_value);
}
return -1;
}
num = search_package_hashtable(new_node->name, new_node->version, VER_EQUAL);
- if (package_hashtable[num] == NULL) {
- package_hashtable[num] = new_node;
- } else {
- free_package(new_node);
- }
+ free_package(package_hashtable[num]);
+ package_hashtable[num] = new_node;
return num;
}
/* if num = 1, it returns the want status, 2 returns flag, 3 returns status */
-static unsigned int get_status(const unsigned int status_node, const int num)
+static unsigned get_status(const unsigned status_node, const int num)
{
char *status_string = name_hashtable[status_hashtable[status_node]->status];
char *state_sub_string;
- unsigned int state_sub_num;
+ unsigned state_sub_num;
int len;
int i;
return state_sub_num;
}
-static void set_status(const unsigned int status_node_num, const char *new_value, const int position)
+static void set_status(const unsigned status_node_num, const char *new_value, const int position)
{
- const unsigned int new_value_len = strlen(new_value);
- const unsigned int new_value_num = search_name_hashtable(new_value);
- unsigned int want = get_status(status_node_num, 1);
- unsigned int flag = get_status(status_node_num, 2);
- unsigned int status = get_status(status_node_num, 3);
+ const unsigned new_value_len = strlen(new_value);
+ const unsigned new_value_num = search_name_hashtable(new_value);
+ unsigned want = get_status(status_node_num, 1);
+ unsigned flag = get_status(status_node_num, 2);
+ unsigned status = get_status(status_node_num, 3);
int want_len = strlen(name_hashtable[want]);
int flag_len = strlen(name_hashtable[flag]);
int status_len = strlen(name_hashtable[status]);
new_status = xasprintf("%s %s %s", name_hashtable[want], name_hashtable[flag], name_hashtable[status]);
status_hashtable[status_node_num]->status = search_name_hashtable(new_status);
free(new_status);
- return;
}
-static const char *describe_status(int status_num) {
- int status_want, status_state ;
+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);
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";
char *control_buffer;
char *status_line;
status_node_t *status_node = NULL;
- unsigned int status_num;
+ unsigned status_num;
status_file = xfopen(filename, "r");
- while ((control_buffer = fgets_str(status_file, "\n\n")) != NULL) {
- const unsigned int package_num = fill_package_struct(control_buffer);
+ while ((control_buffer = xmalloc_fgetline_str(status_file, "\n\n")) != NULL) {
+ const unsigned package_num = fill_package_struct(control_buffer);
if (package_num != -1) {
status_node = xmalloc(sizeof(status_node_t));
/* fill_package_struct doesnt handle the status field */
free(control_buffer);
}
fclose(status_file);
- return;
}
static void write_buffer_no_status(FILE *new_status_file, const char *control_buffer)
fprintf(new_status_file, "%s: %s\n", name, value);
}
}
- return;
}
/* This could do with a cleanup */
int i = 0;
/* Update previously known packages */
- while ((control_buffer = fgets_str(old_status_file, "\n\n")) != NULL) {
- if ((tmp_string = strstr(control_buffer, "Package:")) == NULL) {
+ while ((control_buffer = xmalloc_fgetline_str(old_status_file, "\n\n")) != NULL) {
+ tmp_string = strstr(control_buffer, "Package:");
+ if (tmp_string == NULL) {
continue;
}
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) {
}
}
/* 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);
}
fclose(old_status_file);
fclose(new_status_file);
-
/* Create a separate backfile to dpkg */
if (rename("/var/lib/dpkg/status", "/var/lib/dpkg/status.udeb.bak") == -1) {
- struct stat stat_buf;
- xstat("/var/lib/dpkg/status", &stat_buf);
+ if (errno != ENOENT)
+ bb_error_msg_and_die("cannot create backup status file");
/* Its ok if renaming the status file fails because status
* file doesnt exist, maybe we are starting from scratch */
bb_error_msg("no status file found, creating new one");
}
- 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
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;
/* Create array of package numbers to check against
* installed package for conflicts*/
while (deb_file[i] != NULL) {
- const unsigned int package_num = deb_file[i]->package;
+ const unsigned package_num = deb_file[i]->package;
conflicts = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
conflicts[conflicts_num] = package_num;
conflicts_num++;
package_hashtable[package_num]->edge[j]->operator);
if (package_hashtable[conflicts_package_num] == NULL) {
/* create a new package */
- common_node_t *new_node = (common_node_t *) xzalloc(sizeof(common_node_t));
+ common_node_t *new_node = xzalloc(sizeof(common_node_t));
new_node->name = package_hashtable[package_num]->edge[j]->name;
new_node->version = package_hashtable[package_num]->edge[j]->version;
package_hashtable[conflicts_package_num] = new_node;
const edge_t *package_edge = package_node->edge[j];
if (package_edge->type == EDGE_CONFLICTS) {
- const unsigned int package_num =
+ const unsigned package_num =
search_package_hashtable(package_edge->name,
package_edge->version,
package_edge->operator);
*/
for (j = 0; j < package_node->num_of_edges; j++) {
const edge_t *package_edge = package_node->edge[j];
- unsigned int package_num;
+ unsigned package_num;
- if (package_edge->type == EDGE_OR_PRE_DEPENDS ||
- package_edge->type == EDGE_OR_DEPENDS) { /* start an EDGE_OR_ list */
+ if (package_edge->type == EDGE_OR_PRE_DEPENDS
+ || package_edge->type == EDGE_OR_DEPENDS
+ ) { /* start an EDGE_OR_ list */
number_of_alternatives = package_edge->version;
root_of_alternatives = package_edge;
continue;
- } else if (number_of_alternatives == 0) { /* not in the middle of an EDGE_OR_ list */
+ }
+ if (number_of_alternatives == 0) { /* not in the middle of an EDGE_OR_ list */
number_of_alternatives = 1;
root_of_alternatives = NULL;
}
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
return NULL;
}
- while ((line = xmalloc_getline(list_stream)) != NULL) {
+ while ((line = xmalloc_fgetline(list_stream)) != NULL) {
file_list = xrealloc(file_list, sizeof(char *) * (count + 2));
file_list[count] = line;
count++;
if (count == 0) {
return NULL;
- } else {
- file_list[count] = NULL;
- return file_list;
}
+ file_list[count] = NULL;
+ return file_list;
}
/* maybe i should try and hook this into remove_file.c somehow */
static int remove_file_array(char **remove_names, char **exclude_names)
{
struct stat path_stat;
- int match_flag;
- int remove_flag = FALSE;
- int i,j;
+ int remove_flag = 1; /* not removed anything yet */
+ int i, j;
if (remove_names == NULL) {
- return FALSE;
+ return 0;
}
for (i = 0; remove_names[i] != NULL; i++) {
- match_flag = FALSE;
if (exclude_names != NULL) {
- for (j = 0; exclude_names[j] != 0; j++) {
+ for (j = 0; exclude_names[j] != NULL; j++) {
if (strcmp(remove_names[i], exclude_names[j]) == 0) {
- match_flag = TRUE;
- break;
+ goto skip;
}
}
}
- if (!match_flag) {
- if (lstat(remove_names[i], &path_stat) < 0) {
- continue;
- }
- if (S_ISDIR(path_stat.st_mode)) {
- if (rmdir(remove_names[i]) != -1) {
- remove_flag = TRUE;
- }
- } else {
- if (unlink(remove_names[i]) != -1) {
- remove_flag = TRUE;
- }
- }
+ /* TODO: why we are checking lstat? we can just try rm/rmdir */
+ if (lstat(remove_names[i], &path_stat) < 0) {
+ continue;
+ }
+ if (S_ISDIR(path_stat.st_mode)) {
+ remove_flag &= rmdir(remove_names[i]); /* 0 if no error */
+ } else {
+ remove_flag &= unlink(remove_names[i]); /* 0 if no error */
}
+ skip:
+ continue;
}
- return remove_flag;
+ return (remove_flag == 0);
}
static int run_package_script(const char *package_name, const char *script_type)
return result;
}
-static const char *all_control_files[] = {"preinst", "postinst", "prerm", "postrm",
- "list", "md5sums", "shlibs", "conffiles", "config", "templates", NULL };
+static const char *const all_control_files[] = {
+ "preinst", "postinst", "prerm", "postrm",
+ "list", "md5sums", "shlibs", "conffiles",
+ "config", "templates", NULL
+};
static char **all_control_list(const char *package_name)
{
static void free_array(char **array)
{
-
if (array) {
unsigned i = 0;
while (array[i]) {
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 */
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];
/* print out the line formatted like Debian dpkg */
printf("%c%c %-14s %s\n", s1, s2, name_str, vers_str);
}
- }
+ }
}
-static void remove_package(const unsigned int package_num, int noisy)
+static void remove_package(const unsigned package_num, int noisy)
{
const char *package_name = name_hashtable[package_hashtable[package_num]->name];
const char *package_version = name_hashtable[package_hashtable[package_num]->version];
- const unsigned int status_num = search_status_hashtable(package_name);
+ const unsigned status_num = search_status_hashtable(package_name);
const int package_name_length = strlen(package_name);
char **remove_files;
char **exclude_files;
char list_name[package_name_length + 25];
char conffile_name[package_name_length + 30];
- int return_value;
if (noisy)
printf("Removing %s (%s)...\n", package_name, package_version);
/* run prerm script */
- return_value = run_package_script(package_name, "prerm");
- if (return_value == -1) {
+ if (run_package_script(package_name, "prerm") != 0) {
bb_error_msg_and_die("script failed, prerm failure");
}
free_array(exclude_files);
/* rename <package>.conffile to <package>.list */
- rename(conffile_name, list_name);
+ xrename(conffile_name, list_name);
/* Change package status */
set_status(status_num, "config-files", 3);
}
-static void purge_package(const unsigned int package_num)
+static void purge_package(const unsigned package_num)
{
const char *package_name = name_hashtable[package_hashtable[package_num]->name];
const char *package_version = name_hashtable[package_hashtable[package_num]->version];
- const unsigned int status_num = search_status_hashtable(package_name);
+ const unsigned status_num = search_status_hashtable(package_name);
char **remove_files;
char **exclude_files;
char list_name[strlen(package_name) + 25];
free(exclude_files);
/* run postrm script */
- if (run_package_script(package_name, "postrm") == -1) {
- bb_error_msg_and_die("postrm fialure.. set status to what?");
+ if (run_package_script(package_name, "postrm") != 0) {
+ bb_error_msg_and_die("postrm failure.. set status to what?");
}
/* Change package status */
tar_handle->src_fd = ar_handle->src_fd;
/* We don't care about data.tar.* or debian-binary, just control.tar.* */
-#ifdef CONFIG_FEATURE_DEB_TAR_GZ
- llist_add_to(&(ar_handle->accept), "control.tar.gz");
+#if ENABLE_FEATURE_DEB_TAR_GZ
+ llist_add_to(&(ar_handle->accept), (char*)"control.tar.gz");
#endif
-#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
- llist_add_to(&(ar_handle->accept), "control.tar.bz2");
+#if ENABLE_FEATURE_DEB_TAR_BZ2
+ llist_add_to(&(ar_handle->accept), (char*)"control.tar.bz2");
#endif
/* Assign the tar handle as a subarchive of the ar handle */
ar_handle->sub_archive = tar_handle;
-
- return;
}
static void init_archive_deb_data(archive_handle_t *ar_handle)
tar_handle->src_fd = ar_handle->src_fd;
/* We don't care about control.tar.* or debian-binary, just data.tar.* */
-#ifdef CONFIG_FEATURE_DEB_TAR_GZ
- llist_add_to(&(ar_handle->accept), "data.tar.gz");
+#if ENABLE_FEATURE_DEB_TAR_GZ
+ llist_add_to(&(ar_handle->accept), (char*)"data.tar.gz");
#endif
-#ifdef CONFIG_FEATURE_DEB_TAR_BZ2
- llist_add_to(&(ar_handle->accept), "data.tar.bz2");
+#if ENABLE_FEATURE_DEB_TAR_BZ2
+ llist_add_to(&(ar_handle->accept), (char*)"data.tar.bz2");
#endif
/* Assign the tar handle as a subarchive of the ar handle */
ar_handle->sub_archive = tar_handle;
-
- return;
}
static char *deb_extract_control_file_to_buffer(archive_handle_t *ar_handle, llist_t *myaccept)
archive_handle->file_header->name = xasprintf("%s%s", archive_handle->buffer, name_ptr);
data_extract_all(archive_handle);
}
- return;
}
static void unpack_package(deb_file_t *deb_file)
{
const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
- const unsigned int status_num = search_status_hashtable(package_name);
- const unsigned int status_package_num = status_hashtable[status_num]->package;
+ const unsigned status_num = search_status_hashtable(package_name);
+ const unsigned status_package_num = status_hashtable[status_num]->package;
char *info_prefix;
char *list_filename;
archive_handle_t *archive_handle;
archive_handle = init_archive_deb_ar(deb_file->filename);
init_archive_deb_data(archive_handle);
archive_handle->sub_archive->action_data = data_extract_all_prefix;
- archive_handle->sub_archive->buffer = "/";
+ archive_handle->sub_archive->buffer = (char*)"/"; /* huh? */
archive_handle->sub_archive->flags |= ARCHIVE_EXTRACT_UNCONDITIONAL;
unpack_ar_archive(archive_handle);
/* Run the postinst script */
if (run_package_script(package_name, "postinst") != 0) {
/* TODO: handle failure gracefully */
- bb_error_msg_and_die("postrm failure.. set status to what?");
+ bb_error_msg_and_die("postinst failure.. set status to what?");
}
/* Change status to reflect success */
set_status(status_num, "install", 1);
set_status(status_num, "installed", 3);
}
+int dpkg_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int dpkg_main(int argc, char **argv)
{
deb_file_t **deb_file = NULL;
status_node_t *status_node;
+ char *str_f;
int opt;
int package_num;
- int dpkg_opt = 0;
int deb_count = 0;
int state_status;
int status_num;
int i;
+ enum {
+ OPT_configure = 0x1,
+ OPT_force_ignore_depends = 0x2,
+ OPT_install = 0x4,
+ OPT_list_installed = 0x8,
+ OPT_purge = 0x10,
+ OPT_remove = 0x20,
+ OPT_unpack = 0x40,
+ };
- 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));
-
- while ((opt = getopt(argc, argv, "CF:ilPru")) != -1) {
- switch (opt) {
- case 'C': // equivalent to --configure in official dpkg
- dpkg_opt |= dpkg_opt_configure;
- dpkg_opt |= dpkg_opt_package_name;
- break;
- case 'F': // equivalent to --force in official dpkg
- if (strcmp(optarg, "depends") == 0) {
- dpkg_opt |= dpkg_opt_force_ignore_depends;
- }
- break;
- case 'i':
- dpkg_opt |= dpkg_opt_install;
- dpkg_opt |= dpkg_opt_filename;
- break;
- case 'l':
- dpkg_opt |= dpkg_opt_list_installed;
- break;
- case 'P':
- dpkg_opt |= dpkg_opt_purge;
- dpkg_opt |= dpkg_opt_package_name;
- break;
- case 'r':
- dpkg_opt |= dpkg_opt_remove;
- dpkg_opt |= dpkg_opt_package_name;
- break;
- case 'u': /* Equivalent to --unpack in official dpkg */
- dpkg_opt |= dpkg_opt_unpack;
- dpkg_opt |= dpkg_opt_filename;
- break;
- default:
- bb_show_usage();
- }
+ opt = getopt32(argv, "CF:ilPru", &str_f);
+ //if (opt & OPT_configure) ... // -C
+ if (opt & OPT_force_ignore_depends) { // -F (--force in official dpkg)
+ if (strcmp(str_f, "depends"))
+ opt &= ~OPT_force_ignore_depends;
}
+ //if (opt & OPT_install) ... // -i
+ //if (opt & OPT_list_installed) ... // -l
+ //if (opt & OPT_purge) ... // -P
+ //if (opt & OPT_remove) ... // -r
+ //if (opt & OPT_unpack) ... // -u (--unpack in official dpkg)
+ argc -= optind;
+ argv += optind;
/* check for non-option argument if expected */
- if ((dpkg_opt == 0) || ((argc == optind) && !(dpkg_opt && dpkg_opt_list_installed))) {
+ if (!opt || (!argc && !(opt && OPT_list_installed)))
bb_show_usage();
- }
+
+ name_hashtable = xzalloc(sizeof(name_hashtable[0]) * (NAME_HASH_PRIME + 1));
+ package_hashtable = xzalloc(sizeof(package_hashtable[0]) * (PACKAGE_HASH_PRIME + 1));
+ status_hashtable = xzalloc(sizeof(status_hashtable[0]) * (STATUS_HASH_PRIME + 1));
/* puts("(Reading database ... xxxxx files and directories installed.)"); */
index_status_file("/var/lib/dpkg/status");
/* if the list action was given print the installed packages and exit */
- if (dpkg_opt & dpkg_opt_list_installed) {
+ if (opt & OPT_list_installed) {
list_packages();
return EXIT_SUCCESS;
}
/* Read arguments and store relevant info in structs */
- while (optind < argc) {
+ while (*argv) {
/* deb_count = nb_elem - 1 and we need nb_elem + 1 to allocate terminal node [NULL pointer] */
- deb_file = xrealloc(deb_file, sizeof(deb_file_t *) * (deb_count + 2));
- deb_file[deb_count] = (deb_file_t *) xzalloc(sizeof(deb_file_t));
- if (dpkg_opt & dpkg_opt_filename) {
+ deb_file = xrealloc(deb_file, sizeof(deb_file[0]) * (deb_count + 2));
+ deb_file[deb_count] = xzalloc(sizeof(deb_file[0][0]));
+ if (opt & (OPT_install | OPT_unpack)) {
+ /* -i/-u: require filename */
archive_handle_t *archive_handle;
llist_t *control_list = NULL;
/* Extract the control file */
- llist_add_to(&control_list, "./control");
- archive_handle = init_archive_deb_ar(argv[optind]);
+ llist_add_to(&control_list, (char*)"./control");
+ archive_handle = init_archive_deb_ar(argv[0]);
init_archive_deb_control(archive_handle);
deb_file[deb_count]->control_file = deb_extract_control_file_to_buffer(archive_handle, control_list);
if (deb_file[deb_count]->control_file == NULL) {
bb_error_msg_and_die("cannot extract control file");
}
- deb_file[deb_count]->filename = xstrdup(argv[optind]);
+ deb_file[deb_count]->filename = xstrdup(argv[0]);
package_num = fill_package_struct(deb_file[deb_count]->control_file);
if (package_num == -1) {
- bb_error_msg("invalid control file in %s", argv[optind]);
- optind++;
+ bb_error_msg("invalid control file in %s", argv[0]);
+ argv++;
continue;
}
- deb_file[deb_count]->package = (unsigned int) package_num;
+ deb_file[deb_count]->package = (unsigned) package_num;
/* Add the package to the status hashtable */
- if ((dpkg_opt & dpkg_opt_unpack) || (dpkg_opt & dpkg_opt_install)) {
+ if (opt & (OPT_unpack | OPT_install)) {
/* Try and find a currently installed version of this package */
status_num = search_status_hashtable(name_hashtable[package_hashtable[deb_file[deb_count]->package]->name]);
/* If no previous entry was found initialise a new entry */
- if ((status_hashtable[status_num] == NULL) ||
- (status_hashtable[status_num]->status == 0)) {
- status_node = (status_node_t *) xmalloc(sizeof(status_node_t));
+ if (status_hashtable[status_num] == NULL
+ || status_hashtable[status_num]->status == 0
+ ) {
+ status_node = xmalloc(sizeof(status_node_t));
status_node->package = deb_file[deb_count]->package;
/* reinstreq isnt changed to "ok" until the package control info
* is written to the status file*/
set_status(status_num, "reinstreq", 2);
}
}
- }
- else if (dpkg_opt & dpkg_opt_package_name) {
+ } else if (opt & (OPT_configure | OPT_purge | OPT_remove)) {
+ /* -C/-p/-r: require package name */
deb_file[deb_count]->package = search_package_hashtable(
- search_name_hashtable(argv[optind]),
- search_name_hashtable("ANY"), VER_ANY);
+ search_name_hashtable(argv[0]),
+ search_name_hashtable("ANY"), VER_ANY);
if (package_hashtable[deb_file[deb_count]->package] == NULL) {
- bb_error_msg_and_die("package %s is uninstalled or unknown", argv[optind]);
+ bb_error_msg_and_die("package %s is uninstalled or unknown", argv[0]);
}
package_num = deb_file[deb_count]->package;
status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
state_status = get_status(status_num, 3);
/* check package status is "installed" */
- if (dpkg_opt & dpkg_opt_remove) {
- if ((strcmp(name_hashtable[state_status], "not-installed") == 0) ||
- (strcmp(name_hashtable[state_status], "config-files") == 0)) {
+ if (opt & OPT_remove) {
+ if (strcmp(name_hashtable[state_status], "not-installed") == 0
+ || strcmp(name_hashtable[state_status], "config-files") == 0
+ ) {
bb_error_msg_and_die("%s is already removed", name_hashtable[package_hashtable[package_num]->name]);
}
set_status(status_num, "deinstall", 1);
- }
- else if (dpkg_opt & dpkg_opt_purge) {
+ } else if (opt & OPT_purge) {
/* if package status is "conf-files" then its ok */
if (strcmp(name_hashtable[state_status], "not-installed") == 0) {
bb_error_msg_and_die("%s is already purged", name_hashtable[package_hashtable[package_num]->name]);
}
}
deb_count++;
- optind++;
+ argv++;
}
+ if (!deb_count)
+ bb_error_msg_and_die("no package files specified");
deb_file[deb_count] = NULL;
/* Check that the deb file arguments are installable */
- if ((dpkg_opt & dpkg_opt_force_ignore_depends) != dpkg_opt_force_ignore_depends) {
- if (!check_deps(deb_file, 0, deb_count)) {
+ if (!(opt & OPT_force_ignore_depends)) {
+ if (!check_deps(deb_file, 0 /*, deb_count*/)) {
bb_error_msg_and_die("dependency check failed");
}
}
/* TODO: install or remove packages in the correct dependency order */
for (i = 0; i < deb_count; i++) {
/* Remove or purge packages */
- if (dpkg_opt & dpkg_opt_remove) {
+ if (opt & OPT_remove) {
remove_package(deb_file[i]->package, 1);
}
- else if (dpkg_opt & dpkg_opt_purge) {
+ else if (opt & OPT_purge) {
purge_package(deb_file[i]->package);
}
- else if (dpkg_opt & dpkg_opt_unpack) {
+ else if (opt & OPT_unpack) {
unpack_package(deb_file[i]);
}
- else if (dpkg_opt & dpkg_opt_install) {
+ else if (opt & OPT_install) {
unpack_package(deb_file[i]);
/* package is configured in second pass below */
}
- else if (dpkg_opt & dpkg_opt_configure) {
+ else if (opt & OPT_configure) {
configure_package(deb_file[i]);
}
}
/* configure installed packages */
- if (dpkg_opt & dpkg_opt_install) {
+ if (opt & OPT_install) {
for (i = 0; i < deb_count; i++)
configure_package(deb_file[i]);
}
}
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++) {
projects / oweals / busybox.git / blobdiff