libopkg: implement pkg_hash_load_package_details() helper

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

diff --git a/libopkg/pkg_hash.c b/libopkg/pkg_hash.c
index 1b3fd05526144654b3c51c58f19676ec29a61fe6..3b49301ec488f028e682af95c2beebbfb45db546 100644 (file)
--- a/libopkg/pkg_hash.c
+++ b/libopkg/pkg_hash.c
@@ -79,7 +79,7 @@ int dist_hash_add_from_file(const char *lists_dir, pkg_src_t * dist)
                sprintf_alloc(&list_file, "%s/%s", lists_dir, subname);
 
                if (file_exists(list_file)) {
-                       if (pkg_hash_add_from_file(list_file, dist, NULL, 0)) {
+                       if (pkg_hash_add_from_file(list_file, dist, NULL, 0, 0)) {
                                free(list_file);
                                return -1;
                        }
@@ -95,7 +95,7 @@ int dist_hash_add_from_file(const char *lists_dir, pkg_src_t * dist)
 
 int
 pkg_hash_add_from_file(const char *file_name,
-                      pkg_src_t * src, pkg_dest_t * dest, int is_status_file)
+                      pkg_src_t * src, pkg_dest_t * dest, int is_status_file, int state_flags)
 {
        pkg_t *pkg;
        FILE *fp;
@@ -121,6 +121,7 @@ pkg_hash_add_from_file(const char *file_name,
                pkg = pkg_new();
                pkg->src = src;
                pkg->dest = dest;
+               pkg->state_flag |= state_flags;
 
                ret = parse_from_stream_nomalloc(pkg_parse_line, pkg, fp, 0,
                                                 &buf, len);
@@ -141,7 +142,7 @@ pkg_hash_add_from_file(const char *file_name,
                        continue;
                }
 
-               if (!pkg_get_string(pkg, PKG_ARCHITECTURE) || !pkg->arch_priority) {
+               if (!pkg_get_architecture(pkg) || !pkg_get_arch_priority(pkg)) {
                        char *version_str = pkg_version_str_alloc(pkg);
                        opkg_msg(NOTICE, "Package %s version %s has no "
                                 "valid architecture, ignoring.\n",
@@ -166,7 +167,7 @@ pkg_hash_add_from_file(const char *file_name,
 /*
  * Load in feed files from the cached "src" and/or "src/gz" locations.
  */
-int pkg_hash_load_feeds(void)
+int pkg_hash_load_feeds(int state_flags)
 {
        pkg_src_list_elt_t *iter;
        pkg_src_t *src, *subdist;
@@ -185,7 +186,7 @@ int pkg_hash_load_feeds(void)
                sprintf_alloc(&list_file, "%s/%s", lists_dir, src->name);
 
                if (file_exists(list_file)) {
-                       if (pkg_hash_add_from_file(list_file, src, NULL, 0)) {
+                       if (pkg_hash_add_from_file(list_file, src, NULL, 0, state_flags)) {
                                free(list_file);
                                return -1;
                        }
@@ -213,7 +214,7 @@ int pkg_hash_load_status_files(void)
 
                if (file_exists(dest->status_file_name)) {
                        if (pkg_hash_add_from_file
-                           (dest->status_file_name, NULL, dest, 1))
+                           (dest->status_file_name, NULL, dest, 1, SF_NEED_DETAIL))
                                return -1;
                }
        }
@@ -221,9 +222,44 @@ int pkg_hash_load_status_files(void)
        return 0;
 }
 
-static abstract_pkg_t *abstract_pkg_fetch_by_name(const char *pkg_name)
+static void
+pkg_hash_load_package_details_helper(const char *pkg_name, void *entry, void *data)
+{
+       int *count = data;
+       abstract_pkg_t *ab_pkg = (abstract_pkg_t *) entry;
+
+       if (ab_pkg->state_flag & SF_NEED_DETAIL) {
+               if (ab_pkg->state_flag & SF_MARKED) {
+                       opkg_msg(DEBUG, "skipping already seen flagged abpkg %s\n",
+                                ab_pkg->name);
+                       return;
+               }
+
+               opkg_msg(DEBUG, "found yet incomplete flagged abpkg %s\n",
+                        ab_pkg->name);
+
+               (*count)++;
+               ab_pkg->state_flag |= SF_MARKED;
+       }
+}
+
+int pkg_hash_load_package_details(void)
 {
-       return (abstract_pkg_t *) hash_table_get(&conf->pkg_hash, pkg_name);
+       int n_need_detail;
+
+       while (1) {
+               pkg_hash_load_feeds(0);
+
+               n_need_detail = 0;
+               hash_table_foreach(&conf->pkg_hash, pkg_hash_load_package_details_helper, &n_need_detail);
+
+               if (n_need_detail > 0)
+                       opkg_msg(DEBUG, "Found %d packages requiring details, reloading feeds\n", n_need_detail);
+               else
+                       break;
+       }
+
+       return 0;
 }
 
 pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
@@ -237,6 +273,7 @@ pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
        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;
@@ -317,13 +354,15 @@ pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
                        /* 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_arch_priority(maybe);
+
                                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));
+                                        maybe->name, pkg_get_architecture(maybe),
+                                        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++;
@@ -389,9 +428,10 @@ pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
                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_arch_priority(matching);
+                       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);
                        }
@@ -406,7 +446,7 @@ pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
                        pkg_t *matching = matching_pkgs->pkgs[i];
                        opkg_msg(INFO, "%s %s %s\n",
                                 matching->name, pkg_get_string(matching, PKG_VERSION),
-                                pkg_get_string(matching, PKG_ARCHITECTURE));
+                                pkg_get_architecture(matching));
                }
        }
 
@@ -432,7 +472,7 @@ pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
        if (priorized_matching) {
                opkg_msg(INFO, "Using priorized matching %s %s %s.\n",
                         priorized_matching->name, pkg_get_string(priorized_matching, PKG_VERSION),
-                        pkg_get_string(priorized_matching, PKG_ARCHITECTURE));
+                        pkg_get_architecture(priorized_matching));
                return priorized_matching;
        }
        if (nmatching > 1) {
@@ -443,7 +483,7 @@ pkg_t *pkg_hash_fetch_best_installation_candidate(abstract_pkg_t * apkg,
        if (latest_matching) {
                opkg_msg(INFO, "Using latest matching %s %s %s.\n",
                         latest_matching->name, pkg_get_string(latest_matching, PKG_VERSION),
-                        pkg_get_string(latest_matching, PKG_ARCHITECTURE));
+                        pkg_get_architecture(latest_matching));
                return latest_matching;
        }
        return NULL;
@@ -648,6 +688,8 @@ void hash_insert_pkg(pkg_t * pkg, int set_status)
 
        buildProvides(ab_pkg, pkg);
 
+       init_providelist(pkg, NULL);
+
        /* Need to build the conflicts graph before replaces for correct
         * calculation of replaced_by relation.
         */