static void
breaks_check_one(struct varbuf *aemsgs, enum dep_check *ok,
struct deppossi *breaks, struct pkginfo *broken,
struct pkginfo *breaker, struct deppossi *virtbroken)
{
struct varbuf depmsg = VARBUF_INIT;
debug(dbg_depcondetail, " checking breaker %s virtbroken %s",
pkg_name(breaker, pnaw_always),
virtbroken ? virtbroken->ed->name : "<none>");
if (breaker->status == PKG_STAT_NOTINSTALLED ||
breaker->status == PKG_STAT_CONFIGFILES)
return;
if (broken == breaker) return;
if (!versionsatisfied(&broken->installed, breaks)) return;
/* The test below can only trigger if dep_breaks start having
* arch qualifiers different from “any”. */
if (!archsatisfied(&broken->installed, breaks))
return;
if (ignore_depends(breaker)) return;
if (virtbroken && ignore_depends(&virtbroken->ed->pkg))
return;
if (virtbroken && !pkg_virtual_deppossi_satisfied(breaks, virtbroken))
return;
varbufdependency(&depmsg, breaks->up);
varbuf_end_str(&depmsg);
varbuf_printf(aemsgs, _(" %s (%s) breaks %s and is %s.\n"),
pkg_name(breaker, pnaw_nonambig),
versiondescribe(&breaker->installed.version, vdew_nonambig),
depmsg.buf, gettext(statusstrings[breaker->status]));
varbuf_destroy(&depmsg);
if (virtbroken) {
varbuf_printf(aemsgs, _(" %s (%s) provides %s.\n"),
pkg_name(broken, pnaw_nonambig),
versiondescribe(&broken->installed.version, vdew_nonambig),
virtbroken->ed->name);
} else if (breaks->verrel != DPKG_RELATION_NONE) {
varbuf_printf(aemsgs, _(" Version of %s to be configured is %s.\n"),
pkg_name(broken, pnaw_nonambig),
versiondescribe(&broken->installed.version, vdew_nonambig));
if (in_force(FORCE_DEPENDS_VERSION))
return;
}
if (force_breaks(breaks)) return;
*ok = DEP_CHECK_HALT;
}
static void
breaks_check_one(struct varbuf *aemsgs, enum dep_check *ok,
struct deppossi *breaks, struct pkginfo *broken,
struct pkginfo *breaker, struct pkgset *virtbroken)
{
struct varbuf depmsg = VARBUF_INIT;
debug(dbg_depcondetail, " checking breaker %s virtbroken %s",
pkg_name(breaker, pnaw_always),
virtbroken ? virtbroken->name : "<none>");
if (breaker->status == stat_notinstalled ||
breaker->status == stat_configfiles) return;
if (broken == breaker) return;
if (!versionsatisfied(&broken->installed, breaks)) return;
/* The test below can only trigger if dep_breaks start having
* arch qualifiers different from “any”. */
if (!archsatisfied(&broken->installed, breaks))
return;
if (ignore_depends(breaker)) return;
if (virtbroken && ignore_depends(&virtbroken->pkg))
return;
varbufdependency(&depmsg, breaks->up);
varbuf_end_str(&depmsg);
varbuf_printf(aemsgs, _(" %s (%s) breaks %s and is %s.\n"),
pkg_name(breaker, pnaw_nonambig),
versiondescribe(&breaker->installed.version, vdew_nonambig),
depmsg.buf, gettext(statusstrings[breaker->status]));
varbuf_destroy(&depmsg);
if (virtbroken) {
varbuf_printf(aemsgs, _(" %s (%s) provides %s.\n"),
pkg_name(broken, pnaw_nonambig),
versiondescribe(&broken->installed.version, vdew_nonambig),
virtbroken->name);
} else if (breaks->verrel != dpkg_relation_none) {
varbuf_printf(aemsgs, _(" Version of %s to be configured is %s.\n"),
pkg_name(broken, pnaw_nonambig),
versiondescribe(&broken->installed.version, vdew_nonambig));
if (fc_dependsversion) return;
}
if (force_breaks(breaks)) return;
*ok = dep_check_halt;
}
static int
does_replace(struct pkginfo *newpigp, struct pkginfoperfile *newpifp,
struct pkginfo *oldpigp, struct pkginfoperfile *oldpifp)
{
struct dependency *dep;
debug(dbg_depcon,"does_replace new=%s old=%s (%s)",newpigp->name,
oldpigp->name, versiondescribe(&oldpifp->version, vdew_always));
for (dep= newpifp->depends; dep; dep= dep->next) {
if (dep->type != dep_replaces || dep->list->ed != oldpigp) continue;
debug(dbg_depcondetail,"does_replace ... found old, version %s",
versiondescribe(&dep->list->version,vdew_always));
if (!versionsatisfied(oldpifp, dep->list))
continue;
debug(dbg_depcon,"does_replace ... yes");
return true;
}
debug(dbg_depcon,"does_replace ... no");
return false;
}
/*
* *whynot must already have been initialized; it need not be
* empty though - it will be reset before use.
*
* If depisok returns false for ‘not OK’ it will contain a description,
* newline-terminated BUT NOT NUL-TERMINATED, of the reason.
*
* If depisok returns true it will contain garbage.
* allowunconfigd should be non-zero during the ‘Pre-Depends’ checking
* before a package is unpacked, when it is sufficient for the package
* to be unpacked provided that both the unpacked and previously-configured
* versions are acceptable.
*
* On false return (‘not OK’), *canfixbyremove refers to a package which
* if removed (dep_conflicts) or deconfigured (dep_breaks) will fix
* the problem. Caller may pass NULL for canfixbyremove and need not
* initialize *canfixbyremove.
*/
bool
depisok(struct dependency *dep, struct varbuf *whynot,
struct pkginfo **canfixbyremove, bool allowunconfigd)
{
struct deppossi *possi;
struct deppossi *provider;
int nconflicts;
/* Use this buffer so that when internationalisation comes along we
* don't have to rewrite the code completely, only redo the sprintf strings
* (assuming we have the fancy argument-number-specifiers).
* Allow 250x3 for package names, versions, &c, + 250 for ourselves. */
char linebuf[1024];
assert(dep->type == dep_depends || dep->type == dep_predepends ||
dep->type == dep_breaks || dep->type == dep_conflicts ||
dep->type == dep_recommends || dep->type == dep_suggests ||
dep->type == dep_enhances);
if (canfixbyremove)
*canfixbyremove = NULL;
/* The dependency is always OK if we're trying to remove the depend*ing*
* package. */
switch (dep->up->clientdata->istobe) {
case itb_remove: case itb_deconfigure:
return true;
case itb_normal:
/* Only installed packages can be make dependency problems. */
switch (dep->up->status) {
case stat_installed:
case stat_triggerspending:
case stat_triggersawaited:
break;
case stat_notinstalled: case stat_configfiles: case stat_halfinstalled:
case stat_halfconfigured: case stat_unpacked:
return true;
default:
internerr("unknown status depending '%d'", dep->up->status);
}
break;
case itb_installnew: case itb_preinstall:
break;
default:
internerr("unknown istobe depending '%d'", dep->up->clientdata->istobe);
}
/* Describe the dependency, in case we have to moan about it. */
varbufreset(whynot);
varbufaddc(whynot, ' ');
describedepcon(whynot, dep);
varbufaddc(whynot,'\n');
/* TODO: Check dep_enhances as well. */
if (dep->type == dep_depends || dep->type == dep_predepends ||
dep->type == dep_recommends || dep->type == dep_suggests ) {
/* Go through the alternatives. As soon as we find one that
* we like, we return ‘true’ straight away. Otherwise, when we get to
* the end we'll have accumulated all the reasons in whynot and
* can return ‘false’. */
for (possi= dep->list; possi; possi= possi->next) {
switch (possi->ed->clientdata->istobe) {
case itb_remove:
sprintf(linebuf,_(" %.250s is to be removed.\n"),possi->ed->name);
break;
case itb_deconfigure:
sprintf(linebuf,_(" %.250s is to be deconfigured.\n"),possi->ed->name);
break;
case itb_installnew:
if (versionsatisfied(&possi->ed->available, possi))
return true;
sprintf(linebuf,_(" %.250s is to be installed, but is version %.250s.\n"),
possi->ed->name,
versiondescribe(&possi->ed->available.version,vdew_nonambig));
break;
case itb_normal: case itb_preinstall:
switch (possi->ed->status) {
case stat_installed:
case stat_triggerspending:
if (versionsatisfied(&possi->ed->installed, possi))
return true;
sprintf(linebuf,_(" %.250s is installed, but is version %.250s.\n"),
possi->ed->name,
versiondescribe(&possi->ed->installed.version,vdew_nonambig));
break;
case stat_notinstalled:
/* Don't say anything about this yet - it might be a virtual package.
* Later on, if nothing has put anything in linebuf, we know that it
* isn't and issue a diagnostic then. */
*linebuf = '\0';
break;
case stat_unpacked:
case stat_halfconfigured:
case stat_triggersawaited:
if (allowunconfigd) {
if (!informativeversion(&possi->ed->configversion)) {
sprintf(linebuf, _(" %.250s is unpacked, but has never been configured.\n"),
possi->ed->name);
break;
} else if (!versionsatisfied(&possi->ed->installed, possi)) {
sprintf(linebuf, _(" %.250s is unpacked, but is version %.250s.\n"),
possi->ed->name,
versiondescribe(&possi->ed->available.version,vdew_nonambig));
break;
} else if (!versionsatisfied3(&possi->ed->configversion,
&possi->version,possi->verrel)) {
sprintf(linebuf, _(" %.250s latest configured version is %.250s.\n"),
possi->ed->name,
versiondescribe(&possi->ed->configversion,vdew_nonambig));
break;
} else {
return true;
}
}
/* Fall through. */
default:
sprintf(linebuf, _(" %.250s is %s.\n"),
possi->ed->name, gettext(statusstrings[possi->ed->status]));
break;
}
break;
default:
internerr("unknown istobe depended '%d'", possi->ed->clientdata->istobe);
}
varbufaddstr(whynot, linebuf);
/* If there was no version specified we try looking for Providers. */
if (possi->verrel == dvr_none) {
/* See if the package we're about to install Provides it. */
for (provider= possi->ed->available.depended;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (provider->up->up->clientdata->istobe == itb_installnew)
return true;
}
/* Now look at the packages already on the system. */
for (provider= possi->ed->installed.depended;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
switch (provider->up->up->clientdata->istobe) {
case itb_installnew:
/* Don't pay any attention to the Provides field of the
* currently-installed version of the package we're trying
* to install. We dealt with that by using the available
* information above. */
continue;
case itb_remove:
sprintf(linebuf, _(" %.250s provides %.250s but is to be removed.\n"),
provider->up->up->name, possi->ed->name);
break;
case itb_deconfigure:
sprintf(linebuf, _(" %.250s provides %.250s but is to be deconfigured.\n"),
provider->up->up->name, possi->ed->name);
break;
case itb_normal: case itb_preinstall:
if (provider->up->up->status == stat_installed)
return true;
sprintf(linebuf, _(" %.250s provides %.250s but is %s.\n"),
provider->up->up->name, possi->ed->name,
gettext(statusstrings[provider->up->up->status]));
break;
default:
internerr("unknown istobe provider '%d'",
provider->up->up->clientdata->istobe);
}
varbufaddstr(whynot, linebuf);
}
if (!*linebuf) {
/* If the package wasn't installed at all, and we haven't said
* yet why this isn't satisfied, we should say so now. */
sprintf(linebuf, _(" %.250s is not installed.\n"), possi->ed->name);
varbufaddstr(whynot, linebuf);
}
}
}
return false;
} else {
/* It's conflicts or breaks. There's only one main alternative,
* but we also have to consider Providers. We return ‘false’ as soon
* as we find something that matches the conflict, and only describe
* it then. If we get to the end without finding anything we return
* ‘true’. */
possi= dep->list;
nconflicts= 0;
if (possi->ed != possi->up->up) {
/* If the package conflicts with or breaks itself it must mean
* other packages which provide the same virtual name. We
* therefore don't look at the real package and go on to the
* virtual ones. */
switch (possi->ed->clientdata->istobe) {
case itb_remove:
break;
case itb_installnew:
if (!versionsatisfied(&possi->ed->available, possi)) break;
sprintf(linebuf, _(" %.250s (version %.250s) is to be installed.\n"),
possi->ed->name,
versiondescribe(&possi->ed->available.version,vdew_nonambig));
varbufaddstr(whynot, linebuf);
if (!canfixbyremove)
return false;
nconflicts++;
*canfixbyremove= possi->ed;
break;
case itb_deconfigure:
if (dep->type == dep_breaks)
break; /* Already deconfiguring this. */
/* Fall through. */
case itb_normal: case itb_preinstall:
switch (possi->ed->status) {
case stat_notinstalled: case stat_configfiles:
break;
case stat_halfinstalled: case stat_unpacked:
case stat_halfconfigured:
if (dep->type == dep_breaks)
break; /* No problem. */
case stat_installed:
case stat_triggerspending:
case stat_triggersawaited:
if (!versionsatisfied(&possi->ed->installed, possi)) break;
sprintf(linebuf, _(" %.250s (version %.250s) is present and %s.\n"),
possi->ed->name,
versiondescribe(&possi->ed->installed.version,vdew_nonambig),
gettext(statusstrings[possi->ed->status]));
varbufaddstr(whynot, linebuf);
if (!canfixbyremove)
return false;
nconflicts++;
*canfixbyremove= possi->ed;
}
break;
default:
internerr("unknown istobe conflict '%d'",
possi->ed->clientdata->istobe);
}
}
/* If there was no version specified we try looking for Providers. */
if (possi->verrel == dvr_none) {
/* See if the package we're about to install Provides it. */
for (provider= possi->ed->available.depended;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (provider->up->up->clientdata->istobe != itb_installnew) continue;
if (provider->up->up == dep->up)
continue; /* Conflicts and provides the same. */
sprintf(linebuf, _(" %.250s provides %.250s and is to be installed.\n"),
provider->up->up->name, possi->ed->name);
varbufaddstr(whynot, linebuf);
/* We can't remove the one we're about to install: */
if (canfixbyremove)
*canfixbyremove = NULL;
return false;
}
/* Now look at the packages already on the system. */
for (provider= possi->ed->installed.depended;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (provider->up->up == dep->up)
continue; /* Conflicts and provides the same. */
switch (provider->up->up->clientdata->istobe) {
case itb_installnew:
/* Don't pay any attention to the Provides field of the
* currently-installed version of the package we're trying
* to install. We dealt with that package by using the
* available information above. */
continue;
case itb_remove:
continue;
case itb_deconfigure:
if (dep->type == dep_breaks)
continue; /* Already deconfiguring. */
case itb_normal: case itb_preinstall:
switch (provider->up->up->status) {
case stat_notinstalled: case stat_configfiles:
continue;
case stat_halfinstalled: case stat_unpacked:
case stat_halfconfigured:
if (dep->type == dep_breaks)
break; /* No problem. */
case stat_installed:
case stat_triggerspending:
case stat_triggersawaited:
sprintf(linebuf,
_(" %.250s provides %.250s and is present and %s.\n"),
provider->up->up->name, possi->ed->name,
gettext(statusstrings[provider->up->up->status]));
varbufaddstr(whynot, linebuf);
if (!canfixbyremove)
return false;
nconflicts++;
*canfixbyremove= provider->up->up;
break;
}
break;
default:
internerr("unknown istobe conflict provider '%d'",
provider->up->up->clientdata->istobe);
}
}
}
if (!nconflicts)
return true;
if (nconflicts > 1)
*canfixbyremove = NULL;
return false;
} /* if (dependency) {...} else {...} */
}
/*
* *whynot must already have been initialized; it need not be
* empty though - it will be reset before use.
*
* If depisok returns false for ‘not OK’ it will contain a description,
* newline-terminated BUT NOT NUL-TERMINATED, of the reason.
*
* If depisok returns true it will contain garbage.
* allowunconfigd should be non-zero during the ‘Pre-Depends’ checking
* before a package is unpacked, when it is sufficient for the package
* to be unpacked provided that both the unpacked and previously-configured
* versions are acceptable.
*
* On false return (‘not OK’), *canfixbyremove refers to a package which
* if removed (dep_conflicts) or deconfigured (dep_breaks) will fix
* the problem. Caller may pass NULL for canfixbyremove and need not
* initialize *canfixbyremove.
*
* On false return (‘not OK’), *canfixbytrigaw refers to a package which
* can fix the problem if all the packages listed in Triggers-Awaited have
* their triggers processed. Caller may pass NULL for canfixbytrigaw and
* need not initialize *canfixbytrigaw.
*/
bool
depisok(struct dependency *dep, struct varbuf *whynot,
struct pkginfo **canfixbyremove, struct pkginfo **canfixbytrigaw,
bool allowunconfigd)
{
struct deppossi *possi;
struct deppossi *provider;
struct pkginfo *pkg_pos;
int nconflicts;
/* Use this buffer so that when internationalisation comes along we
* don't have to rewrite the code completely, only redo the sprintf strings
* (assuming we have the fancy argument-number-specifiers).
* Allow 250x3 for package names, versions, &c, + 250 for ourselves. */
char linebuf[1024];
assert(dep->type == dep_depends || dep->type == dep_predepends ||
dep->type == dep_breaks || dep->type == dep_conflicts ||
dep->type == dep_recommends || dep->type == dep_suggests ||
dep->type == dep_enhances);
if (canfixbyremove)
*canfixbyremove = NULL;
if (canfixbytrigaw)
*canfixbytrigaw = NULL;
/* The dependency is always OK if we're trying to remove the depend*ing*
* package. */
switch (dep->up->clientdata->istobe) {
case PKG_ISTOBE_REMOVE:
case PKG_ISTOBE_DECONFIGURE:
return true;
case PKG_ISTOBE_NORMAL:
/* Only installed packages can be make dependency problems. */
switch (dep->up->status) {
case PKG_STAT_INSTALLED:
case PKG_STAT_TRIGGERSPENDING:
case PKG_STAT_TRIGGERSAWAITED:
break;
case PKG_STAT_HALFCONFIGURED:
case PKG_STAT_UNPACKED:
case PKG_STAT_HALFINSTALLED:
if (dep->type == dep_predepends ||
dep->type == dep_conflicts ||
dep->type == dep_breaks)
break;
/* Fall through. */
case PKG_STAT_CONFIGFILES:
case PKG_STAT_NOTINSTALLED:
return true;
default:
internerr("unknown status depending '%d'", dep->up->status);
}
break;
case PKG_ISTOBE_INSTALLNEW:
case PKG_ISTOBE_PREINSTALL:
break;
default:
internerr("unknown istobe depending '%d'", dep->up->clientdata->istobe);
}
/* Describe the dependency, in case we have to moan about it. */
varbuf_reset(whynot);
varbuf_add_char(whynot, ' ');
describedepcon(whynot, dep);
varbuf_add_char(whynot, '\n');
/* TODO: Check dep_enhances as well. */
if (dep->type == dep_depends || dep->type == dep_predepends ||
dep->type == dep_recommends || dep->type == dep_suggests ) {
/* Go through the alternatives. As soon as we find one that
* we like, we return ‘true’ straight away. Otherwise, when we get to
* the end we'll have accumulated all the reasons in whynot and
* can return ‘false’. */
for (possi= dep->list; possi; possi= possi->next) {
struct deppossi_pkg_iterator *possi_iter;
possi_iter = deppossi_pkg_iter_new(possi, wpb_by_istobe);
while ((pkg_pos = deppossi_pkg_iter_next(possi_iter))) {
switch (pkg_pos->clientdata->istobe) {
case PKG_ISTOBE_REMOVE:
sprintf(linebuf, _(" %.250s is to be removed.\n"),
pkg_name(pkg_pos, pnaw_nonambig));
break;
case PKG_ISTOBE_DECONFIGURE:
sprintf(linebuf, _(" %.250s is to be deconfigured.\n"),
pkg_name(pkg_pos, pnaw_nonambig));
break;
case PKG_ISTOBE_INSTALLNEW:
if (versionsatisfied(&pkg_pos->available, possi)) {
deppossi_pkg_iter_free(possi_iter);
return true;
}
sprintf(linebuf, _(" %.250s is to be installed, but is version "
"%.250s.\n"),
pkgbin_name(pkg_pos, &pkg_pos->available, pnaw_nonambig),
versiondescribe(&pkg_pos->available.version, vdew_nonambig));
break;
case PKG_ISTOBE_NORMAL:
case PKG_ISTOBE_PREINSTALL:
switch (pkg_pos->status) {
case PKG_STAT_INSTALLED:
case PKG_STAT_TRIGGERSPENDING:
if (versionsatisfied(&pkg_pos->installed, possi)) {
deppossi_pkg_iter_free(possi_iter);
return true;
}
sprintf(linebuf, _(" %.250s is installed, but is version "
"%.250s.\n"),
pkg_name(pkg_pos, pnaw_nonambig),
versiondescribe(&pkg_pos->installed.version, vdew_nonambig));
break;
case PKG_STAT_NOTINSTALLED:
/* Don't say anything about this yet - it might be a virtual package.
* Later on, if nothing has put anything in linebuf, we know that it
* isn't and issue a diagnostic then. */
*linebuf = '\0';
break;
case PKG_STAT_TRIGGERSAWAITED:
if (canfixbytrigaw && versionsatisfied(&pkg_pos->installed, possi))
*canfixbytrigaw = pkg_pos;
/* Fall through to have a chance to return OK due to
* allowunconfigd and to fill the explanation */
case PKG_STAT_UNPACKED:
case PKG_STAT_HALFCONFIGURED:
if (allowunconfigd) {
if (!dpkg_version_is_informative(&pkg_pos->configversion)) {
sprintf(linebuf, _(" %.250s is unpacked, but has never been "
"configured.\n"),
pkg_name(pkg_pos, pnaw_nonambig));
break;
} else if (!versionsatisfied(&pkg_pos->installed, possi)) {
sprintf(linebuf, _(" %.250s is unpacked, but is version "
"%.250s.\n"),
pkg_name(pkg_pos, pnaw_nonambig),
versiondescribe(&pkg_pos->installed.version,
vdew_nonambig));
break;
} else if (!dpkg_version_relate(&pkg_pos->configversion,
possi->verrel,
&possi->version)) {
sprintf(linebuf, _(" %.250s latest configured version is "
"%.250s.\n"),
pkg_name(pkg_pos, pnaw_nonambig),
versiondescribe(&pkg_pos->configversion, vdew_nonambig));
break;
} else {
deppossi_pkg_iter_free(possi_iter);
return true;
}
}
/* Fall through. */
default:
sprintf(linebuf, _(" %.250s is %s.\n"),
pkg_name(pkg_pos, pnaw_nonambig),
gettext(statusstrings[pkg_pos->status]));
break;
}
break;
default:
internerr("unknown istobe depended '%d'", pkg_pos->clientdata->istobe);
}
varbuf_add_str(whynot, linebuf);
}
deppossi_pkg_iter_free(possi_iter);
/* See if the package we're about to install Provides it. */
for (provider = possi->ed->depended.available;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (!pkg_virtual_deppossi_satisfied(possi, provider))
continue;
if (provider->up->up->clientdata->istobe == PKG_ISTOBE_INSTALLNEW)
return true;
}
/* Now look at the packages already on the system. */
for (provider = possi->ed->depended.installed;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (!pkg_virtual_deppossi_satisfied(possi, provider))
continue;
switch (provider->up->up->clientdata->istobe) {
case PKG_ISTOBE_INSTALLNEW:
/* Don't pay any attention to the Provides field of the
* currently-installed version of the package we're trying
* to install. We dealt with that by using the available
* information above. */
continue;
case PKG_ISTOBE_REMOVE:
sprintf(linebuf, _(" %.250s provides %.250s but is to be removed.\n"),
pkg_name(provider->up->up, pnaw_nonambig),
possi->ed->name);
break;
case PKG_ISTOBE_DECONFIGURE:
sprintf(linebuf, _(" %.250s provides %.250s but is to be deconfigured.\n"),
pkg_name(provider->up->up, pnaw_nonambig),
possi->ed->name);
break;
case PKG_ISTOBE_NORMAL:
case PKG_ISTOBE_PREINSTALL:
if (provider->up->up->status == PKG_STAT_INSTALLED ||
provider->up->up->status == PKG_STAT_TRIGGERSPENDING)
return true;
if (provider->up->up->status == PKG_STAT_TRIGGERSAWAITED)
*canfixbytrigaw = provider->up->up;
sprintf(linebuf, _(" %.250s provides %.250s but is %s.\n"),
pkg_name(provider->up->up, pnaw_nonambig),
possi->ed->name,
gettext(statusstrings[provider->up->up->status]));
break;
default:
internerr("unknown istobe provider '%d'",
provider->up->up->clientdata->istobe);
}
varbuf_add_str(whynot, linebuf);
}
if (!*linebuf) {
/* If the package wasn't installed at all, and we haven't said
* yet why this isn't satisfied, we should say so now. */
sprintf(linebuf, _(" %.250s is not installed.\n"), possi->ed->name);
varbuf_add_str(whynot, linebuf);
}
}
return false;
} else {
/* It's conflicts or breaks. There's only one main alternative,
* but we also have to consider Providers. We return ‘false’ as soon
* as we find something that matches the conflict, and only describe
* it then. If we get to the end without finding anything we return
* ‘true’. */
possi= dep->list;
nconflicts= 0;
if (possi->ed != possi->up->up->set) {
struct deppossi_pkg_iterator *possi_iter;
/* If the package conflicts with or breaks itself it must mean
* other packages which provide the same virtual name. We
* therefore don't look at the real package and go on to the
* virtual ones. */
possi_iter = deppossi_pkg_iter_new(possi, wpb_by_istobe);
while ((pkg_pos = deppossi_pkg_iter_next(possi_iter))) {
switch (pkg_pos->clientdata->istobe) {
case PKG_ISTOBE_REMOVE:
break;
case PKG_ISTOBE_INSTALLNEW:
if (!versionsatisfied(&pkg_pos->available, possi))
break;
sprintf(linebuf, _(" %.250s (version %.250s) is to be installed.\n"),
pkgbin_name(pkg_pos, &pkg_pos->available, pnaw_nonambig),
versiondescribe(&pkg_pos->available.version, vdew_nonambig));
varbuf_add_str(whynot, linebuf);
if (!canfixbyremove) {
deppossi_pkg_iter_free(possi_iter);
return false;
}
nconflicts++;
*canfixbyremove = pkg_pos;
break;
case PKG_ISTOBE_DECONFIGURE:
if (dep->type == dep_breaks)
break; /* Already deconfiguring this. */
/* Fall through. */
case PKG_ISTOBE_NORMAL:
case PKG_ISTOBE_PREINSTALL:
switch (pkg_pos->status) {
case PKG_STAT_NOTINSTALLED:
case PKG_STAT_CONFIGFILES:
break;
case PKG_STAT_HALFINSTALLED:
case PKG_STAT_UNPACKED:
case PKG_STAT_HALFCONFIGURED:
if (dep->type == dep_breaks)
break; /* No problem. */
case PKG_STAT_INSTALLED:
case PKG_STAT_TRIGGERSPENDING:
case PKG_STAT_TRIGGERSAWAITED:
if (!versionsatisfied(&pkg_pos->installed, possi))
break;
sprintf(linebuf, _(" %.250s (version %.250s) is present and %s.\n"),
pkg_name(pkg_pos, pnaw_nonambig),
versiondescribe(&pkg_pos->installed.version, vdew_nonambig),
gettext(statusstrings[pkg_pos->status]));
varbuf_add_str(whynot, linebuf);
if (!canfixbyremove) {
deppossi_pkg_iter_free(possi_iter);
return false;
}
nconflicts++;
*canfixbyremove = pkg_pos;
}
break;
default:
internerr("unknown istobe conflict '%d'", pkg_pos->clientdata->istobe);
}
}
deppossi_pkg_iter_free(possi_iter);
}
/* See if the package we're about to install Provides it. */
for (provider = possi->ed->depended.available;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (provider->up->up->clientdata->istobe != PKG_ISTOBE_INSTALLNEW)
continue;
if (provider->up->up->set == dep->up->set)
continue; /* Conflicts and provides the same. */
if (!pkg_virtual_deppossi_satisfied(possi, provider))
continue;
sprintf(linebuf, _(" %.250s provides %.250s and is to be installed.\n"),
pkgbin_name(provider->up->up, &provider->up->up->available,
pnaw_nonambig), possi->ed->name);
varbuf_add_str(whynot, linebuf);
/* We can't remove the one we're about to install: */
if (canfixbyremove)
*canfixbyremove = NULL;
return false;
}
/* Now look at the packages already on the system. */
for (provider = possi->ed->depended.installed;
provider;
provider = provider->rev_next) {
if (provider->up->type != dep_provides) continue;
if (provider->up->up->set == dep->up->set)
continue; /* Conflicts and provides the same. */
if (!pkg_virtual_deppossi_satisfied(possi, provider))
continue;
switch (provider->up->up->clientdata->istobe) {
case PKG_ISTOBE_INSTALLNEW:
/* Don't pay any attention to the Provides field of the
* currently-installed version of the package we're trying
* to install. We dealt with that package by using the
* available information above. */
continue;
case PKG_ISTOBE_REMOVE:
continue;
case PKG_ISTOBE_DECONFIGURE:
if (dep->type == dep_breaks)
continue; /* Already deconfiguring. */
case PKG_ISTOBE_NORMAL:
case PKG_ISTOBE_PREINSTALL:
switch (provider->up->up->status) {
case PKG_STAT_NOTINSTALLED:
case PKG_STAT_CONFIGFILES:
continue;
case PKG_STAT_HALFINSTALLED:
case PKG_STAT_UNPACKED:
case PKG_STAT_HALFCONFIGURED:
if (dep->type == dep_breaks)
break; /* No problem. */
case PKG_STAT_INSTALLED:
case PKG_STAT_TRIGGERSPENDING:
case PKG_STAT_TRIGGERSAWAITED:
sprintf(linebuf,
_(" %.250s provides %.250s and is present and %s.\n"),
pkg_name(provider->up->up, pnaw_nonambig), possi->ed->name,
gettext(statusstrings[provider->up->up->status]));
varbuf_add_str(whynot, linebuf);
if (!canfixbyremove)
return false;
nconflicts++;
*canfixbyremove= provider->up->up;
break;
}
break;
default:
internerr("unknown istobe conflict provider '%d'",
provider->up->up->clientdata->istobe);
}
}
if (!nconflicts)
return true;
if (nconflicts > 1)
*canfixbyremove = NULL;
return false;
} /* if (dependency) {...} else {...} */
}
/**
* Print a single package which:
* (a) is the target of one or more relevant predependencies.
* (b) has itself no unsatisfied pre-dependencies.
*
* If such a package is present output is the Packages file entry,
* which can be massaged as appropriate.
*
* Exit status:
* 0 = a package printed, OK
* 1 = no suitable package available
* 2 = error
*/
void predeppackage(const char *const *argv) {
static struct varbuf vb;
struct pkgiterator *it;
struct pkginfo *pkg = NULL, *startpkg, *trypkg;
struct dependency *dep;
struct deppossi *possi, *provider;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
modstatdb_init(admindir,msdbrw_readonly);
/* We use clientdata->istobe to detect loops. */
clear_istobes();
dep = NULL;
it = pkg_db_iter_new();
while (!dep && (pkg = pkg_db_iter_next(it))) {
/* Ignore packages user doesn't want. */
if (pkg->want != want_install)
continue;
/* Ignore packages not available. */
if (!pkg->files)
continue;
pkg->clientdata->istobe= itb_preinstall;
for (dep= pkg->available.depends; dep; dep= dep->next) {
if (dep->type != dep_predepends) continue;
if (depisok(dep, &vb, NULL, true))
continue;
/* This will leave dep non-NULL, and so exit the loop. */
break;
}
pkg->clientdata->istobe= itb_normal;
/* If dep is NULL we go and get the next package. */
}
pkg_db_iter_free(it);
if (!dep)
exit(1); /* Not found. */
assert(pkg);
startpkg= pkg;
pkg->clientdata->istobe= itb_preinstall;
/* OK, we have found an unsatisfied predependency.
* Now go and find the first thing we need to install, as a first step
* towards satisfying it. */
do {
/* We search for a package which would satisfy dep, and put it in pkg. */
for (possi = dep->list, pkg = NULL;
!pkg && possi;
possi=possi->next) {
trypkg= possi->ed;
if (trypkg->files && versionsatisfied(&trypkg->available,possi)) {
if (trypkg->clientdata->istobe == itb_normal) { pkg= trypkg; break; }
}
if (possi->verrel != dvr_none) continue;
for (provider=possi->ed->available.depended;
!pkg && provider;
provider=provider->next) {
if (provider->up->type != dep_provides) continue;
trypkg= provider->up->up;
if (!trypkg->files)
continue;
if (trypkg->clientdata->istobe == itb_normal) { pkg= trypkg; break; }
}
}
if (!pkg) {
varbufreset(&vb);
describedepcon(&vb,dep);
varbufaddc(&vb,0);
fprintf(stderr, _("dpkg: cannot see how to satisfy pre-dependency:\n %s\n"),vb.buf);
ohshit(_("cannot satisfy pre-dependencies for %.250s (wanted due to %.250s)"),
dep->up->name,startpkg->name);
}
pkg->clientdata->istobe= itb_preinstall;
for (dep= pkg->available.depends; dep; dep= dep->next) {
if (dep->type != dep_predepends) continue;
if (depisok(dep, &vb, NULL, true))
continue;
/* This will leave dep non-NULL, and so exit the loop. */
break;
}
} while (dep);
/* OK, we've found it - pkg has no unsatisfied pre-dependencies! */
writerecord(stdout, _("<standard output>"), pkg, &pkg->available);
m_output(stdout, _("<standard output>"));
}
/**
* Print a single package which:
* (a) is the target of one or more relevant predependencies.
* (b) has itself no unsatisfied pre-dependencies.
*
* If such a package is present output is the Packages file entry,
* which can be massaged as appropriate.
*
* Exit status:
* 0 = a package printed, OK
* 1 = no suitable package available
* 2 = error
*/
int
predeppackage(const char *const *argv)
{
static struct varbuf vb;
struct pkgiterator *it;
struct pkginfo *pkg = NULL, *startpkg, *trypkg;
struct dependency *dep;
struct deppossi *possi, *provider;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
modstatdb_open(msdbrw_readonly | msdbrw_available_readonly);
/* We use clientdata->istobe to detect loops. */
clear_istobes();
dep = NULL;
it = pkg_db_iter_new();
while (!dep && (pkg = pkg_db_iter_next_pkg(it))) {
/* Ignore packages user doesn't want. */
if (pkg->want != PKG_WANT_INSTALL)
continue;
/* Ignore packages not available. */
if (!pkg->files)
continue;
pkg->clientdata->istobe = PKG_ISTOBE_PREINSTALL;
for (dep= pkg->available.depends; dep; dep= dep->next) {
if (dep->type != dep_predepends) continue;
if (depisok(dep, &vb, NULL, NULL, true))
continue;
/* This will leave dep non-NULL, and so exit the loop. */
break;
}
pkg->clientdata->istobe = PKG_ISTOBE_NORMAL;
/* If dep is NULL we go and get the next package. */
}
pkg_db_iter_free(it);
if (!dep)
return 1; /* Not found. */
assert(pkg);
startpkg= pkg;
pkg->clientdata->istobe = PKG_ISTOBE_PREINSTALL;
/* OK, we have found an unsatisfied predependency.
* Now go and find the first thing we need to install, as a first step
* towards satisfying it. */
do {
/* We search for a package which would satisfy dep, and put it in pkg. */
for (possi = dep->list, pkg = NULL;
!pkg && possi;
possi=possi->next) {
struct deppossi_pkg_iterator *possi_iter;
possi_iter = deppossi_pkg_iter_new(possi, wpb_available);
while (!pkg && (trypkg = deppossi_pkg_iter_next(possi_iter))) {
if (trypkg->files &&
trypkg->clientdata->istobe == PKG_ISTOBE_NORMAL &&
versionsatisfied(&trypkg->available, possi)) {
pkg = trypkg;
break;
}
for (provider = possi->ed->depended.available;
!pkg && provider;
provider = provider->next) {
if (provider->up->type != dep_provides)
continue;
if (!pkg_virtual_deppossi_satisfied(possi, provider))
continue;
trypkg = provider->up->up;
if (!trypkg->files)
continue;
if (trypkg->clientdata->istobe == PKG_ISTOBE_NORMAL) {
pkg = trypkg;
break;
}
}
}
deppossi_pkg_iter_free(possi_iter);
}
if (!pkg) {
varbuf_reset(&vb);
describedepcon(&vb,dep);
varbuf_end_str(&vb);
notice(_("cannot see how to satisfy pre-dependency:\n %s"), vb.buf);
ohshit(_("cannot satisfy pre-dependencies for %.250s (wanted due to %.250s)"),
pkgbin_name(dep->up, &dep->up->available, pnaw_nonambig),
pkgbin_name(startpkg, &startpkg->available, pnaw_nonambig));
}
pkg->clientdata->istobe = PKG_ISTOBE_PREINSTALL;
for (dep= pkg->available.depends; dep; dep= dep->next) {
if (dep->type != dep_predepends) continue;
if (depisok(dep, &vb, NULL, NULL, true))
continue;
/* This will leave dep non-NULL, and so exit the loop. */
break;
}
} while (dep);
/* OK, we've found it - pkg has no unsatisfied pre-dependencies! */
writerecord(stdout, _("<standard output>"), pkg, &pkg->available);
m_output(stdout, _("<standard output>"));
return 0;
}
/*
* Return values:
* 0: cannot be satisfied.
* 1: defer: may be satisfied later, when other packages are better or
* at higher dependtry due to --force
* will set *fixbytrig to package whose trigger processing would help
* if applicable (and leave it alone otherwise).
* 2: not satisfied but forcing
* (*interestingwarnings >= 0 on exit? caller is to print oemsgs).
* 3: satisfied now.
*/
static enum found_status
deppossi_ok_found(struct pkginfo *possdependee, struct pkginfo *requiredby,
struct pkginfo *removing, struct deppossi *provider,
struct pkginfo **fixbytrig,
bool *matched, struct deppossi *checkversion,
int *interestingwarnings, struct varbuf *oemsgs)
{
enum found_status thisf;
if (ignore_depends(possdependee)) {
debug(dbg_depcondetail," ignoring depended package so ok and found");
return FOUND_OK;
}
thisf = FOUND_NONE;
if (possdependee == removing) {
if (provider) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s is to be removed.\n"),
pkg_name(possdependee, pnaw_nonambig),
provider->ed->name);
} else {
varbuf_printf(oemsgs, _(" Package %s is to be removed.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
*matched = true;
debug(dbg_depcondetail," removing possdependee, returning %d",thisf);
return thisf;
}
switch (possdependee->status) {
case PKG_STAT_UNPACKED:
case PKG_STAT_HALFCONFIGURED:
case PKG_STAT_TRIGGERSAWAITED:
case PKG_STAT_TRIGGERSPENDING:
case PKG_STAT_INSTALLED:
if (checkversion) {
if (provider) {
debug(dbg_depcondetail, " checking package %s provided by pkg %s",
checkversion->ed->name, pkg_name(possdependee, pnaw_always));
if (!pkg_virtual_deppossi_satisfied(checkversion, provider)) {
varbuf_printf(oemsgs,
_(" Version of %s on system, provided by %s, is %s.\n"),
checkversion->ed->name,
pkg_name(possdependee, pnaw_always),
versiondescribe(&provider->version, vdew_nonambig));
if (in_force(FORCE_DEPENDS_VERSION))
thisf = found_forced_on(DEPEND_TRY_FORCE_DEPENDS_VERSION);
debug(dbg_depcondetail, " bad version");
goto unsuitable;
}
} else {
debug(dbg_depcondetail, " checking non-provided pkg %s",
pkg_name(possdependee, pnaw_always));
if (!versionsatisfied(&possdependee->installed, checkversion)) {
varbuf_printf(oemsgs, _(" Version of %s on system is %s.\n"),
pkg_name(possdependee, pnaw_nonambig),
versiondescribe(&possdependee->installed.version,
vdew_nonambig));
if (in_force(FORCE_DEPENDS_VERSION))
thisf = found_forced_on(DEPEND_TRY_FORCE_DEPENDS_VERSION);
debug(dbg_depcondetail, " bad version");
goto unsuitable;
}
}
}
if (possdependee->status == PKG_STAT_INSTALLED ||
possdependee->status == PKG_STAT_TRIGGERSPENDING) {
debug(dbg_depcondetail," is installed, ok and found");
return FOUND_OK;
}
if (possdependee->status == PKG_STAT_TRIGGERSAWAITED) {
if (possdependee->trigaw.head == NULL)
internerr("package %s in state %s, has no awaited triggers",
pkg_name(possdependee, pnaw_always),
pkg_status_name(possdependee));
if (removing ||
!(f_triggers ||
(possdependee->clientdata &&
possdependee->clientdata->istobe == PKG_ISTOBE_INSTALLNEW))) {
if (provider) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s awaits trigger processing.\n"),
pkg_name(possdependee, pnaw_nonambig),
provider->ed->name);
} else {
varbuf_printf(oemsgs,
_(" Package %s awaits trigger processing.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
debug(dbg_depcondetail, " triggers-awaited, no fixbytrig");
goto unsuitable;
}
/* We don't check the status of trigaw.head->pend here, just in case
* we get into the pathological situation where Triggers-Awaited but
* the named package doesn't actually have any pending triggers. In
* that case we queue the non-pending package for trigger processing
* anyway, and that trigger processing will be a noop except for
* sorting out all of the packages which name it in Triggers-Awaited.
*
* (This situation can only arise if modstatdb_note success in
* clearing the triggers-pending status of the pending package
* but then fails to go on to update the awaiters.) */
*fixbytrig = possdependee->trigaw.head->pend;
debug(dbg_depcondetail,
" triggers-awaited, fixbytrig '%s', defer",
pkg_name(*fixbytrig, pnaw_always));
return FOUND_DEFER;
}
if (possdependee->clientdata &&
possdependee->clientdata->istobe == PKG_ISTOBE_INSTALLNEW) {
debug(dbg_depcondetail," unpacked/halfconfigured, defer");
return FOUND_DEFER;
} else if (!removing && in_force(FORCE_CONFIGURE_ANY) &&
!skip_due_to_hold(possdependee) &&
!(possdependee->status == PKG_STAT_HALFCONFIGURED)) {
notice(_("also configuring '%s' (required by '%s')"),
pkg_name(possdependee, pnaw_nonambig),
pkg_name(requiredby, pnaw_nonambig));
enqueue_package(possdependee);
sincenothing = 0;
return FOUND_DEFER;
} else {
if (provider) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s is not configured yet.\n"),
pkg_name(possdependee, pnaw_nonambig),
provider->ed->name);
} else {
varbuf_printf(oemsgs, _(" Package %s is not configured yet.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
debug(dbg_depcondetail, " not configured/able");
goto unsuitable;
}
default:
if (provider) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s is not installed.\n"),
pkg_name(possdependee, pnaw_nonambig),
provider->ed->name);
} else {
varbuf_printf(oemsgs, _(" Package %s is not installed.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
debug(dbg_depcondetail, " not installed");
goto unsuitable;
}
unsuitable:
debug(dbg_depcondetail, " returning %d", thisf);
(*interestingwarnings)++;
return thisf;
}
/*
* Return values:
* 0: cannot be satisfied.
* 1: defer: may be satisfied later, when other packages are better or
* at higher dependtry due to --force
* will set *fixbytrig to package whose trigger processing would help
* if applicable (and leave it alone otherwise).
* 2: not satisfied but forcing
* (*interestingwarnings >= 0 on exit? caller is to print oemsgs).
* 3: satisfied now.
*/
static enum found_status
deppossi_ok_found(struct pkginfo *possdependee, struct pkginfo *requiredby,
struct pkginfo *removing, struct pkgset *providing,
struct pkginfo **fixbytrig,
bool *matched, struct deppossi *checkversion,
int *interestingwarnings, struct varbuf *oemsgs)
{
enum found_status thisf;
if (ignore_depends(possdependee)) {
debug(dbg_depcondetail," ignoring depended package so ok and found");
return found_ok;
}
thisf = found_none;
if (possdependee == removing) {
if (providing) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s is to be removed.\n"),
pkg_name(possdependee, pnaw_nonambig), providing->name);
} else {
varbuf_printf(oemsgs, _(" Package %s is to be removed.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
*matched = true;
debug(dbg_depcondetail," removing possdependee, returning %d",thisf);
return thisf;
}
switch (possdependee->status) {
case stat_unpacked:
case stat_halfconfigured:
case stat_triggersawaited:
case stat_triggerspending:
case stat_installed:
if (checkversion && !versionsatisfied(&possdependee->installed,checkversion)) {
varbuf_printf(oemsgs, _(" Version of %s on system is %s.\n"),
pkg_name(possdependee, pnaw_nonambig),
versiondescribe(&possdependee->installed.version,
vdew_nonambig));
assert(checkversion->verrel != dpkg_relation_none);
if (fc_dependsversion)
thisf = (dependtry >= 3) ? found_forced : found_defer;
debug(dbg_depcondetail," bad version, returning %d",thisf);
(*interestingwarnings)++;
return thisf;
}
if (possdependee->status == stat_installed ||
possdependee->status == stat_triggerspending) {
debug(dbg_depcondetail," is installed, ok and found");
return found_ok;
}
if (possdependee->status == stat_triggersawaited) {
assert(possdependee->trigaw.head);
if (removing || !(f_triggers ||
possdependee->clientdata->istobe == itb_installnew)) {
if (providing) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s awaits trigger processing.\n"),
pkg_name(possdependee, pnaw_nonambig), providing->name);
} else {
varbuf_printf(oemsgs,
_(" Package %s awaits trigger processing.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
debug(dbg_depcondetail, " triggers-awaited, no fixbytrig");
goto unsuitable;
}
/* We don't check the status of trigaw.head->pend here, just in case
* we get into the pathological situation where Triggers-Awaited but
* the named package doesn't actually have any pending triggers. In
* that case we queue the non-pending package for trigger processing
* anyway, and that trigger processing will be a noop except for
* sorting out all of the packages which name it in Triggers-Awaited.
*
* (This situation can only arise if modstatdb_note success in
* clearing the triggers-pending status of the pending package
* but then fails to go on to update the awaiters.) */
*fixbytrig = possdependee->trigaw.head->pend;
debug(dbg_depcondetail,
" triggers-awaited, fixbytrig '%s', defer",
pkg_name(*fixbytrig, pnaw_always));
return found_defer;
}
if (possdependee->clientdata &&
possdependee->clientdata->istobe == itb_installnew) {
debug(dbg_depcondetail," unpacked/halfconfigured, defer");
return found_defer;
} else if (!removing && fc_configureany &&
!skip_due_to_hold(possdependee) &&
!(possdependee->status == stat_halfconfigured)) {
notice(_("also configuring '%s' (required by '%s')"),
pkg_name(possdependee, pnaw_nonambig),
pkg_name(requiredby, pnaw_nonambig));
enqueue_package(possdependee);
sincenothing = 0;
return found_defer;
} else {
if (providing) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s is not configured yet.\n"),
pkg_name(possdependee, pnaw_nonambig), providing->name);
} else {
varbuf_printf(oemsgs, _(" Package %s is not configured yet.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
debug(dbg_depcondetail, " not configured/able");
goto unsuitable;
}
default:
if (providing) {
varbuf_printf(oemsgs,
_(" Package %s which provides %s is not installed.\n"),
pkg_name(possdependee, pnaw_nonambig), providing->name);
} else {
varbuf_printf(oemsgs, _(" Package %s is not installed.\n"),
pkg_name(possdependee, pnaw_nonambig));
}
debug(dbg_depcondetail, " not installed");
goto unsuitable;
}
unsuitable:
debug(dbg_depcondetail, " returning %d", thisf);
(*interestingwarnings)++;
return thisf;
}
