/**
* Check if a pkg is informative.
*
* Used by dselect and dpkg query options as an aid to decide whether to
* display things, and by dump to decide whether to write them out.
*/
bool
pkg_is_informative(struct pkginfo *pkg, struct pkgbin *pkgbin)
{
/* We ignore Section and Priority, as these tend to hang around. */
if (pkgbin == &pkg->installed &&
(pkg->want != want_unknown ||
pkg->eflag != eflag_ok ||
pkg->status != stat_notinstalled ||
dpkg_version_is_informative(&pkg->configversion)))
return true;
if (pkgbin->depends ||
str_is_set(pkgbin->description) ||
str_is_set(pkgbin->maintainer) ||
str_is_set(pkgbin->origin) ||
str_is_set(pkgbin->bugs) ||
str_is_set(pkgbin->installedsize) ||
str_is_set(pkgbin->source) ||
dpkg_version_is_informative(&pkgbin->version) ||
pkgbin->conffiles ||
pkgbin->arbs)
return true;
return false;
}
const char *versiondescribe
(const struct dpkg_version *version,
enum versiondisplayepochwhen vdew)
{
static struct varbuf bufs[10];
static int bufnum=0;
struct varbuf *vb;
if (!dpkg_version_is_informative(version))
return C_("version", "<none>");
vb= &bufs[bufnum]; bufnum++; if (bufnum == 10) bufnum= 0;
varbuf_reset(vb);
varbufversion(vb,version,vdew);
varbuf_end_str(vb);
return vb->buf;
}
/*
* *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 {...} */
}
/**
* Load the list of files in this package into memory, or update the
* list if it is there but stale.
*/
void
ensure_packagefiles_available(struct pkginfo *pkg)
{
static int fd;
const char *filelistfile;
struct fileinlist **lendp;
struct stat stat_buf;
char *loaded_list, *loaded_list_end, *thisline, *nextline, *ptr;
if (pkg->clientdata && pkg->clientdata->fileslistvalid)
return;
ensure_package_clientdata(pkg);
/* Throw away any stale data, if there was any. */
pkg_files_blank(pkg);
/* Packages which aren't installed don't have a files list. */
if (pkg->status == stat_notinstalled) {
pkg->clientdata->fileslistvalid = true;
return;
}
filelistfile = pkg_infodb_get_file(pkg, &pkg->installed, LISTFILE);
onerr_abort++;
fd= open(filelistfile,O_RDONLY);
if (fd==-1) {
if (errno != ENOENT)
ohshite(_("unable to open files list file for package `%.250s'"),
pkg_name(pkg, pnaw_nonambig));
onerr_abort--;
if (pkg->status != stat_configfiles &&
dpkg_version_is_informative(&pkg->configversion)) {
warning(_("files list file for package '%.250s' missing; assuming "
"package has no files currently installed"),
pkg_name(pkg, pnaw_nonambig));
}
pkg->clientdata->files = NULL;
pkg->clientdata->fileslistvalid = true;
return;
}
push_cleanup(cu_closefd, ehflag_bombout, NULL, 0, 1, &fd);
if (fstat(fd, &stat_buf))
ohshite(_("unable to stat files list file for package '%.250s'"),
pkg_name(pkg, pnaw_nonambig));
if (!S_ISREG(stat_buf.st_mode))
ohshit(_("files list for package '%.250s' is not a regular file"),
pkg_name(pkg, pnaw_nonambig));
if (stat_buf.st_size) {
loaded_list = nfmalloc(stat_buf.st_size);
loaded_list_end = loaded_list + stat_buf.st_size;
if (fd_read(fd, loaded_list, stat_buf.st_size) < 0)
ohshite(_("reading files list for package '%.250s'"),
pkg_name(pkg, pnaw_nonambig));
lendp= &pkg->clientdata->files;
thisline = loaded_list;
while (thisline < loaded_list_end) {
struct filenamenode *namenode;
ptr = memchr(thisline, '\n', loaded_list_end - thisline);
if (ptr == NULL)
ohshit(_("files list file for package '%.250s' is missing final newline"),
pkg_name(pkg, pnaw_nonambig));
/* Where to start next time around. */
nextline = ptr + 1;
/* Strip trailing ‘/’. */
if (ptr > thisline && ptr[-1] == '/') ptr--;
/* Add the file to the list. */
if (ptr == thisline)
ohshit(_("files list file for package `%.250s' contains empty filename"),
pkg_name(pkg, pnaw_nonambig));
*ptr = '\0';
namenode = findnamenode(thisline, fnn_nocopy);
lendp = pkg_files_add_file(pkg, namenode, lendp);
thisline = nextline;
}
}
pop_cleanup(ehflag_normaltidy); /* fd = open() */
if (close(fd))
ohshite(_("error closing files list file for package `%.250s'"),
pkg_name(pkg, pnaw_nonambig));
onerr_abort--;
pkg->clientdata->fileslistvalid = true;
}
int
cmpversions(const char *const *argv)
{
struct relationinfo {
const char *string;
/* These values are exit status codes, so 0 = true, 1 = false. */
int if_lesser, if_equal, if_greater;
int if_none_a, if_none_both, if_none_b;
};
static const struct relationinfo relationinfos[]= {
/* < = > !a!2!b */
{ "le", 0,0,1, 0,0,1 },
{ "lt", 0,1,1, 0,1,1 },
{ "eq", 1,0,1, 1,0,1 },
{ "ne", 0,1,0, 0,1,0 },
{ "ge", 1,0,0, 1,0,0 },
{ "gt", 1,1,0, 1,1,0 },
/* These treat an empty version as later than any version. */
{ "le-nl", 0,0,1, 1,0,0 },
{ "lt-nl", 0,1,1, 1,1,0 },
{ "ge-nl", 1,0,0, 0,0,1 },
{ "gt-nl", 1,1,0, 0,1,1 },
/* For compatibility with dpkg control file syntax. */
{ "<", 0,0,1, 0,0,1 },
{ "<=", 0,0,1, 0,0,1 },
{ "<<", 0,1,1, 0,1,1 },
{ "=", 1,0,1, 1,0,1 },
{ ">", 1,0,0, 1,0,0 },
{ ">=", 1,0,0, 1,0,0 },
{ ">>", 1,1,0, 1,1,0 },
{ NULL }
};
const struct relationinfo *rip;
struct dpkg_version a, b;
struct dpkg_error err;
int r;
if (!argv[0] || !argv[1] || !argv[2] || argv[3])
badusage(_("--compare-versions takes three arguments:"
" <version> <relation> <version>"));
for (rip=relationinfos; rip->string && strcmp(rip->string,argv[1]); rip++);
if (!rip->string) badusage(_("--compare-versions bad relation"));
if (*argv[0] && strcmp(argv[0],"<unknown>")) {
if (parseversion(&a, argv[0], &err) < 0) {
if (err.type == DPKG_MSG_WARN)
warning(_("version '%s' has bad syntax: %s"), argv[0], err.str);
else
ohshit(_("version '%s' has bad syntax: %s"), argv[0], err.str);
dpkg_error_destroy(&err);
}
} else {
dpkg_version_blank(&a);
}
if (*argv[2] && strcmp(argv[2],"<unknown>")) {
if (parseversion(&b, argv[2], &err) < 0) {
if (err.type == DPKG_MSG_WARN)
warning(_("version '%s' has bad syntax: %s"), argv[2], err.str);
else
ohshit(_("version '%s' has bad syntax: %s"), argv[2], err.str);
dpkg_error_destroy(&err);
}
} else {
dpkg_version_blank(&b);
}
if (!dpkg_version_is_informative(&a)) {
if (dpkg_version_is_informative(&b))
return rip->if_none_a;
else
return rip->if_none_both;
} else if (!dpkg_version_is_informative(&b)) {
return rip->if_none_b;
}
r = dpkg_version_compare(&a, &b);
debug(dbg_general,"cmpversions a=`%s' b=`%s' r=%d",
versiondescribe(&a,vdew_always),
versiondescribe(&b,vdew_always),
r);
if (r > 0)
return rip->if_greater;
else if (r < 0)
return rip->if_lesser;
else
return rip->if_equal;
}
