pkg_vec_t *pkg_hash_fetch_conflicts(pkg_t * pkg)
{
pkg_vec_t *installed_conflicts;
abstract_pkg_t *ab_pkg;
/*
* this is a setup to check for redundant/cyclic dependency checks,
* which are marked at the abstract_pkg level
*/
ab_pkg = pkg->parent;
if (!ab_pkg) {
opkg_msg(ERROR, "Internal error: %s not in hash table\n", pkg->name);
return (pkg_vec_t *) NULL;
}
installed_conflicts = pkg_vec_alloc();
__pkg_hash_fetch_conflicts(pkg, installed_conflicts);
__pkg_hash_fetch_conflictees(pkg, installed_conflicts);
if (installed_conflicts->len)
return installed_conflicts;
pkg_vec_free(installed_conflicts);
return (pkg_vec_t *) NULL;
}
int main(int argc, char *argv[])
{
ipkg_conf_t conf;
hash_table_t *hash = &conf.pkg_hash;
pkg_vec_t * pkg_vec;
if (argc < 3) {
fprintf(stderr, "Usage: %s <pkgs_file1> <pkgs_file2> [pkg_name...]\n", argv[0]);
exit(1);
}
pkg_hash_init("test", hash, 1024);
pkg_hash_add_from_file(&conf, argv[1], NULL, NULL, 0);
pkg_hash_add_from_file(&conf, argv[2], NULL, NULL, 0);
if (argc < 4) {
pkg_print_info( pkg_hash_fetch_by_name_version(hash, "libc6", "2.2.3-2"), stdout);
/* for(i = 0; i < pkg_vec->len; i++)
pkg_print(pkg_vec->pkgs[i], stdout);
*/
} else {
int i, j, k;
char **unresolved;
pkg_vec_t * dep_vec;
for (i = 3; i < argc; i++) {
pkg_vec = pkg_vec_fetch_by_name(hash, argv[i]);
if (pkg_vec == NULL) {
fprintf(stderr, "*** WARNING: Unknown package: %s\n\n", argv[i]);
continue;
}
for(j = 0; j < pkg_vec->len; j++){
pkg_print_info(pkg_vec->pkgs[j], stdout);
dep_vec = pkg_vec_alloc();
pkg_hash_fetch_unsatisfied_dependencies(&conf,
pkg_vec->pkgs[j],
dep_vec,
&unresolved);
if(dep_vec){
fprintf(stderr, "and the unsatisfied dependencies are:\n");
for(k = 0; k < dep_vec->len; k++){
fprintf(stderr, "%s version %s\n", dep_vec->pkgs[k]->name, dep_vec->pkgs[k]->version);
}
}
fputs("", stdout);
}
}
}
pkg_hash_deinit(hash);
return 0;
}
pkg_t *hash_insert_pkg(hash_table_t *hash, pkg_t *pkg, int set_status,ipkg_conf_t *conf)
{
abstract_pkg_t * ab_pkg;
int arch_priority;
if(!pkg)
return pkg;
arch_priority = pkg->arch_priority;
if (buildDepends(hash, pkg)<0){
fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
return NULL;
}
ab_pkg = ensure_abstract_pkg_by_name(hash, pkg->name);
if (set_status) {
if (pkg->state_status == SS_INSTALLED) {
ab_pkg->state_status = SS_INSTALLED;
} else if (pkg->state_status == SS_UNPACKED) {
ab_pkg->state_status = SS_UNPACKED;
}
}
if(!ab_pkg->pkgs)
ab_pkg->pkgs = pkg_vec_alloc();
/* pkg_vec_insert_merge might munge package, but it returns an unmunged pkg */
pkg = pkg_vec_insert_merge(ab_pkg->pkgs, pkg, set_status,conf );
pkg->parent = ab_pkg;
if (buildProvides(hash, ab_pkg, pkg)<0){
fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
return NULL;
}
/* need to build the conflicts graph before replaces for correct calculation of replaced_by relation */
if (buildConflicts(hash, ab_pkg, pkg)<0){
fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
return NULL;
}
if (buildReplaces(hash, ab_pkg, pkg)<0) {
fprintf(stderr, "%s : This should never happen. Report this Bug in bugzilla please \n ",__FUNCTION__);
return NULL;
}
buildDependedUponBy(pkg, ab_pkg);
return pkg;
}
static void __pkg_hash_fetch_conflictees(pkg_t * pkg,
pkg_vec_t * installed_conflicts)
{
int i;
pkg_vec_t *available_pkgs = pkg_vec_alloc();
pkg_hash_fetch_all_installed(available_pkgs);
for (i = 0; i < available_pkgs->len; i++) {
pkg_t *cpkg = available_pkgs->pkgs[i];
int is_new_conflict = pkg_conflicts(cpkg, pkg)
&& !is_pkg_a_provides(cpkg, pkg)
&& !is_pkg_in_pkg_vec(installed_conflicts, cpkg)
&& !pkg_replaces(pkg, cpkg);
if (is_new_conflict)
pkg_vec_insert(installed_conflicts, cpkg);
}
pkg_vec_free(available_pkgs);
}
pkg_t *pkg_hash_fetch_best_installation_candidate(ipkg_conf_t *conf, abstract_pkg_t *apkg,
int (*constraint_fcn)(pkg_t *pkg, void *cdata), void *cdata, int quiet)
{
int i;
int nprovides = 0;
int nmatching = 0;
pkg_vec_t *matching_pkgs = pkg_vec_alloc();
abstract_pkg_vec_t *matching_apkgs = abstract_pkg_vec_alloc();
abstract_pkg_vec_t *provided_apkg_vec;
abstract_pkg_t **provided_apkgs;
abstract_pkg_vec_t *providers = abstract_pkg_vec_alloc();
pkg_t *latest_installed_parent = NULL;
pkg_t *latest_matching = NULL;
pkg_t *held_pkg = NULL;
pkg_t *good_pkg_by_name = NULL;
if (matching_apkgs == NULL || providers == NULL ||
apkg == NULL || apkg->provided_by == NULL || (apkg->provided_by->len == 0))
return NULL;
ipkg_message(conf, IPKG_DEBUG, "best installation candidate for %s\n", apkg->name);
provided_apkg_vec = apkg->provided_by;
nprovides = provided_apkg_vec->len;
provided_apkgs = provided_apkg_vec->pkgs;
if (nprovides > 1)
ipkg_message(conf, IPKG_DEBUG, " apkg=%s nprovides=%d\n", apkg->name, nprovides);
/* accumulate all the providers */
for (i = 0; i < nprovides; i++) {
abstract_pkg_t *provider_apkg = provided_apkgs[i];
ipkg_message(conf, IPKG_DEBUG, " adding %s to providers\n", provider_apkg->name);
abstract_pkg_vec_insert(providers, provider_apkg);
}
nprovides = providers->len;
for (i = 0; i < nprovides; i++) {
abstract_pkg_t *provider_apkg = abstract_pkg_vec_get(providers, i);
abstract_pkg_t *replacement_apkg = NULL;
pkg_vec_t *vec;
if (provider_apkg->replaced_by && provider_apkg->replaced_by->len) {
replacement_apkg = provider_apkg->replaced_by->pkgs[0];
if (provider_apkg->replaced_by->len > 1) {
ipkg_message(conf, IPKG_NOTICE, "Multiple replacers for %s, using first one (%s)\n",
provider_apkg->name, replacement_apkg->name);
}
}
if (replacement_apkg)
ipkg_message(conf, IPKG_DEBUG, " replacement_apkg=%s for provider_apkg=%s\n",
replacement_apkg->name, provider_apkg->name);
if (replacement_apkg && (replacement_apkg != provider_apkg)) {
if (abstract_pkg_vec_contains(providers, replacement_apkg))
continue;
else
provider_apkg = replacement_apkg;
}
if (!(vec = provider_apkg->pkgs)) {
ipkg_message(conf, IPKG_DEBUG, " no pkgs for provider_apkg %s\n", provider_apkg->name);
continue;
}
/* now check for supported architecture */
{
int max_count = 0;
int i;
/* count packages matching max arch priority and keep track of last one */
for (i = 0; i < vec->len; i++) {
pkg_t *maybe = vec->pkgs[i];
ipkg_message(conf, IPKG_DEBUG, " %s arch=%s arch_priority=%d version=%s \n",
maybe->name, maybe->architecture, maybe->arch_priority, maybe->version);
if (maybe->arch_priority > 0) {
max_count++;
abstract_pkg_vec_insert(matching_apkgs, maybe->parent);
pkg_vec_insert(matching_pkgs, maybe);
}
}
}
}
if (matching_pkgs->len > 1)
pkg_vec_sort(matching_pkgs, pkg_name_version_and_architecture_compare);
if (matching_apkgs->len > 1)
abstract_pkg_vec_sort(matching_pkgs, abstract_pkg_name_compare);
/* Here it is usefull, if ( matching_apkgs->len > 1 ), to test if one of this matching packages has the same name of the
needed package. In this case, I would return it for install, otherwise I will continue with the procedure */
/* The problem is what to do when there are more than a mathing package, with the same name and several version ?
Until now I always got the latest, but that breaks the downgrade option.
If I stop at the first one, I would probably miss the new ones
Maybe the way is to have some kind of flag somewhere, to see if the package been asked to install is from a file,
or from a Packages feed.
It it is from a file it always need to be checked whatever version I have in feeds or everywhere, according to force-down or whatever options*/
/*Pigi*/
for (i = 0; i < matching_pkgs->len; i++) {
pkg_t *matching = matching_pkgs->pkgs[i];
if (constraint_fcn(matching, cdata)) { /* We found it */
ipkg_message(conf, IPKG_DEBUG, " Found a valid candidate for the install: %s %s \n", matching->name, matching->version) ;
good_pkg_by_name = matching;
if ( matching->provided_by_hand == 1 ) /* It has been provided by hand, so it is what user want */
break;
}
}
for (i = 0; i < matching_pkgs->len; i++) {
pkg_t *matching = matching_pkgs->pkgs[i];
latest_matching = matching;
if (matching->parent->state_status == SS_INSTALLED || matching->parent->state_status == SS_UNPACKED)
latest_installed_parent = matching;
if (matching->state_flag & (SF_HOLD|SF_PREFER)) {
if (held_pkg)
ipkg_message(conf, IPKG_ERROR, "Multiple packages (%s and %s) providing same name marked HOLD or PREFER. Using latest.\n",
held_pkg->name, matching->name);
held_pkg = matching;
}
}
if (!good_pkg_by_name && !held_pkg && !latest_installed_parent && matching_apkgs->len > 1 && !quiet) {
ipkg_message(conf, IPKG_ERROR, "Package=%s, %d matching providers\n",
apkg->name, matching_apkgs->len);
for (i = 0; i < matching_apkgs->len; i++) {
abstract_pkg_t *matching = matching_apkgs->pkgs[i];
ipkg_message(conf, IPKG_ERROR, " %s\n", matching->name);
}
ipkg_message(conf, IPKG_ERROR, "Please select one with ipkg install or ipkg flag prefer\n");
}
if (matching_apkgs->len > 1 && conf->verbosity > 1) {
ipkg_message(conf, IPKG_NOTICE, "%s: for apkg=%s, %d matching pkgs\n",
__FUNCTION__, apkg->name, matching_pkgs->len);
for (i = 0; i < matching_pkgs->len; i++) {
pkg_t *matching = matching_pkgs->pkgs[i];
ipkg_message(conf, IPKG_INFO, " %s %s %s\n",
matching->name, matching->version, matching->architecture);
}
}
nmatching = matching_apkgs->len;
pkg_vec_free(matching_pkgs);
abstract_pkg_vec_free(matching_apkgs);
abstract_pkg_vec_free(providers);
if (good_pkg_by_name) { /* We found a good candidate, we will install it */
return good_pkg_by_name;
}
if (held_pkg) {
ipkg_message(conf, IPKG_INFO, " using held package %s\n", held_pkg->name);
return held_pkg;
}
if (latest_installed_parent) {
ipkg_message(conf, IPKG_INFO, " using latest version of installed package %s\n", latest_installed_parent->name);
return latest_installed_parent;
}
if (nmatching > 1) {
ipkg_message(conf, IPKG_INFO, " no matching pkg out of matching_apkgs=%d\n", nmatching);
return NULL;
}
if (latest_matching) {
ipkg_message(conf, IPKG_INFO, " using latest matching %s %s %s\n",
latest_matching->name, latest_matching->version, latest_matching->architecture);
return latest_matching;
}
return NULL;
}
/* 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;
unsigned int k;
int count, found;
char **the_lost;
abstract_pkg_t *ab_pkg;
/*
* this is a setup to check for redundant/cyclic dependency checks,
* which are marked at the abstract_pkg level
*/
ab_pkg = pkg->parent;
if (!ab_pkg) {
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 */
opkg_msg(DEBUG2, "Already checked dependencies for '%s'.\n",
ab_pkg->name);
*unresolved = NULL;
return 0;
} else {
opkg_msg(DEBUG2, "Checking dependencies for '%s'.\n", ab_pkg->name);
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) {
*unresolved = NULL;
return 0;
}
the_lost = NULL;
/* foreach dependency */
for (i = 0; i < count; i++) {
compound_depend_t *compound_depend = &pkg->depends[i];
depend_t **possible_satisfiers = compound_depend->possibilities;;
found = 0;
satisfier_entry_pkg = NULL;
if (compound_depend->type == GREEDY_DEPEND) {
/* foreach possible satisfier */
for (j = 0; j < compound_depend->possibility_count; j++) {
/* foreach provided_by, which includes the abstract_pkg itself */
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;
int l;
for (l = 0; l < nposs; l++) {
pkg_vec_t *test_vec = ab_providers[l]->pkgs;
/* if no depends on this one, try the first package that
* Provides this one */
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];
/* not installed, and not already known about? */
int wanted = (pkg_scout->state_want != SW_INSTALL)
&& !pkg_scout->parent->dependencies_checked
&& !is_pkg_in_pkg_vec(unsatisfied, pkg_scout);
if (wanted) {
char **newstuff = NULL;
int rc;
pkg_vec_t *tmp_vec = pkg_vec_alloc();
/* check for not-already-installed dependencies */
rc = pkg_hash_fetch_unsatisfied_dependencies(pkg_scout,
tmp_vec, &newstuff);
if (newstuff == NULL) {
int m;
int ok = 1;
for (m = 0; m < rc; m++) {
pkg_t *p = tmp_vec->pkgs[m];
if (p->state_want == SW_INSTALL)
continue;
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_msg(NOTICE,
"Adding satisfier for greedy"
" dependence %s.\n",
pkg_scout->name);
pkg_vec_insert(unsatisfied, pkg_scout);
}
} else {
opkg_msg(DEBUG,
"Not installing %s due to "
"broken depends.\n", pkg_scout->name);
free(newstuff);
}
}
}
}
}
continue;
}
/* foreach possible satisfier, look for installed package */
for (j = 0; j < compound_depend->possibility_count; j++) {
/* 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(
satisfying_apkg,
pkg_installed_and_constraint_satisfied,
dependence_to_satisfy,
1);
opkg_msg(DEBUG, "satisfying_pkg=%p\n", satisfying_pkg);
if (satisfying_pkg != NULL) {
found = 1;
break;
}
}
/* if nothing installed matches, then look for uninstalled satisfier */
if (!found) {
/* foreach possible satisfier, look for installed package */
for (j = 0; j < compound_depend->possibility_count; j++) {
/* 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(
satisfying_apkg,
pkg_constraint_satisfied,
dependence_to_satisfy,
1);
opkg_msg(DEBUG, "satisfying_pkg=%p\n", satisfying_pkg);
if (!satisfying_pkg)
continue;
/* user request overrides package recommendation */
int ignore = (compound_depend->type == RECOMMEND
|| compound_depend->type == SUGGEST)
&& (satisfying_pkg->state_want == SW_DEINSTALL
|| satisfying_pkg->state_want == SW_PURGE
|| opkg_config->no_install_recommends);
if (ignore) {
opkg_msg(NOTICE,
"%s: ignoring recommendation for "
"%s at user request\n", pkg->name,
satisfying_pkg->name);
continue;
}
/* Check for excluded packages */
int exclude = str_list_contains(&opkg_config->exclude_list,
satisfying_pkg->name);
if (exclude) {
opkg_msg(NOTICE,
"%s: exclude required package %s at users request\n",
pkg->name, satisfying_pkg->name);
continue;
}
satisfier_entry_pkg = satisfying_pkg;
break;
}
}
/* we didn't find one, add something to the unsatisfied vector */
if (!found) {
if (!satisfier_entry_pkg) {
/* failure to meet recommendations is not an error */
int required = compound_depend->type != RECOMMEND
&& compound_depend->type != SUGGEST;
if (required)
the_lost = add_unresolved_dep(pkg, the_lost, i);
else
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_msg(NOTICE, "package %s suggests installing %s\n",
pkg->name, satisfier_entry_pkg->name);
} else {
char **newstuff = NULL;
int not_seen_before = satisfier_entry_pkg != pkg
&& !is_pkg_in_pkg_vec(unsatisfied,
satisfier_entry_pkg);
if (not_seen_before) {
pkg_vec_insert(unsatisfied, satisfier_entry_pkg);
pkg_hash_fetch_unsatisfied_dependencies(satisfier_entry_pkg,
unsatisfied, &newstuff);
the_lost = merge_unresolved(the_lost, newstuff);
if (newstuff)
free(newstuff);
}
}
}
}
}
*unresolved = the_lost;
return unsatisfied->len;
}
pkg_vec_t *pkg_hash_fetch_satisfied_dependencies(pkg_t * pkg)
{
pkg_vec_t *satisfiers;
int i, j;
unsigned int k;
int count;
abstract_pkg_t *ab_pkg;
satisfiers = pkg_vec_alloc();
/*
* this is a setup to check for redundant/cyclic dependency checks,
* which are marked at the abstract_pkg level
*/
ab_pkg = pkg->parent;
if (!ab_pkg) {
opkg_msg(ERROR, "Internal error, with pkg %s.\n", pkg->name);
return satisfiers;
}
count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count
+ pkg->suggests_count;
if (!count)
return satisfiers;
/* foreach dependency */
for (i = 0; i < count; i++) {
compound_depend_t *compound_depend = &pkg->depends[i];
depend_t **possible_satisfiers = compound_depend->possibilities;;
int not_required = compound_depend->type == RECOMMEND
|| compound_depend->type == SUGGEST;
if (not_required)
continue;
if (compound_depend->type == GREEDY_DEPEND) {
/* foreach possible satisfier */
for (j = 0; j < compound_depend->possibility_count; j++) {
/* foreach provided_by, which includes the abstract_pkg itself */
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;
int l;
for (l = 0; l < nposs; l++) {
pkg_vec_t *test_vec = ab_providers[l]->pkgs;
/* if no depends on this one, try the first package that
* Provides this one */
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];
/* not installed, and not already known about? */
int not_seen_before = pkg_scout != pkg
&& pkg_scout->state_want == SW_INSTALL;
if (not_seen_before)
pkg_vec_insert(satisfiers, pkg_scout);
}
}
}
continue;
}
/* foreach possible satisfier, look for installed package */
for (j = 0; j < compound_depend->possibility_count; j++) {
/* 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(satisfying_apkg,
pkg_constraint_satisfied,
dependence_to_satisfy,
0);
int need_to_insert = satisfying_pkg != NULL
&& satisfying_pkg != pkg
&& (satisfying_pkg->state_want == SW_INSTALL
|| satisfying_pkg->state_want == SW_UNKNOWN);
if (need_to_insert)
pkg_vec_insert(satisfiers, satisfying_pkg);
}
}
return satisfiers;
}
static int opkg_remove_dependent_pkgs(pkg_t * pkg, abstract_pkg_t ** dependents)
{
unsigned int i;
unsigned int a;
int count;
pkg_vec_t *dependent_pkgs;
abstract_pkg_t *ab_pkg;
ab_pkg = pkg->parent;
if (ab_pkg == NULL) {
opkg_msg(ERROR, "Internal error: pkg %s isn't in hash table\n",
pkg->name);
return 0;
}
if (dependents == NULL)
return 0;
// here i am using the dependencies_checked
if (ab_pkg->dependencies_checked == 2) // variable to make out whether this package
return 0; // has already been encountered in the process
// of marking packages for removal - Karthik
ab_pkg->dependencies_checked = 2;
count = 1;
dependent_pkgs = pkg_vec_alloc();
for (i = 0; dependents[i] != NULL; i++) {
abstract_pkg_t *dep_ab_pkg = dependents[i];
if (dep_ab_pkg->dependencies_checked == 2) {
continue;
}
if (dep_ab_pkg->state_status == SS_INSTALLED) {
for (a = 0; a < dep_ab_pkg->pkgs->len; a++) {
pkg_t *dep_pkg = dep_ab_pkg->pkgs->pkgs[a];
if (dep_pkg->state_status == SS_INSTALLED) {
pkg_vec_insert(dependent_pkgs, dep_pkg);
count++;
}
}
}
/* 1 - to keep track of visited ab_pkgs when checking for possiblility
* of a broken removal of pkgs.
* 2 - to keep track of pkgs whose deps have been checked alrdy -
* Karthik */
}
if (count == 1) {
pkg_vec_free(dependent_pkgs);
return 0;
}
int err = 0;
for (i = 0; i < dependent_pkgs->len; i++) {
err = opkg_remove_pkg(dependent_pkgs->pkgs[i]);
if (err)
break;
}
pkg_vec_free(dependent_pkgs);
return err;
}
int ipkg_conf_write_status_files(ipkg_conf_t *conf)
{
pkg_dest_list_elt_t *iter;
pkg_dest_t *dest;
pkg_vec_t *all;
pkg_t *pkg;
register int i;
int err;
if (conf->noaction)
return 0;
for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) {
dest = iter->data;
dest->status_file = fopen(dest->status_file_tmp_name, "w");
if (dest->status_file == NULL) {
fprintf(stderr, "%s: Can't open status file: %s for writing: %s\n",
__FUNCTION__, dest->status_file_name, strerror(errno));
}
}
all = pkg_vec_alloc();
pkg_hash_fetch_available(&conf->pkg_hash, all);
for(i = 0; i < all->len; i++) {
pkg = all->pkgs[i];
/* We don't need most uninstalled packages in the status file */
if (pkg->state_status == SS_NOT_INSTALLED
&& (pkg->state_want == SW_UNKNOWN
|| pkg->state_want == SW_DEINSTALL
|| pkg->state_want == SW_PURGE)) {
continue;
}
if (!pkg) {
fprintf(stderr, "Null package\n");
}
if (pkg->dest == NULL) {
fprintf(stderr, "%s: ERROR: Can't write status for "
"package %s since it has a NULL dest\n",
__FUNCTION__, pkg->name);
continue;
}
if (pkg->dest->status_file) {
pkg_print_status(pkg, pkg->dest->status_file);
}
}
pkg_vec_free(all);
for (iter = conf->pkg_dest_list.head; iter; iter = iter->next) {
dest = iter->data;
if (dest->status_file) {
err = ferror(dest->status_file);
fclose(dest->status_file);
dest->status_file = NULL;
if (!err) {
file_move(dest->status_file_tmp_name, dest->status_file_name);
} else {
fprintf(stderr, "%s: ERROR: An error has occurred writing %s, "
"retaining old %s\n", __FUNCTION__,
dest->status_file_tmp_name, dest->status_file_name);
}
}
}
return 0;
}
