Apple-2gs-SW/hush
1
0
Fork 0
mirror of https://github.com/sheumann/hush.git synced 2024-11-05 06:07:00 +00:00
Code Issues Projects Releases Wiki Activity

dpkg: getopt32-ification etc, -100 bytes

Browse Source
This commit is contained in:
Denis Vlasenko 2006-12-22 18:32:40 +00:00
parent e31f721e14
commit a6df5907d2
1 changed files with 170 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

393
archival/dpkg.c
View File

@ -34,7 +34,7 @@
* 3) all _hash_prime's must be a prime number or chaos is assured, if your looking * 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 * 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 * 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 * int's and chaos is assured, 16381 is the max prime for 14 bit field
*/ */
@ -53,16 +53,16 @@
* and available file */ * and available file */
#define PACKAGE_HASH_PRIME 10007 #define PACKAGE_HASH_PRIME 10007
typedef struct edge_s { typedef struct edge_s {
unsigned int operator:3; unsigned operator:3;
unsigned int type:4; unsigned type:4;
unsigned int name:14; unsigned name:14;
unsigned int version:14; unsigned version:14;
} edge_t; } edge_t;
typedef struct common_node_s { typedef struct common_node_s {
unsigned int name:14; unsigned name:14;
unsigned int version:14; unsigned version:14;
unsigned int num_of_edges:14; unsigned num_of_edges:14;
edge_t **edge; edge_t **edge;
} common_node_t; } common_node_t;
@ -71,8 +71,8 @@ typedef struct common_node_s {
* likely to be installed at any one time, so there is a bit of leeway here */ * likely to be installed at any one time, so there is a bit of leeway here */
#define STATUS_HASH_PRIME 8191 #define STATUS_HASH_PRIME 8191
typedef struct status_node_s { typedef struct status_node_s {
unsigned int package:14; /* has to fit PACKAGE_HASH_PRIME */ unsigned package:14; /* has to fit PACKAGE_HASH_PRIME */
unsigned int status:14; /* has to fit STATUS_HASH_PRIME */ unsigned status:14; /* has to fit STATUS_HASH_PRIME */
} status_node_t; } status_node_t;
/* Were statically declared here, but such a big bss is nommu-unfriendly */ /* Were statically declared here, but such a big bss is nommu-unfriendly */
@ -104,26 +104,14 @@ enum operator_e {
VER_ANY = 6 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 { typedef struct deb_file_s {
char *control_file; char *control_file;
char *filename; char *filename;
unsigned int package:14; unsigned package:14;
} deb_file_t; } 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 int hash_num = key[0];
int len = strlen(key); int len = strlen(key);
@ -138,26 +126,24 @@ static void make_hash(const char *key, unsigned int *start, unsigned int *decrem
* no effect*/ * no effect*/
hash_num += ((key[i] + key[i-1]) << ((key[i] * i) % 24)); hash_num += ((key[i] + key[i-1]) << ((key[i] * i) % 24));
} }
*start = (unsigned int) hash_num % hash_prime; *start = (unsigned) hash_num % hash_prime;
*decrement = (unsigned int) 1 + (hash_num % (hash_prime - 1)); *decrement = (unsigned) 1 + (hash_num % (hash_prime - 1));
} }
/* this adds the key to the hash table */ /* this adds the key to the hash table */
static int search_name_hashtable(const char *key) static int search_name_hashtable(const char *key)
{ {
unsigned int probe_address = 0; unsigned probe_address = 0;
unsigned int probe_decrement = 0; unsigned probe_decrement = 0;
// char *temp;
make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME); make_hash(key, &probe_address, &probe_decrement, NAME_HASH_PRIME);
while (name_hashtable[probe_address] != NULL) { while (name_hashtable[probe_address] != NULL) {
if (strcmp(name_hashtable[probe_address], key) == 0) { if (strcmp(name_hashtable[probe_address], key) == 0) {
return probe_address; return probe_address;
} else { }
probe_address -= probe_decrement; probe_address -= probe_decrement;
if ((int)probe_address < 0) { if ((int)probe_address < 0) {
probe_address += NAME_HASH_PRIME; probe_address += NAME_HASH_PRIME;
}
} }
} }
name_hashtable[probe_address] = xstrdup(key); name_hashtable[probe_address] = xstrdup(key);
@ -167,20 +153,19 @@ static int search_name_hashtable(const char *key)
/* this DOESNT add the key to the hashtable /* this DOESNT add the key to the hashtable
* TODO make it consistent with search_name_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 probe_address = 0;
unsigned int probe_decrement = 0; unsigned probe_decrement = 0;
make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME); make_hash(key, &probe_address, &probe_decrement, STATUS_HASH_PRIME);
while (status_hashtable[probe_address] != NULL) { while (status_hashtable[probe_address] != NULL) {
if (strcmp(key, name_hashtable[package_hashtable[status_hashtable[probe_address]->package]->name]) == 0) { if (strcmp(key, name_hashtable[package_hashtable[status_hashtable[probe_address]->package]->name]) == 0) {
break; break;
} else { }
probe_address -= probe_decrement; probe_address -= probe_decrement;
if ((int)probe_address < 0) { if ((int)probe_address < 0) {
probe_address += STATUS_HASH_PRIME; probe_address += STATUS_HASH_PRIME;
}
} }
} }
return probe_address; return probe_address;
@ -198,7 +183,6 @@ static int version_compare_part(const char *version1, const char *version2)
int tmp_int; int tmp_int;
int ver_num1; int ver_num1;
int ver_num2; int ver_num2;
int ret;
if (version1 == NULL) { if (version1 == NULL) {
version1 = xstrdup(""); version1 = xstrdup("");
@ -221,8 +205,7 @@ static int version_compare_part(const char *version1, const char *version2)
free(name1_char); free(name1_char);
free(name2_char); free(name2_char);
if (tmp_int != 0) { if (tmp_int != 0) {
ret = tmp_int; return tmp_int;
goto cleanup_version_compare_part;
} }
/* Compare digits */ /* Compare digits */
@ -237,24 +220,20 @@ static int version_compare_part(const char *version1, const char *version2)
free(name1_char); free(name1_char);
free(name2_char); free(name2_char);
if (ver_num1 < ver_num2) { if (ver_num1 < ver_num2) {
ret = -1; return -1;
goto cleanup_version_compare_part;
} }
else if (ver_num1 > ver_num2) { if (ver_num1 > ver_num2) {
ret = 1; return 1;
goto cleanup_version_compare_part;
} }
} }
ret = 0; return 0;
cleanup_version_compare_part:
return ret;
} }
/* if ver1 < ver2 return -1, /* if ver1 < ver2 return -1,
* if ver1 = ver2 return 0, * if ver1 = ver2 return 0,
* if ver1 > ver2 return 1, * 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_ver1 = name_hashtable[ver1];
char *ch_ver2 = name_hashtable[ver2]; char *ch_ver2 = name_hashtable[ver2];
@ -313,46 +292,31 @@ static int version_compare(const unsigned int ver1, const unsigned int ver2)
return result; 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); const int version_result = version_compare(version1, version2);
switch (operator) { switch (operator) {
case VER_ANY: case VER_ANY:
return TRUE; return TRUE;
case VER_EQUAL: case VER_EQUAL:
if (version_result == 0) { return (version_result == 0);
return TRUE; case VER_LESS:
} return (version_result < 0);
break; case VER_LESS_EQUAL:
case VER_LESS: return (version_result <= 0);
if (version_result < 0) { case VER_MORE:
return TRUE; return (version_result > 0);
} case VER_MORE_EQUAL:
break; return (version_result >= 0);
case VER_LESS_EQUAL:
if (version_result <= 0) {
return TRUE;
}
break;
case VER_MORE:
if (version_result > 0) {
return TRUE;
}
break;
case VER_MORE_EQUAL:
if (version_result >= 0) {
return TRUE;
}
break;
} }
return FALSE; 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 probe_address = 0;
unsigned int probe_decrement = 0; unsigned probe_decrement = 0;
make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME); make_hash(name_hashtable[name], &probe_address, &probe_decrement, PACKAGE_HASH_PRIME);
while (package_hashtable[probe_address] != NULL) { while (package_hashtable[probe_address] != NULL) {
@ -393,7 +357,8 @@ static int search_for_provides(int needle, int start_at) {
common_node_t *p; common_node_t *p;
for (i = start_at + 1; i < PACKAGE_HASH_PRIME; i++) { for (i = start_at + 1; i < PACKAGE_HASH_PRIME; i++) {
p = package_hashtable[i]; p = package_hashtable[i];
if (p == NULL) continue; if (p == NULL)
continue;
for (j = 0; j < p->num_of_edges; j++) for (j = 0; j < p->num_of_edges; j++)
if (p->edge[j]->type == EDGE_PROVIDES && p->edge[j]->name == needle) if (p->edge[j]->type == EDGE_PROVIDES && p->edge[j]->name == needle)
return i; return i;
@ -421,7 +386,7 @@ static void add_edge_to_node(common_node_t *node, edge_t *edge)
* field contains the number of EDGE nodes which follow as part of * field contains the number of EDGE nodes which follow as part of
* this alternative. * 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 *line = xstrdup(whole_line);
char *line2; char *line2;
@ -440,18 +405,14 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
field += strspn(field, " "); field += strspn(field, " ");
line2 = xstrdup(field); line2 = xstrdup(field);
field2 = strtok_r(line2, "|", &line_ptr2); field2 = strtok_r(line2, "|", &line_ptr2);
if ((edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS) && or_edge = NULL;
(strcmp(field, field2) != 0)) { if ((edge_type == EDGE_DEPENDS || edge_type == EDGE_PRE_DEPENDS)
&& (strcmp(field, field2) != 0)
) {
or_edge = xmalloc(sizeof(edge_t)); or_edge = xmalloc(sizeof(edge_t));
or_edge->type = edge_type + 1; or_edge->type = edge_type + 1;
} else {
or_edge = NULL;
}
if (or_edge) {
or_edge->name = search_name_hashtable(field); or_edge->name = search_name_hashtable(field);
or_edge->version = 0; // tracks the number of altenatives or_edge->version = 0; // tracks the number of altenatives
add_edge_to_node(parent_node, or_edge); add_edge_to_node(parent_node, or_edge);
} }
@ -470,8 +431,7 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
edge->version = search_name_hashtable("ANY"); edge->version = search_name_hashtable("ANY");
} else { } else {
/* Skip leading ' ' or '(' */ /* Skip leading ' ' or '(' */
version += strspn(field2, " "); version += strspn(field2, " (");
version += strspn(version, "(");
/* Calculate length of any operator characters */ /* Calculate length of any operator characters */
offset_ch = strspn(version, "<=>"); offset_ch = strspn(version, "<=>");
/* Determine operator */ /* Determine operator */
@ -516,8 +476,6 @@ static void add_split_dependencies(common_node_t *parent_node, const char *whole
free(line2); free(line2);
} while ((field = strtok_r(NULL, ",", &line_ptr1)) != NULL); } while ((field = strtok_r(NULL, ",", &line_ptr1)) != NULL);
free(line); free(line);
return;
} }
static void free_package(common_node_t *node) static void free_package(common_node_t *node)
@ -606,20 +564,18 @@ static int read_package_field(const char *package_buffer, char **field_name, cha
} }
offset++; offset++;
} }
if (name_length == 0) { *field_name = NULL;
*field_name = NULL; if (name_length) {
} else {
*field_name = xstrndup(&package_buffer[offset_name_start], name_length); *field_name = xstrndup(&package_buffer[offset_name_start], name_length);
} }
*field_value = NULL;
if (value_length > 0) { if (value_length > 0) {
*field_value = xstrndup(&package_buffer[offset_value_start], value_length); *field_value = xstrndup(&package_buffer[offset_value_start], value_length);
} else {
*field_value = NULL;
} }
return next_offset; return next_offset;
} }
static unsigned int fill_package_struct(char *control_buffer) static unsigned fill_package_struct(char *control_buffer)
{ {
static const char *const field_names[] = { "Package", "Version", static const char *const field_names[] = { "Package", "Version",
"Pre-Depends", "Depends","Replaces", "Provides", "Pre-Depends", "Depends","Replaces", "Provides",
@ -646,38 +602,38 @@ static unsigned int fill_package_struct(char *control_buffer)
field_num = index_in_str_array(field_names, field_name); field_num = index_in_str_array(field_names, field_name);
switch (field_num) { switch (field_num) {
case 0: /* Package */ case 0: /* Package */
new_node->name = search_name_hashtable(field_value); new_node->name = search_name_hashtable(field_value);
break; break;
case 1: /* Version */ case 1: /* Version */
new_node->version = search_name_hashtable(field_value); new_node->version = search_name_hashtable(field_value);
break; break;
case 2: /* Pre-Depends */ case 2: /* Pre-Depends */
add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS); add_split_dependencies(new_node, field_value, EDGE_PRE_DEPENDS);
break; break;
case 3: /* Depends */ case 3: /* Depends */
add_split_dependencies(new_node, field_value, EDGE_DEPENDS); add_split_dependencies(new_node, field_value, EDGE_DEPENDS);
break; break;
case 4: /* Replaces */ case 4: /* Replaces */
add_split_dependencies(new_node, field_value, EDGE_REPLACES); add_split_dependencies(new_node, field_value, EDGE_REPLACES);
break; break;
case 5: /* Provides */ case 5: /* Provides */
add_split_dependencies(new_node, field_value, EDGE_PROVIDES); add_split_dependencies(new_node, field_value, EDGE_PROVIDES);
break; break;
case 6: /* Conflicts */ case 6: /* Conflicts */
add_split_dependencies(new_node, field_value, EDGE_CONFLICTS); add_split_dependencies(new_node, field_value, EDGE_CONFLICTS);
break; break;
case 7: /* Suggests */ case 7: /* Suggests */
add_split_dependencies(new_node, field_value, EDGE_SUGGESTS); add_split_dependencies(new_node, field_value, EDGE_SUGGESTS);
break; break;
case 8: /* Recommends */ case 8: /* Recommends */
add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS); add_split_dependencies(new_node, field_value, EDGE_RECOMMENDS);
break; break;
case 9: /* Enhances */ case 9: /* Enhances */
add_split_dependencies(new_node, field_value, EDGE_ENHANCES); add_split_dependencies(new_node, field_value, EDGE_ENHANCES);
break; break;
} }
fill_package_struct_cleanup: fill_package_struct_cleanup:
free(field_name); free(field_name);
free(field_value); free(field_value);
} }
@ -696,11 +652,11 @@ fill_package_struct_cleanup:
} }
/* if num = 1, it returns the want status, 2 returns flag, 3 returns status */ /* 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 *status_string = name_hashtable[status_hashtable[status_node]->status];
char *state_sub_string; char *state_sub_string;
unsigned int state_sub_num; unsigned state_sub_num;
int len; int len;
int i; int i;
@ -718,13 +674,13 @@ static unsigned int get_status(const unsigned int status_node, const int num)
return state_sub_num; return state_sub_num;
} }
static void set_status(const unsigned int status_node_num, const char *new_value, const int position) static void set_status(const unsigned status_node_num, const char *new_value, const int position)
{ {
const unsigned int new_value_len = strlen(new_value); const unsigned new_value_len = strlen(new_value);
const unsigned int new_value_num = search_name_hashtable(new_value); const unsigned new_value_num = search_name_hashtable(new_value);
unsigned int want = get_status(status_node_num, 1); unsigned want = get_status(status_node_num, 1);
unsigned int flag = get_status(status_node_num, 2); unsigned flag = get_status(status_node_num, 2);
unsigned int status = get_status(status_node_num, 3); unsigned status = get_status(status_node_num, 3);
int want_len = strlen(name_hashtable[want]); int want_len = strlen(name_hashtable[want]);
int flag_len = strlen(name_hashtable[flag]); int flag_len = strlen(name_hashtable[flag]);
int status_len = strlen(name_hashtable[status]); int status_len = strlen(name_hashtable[status]);
@ -784,11 +740,11 @@ static void index_status_file(const char *filename)
char *control_buffer; char *control_buffer;
char *status_line; char *status_line;
status_node_t *status_node = NULL; status_node_t *status_node = NULL;
unsigned int status_num; unsigned status_num;
status_file = xfopen(filename, "r"); status_file = xfopen(filename, "r");
while ((control_buffer = xmalloc_fgets_str(status_file, "\n\n")) != NULL) { while ((control_buffer = xmalloc_fgets_str(status_file, "\n\n")) != NULL) {
const unsigned int package_num = fill_package_struct(control_buffer); const unsigned package_num = fill_package_struct(control_buffer);
if (package_num != -1) { if (package_num != -1) {
status_node = xmalloc(sizeof(status_node_t)); status_node = xmalloc(sizeof(status_node_t));
/* fill_package_struct doesnt handle the status field */ /* fill_package_struct doesnt handle the status field */
@ -1012,7 +968,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
/* Create array of package numbers to check against /* Create array of package numbers to check against
* installed package for conflicts*/ * installed package for conflicts*/
while (deb_file[i] != NULL) { 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 = xrealloc(conflicts, sizeof(int) * (conflicts_num + 1));
conflicts[conflicts_num] = package_num; conflicts[conflicts_num] = package_num;
conflicts_num++; conflicts_num++;
@ -1054,7 +1010,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
const edge_t *package_edge = package_node->edge[j]; const edge_t *package_edge = package_node->edge[j];
if (package_edge->type == EDGE_CONFLICTS) { if (package_edge->type == EDGE_CONFLICTS) {
const unsigned int package_num = const unsigned package_num =
search_package_hashtable(package_edge->name, search_package_hashtable(package_edge->name,
package_edge->version, package_edge->version,
package_edge->operator); package_edge->operator);
@ -1113,7 +1069,7 @@ static int check_deps(deb_file_t **deb_file, int deb_start, int dep_max_count)
*/ */
for (j = 0; j < package_node->num_of_edges; j++) { for (j = 0; j < package_node->num_of_edges; j++) {
const edge_t *package_edge = package_node->edge[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 || if (package_edge->type == EDGE_OR_PRE_DEPENDS ||
package_edge->type == EDGE_OR_DEPENDS) { /* start an EDGE_OR_ list */ package_edge->type == EDGE_OR_DEPENDS) { /* start an EDGE_OR_ list */
@ -1346,11 +1302,11 @@ static void list_packages(void)
} }
} }
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_name = name_hashtable[package_hashtable[package_num]->name];
const char *package_version = name_hashtable[package_hashtable[package_num]->version]; 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); const int package_name_length = strlen(package_name);
char **remove_files; char **remove_files;
char **exclude_files; char **exclude_files;
@ -1398,11 +1354,11 @@ static void remove_package(const unsigned int package_num, int noisy)
set_status(status_num, "config-files", 3); 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_name = name_hashtable[package_hashtable[package_num]->name];
const char *package_version = name_hashtable[package_hashtable[package_num]->version]; 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 **remove_files;
char **exclude_files; char **exclude_files;
char list_name[strlen(package_name) + 25]; char list_name[strlen(package_name) + 25];
@ -1522,8 +1478,8 @@ static void data_extract_all_prefix(archive_handle_t *archive_handle)
static void unpack_package(deb_file_t *deb_file) static void unpack_package(deb_file_t *deb_file)
{ {
const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name]; const char *package_name = name_hashtable[package_hashtable[deb_file->package]->name];
const unsigned int status_num = search_status_hashtable(package_name); const unsigned status_num = search_status_hashtable(package_name);
const unsigned int status_package_num = status_hashtable[status_num]->package; const unsigned status_package_num = status_hashtable[status_num]->package;
char *info_prefix; char *info_prefix;
char *list_filename; char *list_filename;
archive_handle_t *archive_handle; archive_handle_t *archive_handle;
@ -1614,100 +1570,90 @@ int dpkg_main(int argc, char **argv)
{ {
deb_file_t **deb_file = NULL; deb_file_t **deb_file = NULL;
status_node_t *status_node; status_node_t *status_node;
char *str_f;
int opt; int opt;
int package_num; int package_num;
int dpkg_opt = 0;
int deb_count = 0; int deb_count = 0;
int state_status; int state_status;
int status_num; int status_num;
int i; 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,
REQ_package_name = 0x8000,
REQ_filename = 0x4000,
};
opt = getopt32(argc, argv, "CF:ilPru", &str_f);
if (opt & OPT_configure) opt |= REQ_package_name; // -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) opt |= REQ_filename; // -i
//if (opt & OPT_list_installed) ... // -l
if (opt & OPT_purge) opt |= REQ_package_name; // -P
if (opt & OPT_remove) opt |= REQ_package_name; // -r
if (opt & OPT_unpack) opt |= REQ_filename; // -u (--unpack in official dpkg)
argc -= optind;
argv += optind;
/* check for non-option argument if expected */
if (!opt || (!argc && !(opt && OPT_list_installed)))
bb_show_usage();
name_hashtable = xzalloc(sizeof(name_hashtable[0]) * (NAME_HASH_PRIME + 1)); name_hashtable = xzalloc(sizeof(name_hashtable[0]) * (NAME_HASH_PRIME + 1));
package_hashtable = xzalloc(sizeof(package_hashtable[0]) * (PACKAGE_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)); 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();
}
}
/* check for non-option argument if expected */
if ((dpkg_opt == 0) || ((argc == optind) && !(dpkg_opt && dpkg_opt_list_installed))) {
bb_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"); index_status_file("/var/lib/dpkg/status");
/* if the list action was given print the installed packages and exit */ /* 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(); list_packages();
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
/* Read arguments and store relevant info in structs */ /* 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_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 = xrealloc(deb_file, sizeof(deb_file_t *) * (deb_count + 2));
deb_file[deb_count] = (deb_file_t *) xzalloc(sizeof(deb_file_t)); deb_file[deb_count] = xzalloc(sizeof(deb_file_t));
if (dpkg_opt & dpkg_opt_filename) { if (opt & REQ_filename) {
archive_handle_t *archive_handle; archive_handle_t *archive_handle;
llist_t *control_list = NULL; llist_t *control_list = NULL;
/* Extract the control file */ /* Extract the control file */
llist_add_to(&control_list, "./control"); llist_add_to(&control_list, "./control");
archive_handle = init_archive_deb_ar(argv[optind]); archive_handle = init_archive_deb_ar(argv[0]);
init_archive_deb_control(archive_handle); init_archive_deb_control(archive_handle);
deb_file[deb_count]->control_file = deb_extract_control_file_to_buffer(archive_handle, control_list); deb_file[deb_count]->control_file = deb_extract_control_file_to_buffer(archive_handle, control_list);
if (deb_file[deb_count]->control_file == NULL) { if (deb_file[deb_count]->control_file == NULL) {
bb_error_msg_and_die("cannot extract control file"); bb_error_msg_and_die("cannot extract control file");
} }
deb_file[deb_count]->filename = xstrdup(argv[optind]); deb_file[deb_count]->filename = xstrdup(argv[0]);
package_num = fill_package_struct(deb_file[deb_count]->control_file); package_num = fill_package_struct(deb_file[deb_count]->control_file);
if (package_num == -1) { if (package_num == -1) {
bb_error_msg("invalid control file in %s", argv[optind]); bb_error_msg("invalid control file in %s", argv[0]);
optind++; argv++;
continue; 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 */ /* 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 */ /* 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_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 no previous entry was found initialise a new entry */
if ((status_hashtable[status_num] == NULL) || if (status_hashtable[status_num] == NULL
(status_hashtable[status_num]->status == 0)) { || status_hashtable[status_num]->status == 0
) {
status_node = xmalloc(sizeof(status_node_t)); status_node = xmalloc(sizeof(status_node_t));
status_node->package = deb_file[deb_count]->package; status_node->package = deb_file[deb_count]->package;
/* reinstreq isnt changed to "ok" until the package control info /* reinstreq isnt changed to "ok" until the package control info
@ -1720,26 +1666,27 @@ int dpkg_main(int argc, char **argv)
} }
} }
} }
else if (dpkg_opt & dpkg_opt_package_name) { else if (opt & REQ_package_name) {
deb_file[deb_count]->package = search_package_hashtable( deb_file[deb_count]->package = search_package_hashtable(
search_name_hashtable(argv[optind]), search_name_hashtable(argv[0]),
search_name_hashtable("ANY"), VER_ANY); search_name_hashtable("ANY"), VER_ANY);
if (package_hashtable[deb_file[deb_count]->package] == NULL) { 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; package_num = deb_file[deb_count]->package;
status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]); status_num = search_status_hashtable(name_hashtable[package_hashtable[package_num]->name]);
state_status = get_status(status_num, 3); state_status = get_status(status_num, 3);
/* check package status is "installed" */ /* check package status is "installed" */
if (dpkg_opt & dpkg_opt_remove) { if (opt & OPT_remove) {
if ((strcmp(name_hashtable[state_status], "not-installed") == 0) || if (strcmp(name_hashtable[state_status], "not-installed") == 0
(strcmp(name_hashtable[state_status], "config-files") == 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]); bb_error_msg_and_die("%s is already removed", name_hashtable[package_hashtable[package_num]->name]);
} }
set_status(status_num, "deinstall", 1); 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 package status is "conf-files" then its ok */
if (strcmp(name_hashtable[state_status], "not-installed") == 0) { if (strcmp(name_hashtable[state_status], "not-installed") == 0) {
bb_error_msg_and_die("%s is already purged", name_hashtable[package_hashtable[package_num]->name]); bb_error_msg_and_die("%s is already purged", name_hashtable[package_hashtable[package_num]->name]);
@ -1748,12 +1695,12 @@ int dpkg_main(int argc, char **argv)
} }
} }
deb_count++; deb_count++;
optind++; argv++;
} }
deb_file[deb_count] = NULL; deb_file[deb_count] = NULL;
/* Check that the deb file arguments are installable */ /* Check that the deb file arguments are installable */
if ((dpkg_opt & dpkg_opt_force_ignore_depends) != dpkg_opt_force_ignore_depends) { 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"); bb_error_msg_and_die("dependency check failed");
} }
@ -1762,25 +1709,25 @@ int dpkg_main(int argc, char **argv)
/* TODO: install or remove packages in the correct dependency order */ /* TODO: install or remove packages in the correct dependency order */
for (i = 0; i < deb_count; i++) { for (i = 0; i < deb_count; i++) {
/* Remove or purge packages */ /* Remove or purge packages */
if (dpkg_opt & dpkg_opt_remove) { if (opt & OPT_remove) {
remove_package(deb_file[i]->package, 1); 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); purge_package(deb_file[i]->package);
} }
else if (dpkg_opt & dpkg_opt_unpack) { else if (opt & OPT_unpack) {
unpack_package(deb_file[i]); unpack_package(deb_file[i]);
} }
else if (dpkg_opt & dpkg_opt_install) { else if (opt & OPT_install) {
unpack_package(deb_file[i]); unpack_package(deb_file[i]);
/* package is configured in second pass below */ /* 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_package(deb_file[i]);
} }
} }
/* configure installed packages */ /* configure installed packages */
if (dpkg_opt & dpkg_opt_install) { if (opt & OPT_install) {
for (i = 0; i < deb_count; i++) for (i = 0; i < deb_count; i++)
configure_package(deb_file[i]); configure_package(deb_file[i]);
} }