X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fpkg_depends.c;h=1e14d1fb412485707d52c574b99c16d4b614fc4b;hp=6ce9fdd3c8e2aeca37605ee62e46f9110a4e0d80;hb=ac2222f7d6514fb403ce0848f6812a22a48f75c7;hpb=11af232b19155c76002b5ca1f2b0e89d75699d3a diff --git a/libopkg/pkg_depends.c b/libopkg/pkg_depends.c index 6ce9fdd..1e14d1f 100644 --- a/libopkg/pkg_depends.c +++ b/libopkg/pkg_depends.c @@ -1,7 +1,7 @@ /* pkg_depends.c - the opkg package management system Steven M. Ayer - + Copyright (C) 2002 Compaq Computer Corporation This program is free software; you can redistribute it and/or @@ -15,10 +15,9 @@ General Public License for more details. */ -#include "includes.h" -#include +#include #include - + #include "pkg.h" #include "opkg_utils.h" #include "pkg_hash.h" @@ -27,9 +26,8 @@ #include "hash_table.h" #include "libbb/libbb.h" -static int parseDepends(compound_depend_t *compound_depend, hash_table_t * hash, char * depend_str); +static int parseDepends(compound_depend_t *compound_depend, char * depend_str); static depend_t * depend_init(void); -static void depend_deinit(depend_t *d); static char ** add_unresolved_dep(pkg_t * pkg, char ** the_lost, int ref_ndx); static char ** merge_unresolved(char ** oldstuff, char ** newstuff); static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg); @@ -52,9 +50,10 @@ static int pkg_constraint_satisfied(pkg_t *pkg, void *cdata) return 0; } -/* returns ndependences or negative error value */ -int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, - pkg_vec_t *unsatisfied, char *** unresolved) +/* returns ndependencies or negative error value */ +int +pkg_hash_fetch_unsatisfied_dependencies(pkg_t * pkg, pkg_vec_t *unsatisfied, + char *** unresolved) { pkg_t * satisfier_entry_pkg; int i, j, k; @@ -62,19 +61,19 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, char ** the_lost; abstract_pkg_t * ab_pkg; - /* - * this is a setup to check for redundant/cyclic dependency checks, + /* + * this is a setup to check for redundant/cyclic dependency checks, * which are marked at the abstract_pkg level */ if (!(ab_pkg = pkg->parent)) { - fprintf(stderr, "%s:%d: something terribly wrong with pkg %s\n", __FUNCTION__, __LINE__, pkg->name); + opkg_msg(ERROR, "Internal error, with pkg %s.\n", pkg->name); *unresolved = NULL; return 0; } if (ab_pkg->dependencies_checked) { /* avoid duplicate or cyclic checks */ *unresolved = NULL; return 0; - } else { + } else { ab_pkg->dependencies_checked = 1; /* mark it for subsequent visits */ } /**/ @@ -86,7 +85,7 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, } the_lost = NULL; - + /* foreach dependency */ for (i = 0; i < count; i++) { compound_depend_t * compound_depend = &pkg->depends[i]; @@ -101,7 +100,7 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, abstract_pkg_t *abpkg = possible_satisfiers[j]->pkg; abstract_pkg_vec_t *ab_provider_vec = abpkg->provided_by; int nposs = ab_provider_vec->len; - abstract_pkg_t **ab_providers = ab_provider_vec->pkgs; + abstract_pkg_t **ab_providers = ab_provider_vec->pkgs; int l; for (l = 0; l < nposs; l++) { pkg_vec_t *test_vec = ab_providers[l]->pkgs; @@ -109,7 +108,7 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, if (!test_vec){ /* no pkg_vec hooked up to the abstract_pkg! (need another feed?) */ continue; } - + /* cruise this possiblity's pkg_vec looking for an installed version */ for (k = 0; k < test_vec->len; k++) { pkg_t *pkg_scout = test_vec->pkgs[k]; @@ -121,29 +120,38 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, int rc; pkg_vec_t *tmp_vec = pkg_vec_alloc (); /* check for not-already-installed dependencies */ - rc = pkg_hash_fetch_unsatisfied_dependencies(conf, - pkg_scout, + rc = pkg_hash_fetch_unsatisfied_dependencies(pkg_scout, tmp_vec, &newstuff); if (newstuff == NULL) { - int i; + int m; int ok = 1; - for (i = 0; i < rc; i++) { - pkg_t *p = tmp_vec->pkgs[i]; + for (m = 0; m < rc; m++) { + pkg_t *p = tmp_vec->pkgs[m]; if (p->state_want == SW_INSTALL) continue; - opkg_message(conf, OPKG_DEBUG, "not installing %s due to requirement for %s\n", pkg_scout->name, p->name); + opkg_msg(DEBUG, + "Not installing %s due" + " to requirement for %s.\n", + pkg_scout->name, + p->name); ok = 0; break; } pkg_vec_free (tmp_vec); if (ok) { /* mark this one for installation */ - opkg_message(conf, OPKG_NOTICE, "Adding satisfier for greedy dependence: %s\n", pkg_scout->name); + opkg_msg(NOTICE, + "Adding satisfier for greedy" + " dependence %s.\n", + pkg_scout->name); pkg_vec_insert(unsatisfied, pkg_scout); } } else { - opkg_message(conf, OPKG_DEBUG, "not installing %s due to broken depends \n", pkg_scout->name); + opkg_msg(DEBUG, + "Not installing %s due to " + "broken depends.\n", + pkg_scout->name); free (newstuff); } } @@ -159,17 +167,17 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, /* foreach provided_by, which includes the abstract_pkg itself */ depend_t *dependence_to_satisfy = possible_satisfiers[j]; abstract_pkg_t *satisfying_apkg = possible_satisfiers[j]->pkg; - pkg_t *satisfying_pkg = - pkg_hash_fetch_best_installation_candidate(conf, satisfying_apkg, - pkg_installed_and_constraint_satisfied, - dependence_to_satisfy, 1, NULL); + pkg_t *satisfying_pkg = + pkg_hash_fetch_best_installation_candidate(satisfying_apkg, + pkg_installed_and_constraint_satisfied, + dependence_to_satisfy, 1); /* Being that I can't test constraing in pkg_hash, I will test it here */ if (satisfying_pkg != NULL) { if (!pkg_installed_and_constraint_satisfied ( satisfying_pkg,dependence_to_satisfy)) { satisfying_pkg = NULL; } } - opkg_message(conf, OPKG_DEBUG, "%s:%d: satisfying_pkg=%p \n", __FILE__, __LINE__, satisfying_pkg); + opkg_msg(DEBUG, "satisfying_pkg=%p\n", satisfying_pkg); if (satisfying_pkg != NULL) { found = 1; break; @@ -183,10 +191,10 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, /* foreach provided_by, which includes the abstract_pkg itself */ depend_t *dependence_to_satisfy = possible_satisfiers[j]; abstract_pkg_t *satisfying_apkg = possible_satisfiers[j]->pkg; - pkg_t *satisfying_pkg = - pkg_hash_fetch_best_installation_candidate(conf, satisfying_apkg, - pkg_constraint_satisfied, - dependence_to_satisfy, 1, NULL); + pkg_t *satisfying_pkg = + pkg_hash_fetch_best_installation_candidate(satisfying_apkg, + pkg_constraint_satisfied, + dependence_to_satisfy, 1); /* Being that I can't test constraing in pkg_hash, I will test it here too */ if (satisfying_pkg != NULL) { if (!pkg_constraint_satisfied ( satisfying_pkg,dependence_to_satisfy)) { @@ -198,12 +206,13 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, if (satisfying_pkg != NULL && (compound_depend->type == RECOMMEND || compound_depend->type == SUGGEST) && (satisfying_pkg->state_want == SW_DEINSTALL || satisfying_pkg->state_want == SW_PURGE)) { - opkg_message (conf, OPKG_NOTICE, "%s: ignoring recommendation for %s at user request\n", - pkg->name, satisfying_pkg->name); + opkg_msg(NOTICE, "%s: ignoring recommendation for " + "%s at user request\n", + pkg->name, satisfying_pkg->name); continue; } - opkg_message(conf, OPKG_DEBUG, "%s:%d: satisfying_pkg=%p\n", __FILE__, __LINE__, satisfying_pkg); + opkg_msg(DEBUG, "satisfying_pkg=%p\n", satisfying_pkg); if (satisfying_pkg != NULL) { satisfier_entry_pkg = satisfying_pkg; break; @@ -218,25 +227,28 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, if (compound_depend->type != RECOMMEND && compound_depend->type != SUGGEST) the_lost = add_unresolved_dep(pkg, the_lost, i); else - opkg_message (conf, OPKG_NOTICE, "%s: unsatisfied recommendation for %s\n", - pkg->name, compound_depend->possibilities[0]->pkg->name); + opkg_msg(NOTICE, + "%s: unsatisfied recommendation for %s\n", + pkg->name, + compound_depend->possibilities[0]->pkg->name); } else { if (compound_depend->type == SUGGEST) { /* just mention it politely */ - opkg_message (conf, OPKG_NOTICE, "package %s suggests installing %s\n", - pkg->name, satisfier_entry_pkg->name); + opkg_msg(NOTICE, "package %s suggests installing %s\n", + pkg->name, satisfier_entry_pkg->name); } else { char ** newstuff = NULL; - + 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(conf, - satisfier_entry_pkg, + pkg_hash_fetch_unsatisfied_dependencies(satisfier_entry_pkg, unsatisfied, &newstuff); the_lost = merge_unresolved(the_lost, newstuff); + if (newstuff) + free(newstuff); } } } @@ -247,12 +259,13 @@ int pkg_hash_fetch_unsatisfied_dependencies(opkg_conf_t *conf, pkg_t * pkg, return unsatisfied->len; } -/*checking for conflicts !in replaces - If a packages conflicts with another but is also replacing it, I should not consider it a - really conflicts - returns 0 if conflicts <> replaces or 1 if conflicts == replaces +/*checking for conflicts !in replaces + If a packages conflicts with another but is also replacing it, I should not consider it a + really conflicts + returns 0 if conflicts <> replaces or 1 if conflicts == replaces */ -int is_pkg_a_replaces(pkg_t *pkg_scout,pkg_t *pkg) +static int +is_pkg_a_replaces(pkg_t *pkg_scout,pkg_t *pkg) { int i ; int replaces_count = pkg->replaces_count; @@ -265,7 +278,8 @@ int is_pkg_a_replaces(pkg_t *pkg_scout,pkg_t *pkg) for (i = 0; i < replaces_count; i++) { if (strcmp(pkg_scout->name,pkg->replaces[i]->name)==0) { // Found - opkg_message(NULL, OPKG_DEBUG2, "Seems I've found a replace %s %s \n",pkg_scout->name,pkg->replaces[i]->name); + opkg_msg(DEBUG2, "Seems I've found a replace %s %s\n", + pkg_scout->name, pkg->replaces[i]->name); return 1; } } @@ -274,8 +288,7 @@ int is_pkg_a_replaces(pkg_t *pkg_scout,pkg_t *pkg) } -/* Abhaya: added support for conflicts */ -pkg_vec_t * pkg_hash_fetch_conflicts(hash_table_t * hash, pkg_t * pkg) +pkg_vec_t * pkg_hash_fetch_conflicts(pkg_t * pkg) { pkg_vec_t * installed_conflicts, * test_vec; compound_depend_t * conflicts; @@ -284,15 +297,15 @@ pkg_vec_t * pkg_hash_fetch_conflicts(hash_table_t * hash, pkg_t * pkg) int i, j, k; int count; abstract_pkg_t * ab_pkg; - pkg_t **pkg_scouts; - pkg_t *pkg_scout; + pkg_t **pkg_scouts; + pkg_t *pkg_scout; - /* - * this is a setup to check for redundant/cyclic dependency checks, + /* + * this is a setup to check for redundant/cyclic dependency checks, * which are marked at the abstract_pkg level */ if(!(ab_pkg = pkg->parent)){ - fprintf(stderr, "dependency check error. pkg %s isn't in hash table\n", pkg->name); + opkg_msg(ERROR, "Internal error: %s not in hash table\n", pkg->name); return (pkg_vec_t *)NULL; } @@ -315,9 +328,9 @@ pkg_vec_t * pkg_hash_fetch_conflicts(hash_table_t * hash, pkg_t * pkg) for(j = 0; j < conflicts->possibility_count; j++){ possible_satisfier = possible_satisfiers[j]; if (!possible_satisfier) - fprintf(stderr, "%s:%d: possible_satisfier is null\n", __FUNCTION__, __LINE__); + opkg_msg(ERROR, "Internal error: possible_satisfier=NULL\n"); if (!possible_satisfier->pkg) - fprintf(stderr, "%s:%d: possible_satisfier->pkg is null\n", __FUNCTION__, __LINE__); + opkg_msg(ERROR, "Internal error: possible_satisfier->pkg=NULL\n"); test_vec = possible_satisfier->pkg->pkgs; if (test_vec) { /* pkg_vec found, it is an actual package conflict @@ -326,8 +339,8 @@ pkg_vec_t * pkg_hash_fetch_conflicts(hash_table_t * hash, pkg_t * pkg) for(k = 0; k < test_vec->len; k++){ pkg_scout = pkg_scouts[k]; if (!pkg_scout) { - fprintf(stderr, "%s: null pkg scout\n", __FUNCTION__); - continue; + opkg_msg(ERROR, "Internal error: pkg_scout=NULL\n"); + continue; } if ((pkg_scout->state_status == SS_INSTALLED || pkg_scout->state_want == SW_INSTALL) && version_constraints_satisfied(possible_satisfier, pkg_scout) && !is_pkg_a_replaces(pkg_scout,pkg)){ @@ -357,39 +370,39 @@ int version_constraints_satisfied(depend_t * depends, pkg_t * pkg) temp = pkg_new(); - parseVersion(temp, depends->version); + parse_version(temp, depends->version); comparison = pkg_compare_versions(pkg, temp); free (temp->version); free(temp); - if((depends->constraint == EARLIER) && + if((depends->constraint == EARLIER) && (comparison < 0)) return 1; - else if((depends->constraint == LATER) && + else if((depends->constraint == LATER) && (comparison > 0)) return 1; else if(comparison == 0) return 1; - else if((depends->constraint == LATER_EQUAL) && + else if((depends->constraint == LATER_EQUAL) && (comparison >= 0)) return 1; - else if((depends->constraint == EARLIER_EQUAL) && + else if((depends->constraint == EARLIER_EQUAL) && (comparison <= 0)) return 1; - + return 0; } -int pkg_dependence_satisfiable(opkg_conf_t *conf, depend_t *depend) +int pkg_dependence_satisfiable(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; pkg_vec_t *pkg_vec; - int n_pkgs ; + int n_pkgs ; int i; int j; @@ -409,7 +422,7 @@ int pkg_dependence_satisfiable(opkg_conf_t *conf, depend_t *depend) return 0; } -int pkg_dependence_satisfied(opkg_conf_t *conf, depend_t *depend) +int pkg_dependence_satisfied(depend_t *depend) { abstract_pkg_t *apkg = depend->pkg; abstract_pkg_vec_t *provider_apkgs = apkg->provided_by; @@ -449,47 +462,6 @@ static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg) return 0; } - -#ifdef DeadCode -/** - * pkg_has_common_provides returns 1 if pkg and replacee both provide - * the same abstract package and 0 otherwise. - */ -int pkg_has_common_provides(pkg_t *pkg, pkg_t *replacee) -{ - abstract_pkg_t **provides = pkg->provides; - int provides_count = pkg->provides_count; - abstract_pkg_t **replacee_provides = replacee->provides; - int replacee_provides_count = replacee->provides_count; - int i, j; - for (i = 0; i < provides_count; i++) { - abstract_pkg_t *apkg = provides[i]; - for (j = 0; j < replacee_provides_count; j++) { - abstract_pkg_t *replacee_apkg = replacee_provides[i]; - if (apkg == replacee_apkg) - return 1; - } - } - return 0; -} -#endif - -/** - * pkg_provides_abstract returns 1 if pkg->provides contains providee - * and 0 otherwise. - */ -int pkg_provides_abstract(pkg_t *pkg, abstract_pkg_t *providee) -{ - abstract_pkg_t **provides = pkg->provides; - int provides_count = pkg->provides_count; - int i; - for (i = 0; i < provides_count; i++) { - if (provides[i] == providee) - return 1; - } - return 0; -} - /** * pkg_replaces returns 1 if pkg->replaces contains one of replacee's provides and 0 * otherwise. @@ -498,14 +470,11 @@ int pkg_replaces(pkg_t *pkg, pkg_t *replacee) { abstract_pkg_t **replaces = pkg->replaces; int replaces_count = pkg->replaces_count; - /* abstract_pkg_t **replacee_provides = pkg->provides; - int replacee_provides_count = pkg->provides_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 < replaces_count; j++) { - /* opkg_message(NULL, OPKG_DEBUG2, "Searching pkg-name %s repprovname %s absrepname %s \n", - pkg->name,replacee->provides[j]->name, abstract_replacee->name); */ + for (j = 0; j < replacee_provides_count; j++) { if (replacee->provides[j] == abstract_replacee) return 1; } @@ -573,333 +542,293 @@ static char ** merge_unresolved(char ** oldstuff, char ** newstuff) if(!newstuff) return oldstuff; - + while(oldstuff && oldstuff[oldlen]) oldlen++; while(newstuff && newstuff[newlen]) newlen++; - - result = (char **)realloc(oldstuff, sizeof(char *) * (oldlen + newlen + 1)); - if (result == NULL) { - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return NULL; - } - + + result = xrealloc(oldstuff, sizeof(char *) * (oldlen + newlen + 1)); + for(i = oldlen, j = 0; i < (oldlen + newlen); i++, j++) *(result + i) = *(newstuff + j); - + *(result + i) = NULL; return result; } - -/* + +/* * a kinda kludgy way to back out depends str from two different arrays (reg'l'r 'n pre) - * this is null terminated, no count is carried around + * this is null terminated, no count is carried around */ char ** add_unresolved_dep(pkg_t * pkg, char ** the_lost, int ref_ndx) { int count; char ** resized; - char *depend_str = pkg_depend_str(pkg, ref_ndx); count = 0; while(the_lost && the_lost[count]) count++; count++; /* need one to hold the null */ - resized = (char **)realloc(the_lost, sizeof(char *) * (count + 1)); - if (resized == NULL) { - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return NULL; - } - resized[count - 1] = xstrdup(depend_str); + resized = xrealloc(the_lost, sizeof(char *) * (count + 1)); + resized[count - 1] = pkg_depend_str(pkg, ref_ndx); resized[count] = NULL; - + return resized; } - -void printDepends(pkg_t * pkg) -{ - int i, j; - compound_depend_t * depend; - int count; - - count = pkg->pre_depends_count + pkg->depends_count; - - depend = pkg->depends; - if(!depend){ - fprintf(stderr, "Depends pointer is NULL\n"); - return; - } - for(i = 0; i < count; i++){ - fprintf(stderr, "%s has %d possibilities:\n", - (depend->type == GREEDY_DEPEND) ? "Greedy-Depend" : ((depend->type == DEPEND) ? "Depend" : "Pre-Depend"), - depend->possibility_count); - for(j = 0; j < depend->possibility_count; j++) - fprintf(stderr, "\t%s version %s (%d)\n", - depend->possibilities[j]->pkg->name, - depend->possibilities[j]->version, - depend->possibilities[j]->constraint); - depend++; - } -} -int buildProvides(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg) +void buildProvides(abstract_pkg_t * ab_pkg, pkg_t * pkg) { - int i, j; + int i; /* every pkg provides itself */ + pkg->provides_count++; abstract_pkg_vec_insert(ab_pkg->provided_by, ab_pkg); - - if (!pkg->provides_count) - return 0; - if (pkg->provides) - return 0; - - pkg->provides = (abstract_pkg_t **)calloc((pkg->provides_count + 1), sizeof(abstract_pkg_t *)); - if (pkg->provides == NULL) { - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return -1 ; - } + pkg->provides = xcalloc(pkg->provides_count, sizeof(abstract_pkg_t *)); pkg->provides[0] = ab_pkg; - // if (strcmp(ab_pkg->name, pkg->name)) - // fprintf(stderr, __FUNCTION__ ": ab_pkg=%s pkg=%s\n", ab_pkg->name, pkg->name); - - for(i = 0; i < pkg->provides_count; i++){ - abstract_pkg_t *provided_abpkg = ensure_abstract_pkg_by_name(hash, pkg->provides_str[i]); + for (i=1; iprovides_count; i++) { + abstract_pkg_t *provided_abpkg = ensure_abstract_pkg_by_name( + pkg->provides_str[i-1]); + free(pkg->provides_str[i-1]); - pkg->provides[i+1] = provided_abpkg; + pkg->provides[i] = provided_abpkg; - j = 0; abstract_pkg_vec_insert(provided_abpkg->provided_by, ab_pkg); } - return 0; + if (pkg->provides_str) + free(pkg->provides_str); } -/* Abhaya: added conflicts support */ -int buildConflicts(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg) +void buildConflicts(pkg_t * pkg) { int i; compound_depend_t * conflicts; if (!pkg->conflicts_count) - return 0; + return; - conflicts = pkg->conflicts = calloc(pkg->conflicts_count, sizeof(compound_depend_t)); - if (conflicts == NULL) { - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return -1; - } + conflicts = pkg->conflicts = xcalloc(pkg->conflicts_count, sizeof(compound_depend_t)); for (i = 0; i < pkg->conflicts_count; i++) { conflicts->type = CONFLICTS; - parseDepends(conflicts, hash, - pkg->conflicts_str[i]); + parseDepends(conflicts, pkg->conflicts_str[i]); + free(pkg->conflicts_str[i]); conflicts++; } - return 0; + if (pkg->conflicts_str) + free(pkg->conflicts_str); } -int buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg) +void buildReplaces(abstract_pkg_t * ab_pkg, pkg_t * pkg) { - int i, j; + int i; if (!pkg->replaces_count) - return 0; + return; - pkg->replaces = (abstract_pkg_t **)calloc(pkg->replaces_count, sizeof(abstract_pkg_t *)); - if (pkg->replaces == NULL) { - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return -1; - } + pkg->replaces = xcalloc(pkg->replaces_count, sizeof(abstract_pkg_t *)); for(i = 0; i < pkg->replaces_count; i++){ - abstract_pkg_t *old_abpkg = ensure_abstract_pkg_by_name(hash, pkg->replaces_str[i]); + abstract_pkg_t *old_abpkg = ensure_abstract_pkg_by_name(pkg->replaces_str[i]); pkg->replaces[i] = old_abpkg; + free(pkg->replaces_str[i]); - j = 0; if (!old_abpkg->replaced_by) old_abpkg->replaced_by = abstract_pkg_vec_alloc(); - if ( old_abpkg->replaced_by == NULL ){ - return -1; - } /* 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); } - return 0; + + if (pkg->replaces_str) + free(pkg->replaces_str); } -int buildDepends(hash_table_t * hash, pkg_t * pkg) +void buildDepends(pkg_t * pkg) { - int count; + unsigned int count; int i; compound_depend_t * depends; if(!(count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count)) - return 0; + return; - if (0 && pkg->pre_depends_count) - fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n", - pkg->name, pkg->pre_depends_count, pkg->depends_count); - depends = pkg->depends = calloc(count, sizeof(compound_depend_t)); - if (depends == NULL) { - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return -1; - } - + depends = pkg->depends = xcalloc(count, sizeof(compound_depend_t)); for(i = 0; i < pkg->pre_depends_count; i++){ - parseDepends(depends, hash, pkg->pre_depends_str[i]); - if (0 && pkg->pre_depends_count) - fprintf(stderr, " pre_depends_str=%s depends=%p possibility_count=%x\n", - pkg->pre_depends_str[i], depends, depends->possibility_count); + parseDepends(depends, pkg->pre_depends_str[i]); + free(pkg->pre_depends_str[i]); depends->type = PREDEPEND; depends++; } + if (pkg->pre_depends_str) + free(pkg->pre_depends_str); + + for(i = 0; i < pkg->depends_count; i++){ + parseDepends(depends, pkg->depends_str[i]); + free(pkg->depends_str[i]); + depends++; + } + if (pkg->depends_str) + free(pkg->depends_str); for(i = 0; i < pkg->recommends_count; i++){ - parseDepends(depends, hash, pkg->recommends_str[i]); - if (0 && pkg->recommends_count) - fprintf(stderr, " recommends_str=%s depends=%p possibility_count=%x\n", - pkg->recommends_str[i], depends, depends->possibility_count); + parseDepends(depends, pkg->recommends_str[i]); + free(pkg->recommends_str[i]); depends->type = RECOMMEND; depends++; } + if(pkg->recommends_str) + free(pkg->recommends_str); for(i = 0; i < pkg->suggests_count; i++){ - parseDepends(depends, hash, pkg->suggests_str[i]); - if (0 && pkg->suggests_count) - fprintf(stderr, " suggests_str=%s depends=%p possibility_count=%x\n", - pkg->suggests_str[i], depends, depends->possibility_count); + parseDepends(depends, pkg->suggests_str[i]); + free(pkg->suggests_str[i]); depends->type = SUGGEST; depends++; } + if(pkg->suggests_str) + free(pkg->suggests_str); +} - for(i = 0; i < pkg->depends_count; i++){ - parseDepends(depends, hash, pkg->depends_str[i]); - if (0 && pkg->depends_count) - fprintf(stderr, " depends_str=%s depends=%p possibility_count=%x\n", - pkg->depends_str[i], depends, depends->possibility_count); - depends++; - } - return 0; -} +const char* +constraint_to_str(enum version_constraint c) +{ + switch (c) { + case NONE: + return ""; + case EARLIER: + return "< "; + case EARLIER_EQUAL: + return "<= "; + case EQUAL: + return "= "; + case LATER_EQUAL: + return ">= "; + case LATER: + return "> "; + } + + return ""; +} /* - * pkg_depend_string: returns the depends string specified by index. - * All 4 kinds of dependences: dependence, pre-dependence, recommend, and suggest are number starting from 0. - * [0,npredepends) -> returns pre_depends_str[index] - * [npredepends,npredepends+nrecommends) -> returns recommends_str[index] - * [npredepends+nrecommends,npredepends+nrecommends+nsuggests) -> returns recommends_str[index] - * [npredepends+nrecommends+nsuggests,npredepends+nrecommends+nsuggests+ndepends) -> returns depends_str[index] + * Returns a printable string for pkg's dependency at the specified idx. The + * resultant string must be passed to free() by the caller. */ -char *pkg_depend_str(pkg_t *pkg, int index) +char * +pkg_depend_str(pkg_t *pkg, int idx) { - if (index < pkg->pre_depends_count) { - return pkg->pre_depends_str[index]; - } - index -= pkg->pre_depends_count; + int i; + unsigned int len; + char *str; + compound_depend_t *cdep; + depend_t *dep; - if (index < pkg->recommends_count) { - return pkg->recommends_str[index]; - } - index -= pkg->recommends_count; + len = 0; + cdep = &pkg->depends[idx]; - if (index < pkg->suggests_count) { - return pkg->suggests_str[index]; - } - index -= pkg->suggests_count; + /* calculate string length */ + for (i=0; ipossibility_count; i++) { + dep = cdep->possibilities[i]; - if (index < pkg->depends_count) { - return pkg->depends_str[index]; - } - fprintf(stderr, "pkg_depend_str: index %d out of range for pkg=%s\n", index, pkg->name); - return NULL; -} + if (i != 0) + len += 3; /* space, pipe, space */ -void freeDepends(pkg_t *pkg) -{ - int i; + len += strlen(dep->pkg->name); - if (pkg == NULL || pkg->depends == NULL) { - return; - } + if (dep->version) { + len += 2; /* space, left parenthesis */ + len += 3; /* constraint string (<=, >=, etc), space */ + len += strlen(dep->version); + len += 1; /* right parenthesis */ + } + } - fprintf(stderr, "Freeing depends=%p\n", pkg->depends); - for (i=0; i < pkg->depends->possibility_count; i++) { - depend_deinit(pkg->depends->possibilities[i]); - } - free(pkg->depends->possibilities); - free(pkg->depends); - pkg->depends = NULL; + str = xmalloc(len + 1); /* +1 for the NULL terminator */ + str[0] = '\0'; + + for (i=0; ipossibility_count; i++) { + dep = cdep->possibilities[i]; + + if (i != 0) + strncat(str, " | ", len); + + strncat(str, dep->pkg->name, len); + + if (dep->version) { + strncat(str, " (", len); + strncat(str, constraint_to_str(dep->constraint), len); + strncat(str, dep->version, len); + strncat(str, ")", len); + } + } + + return str; } void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg) { - compound_depend_t * depends; - int count, othercount; - int i, j; - abstract_pkg_t * ab_depend; - abstract_pkg_t ** temp; + compound_depend_t * depends; + int count, othercount; + int i, 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]; + if (depends->type != PREDEPEND + && depends->type != DEPEND + && depends->type != RECOMMEND) + continue; + for (j = 0; j < depends->possibility_count; j++) { + ab_depend = depends->possibilities[j]->pkg; + if (!ab_depend->depended_upon_by) { + ab_depend->depended_upon_by = + xcalloc(1, sizeof(abstract_pkg_t *)); + } - count = pkg->pre_depends_count + pkg->depends_count; - depends = pkg->depends; + temp = ab_depend->depended_upon_by; + othercount = 1; + while (*temp) { + temp++; + othercount++; + } + *temp = ab_pkg; - if (0 && pkg->pre_depends_count) - fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n", - pkg->name, pkg->pre_depends_count, pkg->depends_count); - for (i = 0; i < count; i++) { - if (0 && pkg->pre_depends_count) - fprintf(stderr, " i=%d possibility_count=%x depends=%p\n", i, depends->possibility_count, depends); - for (j = 0; j < depends->possibility_count; j++){ - ab_depend = depends->possibilities[j]->pkg; - if(!ab_depend->depended_upon_by) - ab_depend->depended_upon_by = (abstract_pkg_t **)calloc(1, sizeof(abstract_pkg_t *)); - - temp = ab_depend->depended_upon_by; - othercount = 1; - while(*temp){ - temp++; - othercount++; - } - *temp = ab_pkg; + ab_depend->depended_upon_by = + xrealloc(ab_depend->depended_upon_by, + (othercount + 1) * sizeof(abstract_pkg_t *)); - ab_depend->depended_upon_by = (abstract_pkg_t **)realloc(ab_depend->depended_upon_by, - (othercount + 1) * sizeof(abstract_pkg_t *)); - /* the array may have moved */ - temp = ab_depend->depended_upon_by + othercount; - *temp = NULL; - } - depends++; - } + /* the array may have been moved by realloc */ + temp = ab_depend->depended_upon_by + othercount; + *temp = NULL; + } + } } static depend_t * depend_init(void) { - depend_t * d = (depend_t *)calloc(1, sizeof(depend_t)); - if ( d==NULL ){ - fprintf(stderr, "%s: out of memory\n", __FUNCTION__); - return NULL; - } + depend_t * d = xcalloc(1, sizeof(depend_t)); d->constraint = NONE; d->version = NULL; d->pkg = NULL; - - return d; -} -static void depend_deinit(depend_t *d) -{ - free(d); + return d; } -static int parseDepends(compound_depend_t *compound_depend, - hash_table_t * hash, char * depend_str) +static int parseDepends(compound_depend_t *compound_depend, + char * depend_str) { char * pkg_name, buffer[2048]; - int num_of_ors = 0; + unsigned int num_of_ors = 0; int i; char * src, * dest; depend_t ** possibilities; @@ -913,16 +842,12 @@ static int parseDepends(compound_depend_t *compound_depend, compound_depend->type = DEPEND; compound_depend->possibility_count = num_of_ors + 1; - possibilities = (depend_t **)calloc((num_of_ors + 1), sizeof(depend_t *) ); - if (!possibilities) - return -ENOMEM; + possibilities = xcalloc((num_of_ors + 1), sizeof(depend_t *) ); compound_depend->possibilities = possibilities; src = depend_str; for(i = 0; i < num_of_ors + 1; i++){ possibilities[i] = depend_init(); - if (!possibilities[i]) - return -ENOMEM; /* gobble up just the name first */ dest = buffer; while(*src && @@ -932,12 +857,10 @@ static int parseDepends(compound_depend_t *compound_depend, (*src != '|')) *dest++ = *src++; *dest = '\0'; - pkg_name = trim_alloc(buffer); - if (pkg_name == NULL ) - return -ENOMEM; - + pkg_name = trim_xstrdup(buffer); + /* now look at possible version info */ - + /* skip to next chars */ if(isspace(*src)) while(*src && isspace(*src)) src++; @@ -972,7 +895,7 @@ static int parseDepends(compound_depend_t *compound_depend, } else if(!strncmp(src, ">", 1)){ possibilities[i]->constraint = LATER_EQUAL; - src++; + src++; } /* now we have any constraint, pass space to version string */ @@ -983,20 +906,14 @@ static int parseDepends(compound_depend_t *compound_depend, while(*src && *src != ')') *dest++ = *src++; *dest = '\0'; - - possibilities[i]->version = trim_alloc(buffer); - /* fprintf(stderr, "let's print the depends version string:"); - fprintf(stderr, "version %s\n", possibilities[i]->version);*/ - if (possibilities[i]->version == NULL ) - return -ENOMEM; - - + + possibilities[i]->version = trim_xstrdup(buffer); } /* hook up the dependency to its abstract pkg */ - possibilities[i]->pkg = ensure_abstract_pkg_by_name(hash, pkg_name); + 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) ||