pkg_vec_t * visited, pkg_vec_t * ordered)
{
int j, k, l, m;
- int count;
pkg_t *dep;
compound_depend_t *compound_depend;
depend_t **possible_satisfiers;
pkg_vec_insert(visited, pkg);
- count = pkg->pre_depends_count + pkg->depends_count +
- pkg->recommends_count + pkg->suggests_count;
-
opkg_msg(DEBUG, "pkg %s.\n", pkg->name);
/* Iterate over all the dependencies of pkg. For each one, find a package
that is either installed or unpacked and satisfies this dependency.
(there should only be one such package per dependency installed or
unpacked). Then recurse to the dependency package */
- for (j = 0; j < count; j++) {
- compound_depend = &pkg->depends[j];
+ for (compound_depend = pkg_get_ptr(pkg, PKG_DEPENDS); compound_depend && compound_depend->type; compound_depend++) {
possible_satisfiers = compound_depend->possibilities;
for (k = 0; k < compound_depend->possibility_count; k++) {
abpkg = possible_satisfiers[k]->pkg;
pkg_t *pkg;
char *pkg_name = NULL;
conffile_list_elt_t *iter;
+ conffile_list_t *cl;
conffile_t *cf;
if (argc > 0) {
pkg_vec_sort(available, pkg_compare_names);
for (i = 0; i < available->len; i++) {
pkg = available->pkgs[i];
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
/* if we have package name or pattern and pkg does not match, then skip it */
if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase))
continue;
- if (nv_pair_list_empty(&pkg->conffiles))
+ if (!cl || nv_pair_list_empty(cl))
continue;
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ for (iter = nv_pair_list_first(cl); iter;
+ iter = nv_pair_list_next(cl, iter)) {
cf = (conffile_t *) iter->data;
if (cf->name && cf->value
&& conffile_has_been_modified(cf))
pkg_vec_t *available;
pkg_t *pkg;
char *pkg_name = NULL;
+ conffile_list_t *cl;
if (argc > 0) {
pkg_name = argv[0];
pkg_formatted_info(stdout, pkg);
- if (conf->verbosity >= NOTICE) {
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ if (conf->verbosity >= NOTICE && cl) {
conffile_list_elt_t *iter;
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ for (iter = nv_pair_list_first(cl); iter;
+ iter = nv_pair_list_next(cl, iter)) {
conffile_t *cf = (conffile_t *) iter->data;
int modified = conffile_has_been_modified(cf);
if (cf->value)
static int opkg_depends_cmd(int argc, char **argv)
{
int i, j, k;
- int depends_count;
pkg_vec_t *available_pkgs;
compound_depend_t *cdep;
pkg_t *pkg;
if (fnmatch(argv[i], pkg->name, conf->nocase) != 0)
continue;
- depends_count = pkg->depends_count +
- pkg->pre_depends_count +
- pkg->recommends_count + pkg->suggests_count;
-
opkg_msg(NOTICE, "%s depends on:\n", pkg->name);
- for (k = 0; k < depends_count; k++) {
- cdep = &pkg->depends[k];
-
+ for (k = 0, cdep = pkg_get_ptr(pkg, PKG_DEPENDS); cdep && cdep->type; k++, cdep++) {
if (cdep->type != DEPEND)
continue;
static int pkg_mark_provides(pkg_t * pkg)
{
- int provides_count = pkg->provides_count;
- abstract_pkg_t **provides = pkg->provides;
- int i;
+ abstract_pkg_t **provider = pkg_get_ptr(pkg, PKG_PROVIDES);
+
pkg->parent->state_flag |= SF_MARKED;
- for (i = 0; i < provides_count; i++) {
- provides[i]->state_flag |= SF_MARKED;
+
+ while (provider && *provider) {
+ (*provider)->state_flag |= SF_MARKED;
+ provider++;
}
+
return 0;
}
int argc, char **argv)
{
depend_t *possibility;
- compound_depend_t *cdep;
+ compound_depend_t *cdep, *deps;
pkg_vec_t *available_pkgs;
pkg_t *pkg;
- int i, j, k, l;
- int changed, count;
+ int i, j, l;
+ int changed;
const char *rel_str = NULL;
char *ver;
for (j = 0; j < available_pkgs->len; j++) {
pkg = available_pkgs->pkgs[j];
+ /*
count = ((what_field_type == CONFLICTS)
? pkg->conflicts_count
: pkg->pre_depends_count +
pkg->depends_count +
pkg->recommends_count + pkg->suggests_count);
+ */
/* skip this package if it is already marked */
if (pkg->parent->state_flag & SF_MARKED)
continue;
- for (k = 0; k < count; k++) {
- cdep = (what_field_type == CONFLICTS)
- ? &pkg->conflicts[k]
- : &pkg->depends[k];
+ deps = pkg_get_ptr(pkg, (what_field_type == CONFLICTS) ? PKG_CONFLICTS : PKG_DEPENDS);
+ for (cdep = deps; cdep->type; cdep++) {
if (what_field_type != cdep->type)
continue;
opkg_what_provides_replaces_cmd(enum what_field_type what_field_type, int argc,
char **argv)
{
+ abstract_pkg_t *apkg, **abpkgs;
if (argc > 0) {
pkg_vec_t *available_pkgs = pkg_vec_alloc();
opkg_msg(NOTICE, "What %s %s\n", rel_str, target);
for (j = 0; j < available_pkgs->len; j++) {
pkg_t *pkg = available_pkgs->pkgs[j];
- int k;
- int count =
- (what_field_type ==
- WHATPROVIDES) ? pkg->provides_count : pkg->
- replaces_count;
- for (k = 0; k < count; k++) {
- abstract_pkg_t *apkg =
- ((what_field_type == WHATPROVIDES)
- ? pkg->provides[k]
- : pkg->replaces[k]);
- if (fnmatch
- (target, apkg->name,
- conf->nocase) == 0) {
- opkg_msg(NOTICE, " %s",
- pkg->name);
- if ((conf->
- nocase ? strcasecmp(target,
- apkg->
- name) :
- strcmp(target,
- apkg->name)) != 0)
- opkg_msg(NOTICE,
- "\t%s %s\n",
- rel_str,
- apkg->name);
- opkg_message(NOTICE, "\n");
- }
+ abpkgs = pkg_get_ptr(pkg, (what_field_type == WHATPROVIDES) ? PKG_PROVIDES : PKG_REPLACES);
+
+ while (abpkgs && *abpkgs) {
+ apkg = *abpkgs;
+
+ if (fnmatch(target, apkg->name, conf->nocase))
+ continue;
+
+ opkg_msg(NOTICE, " %s", pkg->name);
+
+ if ((conf->nocase ? strcasecmp(target, apkg->name)
+ : strcmp(target, apkg->name)))
+ opkg_msg(NOTICE, "\t%s %s\n", rel_str, apkg->name);
+
+ opkg_message(NOTICE, "\n");
+ abpkgs++;
}
}
}
int err;
char *conffiles_file_name;
char *root_dir;
+ char *tmp_unpack_dir;
FILE *conffiles_file;
+ conffile_list_t *cl;
- sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir,
+ sprintf_alloc(&tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir,
pkg->name);
- pkg->tmp_unpack_dir = mkdtemp(pkg->tmp_unpack_dir);
- if (pkg->tmp_unpack_dir == NULL) {
+ tmp_unpack_dir = mkdtemp(tmp_unpack_dir);
+ if (tmp_unpack_dir == NULL) {
opkg_perror(ERROR, "Failed to create temporary directory '%s'",
- pkg->tmp_unpack_dir);
+ tmp_unpack_dir);
return -1;
}
- err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
+ pkg_set_string(pkg, PKG_TMP_UNPACK_DIR, tmp_unpack_dir);
+
+ err = pkg_extract_control_files_to_dir(pkg, tmp_unpack_dir);
if (err) {
return err;
}
move all of unpack_pkg_control_files to that function. */
/* Don't need to re-read conffiles if we already have it */
- if (!nv_pair_list_empty(&pkg->conffiles)) {
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+ if (cl && !nv_pair_list_empty(cl)) {
return 0;
}
sprintf_alloc(&conffiles_file_name, "%s/conffiles",
- pkg->tmp_unpack_dir);
+ tmp_unpack_dir);
if (!file_exists(conffiles_file_name)) {
free(conffiles_file_name);
return 0;
}
free(conffiles_file_name);
+ cl = xcalloc(1, sizeof(*cl));
+ conffile_list_init(cl);
+
while (1) {
char *cf_name;
char *cf_name_in_dest;
/* Can't get an md5sum now, (file isn't extracted yet).
We'll wait until resolve_conffiles */
- conffile_list_append(&pkg->conffiles, cf_name_in_dest, NULL);
+ conffile_list_append(cl, cf_name_in_dest, NULL);
free(cf_name);
free(cf_name_in_dest);
}
+ pkg_set_ptr(pkg, PKG_CONFFILES, cl);
+
fclose(conffiles_file);
return 0;
*/
static int pkg_remove_orphan_dependent(pkg_t * pkg, pkg_t * old_pkg)
{
- int i, j, k, l, found, r, err = 0;
+ int j, l, found, r, err = 0;
int n_deps;
pkg_t *p;
struct compound_depend *cd0, *cd1;
abstract_pkg_t **dependents;
- int count0 = old_pkg->pre_depends_count +
- old_pkg->depends_count +
- old_pkg->recommends_count + old_pkg->suggests_count;
- int count1 = pkg->pre_depends_count +
- pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
-
- for (i = 0; i < count0; i++) {
- cd0 = &old_pkg->depends[i];
+ for (cd0 = pkg_get_ptr(old_pkg, PKG_DEPENDS); cd0 && cd0->type; cd0++) {
if (cd0->type != DEPEND)
continue;
for (j = 0; j < cd0->possibility_count; j++) {
found = 0;
- for (k = 0; k < count1; k++) {
- cd1 = &pkg->depends[k];
+ for (cd1 = pkg_get_ptr(pkg, PKG_DEPENDS); cd1 && cd1->type; cd1++) {
if (cd1->type != DEPEND)
continue;
for (l = 0; l < cd1->possibility_count; l++) {
static int
pkg_get_installed_replacees(pkg_t * pkg, pkg_vec_t * installed_replacees)
{
- abstract_pkg_t **replaces = pkg->replaces;
- int replaces_count = pkg->replaces_count;
- int i, j;
- for (i = 0; i < replaces_count; i++) {
- abstract_pkg_t *ab_pkg = replaces[i];
+ abstract_pkg_t **replaces = pkg_get_ptr(pkg, PKG_REPLACES);
+ int j;
+
+ while (replaces && *replaces) {
+ abstract_pkg_t *ab_pkg = *replaces++;
pkg_vec_t *pkg_vec = ab_pkg->pkgs;
if (pkg_vec) {
for (j = 0; j < pkg_vec->len; j++) {
}
}
}
+
return installed_replacees->len;
}
int err;
conffile_list_elt_t *iter;
conffile_t *cf;
+ conffile_list_t *cl;
if (conf->noaction)
return 0;
/* Backup all modified conffiles */
if (old_pkg) {
- for (iter = nv_pair_list_first(&old_pkg->conffiles); iter;
- iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
+ cl = pkg_get_ptr(old_pkg, PKG_CONFFILES);
+
+ for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
+ iter = nv_pair_list_next(cl, iter)) {
char *cf_name;
cf = iter->data;
}
/* Backup all conffiles that were not conffiles in old_pkg */
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
+ iter = nv_pair_list_next(cl, iter)) {
char *cf_name;
cf = (conffile_t *) iter->data;
cf_name = root_filename_alloc(cf->name);
static int backup_modified_conffiles_unwind(pkg_t * pkg, pkg_t * old_pkg)
{
+ conffile_list_t *cl;
conffile_list_elt_t *iter;
if (old_pkg) {
- for (iter = nv_pair_list_first(&old_pkg->conffiles); iter;
- iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
+ cl = pkg_get_ptr(old_pkg, PKG_CONFFILES);
+
+ for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
+ iter = nv_pair_list_next(cl, iter)) {
backup_remove(((nv_pair_t *) iter->data)->name);
}
}
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
+ iter = nv_pair_list_next(cl, iter)) {
backup_remove(((nv_pair_t *) iter->data)->name);
}
static int resolve_conffiles(pkg_t * pkg)
{
conffile_list_elt_t *iter;
+ conffile_list_t *cl;
conffile_t *cf;
char *cf_backup;
char *chksum;
if (conf->noaction)
return 0;
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
+ iter = nv_pair_list_next(cl, iter)) {
char *root_filename;
cf = (conffile_t *) iter->data;
root_filename = root_filename_alloc(cf->name);
pkg->name);
return -1;
}
+
+ local_filename = pkg_get_string(pkg, PKG_LOCAL_FILENAME);
}
/* check that the repository is valid */
return 0;
}
- if (pkg->tmp_unpack_dir == NULL) {
+ if (!pkg_get_string(pkg, PKG_TMP_UNPACK_DIR)) {
if (unpack_pkg_control_files(pkg) == -1) {
opkg_msg(ERROR,
"Failed to unpack control files from %s.\n",
*/
int pkg_has_installed_dependents(pkg_t * pkg, abstract_pkg_t *** pdependents)
{
- int nprovides = pkg->provides_count;
- abstract_pkg_t **provides = pkg->provides;
- unsigned int n_installed_dependents = 0;
- int i;
- for (i = 0; i < nprovides; i++) {
- abstract_pkg_t *providee = provides[i];
+ abstract_pkg_t **provider, **provides = pkg_get_ptr(pkg, PKG_PROVIDES);
+ unsigned int i, n_installed_dependents = 0;
+
+ provider = provides;
+
+ while (provider && *provider) {
+ abstract_pkg_t *providee = *provider++;
abstract_pkg_t **dependers = providee->depended_upon_by;
abstract_pkg_t *dep_ab_pkg;
if (dependers == NULL)
n_installed_dependents++;
}
}
-
}
+
/* if caller requested the set of installed dependents */
if (pdependents) {
int p = 0;
xcalloc((n_installed_dependents + 1),
sizeof(abstract_pkg_t *));
+ provider = provides;
*pdependents = dependents;
- for (i = 0; i < nprovides; i++) {
- abstract_pkg_t *providee = provides[i];
+
+ while (provider && *provider) {
+ abstract_pkg_t *providee = *provider++;
abstract_pkg_t **dependers = providee->depended_upon_by;
abstract_pkg_t *dep_ab_pkg;
if (dependers == NULL)
*/
static int remove_autoinstalled(pkg_t * pkg)
{
- int i, j;
+ int j;
int err = 0;
int n_deps;
pkg_t *p;
struct compound_depend *cdep;
abstract_pkg_t **dependents;
- int count = pkg->pre_depends_count +
- pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
-
- for (i = 0; i < count; i++) {
- cdep = &pkg->depends[i];
+ for (cdep = pkg_get_ptr(pkg, PKG_DEPENDS); cdep && cdep->type; cdep++) {
if (cdep->type != PREDEPEND
&& cdep->type != DEPEND && cdep->type != RECOMMEND)
continue;
pkg->state_want = SW_UNKNOWN;
pkg->state_flag = SF_OK;
pkg->state_status = SS_NOT_INSTALLED;
- pkg->depends_str = NULL;
- pkg->provides_str = NULL;
- pkg->depends_count = 0;
- pkg->depends = NULL;
- pkg->suggests_str = NULL;
- pkg->recommends_str = NULL;
- pkg->suggests_count = 0;
- pkg->recommends_count = 0;
active_list_init(&pkg->list);
- pkg->conflicts = NULL;
- pkg->conflicts_count = 0;
-
- pkg->replaces = NULL;
- pkg->replaces_count = 0;
-
- pkg->pre_depends_count = 0;
- pkg->pre_depends_str = NULL;
- pkg->provides_count = 0;
- pkg->provides = NULL;
- pkg->tmp_unpack_dir = NULL;
- conffile_list_init(&pkg->conffiles);
pkg->installed_files = NULL;
pkg->installed_files_ref_cnt = 0;
pkg->essential = 0;
void pkg_deinit(pkg_t * pkg)
{
- int i;
+ compound_depend_t *deps, *dep;
if (pkg->name)
free(pkg->name);
active_list_clear(&pkg->list);
- if (pkg->replaces)
- free(pkg->replaces);
- pkg->replaces = NULL;
+ deps = pkg_get_ptr(pkg, PKG_DEPENDS);
- if (pkg->depends) {
- int count = pkg->pre_depends_count
- + pkg->depends_count
- + pkg->recommends_count + pkg->suggests_count;
-
- for (i = 0; i < count; i++)
- compound_depend_deinit(&pkg->depends[i]);
- free(pkg->depends);
- }
+ if (deps) {
+ for (dep = deps; dep->type; dep++)
+ compound_depend_deinit(dep);
- if (pkg->conflicts) {
- for (i = 0; i < pkg->conflicts_count; i++)
- compound_depend_deinit(&pkg->conflicts[i]);
- free(pkg->conflicts);
+ free(deps);
+ pkg_set_ptr(pkg, PKG_DEPENDS, NULL);
}
- if (pkg->provides)
- free(pkg->provides);
+ deps = pkg_get_ptr(pkg, PKG_CONFLICTS);
- pkg->pre_depends_count = 0;
- pkg->provides_count = 0;
+ if (deps) {
+ for (dep = deps; dep->type; dep++)
+ compound_depend_deinit(dep);
- /* CLEANUP: It'd be nice to pullin the cleanup function from
- opkg_install.c here. See comment in
- opkg_install.c:cleanup_temporary_files */
- if (pkg->tmp_unpack_dir)
- free(pkg->tmp_unpack_dir);
- pkg->tmp_unpack_dir = NULL;
+ free(deps);
+ pkg_set_ptr(pkg, PKG_CONFLICTS, NULL);
+ }
- conffile_list_deinit(&pkg->conffiles);
+ //conffile_list_deinit(&pkg->conffiles);
/* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
since if they are calling deinit, they should know. Maybe do an
pkg_free_installed_files(pkg);
pkg->essential = 0;
- blob_buf_free(&pkg->blob);
+ //blob_buf_free(&pkg->blob);
}
int pkg_init_from_file(pkg_t * pkg, const char *filename)
/* Merge any new information in newpkg into oldpkg */
int pkg_merge(pkg_t * oldpkg, pkg_t * newpkg)
{
+ abstract_pkg_t **ab;
+ conffile_list_t *cf, head;
+
if (oldpkg == newpkg) {
return 0;
}
oldpkg->dest = newpkg->dest;
if (!pkg_get_string(oldpkg, PKG_ARCHITECTURE))
pkg_set_string(oldpkg, PKG_ARCHITECTURE, pkg_get_string(newpkg, PKG_ARCHITECTURE));
- if (!oldpkg->arch_priority)
- oldpkg->arch_priority = newpkg->arch_priority;
+ if (!pkg_get_int(oldpkg, PKG_ARCH_PRIORITY))
+ pkg_set_int(oldpkg, PKG_ARCH_PRIORITY, pkg_get_int(newpkg, PKG_ARCH_PRIORITY));
if (!pkg_get_string(oldpkg, PKG_SECTION))
pkg_set_string(oldpkg, PKG_SECTION, pkg_get_string(newpkg, PKG_SECTION));
if (!pkg_get_string(oldpkg, PKG_MAINTAINER))
if (!pkg_get_string(oldpkg, PKG_DESCRIPTION))
pkg_set_string(oldpkg, PKG_DESCRIPTION, pkg_get_string(newpkg, PKG_DESCRIPTION));
- if (!oldpkg->depends_count && !oldpkg->pre_depends_count
- && !oldpkg->recommends_count && !oldpkg->suggests_count) {
- oldpkg->depends_count = newpkg->depends_count;
- newpkg->depends_count = 0;
-
- oldpkg->depends = newpkg->depends;
- newpkg->depends = NULL;
-
- oldpkg->pre_depends_count = newpkg->pre_depends_count;
- newpkg->pre_depends_count = 0;
-
- oldpkg->recommends_count = newpkg->recommends_count;
- newpkg->recommends_count = 0;
-
- oldpkg->suggests_count = newpkg->suggests_count;
- newpkg->suggests_count = 0;
+ if (!pkg_get_ptr(oldpkg, PKG_DEPENDS)) {
+ pkg_set_ptr(oldpkg, PKG_DEPENDS, pkg_get_ptr(newpkg, PKG_DEPENDS));
+ pkg_set_ptr(newpkg, PKG_DEPENDS, NULL);
}
- if (oldpkg->provides_count <= 1) {
- oldpkg->provides_count = newpkg->provides_count;
- newpkg->provides_count = 0;
+ ab = pkg_get_ptr(oldpkg, PKG_PROVIDES);
- if (!oldpkg->provides) {
- oldpkg->provides = newpkg->provides;
- newpkg->provides = NULL;
- }
+ if (!ab || !ab[0] || !ab[1]) {
+ pkg_set_ptr(oldpkg, PKG_PROVIDES, pkg_get_ptr(newpkg, PKG_PROVIDES));
+ pkg_set_ptr(newpkg, PKG_PROVIDES, NULL);
}
- if (!oldpkg->conflicts_count) {
- oldpkg->conflicts_count = newpkg->conflicts_count;
- newpkg->conflicts_count = 0;
-
- oldpkg->conflicts = newpkg->conflicts;
- newpkg->conflicts = NULL;
+ if (!pkg_get_ptr(oldpkg, PKG_CONFLICTS)) {
+ pkg_set_ptr(oldpkg, PKG_CONFLICTS, pkg_get_ptr(newpkg, PKG_CONFLICTS));
+ pkg_set_ptr(newpkg, PKG_CONFLICTS, NULL);
}
- if (!oldpkg->replaces_count) {
- oldpkg->replaces_count = newpkg->replaces_count;
- newpkg->replaces_count = 0;
-
- oldpkg->replaces = newpkg->replaces;
- newpkg->replaces = NULL;
+ if (!pkg_get_ptr(oldpkg, PKG_REPLACES)) {
+ pkg_set_ptr(oldpkg, PKG_REPLACES, pkg_get_ptr(newpkg, PKG_REPLACES));
+ pkg_set_ptr(newpkg, PKG_REPLACES, NULL);
}
if (!pkg_get_string(oldpkg, PKG_FILENAME))
pkg_set_string(oldpkg, PKG_FILENAME, pkg_get_string(newpkg, PKG_FILENAME));
if (!pkg_get_string(oldpkg, PKG_LOCAL_FILENAME))
pkg_set_string(oldpkg, PKG_LOCAL_FILENAME, pkg_get_string(newpkg, PKG_LOCAL_FILENAME));
- if (!oldpkg->tmp_unpack_dir)
- oldpkg->tmp_unpack_dir = xstrdup(newpkg->tmp_unpack_dir);
+ if (!pkg_get_string(oldpkg, PKG_TMP_UNPACK_DIR))
+ pkg_set_string(oldpkg, PKG_TMP_UNPACK_DIR, pkg_get_string(newpkg, PKG_TMP_UNPACK_DIR));
if (!pkg_get_string(oldpkg, PKG_MD5SUM))
pkg_set_string(oldpkg, PKG_MD5SUM, pkg_get_string(newpkg, PKG_MD5SUM));
if (!pkg_get_string(oldpkg, PKG_SHA256SUM))
if (!pkg_get_string(oldpkg, PKG_SOURCE))
pkg_set_string(oldpkg, PKG_SOURCE, pkg_get_string(newpkg, PKG_SOURCE));
- if (nv_pair_list_empty(&oldpkg->conffiles)) {
- list_splice_init(&newpkg->conffiles.head,
- &oldpkg->conffiles.head);
+ if (!pkg_get_ptr(oldpkg, PKG_CONFFILES)) {
+ cf = pkg_get_ptr(newpkg, PKG_CONFFILES);
+ if (cf) {
+ conffile_list_init(&head);
+ list_splice_init(&cf->head, &head.head);
+ pkg_set_raw(oldpkg, PKG_CONFFILES, &head, sizeof(head));
+ }
}
if (!oldpkg->installed_files) {
int i, j;
char *str;
const char *p;
- int depends_count = pkg->pre_depends_count +
- pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
+ compound_depend_t *dep;
+ abstract_pkg_t **ab_pkg;
if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
goto UNKNOWN_FMT_FIELD;
case 'c':
case 'C':
if (strcasecmp(field, "Conffiles") == 0) {
+ conffile_list_t *cl;
conffile_list_elt_t *iter;
- if (nv_pair_list_empty(&pkg->conffiles))
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ if (!cl || nv_pair_list_empty(cl))
return;
fprintf(fp, "Conffiles:\n");
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ for (iter = nv_pair_list_first(cl); iter;
+ iter = nv_pair_list_next(cl, iter)) {
if (((conffile_t *) iter->data)->name
&& ((conffile_t *) iter->data)->value) {
fprintf(fp, " %s %s\n",
}
} else if (strcasecmp(field, "Conflicts") == 0) {
struct depend *cdep;
- if (pkg->conflicts_count) {
+ compound_depend_t *deps, *dep;
+ deps = pkg_get_ptr(pkg, PKG_CONFLICTS);
+ if (deps) {
fprintf(fp, "Conflicts:");
- for (i = 0; i < pkg->conflicts_count; i++) {
- cdep =
- pkg->conflicts[i].possibilities[0];
+ for (i = 0, dep = deps; dep->type; dep++, i++) {
+ cdep = dep->possibilities[0];
fprintf(fp, "%s %s", i == 0 ? "" : ",",
cdep->pkg->name);
if (cdep->version) {
case 'd':
case 'D':
if (strcasecmp(field, "Depends") == 0) {
- if (pkg->depends_count) {
+ dep = pkg_get_depends(pkg, DEPEND);
+ if (dep) {
fprintf(fp, "Depends:");
- for (j = 0, i = 0; i < depends_count; i++) {
- if (pkg->depends[i].type != DEPEND)
+ for (i = 0, j = 0; dep && dep->type; i++, dep++) {
+ if (dep->type != DEPEND)
continue;
str = pkg_depend_str(pkg, i);
fprintf(fp, "%s %s", j == 0 ? "" : ",",
} else if (strcasecmp(field, "Priority") == 0) {
fprintf(fp, "Priority: %s\n", pkg_get_string(pkg, PKG_PRIORITY));
} else if (strcasecmp(field, "Provides") == 0) {
- if (pkg->provides_count > 1) {
+ ab_pkg = pkg_get_ptr(pkg, PKG_PROVIDES);
+ if (ab_pkg && ab_pkg[0] && ab_pkg[1]) {
fprintf(fp, "Provides:");
- for (i = 1; i < pkg->provides_count; i++) {
- fprintf(fp, "%s %s", i == 1 ? "" : ",",
- pkg->provides[i]->name);
+ for (i = 0, ab_pkg++; *ab_pkg; i++, ab_pkg++) {
+ fprintf(fp, "%s %s", i == 0 ? "" : ",",
+ (*ab_pkg)->name);
+ ab_pkg++;
}
fprintf(fp, "\n");
}
case 'r':
case 'R':
if (strcasecmp(field, "Replaces") == 0) {
- if (pkg->replaces_count) {
+ ab_pkg = pkg_get_ptr(pkg, PKG_REPLACES);
+ if (ab_pkg && *ab_pkg) {
fprintf(fp, "Replaces:");
- for (i = 0; i < pkg->replaces_count; i++) {
+ for (i = 0; *ab_pkg; i++, ab_pkg++) {
fprintf(fp, "%s %s", i == 0 ? "" : ",",
- pkg->replaces[i]->name);
+ (*ab_pkg)->name);
}
fprintf(fp, "\n");
}
} else if (strcasecmp(field, "Recommends") == 0) {
- if (pkg->recommends_count) {
+ dep = pkg_get_depends(pkg, RECOMMEND);
+ if (dep) {
fprintf(fp, "Recommends:");
- for (j = 0, i = 0; i < depends_count; i++) {
- if (pkg->depends[i].type != RECOMMEND)
+ for (j = 0, i = 0; dep && dep->type; i++, dep++) {
+ if (dep->type != RECOMMEND)
continue;
str = pkg_depend_str(pkg, i);
fprintf(fp, "%s %s", j == 0 ? "" : ",",
pkg_state_status_to_str(pkg->state_status));
free(pflag);
} else if (strcasecmp(field, "Suggests") == 0) {
- if (pkg->suggests_count) {
+ dep = pkg_get_depends(pkg, SUGGEST);
+ if (dep) {
fprintf(fp, "Suggests:");
- for (j = 0, i = 0; i < depends_count; i++) {
- if (pkg->depends[i].type != SUGGEST)
+ for (j = 0, i = 0; dep && dep->type; i++, dep++) {
+ if (dep->type != SUGGEST)
continue;
str = pkg_depend_str(pkg, i);
fprintf(fp, "%s %s", j == 0 ? "" : ",",
{
unsigned int epoch1 = (unsigned int) pkg_get_int(pkg, PKG_EPOCH);
unsigned int epoch2 = (unsigned int) pkg_get_int(ref_pkg, PKG_EPOCH);
- char *revision1 = pkg_get_ptr(pkg, PKG_REVISION);
- char *revision2 = pkg_get_ptr(ref_pkg, PKG_REVISION);
+ char *revision1 = pkg_get_string(pkg, PKG_REVISION);
+ char *revision2 = pkg_get_string(ref_pkg, PKG_REVISION);
const char *version1 = pkg_get_string(pkg, PKG_VERSION);
const char *version2 = pkg_get_string(ref_pkg, PKG_VERSION);
int r;
const pkg_t * b = *(const pkg_t **)p2;
int namecmp;
int vercmp;
+ int arch_prio1, arch_prio2;
if (!a->name || !b->name) {
opkg_msg(ERROR, "Internal error: a->name=%p, b->name=%p.\n",
a->name, b->name);
vercmp = pkg_compare_versions(a, b);
if (vercmp)
return vercmp;
- if (!a->arch_priority || !b->arch_priority) {
+ arch_prio1 = pkg_get_int(a, PKG_ARCH_PRIORITY);
+ arch_prio2 = pkg_get_int(b, PKG_ARCH_PRIORITY);
+ if (!arch_prio1 || !arch_prio2) {
opkg_msg(ERROR,
"Internal error: a->arch_priority=%i b->arch_priority=%i.\n",
- a->arch_priority, b->arch_priority);
+ arch_prio1, arch_prio2);
return 0;
}
- if (a->arch_priority > b->arch_priority)
+ if (arch_prio1 > arch_prio2)
return 1;
- if (a->arch_priority < b->arch_priority)
+ if (arch_prio1 < arch_prio2)
return -1;
return 0;
}
char *version, *revptr;
unsigned int epoch = (unsigned int) pkg_get_int(pkg, PKG_EPOCH);
- revptr = pkg_get_ptr(pkg, PKG_REVISION);
+ revptr = pkg_get_string(pkg, PKG_REVISION);
verstr = pkg_get_string(pkg, PKG_VERSION);
if (epoch) {
conffile_t *pkg_get_conffile(pkg_t * pkg, const char *file_name)
{
conffile_list_elt_t *iter;
+ conffile_list_t *cl;
conffile_t *conffile;
if (pkg == NULL) {
return NULL;
}
- for (iter = nv_pair_list_first(&pkg->conffiles); iter;
- iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
+ iter = nv_pair_list_next(cl, iter)) {
conffile = (conffile_t *) iter->data;
if (strcmp(conffile->name, file_name) == 0) {
int err;
char *path;
char *cmd;
+ char *tmp_unpack_dir;
if (conf->noaction)
return 0;
}
/* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
- have scripts in pkg->tmp_unpack_dir. */
+ have scripts in tmp_unpack_dir. */
if (pkg->state_status == SS_INSTALLED
|| pkg->state_status == SS_UNPACKED) {
if (pkg->dest == NULL) {
sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name,
script);
} else {
- if (pkg->tmp_unpack_dir == NULL) {
+ tmp_unpack_dir = pkg_get_string(pkg, PKG_TMP_UNPACK_DIR);
+ if (tmp_unpack_dir == NULL) {
opkg_msg(ERROR,
"Internal error: %s has a NULL tmp_unpack_dir.\n",
pkg->name);
return -1;
}
- sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script);
+ sprintf_alloc(&path, "%s/%s", tmp_unpack_dir, script);
}
opkg_msg(INFO, "Running script %s.\n", path);
PKG_VERSION,
PKG_REVISION,
PKG_ARCHITECTURE,
+ PKG_ARCH_PRIORITY,
PKG_DESCRIPTION,
PKG_MD5SUM,
PKG_SHA256SUM,
PKG_SIZE,
PKG_INSTALLED_SIZE,
PKG_INSTALLED_TIME,
+ PKG_TMP_UNPACK_DIR,
+ PKG_REPLACES,
+ PKG_PROVIDES,
+ PKG_DEPENDS,
+ PKG_CONFLICTS,
+ PKG_CONFFILES,
};
struct abstract_pkg {
char *name;
pkg_src_t *src;
pkg_dest_t *dest;
- pkg_state_want_t state_want;
- pkg_state_flag_t state_flag;
- pkg_state_status_t state_status;
- char **depends_str;
- unsigned int depends_count;
- char **pre_depends_str;
- unsigned int pre_depends_count;
- char **recommends_str;
- unsigned int recommends_count;
- char **suggests_str;
- unsigned int suggests_count;
+ pkg_state_want_t state_want:3;
+ pkg_state_flag_t state_flag:10;
+ pkg_state_status_t state_status:4;
struct active_list list; /* Used for installing|upgrading */
- compound_depend_t *depends;
-
- char **conflicts_str;
- compound_depend_t *conflicts;
- unsigned int conflicts_count;
-
- char **replaces_str;
- unsigned int replaces_count;
- abstract_pkg_t **replaces;
-
- char **provides_str;
- unsigned int provides_count;
- abstract_pkg_t **provides;
abstract_pkg_t *parent;
- char *tmp_unpack_dir;
- conffile_list_t conffiles;
/* As pointer for lazy evaluation */
str_list_t *installed_files;
/* XXX: CLEANUP: I'd like to perhaps come up with a better
installed_files list was being freed from an inner loop while
still being used within an outer loop. */
int installed_files_ref_cnt;
- int arch_priority;
int essential:1;
/* Adding this flag, to "force" opkg to choose a "provided_by_hand" package, if there are multiple choice */
static inline void * pkg_set_ptr(pkg_t *pkg, int id, void *ptr)
{
- return pkg_set_raw(pkg, id, ptr, sizeof(ptr));
+ return ptr ? *(void **) pkg_set_raw(pkg, id, &ptr, sizeof(ptr)) : NULL;
}
static inline void * pkg_get_ptr(const pkg_t *pkg, int id)
{
- return pkg_get_raw(pkg, id);
+ void **ptr = pkg_get_raw(pkg, id);
+ return ptr ? *ptr : NULL;
}
abstract_pkg_t *abstract_pkg_new(void);
{
pkg_t *satisfier_entry_pkg;
int i, j, k;
- int count, found;
+ int found;
char **the_lost;
abstract_pkg_t *ab_pkg;
+ compound_depend_t *compound_depend;
/*
* this is a setup to check for redundant/cyclic dependency checks,
} else {
ab_pkg->dependencies_checked = 1; /* mark it for subsequent visits */
}
- /**/
- count =
- pkg->pre_depends_count + pkg->depends_count +
- pkg->recommends_count + pkg->suggests_count;
- if (!count) {
+
+ compound_depend = pkg_get_ptr(pkg, PKG_DEPENDS);
+
+ if (!compound_depend || !compound_depend->type) {
*unresolved = NULL;
return 0;
}
the_lost = NULL;
/* foreach dependency */
- for (i = 0; i < count; i++) {
- compound_depend_t *compound_depend = &pkg->depends[i];
+ for (; compound_depend && compound_depend->type; compound_depend++) {
depend_t **possible_satisfiers =
compound_depend->possibilities;;
found = 0;
*/
static int is_pkg_a_replaces(pkg_t * pkg_scout, pkg_t * pkg)
{
- int i;
- int replaces_count = pkg->replaces_count;
- abstract_pkg_t **replaces;
+ abstract_pkg_t **replaces = pkg_get_ptr(pkg, PKG_REPLACES);
- if (pkg->replaces_count == 0) // No replaces, it's surely a conflict
+ if (!replaces || !*replaces)
return 0;
- replaces = pkg->replaces;
-
- for (i = 0; i < replaces_count; i++) {
- if (strcmp(pkg_scout->name, pkg->replaces[i]->name) == 0) { // Found
+ while (*replaces) {
+ if (strcmp(pkg_scout->name, (*replaces)->name) == 0) { // Found
opkg_msg(DEBUG2, "Seems I've found a replace %s %s\n",
- pkg_scout->name, pkg->replaces[i]->name);
+ pkg_scout->name, (*replaces)->name);
return 1;
}
+ replaces++;
}
- return 0;
+ return 0;
}
pkg_vec_t *pkg_hash_fetch_conflicts(pkg_t * pkg)
{
pkg_vec_t *installed_conflicts, *test_vec;
- compound_depend_t *conflicts;
+ compound_depend_t *conflicts, *conflict;
depend_t **possible_satisfiers;
depend_t *possible_satisfier;
- int i, j, k;
- int count;
+ int j, k;
abstract_pkg_t *ab_pkg;
pkg_t **pkg_scouts;
pkg_t *pkg_scout;
return (pkg_vec_t *) NULL;
}
- conflicts = pkg->conflicts;
+ conflicts = pkg_get_ptr(pkg, PKG_CONFLICTS);
if (!conflicts) {
return (pkg_vec_t *) NULL;
}
installed_conflicts = pkg_vec_alloc();
- count = pkg->conflicts_count;
-
/* foreach conflict */
- for (i = 0; i < pkg->conflicts_count; i++) {
-
+ for (conflict = conflicts; conflict->type; conflict++ ) {
possible_satisfiers = conflicts->possibilities;
/* foreach possible satisfier */
*/
int pkg_replaces(pkg_t * pkg, pkg_t * replacee)
{
- abstract_pkg_t **replaces = pkg->replaces;
- int replaces_count = pkg->replaces_count;
- int replacee_provides_count = replacee->provides_count;
- int i, j;
- for (i = 0; i < replaces_count; i++) {
- abstract_pkg_t *abstract_replacee = replaces[i];
- for (j = 0; j < replacee_provides_count; j++) {
- if (replacee->provides[j] == abstract_replacee)
+ abstract_pkg_t **replaces = pkg_get_ptr(pkg, PKG_REPLACES);
+ abstract_pkg_t **provides = pkg_get_ptr(replacee, PKG_PROVIDES);
+ abstract_pkg_t **r, **p;
+
+ for (r = replaces; r && *r; r++)
+ for (p = provides; p && *p; p++)
+ if (*r == *p)
return 1;
- }
- }
+
return 0;
}
*/
int pkg_conflicts_abstract(pkg_t * pkg, abstract_pkg_t * conflictee)
{
- compound_depend_t *conflicts = pkg->conflicts;
- int conflicts_count = pkg->conflicts_count;
- int i, j;
- for (i = 0; i < conflicts_count; i++) {
- int possibility_count = conflicts[i].possibility_count;
- struct depend **possibilities = conflicts[i].possibilities;
+ compound_depend_t *conflicts, *conflict;
+
+ conflicts = pkg_get_ptr(pkg, PKG_CONFLICTS);
+
+ int j;
+ for (conflict = conflicts; conflict->type; conflict++) {
+ int possibility_count = conflict->possibility_count;
+ struct depend **possibilities = conflict->possibilities;
for (j = 0; j < possibility_count; j++) {
if (possibilities[j]->pkg == conflictee) {
return 1;
*/
int pkg_conflicts(pkg_t * pkg, pkg_t * conflictee)
{
- compound_depend_t *conflicts = pkg->conflicts;
- int conflicts_count = pkg->conflicts_count;
- abstract_pkg_t **conflictee_provides = conflictee->provides;
- int conflictee_provides_count = conflictee->provides_count;
- int i, j, k;
+ int j;
int possibility_count;
struct depend **possibilities;
- abstract_pkg_t *possibility;
+ compound_depend_t *conflicts, *conflict;
+ abstract_pkg_t **conflictee_provides, **provider, *possibility;
- for (i = 0; i < conflicts_count; i++) {
- possibility_count = conflicts[i].possibility_count;
- possibilities = conflicts[i].possibilities;
+ conflicts = pkg_get_ptr(pkg, PKG_CONFLICTS);
+ conflictee_provides = pkg_get_ptr(conflictee, PKG_PROVIDES);
+
+ for (conflict = conflicts; conflict->type; conflict++) {
+ possibility_count = conflict->possibility_count;
+ possibilities = conflict->possibilities;
for (j = 0; j < possibility_count; j++) {
possibility = possibilities[j]->pkg;
- for (k = 0; k < conflictee_provides_count; k++) {
- if (possibility == conflictee_provides[k]) {
+ for (provider = conflictee_provides; provider && *provider; provider++) {
+ if (possibility == *provider) {
return 1;
}
}
return resized;
}
+abstract_pkg_t **init_providelist(pkg_t *pkg, int *count)
+{
+ abstract_pkg_t *ab_pkg;
+ abstract_pkg_t **provides = pkg_get_ptr(pkg, PKG_PROVIDES);
+
+ if (!provides) {
+ provides = calloc(2, sizeof(abstract_pkg_t *));
+
+ if (!provides) {
+ if (count)
+ *count = 0;
+
+ return NULL;
+ }
+
+ ab_pkg = ensure_abstract_pkg_by_name(pkg->name);
+
+ if (!ab_pkg->pkgs)
+ ab_pkg->pkgs = pkg_vec_alloc();
+
+ abstract_pkg_vec_insert(ab_pkg->provided_by, ab_pkg);
+
+ provides[0] = ab_pkg;
+ provides[1] = NULL;
+
+ if (count)
+ *count = 2;
+
+ pkg_set_ptr(pkg, PKG_PROVIDES, provides);
+ }
+ else if (count) {
+ for (*count = 1; *provides; provides++)
+ (*count)++;
+ }
+
+ return provides;
+}
+
+void parse_providelist(pkg_t *pkg, char *list)
+{
+ int count = 0;
+ char *item, *tok;
+ abstract_pkg_t *ab_pkg, *provided_abpkg, **tmp, **provides;
+
+ provides = init_providelist(pkg, &count);
+ ab_pkg = ensure_abstract_pkg_by_name(pkg->name);
+
+ if (!provides || !ab_pkg)
+ return;
+
+ for (item = strtok_r(list, ", ", &tok); item;
+ count++, item = strtok_r(NULL, ", ", &tok)) {
+ tmp = realloc(provides, sizeof(abstract_pkg_t *) * (count + 1));
+
+ if (!tmp)
+ break;
+
+ provided_abpkg = ensure_abstract_pkg_by_name(item);
+
+ abstract_pkg_vec_insert(provided_abpkg->provided_by, ab_pkg);
+
+ provides = tmp;
+ provides[count - 1] = provided_abpkg;
+ }
+
+ provides[count - 1] = NULL;
+
+ pkg_set_ptr(pkg, PKG_PROVIDES, provides);
+}
+
+void parse_replacelist(pkg_t *pkg, char *list)
+{
+ int count;
+ char *item, *tok;
+ abstract_pkg_t *ab_pkg, *old_abpkg, **tmp, **replaces = NULL;
+
+ ab_pkg = ensure_abstract_pkg_by_name(pkg->name);
+
+ if (!ab_pkg->pkgs)
+ ab_pkg->pkgs = pkg_vec_alloc();
+
+ abstract_pkg_vec_insert(ab_pkg->provided_by, ab_pkg);
+
+ for (count = 1, item = strtok_r(list, ", ", &tok);
+ item;
+ count++, item = strtok_r(NULL, ", ", &tok), count++) {
+ tmp = realloc(replaces, sizeof(abstract_pkg_t *) * (count + 1));
+
+ if (!tmp)
+ break;
+
+ old_abpkg = ensure_abstract_pkg_by_name(item);
+
+ if (!old_abpkg->replaced_by)
+ old_abpkg->replaced_by = abstract_pkg_vec_alloc();
+
+ /* if a package pkg both replaces and conflicts old_abpkg,
+ * then add it to the replaced_by vector so that old_abpkg
+ * will be upgraded to ab_pkg automatically */
+ if (pkg_conflicts_abstract(pkg, old_abpkg))
+ abstract_pkg_vec_insert(old_abpkg->replaced_by, ab_pkg);
+
+ replaces = tmp;
+ replaces[count - 1] = old_abpkg;
+ }
+
+ if (!replaces)
+ return;
+
+ replaces[count - 1] = NULL;
+
+ pkg_set_ptr(pkg, PKG_REPLACES, replaces);
+}
+
void buildProvides(abstract_pkg_t * ab_pkg, pkg_t * pkg)
{
+#if 0
int i;
/* every pkg provides itself */
}
if (pkg->provides_str)
free(pkg->provides_str);
+#endif
}
void buildConflicts(pkg_t * pkg)
{
+ /*
int i;
- compound_depend_t *conflicts;
+ compound_depend_t *conflicts, *conflict;
if (!pkg->conflicts_count)
return;
}
if (pkg->conflicts_str)
free(pkg->conflicts_str);
+ */
}
void buildReplaces(abstract_pkg_t * ab_pkg, pkg_t * pkg)
{
+#if 0
int i;
if (!pkg->replaces_count)
if (pkg->replaces_str)
free(pkg->replaces_str);
+#endif
+}
+
+void parse_deplist(pkg_t *pkg, enum depend_type type, char *list)
+{
+ int id, count;
+ char *item, *tok;
+ compound_depend_t *tmp, *deps;
+
+ switch (type)
+ {
+ case DEPEND:
+ case PREDEPEND:
+ case RECOMMEND:
+ case SUGGEST:
+ case GREEDY_DEPEND:
+ id = PKG_DEPENDS;
+ break;
+
+ case CONFLICTS:
+ id = PKG_CONFLICTS;
+ break;
+
+ default:
+ return;
+ }
+
+ deps = pkg_get_ptr(pkg, id);
+
+ for (tmp = deps, count = 1; tmp && tmp->type; tmp++)
+ count++;
+
+ for (item = strtok_r(list, ",", &tok); item; item = strtok_r(NULL, ",", &tok), count++) {
+ tmp = realloc(deps, sizeof(compound_depend_t) * (count + 1));
+
+ if (!tmp)
+ break;
+
+ deps = tmp;
+
+ memset(deps + count - 1, 0, sizeof(compound_depend_t));
+ parseDepends(deps + count - 1, item);
+
+ deps[count - 1].type = type;
+ }
+
+ if (!deps)
+ return;
+
+ memset(deps + count - 1, 0, sizeof(compound_depend_t));
+ pkg_set_ptr(pkg, id, deps);
}
void buildDepends(pkg_t * pkg)
{
+#if 0
unsigned int count;
int i;
compound_depend_t *depends;
}
if (pkg->suggests_str)
free(pkg->suggests_str);
+
+#endif
}
const char *constraint_to_str(enum version_constraint c)
int i;
unsigned int len;
char *str;
- compound_depend_t *cdep;
+ compound_depend_t *cdep = NULL, *p;
depend_t *dep;
+ for (i = 0, p = pkg_get_ptr(pkg, PKG_DEPENDS); p && p->type; i++, p++)
+ if (i == idx) {
+ cdep = p;
+ break;
+ }
+
+ if (!cdep)
+ return NULL;
+
len = 0;
- cdep = &pkg->depends[idx];
/* calculate string length */
for (i = 0; i < cdep->possibility_count; i++) {
void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg)
{
compound_depend_t *depends;
- int count, othercount;
- int i, j;
+ int othercount;
+ int j;
abstract_pkg_t *ab_depend;
abstract_pkg_t **temp;
- count = pkg->pre_depends_count +
- pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
-
- for (i = 0; i < count; i++) {
- depends = &pkg->depends[i];
+ for (depends = pkg_get_ptr(pkg, PKG_DEPENDS); depends && depends->type; depends++) {
if (depends->type != PREDEPEND
&& depends->type != DEPEND && depends->type != RECOMMEND)
continue;
static int parseDepends(compound_depend_t * compound_depend, char *depend_str)
{
- char *pkg_name, buffer[2048];
- unsigned int num_of_ors = 0;
int i;
- char *src, *dest;
- depend_t **possibilities;
-
- /* first count the number of ored possibilities for satisfying dependency */
- src = depend_str;
- while (*src)
- if (*src++ == '|')
- num_of_ors++;
+ char *depend, *name, *vstr, *rest, *tok = NULL;
+ depend_t **possibilities = NULL, **tmp;
compound_depend->type = DEPEND;
- compound_depend->possibility_count = num_of_ors + 1;
- possibilities = xcalloc((num_of_ors + 1), sizeof(depend_t *));
- compound_depend->possibilities = possibilities;
+ for (i = 0, depend = strtok_r(depend_str, "|", &tok); depend; i++, depend = strtok_r(NULL, "|", &tok)) {
+ name = strtok(depend, " ");
+ rest = strtok(NULL, "\n");
+
+ tmp = realloc(possibilities, sizeof(tmp) * (i + 1));
- src = depend_str;
- for (i = 0; i < num_of_ors + 1; i++) {
+ if (!tmp)
+ return -1;
+
+ possibilities = tmp;
possibilities[i] = depend_init();
- /* gobble up just the name first */
- dest = buffer;
- while (*src &&
- !isspace(*src) &&
- (*src != '(') && (*src != '*') && (*src != '|'))
- *dest++ = *src++;
- *dest = '\0';
- pkg_name = trim_xstrdup(buffer);
-
- /* now look at possible version info */
-
- /* skip to next chars */
- if (isspace(*src))
- while (*src && isspace(*src))
- src++;
-
- /* extract constraint and version */
- if (*src == '(') {
- src++;
- if (!strncmp(src, "<<", 2)) {
+ possibilities[i]->pkg = ensure_abstract_pkg_by_name(name);
+
+ if (rest && *rest == '(') {
+ vstr = strtok(rest + 1, ")");
+
+ if (!strncmp(vstr, "<<", 2)) {
possibilities[i]->constraint = EARLIER;
- src += 2;
- } else if (!strncmp(src, "<=", 2)) {
+ vstr += 2;
+ } else if (!strncmp(vstr, "<=", 2)) {
possibilities[i]->constraint = EARLIER_EQUAL;
- src += 2;
- } else if (!strncmp(src, ">=", 2)) {
+ vstr += 2;
+ } else if (!strncmp(vstr, ">=", 2)) {
possibilities[i]->constraint = LATER_EQUAL;
- src += 2;
- } else if (!strncmp(src, ">>", 2)) {
+ vstr += 2;
+ } else if (!strncmp(vstr, ">>", 2)) {
possibilities[i]->constraint = LATER;
- src += 2;
- } else if (!strncmp(src, "=", 1)) {
+ vstr += 2;
+ } else if (!strncmp(vstr, "=", 1)) {
possibilities[i]->constraint = EQUAL;
- src++;
+ vstr++;
}
/* should these be here to support deprecated designations; dpkg does */
- else if (!strncmp(src, "<", 1)) {
+ else if (!strncmp(vstr, "<", 1)) {
possibilities[i]->constraint = EARLIER_EQUAL;
- src++;
- } else if (!strncmp(src, ">", 1)) {
+ vstr++;
+ } else if (!strncmp(vstr, ">", 1)) {
possibilities[i]->constraint = LATER_EQUAL;
- src++;
+ vstr++;
}
- /* now we have any constraint, pass space to version string */
- while (isspace(*src))
- src++;
-
- /* this would be the version string */
- dest = buffer;
- while (*src && *src != ')')
- *dest++ = *src++;
- *dest = '\0';
-
- possibilities[i]->version = trim_xstrdup(buffer);
+ possibilities[i]->version = trim_xstrdup(vstr);
+ rest = strtok(NULL, " ");
+ }
+ else {
+ rest = strtok(rest, " ");
}
- /* hook up the dependency to its abstract pkg */
- possibilities[i]->pkg = ensure_abstract_pkg_by_name(pkg_name);
-
- free(pkg_name);
- /* now get past the ) and any possible | chars */
- while (*src &&
- (isspace(*src) || (*src == ')') || (*src == '|')))
- src++;
- if (*src == '*') {
+ if (rest && *rest == '*')
compound_depend->type = GREEDY_DEPEND;
- src++;
- }
}
+ compound_depend->possibility_count = i;
+ compound_depend->possibilities = possibilities;
+
return 0;
}
+
+compound_depend_t *pkg_get_depends(pkg_t *pkg, enum depend_type type)
+{
+ compound_depend_t *dep;
+
+ for (dep = pkg_get_ptr(pkg, PKG_DEPENDS); dep && dep->type; dep++)
+ if (type == UNSPEC || dep->type == type)
+ return dep;
+
+ return NULL;
+}
#include "pkg_hash.h"
enum depend_type {
+ UNSPEC,
PREDEPEND,
DEPEND,
CONFLICTS,
void buildReplaces(abstract_pkg_t * ab_pkg, pkg_t * pkg);
void buildDepends(pkg_t * pkg);
+void parse_deplist(pkg_t *pkg, enum depend_type type, char *list);
+
+abstract_pkg_t **init_providelist(pkg_t *pkg, int *count);
+void parse_providelist(pkg_t *pkg, char *list);
+
/**
* pkg_replaces returns 1 if pkg->replaces contains one of replacee's provides and 0
* otherwise.
int pkg_dependence_satisfied(depend_t * depend);
const char *constraint_to_str(enum version_constraint c);
+compound_depend_t *pkg_get_depends(pkg_t *pkg, enum depend_type type);
+
#endif
continue;
}
- if (!pkg_get_string(pkg, PKG_ARCHITECTURE) || !pkg->arch_priority) {
+ if (!pkg_get_string(pkg, PKG_ARCHITECTURE) ||
+ !pkg_get_int(pkg, PKG_ARCH_PRIORITY)) {
char *version_str = pkg_version_str_alloc(pkg);
opkg_msg(NOTICE, "Package %s version %s has no "
"valid architecture, ignoring.\n",
int nprovides = 0;
int nmatching = 0;
int wrong_arch_found = 0;
+ int arch_priority;
pkg_vec_t *matching_pkgs;
abstract_pkg_vec_t *matching_apkgs;
abstract_pkg_vec_t *provided_apkg_vec;
/* count packages matching max arch priority and keep track of last one */
for (j = 0; j < vec->len; j++) {
pkg_t *maybe = vec->pkgs[j];
+ arch_priority = pkg_get_int(maybe, PKG_ARCH_PRIORITY);
+
opkg_msg(DEBUG,
"%s arch=%s arch_priority=%d version=%s.\n",
maybe->name, pkg_get_string(maybe, PKG_ARCHITECTURE),
- maybe->arch_priority, pkg_get_string(maybe, PKG_VERSION));
+ arch_priority, pkg_get_string(maybe, PKG_VERSION));
/* We make sure not to add the same package twice. Need to search for the reason why
they show up twice sometimes. */
- if ((maybe->arch_priority > 0)
+ if ((arch_priority > 0)
&&
(!pkg_vec_contains(matching_pkgs, maybe))) {
max_count++;
int prio = 0;
for (i = 0; i < matching_pkgs->len; i++) {
pkg_t *matching = matching_pkgs->pkgs[i];
- if (matching->arch_priority > prio) {
+ arch_priority = pkg_get_int(matching, PKG_ARCH_PRIORITY);
+ if (arch_priority > prio) {
priorized_matching = matching;
- prio = matching->arch_priority;
+ prio = arch_priority;
opkg_msg(DEBUG, "Match %s with priority %i.\n",
matching->name, prio);
}
buildProvides(ab_pkg, pkg);
+ init_providelist(pkg, NULL);
+
/* Need to build the conflicts graph before replaces for correct
* calculation of replaced_by relation.
*/
#include "pkg.h"
#include "opkg_utils.h"
#include "pkg_parse.h"
+#include "pkg_depends.h"
#include "libbb/libbb.h"
#include "parse_util.h"
static void parse_conffiles(pkg_t * pkg, const char *cstr)
{
+ conffile_list_t *cl;
char file_name[1024], md5sum[85];
if (sscanf(cstr, "%1023s %84s", file_name, md5sum) != 2) {
return;
}
- conffile_list_append(&pkg->conffiles, file_name, md5sum);
+ cl = pkg_get_ptr(pkg, PKG_CONFFILES);
+
+ if (cl)
+ conffile_list_append(cl, file_name, md5sum);
}
int parse_version(pkg_t * pkg, const char *vstr)
vstr = ++colon;
}
- rev = strrchr(pkg_set_string(pkg, PKG_VERSION, vstr), '-');
+ rev = strrchr(vstr, '-');
if (rev) {
*rev++ = '\0';
- pkg_set_ptr(pkg, PKG_REVISION, rev);
+ pkg_set_string(pkg, PKG_REVISION, rev);
}
+ pkg_set_string(pkg, PKG_VERSION, vstr);
+
return 0;
}
int pkg_parse_line(void *ptr, const char *line, uint mask)
{
pkg_t *pkg = (pkg_t *) ptr;
+ abstract_pkg_t *ab_pkg = NULL;
/* these flags are a bit hackish... */
static int reading_conffiles = 0, reading_description = 0;
switch (*line) {
case 'A':
if ((mask & PFM_ARCHITECTURE) && is_field("Architecture", line)) {
- pkg->arch_priority = get_arch_priority(
- pkg_set_string(pkg, PKG_ARCHITECTURE, line + strlen("Architecture") + 1));
+ pkg_set_int(pkg, PKG_ARCH_PRIORITY, get_arch_priority(
+ pkg_set_string(pkg, PKG_ARCHITECTURE, line + strlen("Architecture") + 1)));
} else if ((mask & PFM_AUTO_INSTALLED)
&& is_field("Auto-Installed", line)) {
goto dont_reset_flags;
} else if ((mask & PFM_CONFLICTS)
&& is_field("Conflicts", line))
- pkg->conflicts_str =
- parse_list(line, &pkg->conflicts_count, ',', 0);
+ parse_deplist(pkg, CONFLICTS, line + strlen("Conflicts") + 1);
break;
case 'D':
reading_description = 1;
goto dont_reset_flags;
} else if ((mask & PFM_DEPENDS) && is_field("Depends", line))
- pkg->depends_str =
- parse_list(line, &pkg->depends_count, ',', 0);
+ parse_deplist(pkg, DEPEND, line + strlen("Depends") + 1);
break;
case 'E':
else if ((mask & PFM_PRIORITY) && is_field("Priority", line))
pkg_set_string(pkg, PKG_PRIORITY, line + strlen("Priority") + 1);
else if ((mask & PFM_PROVIDES) && is_field("Provides", line))
- pkg->provides_str =
- parse_list(line, &pkg->provides_count, ',', 0);
+ parse_providelist(pkg, line + strlen("Provides") + 1);
else if ((mask & PFM_PRE_DEPENDS)
&& is_field("Pre-Depends", line))
- pkg->pre_depends_str =
- parse_list(line, &pkg->pre_depends_count, ',', 0);
+ parse_deplist(pkg, PREDEPEND, line + strlen("Pre-Depends") + 1);
break;
case 'R':
if ((mask & PFM_RECOMMENDS) && is_field("Recommends", line))
- pkg->recommends_str =
- parse_list(line, &pkg->recommends_count, ',', 0);
+ parse_deplist(pkg, RECOMMEND, line + strlen("Recommends") + 1);
else if ((mask & PFM_REPLACES) && is_field("Replaces", line))
- pkg->replaces_str =
- parse_list(line, &pkg->replaces_count, ',', 0);
-
+ parse_replacelist(pkg, line + strlen("Replaces") + 1);
break;
case 'S':
else if ((mask & PFM_STATUS) && is_field("Status", line))
parse_status(pkg, line);
else if ((mask & PFM_SUGGESTS) && is_field("Suggests", line))
- pkg->suggests_str =
- parse_list(line, &pkg->suggests_count, ',', 0);
+ parse_deplist(pkg, SUGGEST, line + strlen("Suggests") + 1);
break;
case 'T':
projects / oweals / opkg-lede.git / commitdiff