libopkg: implement lightweight package listing logic

[oweals/opkg-lede.git] / libopkg / pkg_depends.c

diff --git a/libopkg/pkg_depends.c b/libopkg/pkg_depends.c
index 0072e5e5290258d21612615e02b67016d8c923f8..3abdcd38c4436468bed71929c7114ceb3dfacdc9 100644 (file)
--- a/libopkg/pkg_depends.c
+++ b/libopkg/pkg_depends.c
@@ -250,9 +250,9 @@ pkg_hash_fetch_unsatisfied_dependencies(pkg_t * pkg, pkg_vec_t * unsatisfied,
                                        if (satisfier_entry_pkg != pkg &&
                                            !is_pkg_in_pkg_vec(unsatisfied, satisfier_entry_pkg))
                                        {
-                                               pkg_vec_insert(unsatisfied, satisfier_entry_pkg);
                                                pkg_hash_fetch_unsatisfied_dependencies(
                                                        satisfier_entry_pkg, unsatisfied, &newstuff);
+                                               pkg_vec_insert(unsatisfied, satisfier_entry_pkg);
                                                the_lost = merge_unresolved(the_lost, newstuff);
                                                if (newstuff)
                                                        free(newstuff);
@@ -422,34 +422,6 @@ int pkg_dependence_satisfiable(depend_t * depend)
        return 0;
 }
 
-int pkg_dependence_satisfied(depend_t * depend)
-{
-       abstract_pkg_t *apkg = depend->pkg;
-       abstract_pkg_vec_t *provider_apkgs = apkg->provided_by;
-       int n_providers = provider_apkgs->len;
-       abstract_pkg_t **apkgs = provider_apkgs->pkgs;
-       int i;
-       int n_pkgs;
-       int j;
-
-       for (i = 0; i < n_providers; i++) {
-               abstract_pkg_t *papkg = apkgs[i];
-               pkg_vec_t *pkg_vec = papkg->pkgs;
-               if (pkg_vec) {
-                       n_pkgs = pkg_vec->len;
-                       for (j = 0; j < n_pkgs; j++) {
-                               pkg_t *pkg = pkg_vec->pkgs[j];
-                               if (version_constraints_satisfied(depend, pkg)) {
-                                       if (pkg->state_status == SS_INSTALLED
-                                           || pkg->state_status == SS_UNPACKED)
-                                               return 1;
-                               }
-                       }
-               }
-       }
-       return 0;
-}
-
 static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg)
 {
        int i;
@@ -492,20 +464,14 @@ int pkg_replaces(pkg_t * pkg, pkg_t * replacee)
  */
 int pkg_conflicts_abstract(pkg_t * pkg, abstract_pkg_t * conflictee)
 {
-       compound_depend_t *conflicts, *conflict;
-
-       conflicts = pkg_get_ptr(pkg, PKG_CONFLICTS);
+       int i, j;
+       compound_depend_t *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) {
+       for (conflicts = pkg_get_ptr(pkg, PKG_CONFLICTS), i = 0; conflicts && conflicts[i].type; i++)
+               for (j = 0; j < conflicts[i].possibility_count; j++)
+                       if (conflicts[i].possibilities[j]->pkg == conflictee)
                                return 1;
-                       }
-               }
-       }
+
        return 0;
 }
 
@@ -515,27 +481,16 @@ int pkg_conflicts_abstract(pkg_t * pkg, abstract_pkg_t * conflictee)
  */
 int pkg_conflicts(pkg_t * pkg, pkg_t * conflictee)
 {
-       int j;
-       int possibility_count;
-       struct depend **possibilities;
-       compound_depend_t *conflicts, *conflict;
-       abstract_pkg_t **conflictee_provides, **provider, *possibility;
+       int i, j;
+       compound_depend_t *conflicts;
+       abstract_pkg_t **provider;
 
-       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 (provider = conflictee_provides; provider && *provider; provider++) {
-                               if (possibility == *provider) {
+       for (conflicts = pkg_get_ptr(pkg, PKG_CONFLICTS), i = 0; conflicts && conflicts[i].type; i++)
+               for (j = 0; j < conflicts[i].possibility_count; j++)
+                       for (provider = pkg_get_ptr(conflictee, PKG_PROVIDES); provider && *provider; provider++)
+                               if (conflicts[i].possibilities[j]->pkg == *provider)
                                        return 1;
-                               }
-                       }
-               }
-       }
+
        return 0;
 }
 
@@ -678,6 +633,14 @@ void parse_providelist(pkg_t *pkg, char *list)
 
                provided_abpkg = ensure_abstract_pkg_by_name(item);
 
+               if (provided_abpkg->state_flag & SF_NEED_DETAIL) {
+                       if (!(ab_pkg->state_flag & SF_NEED_DETAIL)) {
+                               opkg_msg(DEBUG, "propagating provided abpkg flag to "
+                                               "provider abpkg %s\n", ab_pkg->name);
+                               ab_pkg->state_flag |= SF_NEED_DETAIL;
+                       }
+               }
+
                if (!abstract_pkg_vec_contains(provided_abpkg->provided_by, ab_pkg))
                        abstract_pkg_vec_insert(provided_abpkg->provided_by, ab_pkg);
 
@@ -703,9 +666,8 @@ void parse_replacelist(pkg_t *pkg, char *list)
 
        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++) {
+       for (count = 1, item = strtok_r(list, ", ", &tok); item;
+            count++, item = strtok_r(NULL, ", ", &tok)) {
                tmp = realloc(replaces, sizeof(abstract_pkg_t *) * (count + 1));
 
                if (!tmp)
@@ -727,8 +689,10 @@ void parse_replacelist(pkg_t *pkg, char *list)
                /* 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);
+               if (pkg_conflicts_abstract(pkg, old_abpkg)) {
+                       if (!abstract_pkg_vec_contains(old_abpkg->replaced_by, ab_pkg))
+                               abstract_pkg_vec_insert(old_abpkg->replaced_by, ab_pkg);
+               }
 
                replaces = tmp;
                replaces[count - 1] = old_abpkg;