static void
test_varbuf_addc(void)
{
struct varbuf vb;
varbuf_init(&vb, 1);
varbuf_add_char(&vb, 'a');
test_pass(vb.used == 1);
test_pass(vb.size >= vb.used);
test_pass(vb.buf[0] == 'a');
varbuf_add_char(&vb, 'b');
test_pass(vb.used == 2);
test_pass(vb.size >= vb.used);
test_mem(vb.buf, ==, "ab", 2);
varbuf_add_char(&vb, 'c');
test_pass(vb.used == 3);
test_pass(vb.size >= vb.used);
test_mem(vb.buf, ==, "abc", 3);
varbuf_add_char(&vb, 'd');
test_pass(vb.used == 4);
test_pass(vb.size >= vb.used);
test_mem(vb.buf, ==, "abcd", 4);
varbuf_destroy(&vb);
}
static void
virt_status_abbrev(struct varbuf *vb,
const struct pkginfo *pkg, const struct pkgbin *pkgbin,
enum fwriteflags flags, const struct fieldinfo *fip)
{
if (pkgbin != &pkg->installed)
return;
varbuf_add_char(vb, pkg_abbrev_want(pkg));
varbuf_add_char(vb, pkg_abbrev_status(pkg));
varbuf_add_char(vb, pkg_abbrev_eflag(pkg));
}
void
statusfd_send(const char *fmt, ...)
{
static struct varbuf vb;
struct pipef *pipef;
va_list args;
if (!status_pipes)
return;
va_start(args, fmt);
varbuf_reset(&vb);
varbuf_vprintf(&vb, fmt, args);
/* Sanitize string to not include new lines, as front-ends should be
* doing their own word-wrapping. */
varbuf_map_char(&vb, '\n', ' ');
varbuf_add_char(&vb, '\n');
va_end(args);
for (pipef = status_pipes; pipef; pipef = pipef->next) {
if (fd_write(pipef->fd, vb.buf, vb.used) < 0)
ohshite(_("unable to write to status fd %d"),
pipef->fd);
}
}
/**
* Returns the path to the script inside the chroot.
*/
static const char *
preexecscript(struct command *cmd)
{
const char *admindir = dpkg_db_get_dir();
size_t instdirl = strlen(instdir);
if (*instdir) {
if (strncmp(admindir, instdir, instdirl) != 0)
ohshit(_("admindir must be inside instdir for dpkg to work properly"));
if (setenv("DPKG_ADMINDIR", admindir + instdirl, 1) < 0)
ohshite(_("unable to setenv for subprocesses"));
if (chroot(instdir)) ohshite(_("failed to chroot to `%.250s'"),instdir);
if (chdir("/"))
ohshite(_("failed to chdir to `%.255s'"), "/");
}
if (debug_has_flag(dbg_scripts)) {
struct varbuf args = VARBUF_INIT;
const char **argv = cmd->argv;
while (*++argv) {
varbuf_add_char(&args, ' ');
varbuf_add_str(&args, *argv);
}
varbuf_end_str(&args);
debug(dbg_scripts, "fork/exec %s (%s )", cmd->filename, args.buf);
varbuf_destroy(&args);
}
if (!instdirl)
return cmd->filename;
assert(strlen(cmd->filename) >= instdirl);
return cmd->filename + instdirl;
}
void varbufversion
(struct varbuf *vb,
const struct dpkg_version *version,
enum versiondisplayepochwhen vdew)
{
switch (vdew) {
case vdew_never:
break;
case vdew_nonambig:
if (!version->epoch &&
(!version->version || !strchr(version->version,':')) &&
(!version->revision || !strchr(version->revision,':'))) break;
/* Fall through. */
case vdew_always:
varbuf_printf(vb, "%u:", version->epoch);
break;
default:
internerr("unknown versiondisplayepochwhen '%d'", vdew);
}
if (version->version)
varbuf_add_str(vb, version->version);
if (str_is_set(version->revision)) {
varbuf_add_char(vb, '-');
varbuf_add_str(vb, version->revision);
}
}
bool
find_command(const char *prog)
{
struct varbuf filename = VARBUF_INIT;
struct stat stab;
const char *path_list;
const char *path, *path_end;
size_t path_len;
path_list = getenv("PATH");
if (!path_list)
ohshit(_("PATH is not set"));
for (path = path_list; path; path = path_end ? path_end + 1 : NULL) {
path_end = strchr(path, ':');
path_len = path_end ? (size_t)(path_end - path) : strlen(path);
varbuf_reset(&filename);
varbuf_add_buf(&filename, path, path_len);
if (path_len)
varbuf_add_char(&filename, '/');
varbuf_add_str(&filename, prog);
varbuf_end_str(&filename);
if (stat(filename.buf, &stab) == 0 && (stab.st_mode & 0111)) {
varbuf_destroy(&filename);
return true;
}
}
varbuf_destroy(&filename);
return false;
}
/**
* Verify that some programs can be found in the PATH.
*/
void checkpath(void) {
static const char *const prog_list[] = {
DEFAULTSHELL,
RM,
TAR,
FIND,
BACKEND,
"ldconfig",
#if WITH_START_STOP_DAEMON
"start-stop-daemon",
#endif
NULL
};
const char *const *prog;
const char *path_list;
struct varbuf filename = VARBUF_INIT;
int warned= 0;
path_list = getenv("PATH");
if (!path_list)
ohshit(_("PATH is not set."));
for (prog = prog_list; *prog; prog++) {
struct stat stab;
const char *path, *path_end;
size_t path_len;
for (path = path_list; path; path = path_end ? path_end + 1 : NULL) {
path_end = strchr(path, ':');
path_len = path_end ? (size_t)(path_end - path) : strlen(path);
varbuf_reset(&filename);
varbuf_add_buf(&filename, path, path_len);
if (path_len)
varbuf_add_char(&filename, '/');
varbuf_add_str(&filename, *prog);
varbuf_end_str(&filename);
if (stat(filename.buf, &stab) == 0 && (stab.st_mode & 0111))
break;
}
if (!path) {
warning(_("'%s' not found in PATH or not executable."), *prog);
warned++;
}
}
varbuf_destroy(&filename);
if (warned)
forcibleerr(fc_badpath,
P_("%d expected program not found in PATH or not executable.\n%s",
"%d expected programs not found in PATH or not executable.\n%s",
warned),
warned, _("Note: root's PATH should usually contain "
"/usr/local/sbin, /usr/sbin and /sbin."));
}
const char *
pkgadminfile(struct pkginfo *pkg, struct pkgbin *pkgbin, const char *filetype)
{
static struct varbuf vb;
varbuf_reset(&vb);
varbuf_add_str(&vb, infodir);
varbuf_add_char(&vb, '/');
varbuf_add_str(&vb, pkg->set->name);
if (pkgbin->multiarch == multiarch_same && pkg_infodb_format() >= 1) {
varbuf_add_char(&vb, ':');
varbuf_add_str(&vb, pkgbin->arch->name);
}
varbuf_add_char(&vb, '.');
varbuf_add_str(&vb, filetype);
varbuf_end_str(&vb);
return vb.buf;
}
/*
* Does cycle checking. Doesn't mind if pkg has no triggers pending - in
* that case does nothing but fix up any stale awaiters.
*/
void
trigproc(struct pkginfo *pkg)
{
static struct varbuf namesarg;
struct trigpend *tp;
struct pkginfo *gaveup;
debug(dbg_triggers, "trigproc %s", pkg_describe(pkg, pdo_foreign));
if (pkg->clientdata->trigprocdeferred)
pkg->clientdata->trigprocdeferred->pkg = NULL;
pkg->clientdata->trigprocdeferred = NULL;
if (pkg->trigpend_head) {
assert(pkg->status == stat_triggerspending ||
pkg->status == stat_triggersawaited);
gaveup = check_trigger_cycle(pkg);
if (gaveup == pkg)
return;
printf(_("Processing triggers for %s ...\n"),
pkg_describe(pkg, pdo_foreign));
log_action("trigproc", pkg);
varbuf_reset(&namesarg);
for (tp = pkg->trigpend_head; tp; tp = tp->next) {
varbuf_add_char(&namesarg, ' ');
varbuf_add_str(&namesarg, tp->name);
}
varbuf_end_str(&namesarg);
/* Setting the status to half-configured
* causes modstatdb_note to clear pending triggers. */
pkg->status = stat_halfconfigured;
modstatdb_note(pkg);
if (!f_noact) {
sincenothing = 0;
maintainer_script_postinst(pkg, "triggered",
namesarg.buf + 1, NULL);
}
/* This is to cope if the package triggers itself: */
pkg->status = pkg->trigaw.head ? stat_triggersawaited :
pkg->trigpend_head ? stat_triggerspending :
stat_installed;
post_postinst_tasks_core(pkg);
} else {
/* In other branch is done by modstatdb_note. */
trig_clear_awaiters(pkg);
}
}
/*
* Does cycle checking. Doesn't mind if pkg has no triggers pending - in
* that case does nothing but fix up any stale awaiters.
*/
void
trigproc(struct pkginfo *pkg)
{
static struct varbuf namesarg;
struct trigpend *tp;
struct pkginfo *gaveup;
debug(dbg_triggers, "trigproc %s", pkg_name(pkg, pnaw_always));
if (pkg->clientdata->trigprocdeferred)
pkg->clientdata->trigprocdeferred->pkg = NULL;
pkg->clientdata->trigprocdeferred = NULL;
if (pkg->trigpend_head) {
assert(pkg->status == stat_triggerspending ||
pkg->status == stat_triggersawaited);
gaveup = check_trigger_cycle(pkg);
if (gaveup == pkg)
return;
printf(_("Processing triggers for %s (%s) ...\n"),
pkg_name(pkg, pnaw_nonambig),
versiondescribe(&pkg->installed.version, vdew_nonambig));
log_action("trigproc", pkg, &pkg->installed);
varbuf_reset(&namesarg);
for (tp = pkg->trigpend_head; tp; tp = tp->next) {
varbuf_add_char(&namesarg, ' ');
varbuf_add_str(&namesarg, tp->name);
}
varbuf_end_str(&namesarg);
/* Setting the status to half-configured
* causes modstatdb_note to clear pending triggers. */
pkg_set_status(pkg, stat_halfconfigured);
modstatdb_note(pkg);
if (!f_noact) {
sincenothing = 0;
maintscript_postinst(pkg, "triggered",
namesarg.buf + 1, NULL);
}
post_postinst_tasks(pkg, stat_installed);
} else {
/* In other branch is done by modstatdb_note(), from inside
* post_postinst_tasks(). */
trig_clear_awaiters(pkg);
}
}
/**
* @brief A field extractor to fetch the revision of a package.
*
* dpkg tracks the revision as part of version, but we need to provide our own
* fwritefunction for fieldinfos to extract it.
*/
void w_revision(struct varbuf *vb,
const struct pkginfo *pkg,
const struct pkgbin *pkgbin,
enum fwriteflags flags,
const struct fieldinfo *fip) {
if (flags & fw_printheader) {
varbuf_add_str(vb, "Revision: ");
}
varbuf_add_str(vb, pkgbin->version.revision);
if (flags & fw_printheader) {
varbuf_add_char(vb, '\n');
}
}
const char *
pkg_infodb_get_file(const struct pkginfo *pkg, const struct pkgbin *pkgbin,
const char *filetype)
{
static struct varbuf vb;
enum pkg_infodb_format format;
/* Make sure to always read and verify the format version. */
format = pkg_infodb_get_format();
varbuf_reset(&vb);
varbuf_add_str(&vb, pkg_infodb_get_dir());
varbuf_add_char(&vb, '/');
varbuf_add_str(&vb, pkg->set->name);
if (pkgbin->multiarch == PKG_MULTIARCH_SAME &&
format == PKG_INFODB_FORMAT_MULTIARCH)
varbuf_add_archqual(&vb, pkgbin->arch);
varbuf_add_char(&vb, '.');
varbuf_add_str(&vb, filetype);
varbuf_end_str(&vb);
return vb.buf;
}
static void
trk_explicit_start(const char *trig)
{
trk_explicit_activate_done();
varbuf_reset(&trk_explicit_fn);
varbuf_add_str(&trk_explicit_fn, triggersdir);
varbuf_add_char(&trk_explicit_fn, '/');
varbuf_add_str(&trk_explicit_fn, trig);
varbuf_end_str(&trk_explicit_fn);
trk_explicit_f = fopen(trk_explicit_fn.buf, "r");
if (!trk_explicit_f) {
if (errno != ENOENT)
ohshite(_("failed to open trigger interest list file '%.250s'"),
trk_explicit_fn.buf);
}
}
char *
get_force_string(void)
{
const struct forceinfo *fip;
struct varbuf vb = VARBUF_INIT;
for (fip = forceinfos; fip->name; fip++) {
if ((enum force_flags)fip->flag == FORCE_ALL ||
(fip->flag & force_mask) != fip->flag ||
!in_force(fip->flag))
continue;
if (vb.used)
varbuf_add_char(&vb, ',');
varbuf_add_str(&vb, fip->name);
}
varbuf_end_str(&vb);
return varbuf_detach(&vb);
}
/**
* Verify that some programs can be found in the PATH.
*/
void checkpath(void) {
static const char *const prog_list[] = {
DEFAULTSHELL,
RM,
TAR,
FIND,
BACKEND,
/* Mac OS X uses dyld (Mach-O) instead of ld.so (ELF), and does not have
* an ldconfig. */
#if defined(__APPLE__) && defined(__MACH__)
"update_dyld_shared_cache",
#else
"ldconfig",
#endif
#if BUILD_START_STOP_DAEMON
"start-stop-daemon",
#endif
NULL
};
const char *const *prog;
const char *path_list;
struct varbuf filename = VARBUF_INIT;
int warned= 0;
path_list = getenv("PATH");
if (!path_list)
ohshit(_("PATH is not set"));
for (prog = prog_list; *prog; prog++) {
struct stat stab;
const char *path, *path_end;
size_t path_len;
for (path = path_list; path; path = path_end ? path_end + 1 : NULL) {
path_end = strchr(path, ':');
path_len = path_end ? (size_t)(path_end - path) : strlen(path);
varbuf_reset(&filename);
varbuf_add_buf(&filename, path, path_len);
if (path_len)
varbuf_add_char(&filename, '/');
varbuf_add_str(&filename, *prog);
varbuf_end_str(&filename);
if (stat(filename.buf, &stab) == 0 && (stab.st_mode & 0111))
break;
}
if (!path) {
warning(_("'%s' not found in PATH or not executable"), *prog);
warned++;
}
}
varbuf_destroy(&filename);
if (warned)
forcibleerr(fc_badpath,
P_("%d expected program not found in PATH or not executable\n%s",
"%d expected programs not found in PATH or not executable\n%s",
warned),
warned, _("Note: root's PATH should usually contain "
"/usr/local/sbin, /usr/sbin and /sbin"));
}
/*
* *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 {...} */
}
int
commandfd(const char *const *argv)
{
struct varbuf linevb = VARBUF_INIT;
const char * pipein;
const char **newargs = NULL;
char *ptr, *endptr;
FILE *in;
long infd;
int ret = 0;
int c, lno, i;
bool skipchar;
pipein = *argv++;
if (pipein == NULL || *argv)
badusage(_("--%s takes exactly one argument"), cipaction->olong);
infd = dpkg_options_parse_arg_int(cipaction, pipein);
in = fdopen(infd, "r");
if (in == NULL)
ohshite(_("couldn't open '%i' for stream"), (int)infd);
for (;;) {
bool mode = false;
int argc= 1;
lno= 0;
push_error_context();
do {
c = getc(in);
if (c == '\n')
lno++;
} while (c != EOF && c_isspace(c));
if (c == EOF) break;
if (c == '#') {
do { c= getc(in); if (c == '\n') lno++; } while (c != EOF && c != '\n');
continue;
}
varbuf_reset(&linevb);
do {
varbuf_add_char(&linevb, c);
c= getc(in);
if (c == '\n') lno++;
/* This isn't fully accurate, but overestimating can't hurt. */
if (c_isspace(c))
argc++;
} while (c != EOF && c != '\n');
if (c == EOF)
ohshit(_("unexpected end of file before end of line %d"), lno);
if (!argc) continue;
varbuf_end_str(&linevb);
newargs = m_realloc(newargs, sizeof(const char *) * (argc + 1));
argc= 1;
ptr= linevb.buf;
endptr = ptr + linevb.used + 1;
skipchar = false;
while(ptr < endptr) {
if (skipchar) {
skipchar = false;
} else if (*ptr == '\\') {
memmove(ptr, (ptr+1), (linevb.used-(linevb.buf - ptr)-1));
endptr--;
skipchar = true;
continue;
} else if (c_isspace(*ptr)) {
if (mode == true) {
*ptr = '\0';
mode = false;
}
} else {
if (mode == false) {
newargs[argc]= ptr;
argc++;
mode = true;
}
}
ptr++;
}
*ptr = '\0';
newargs[argc++] = NULL;
/* We strdup() each argument, but never free it, because the
* error messages contain references back to these strings.
* Freeing them, and reusing the memory, would make those
* error messages confusing, to say the least. */
for(i=1;i<argc;i++)
if (newargs[i])
newargs[i] = m_strdup(newargs[i]);
setaction(NULL, NULL);
dpkg_options_parse((const char *const **)&newargs, cmdinfos, printforhelp);
if (!cipaction) badusage(_("need an action option"));
ret |= cipaction->action(newargs);
pop_error_context(ehflag_normaltidy);
}
return ret;
}
/*
* Does cycle checking. Doesn't mind if pkg has no triggers pending - in
* that case does nothing but fix up any stale awaiters.
*/
void
trigproc(struct pkginfo *pkg, enum trigproc_type type)
{
static struct varbuf namesarg;
struct varbuf depwhynot = VARBUF_INIT;
struct trigpend *tp;
struct pkginfo *gaveup;
debug(dbg_triggers, "trigproc %s", pkg_name(pkg, pnaw_always));
if (pkg->clientdata->trigprocdeferred)
pkg->clientdata->trigprocdeferred->pkg = NULL;
pkg->clientdata->trigprocdeferred = NULL;
if (pkg->trigpend_head) {
enum dep_check ok;
assert(pkg->status == PKG_STAT_TRIGGERSPENDING ||
pkg->status == PKG_STAT_TRIGGERSAWAITED);
if (dependtry > 1) {
gaveup = check_trigger_cycle(pkg);
if (gaveup == pkg)
return;
if (findbreakcycle(pkg))
sincenothing = 0;
}
ok = dependencies_ok(pkg, NULL, &depwhynot);
if (ok == DEP_CHECK_DEFER) {
varbuf_destroy(&depwhynot);
enqueue_package(pkg);
return;
} else if (ok == DEP_CHECK_HALT) {
/* We cannot process this package on this dpkg run,
* and we can get here repeatedly if this package is
* required to make progress for other packages. So
* reset the trigger cycles tracking to avoid bogus
* cycle detections. */
trigproc_reset_cycle();
/* When doing opportunistic trigger processig, nothing
* requires us to be able to make progress; skip the
* package and silently ignore the error due to
* unsatisfiable dependencies. */
if (type == TRIGPROC_TRY) {
varbuf_destroy(&depwhynot);
return;
}
sincenothing = 0;
varbuf_end_str(&depwhynot);
notice(_("dependency problems prevent processing "
"triggers for %s:\n%s"),
pkg_name(pkg, pnaw_nonambig), depwhynot.buf);
varbuf_destroy(&depwhynot);
ohshit(_("dependency problems - leaving triggers unprocessed"));
} else if (depwhynot.used) {
varbuf_end_str(&depwhynot);
notice(_("%s: dependency problems, but processing "
"triggers anyway as you requested:\n%s"),
pkg_name(pkg, pnaw_nonambig), depwhynot.buf);
varbuf_destroy(&depwhynot);
}
if (dependtry <= 1) {
gaveup = check_trigger_cycle(pkg);
if (gaveup == pkg)
return;
}
printf(_("Processing triggers for %s (%s) ...\n"),
pkg_name(pkg, pnaw_nonambig),
versiondescribe(&pkg->installed.version, vdew_nonambig));
log_action("trigproc", pkg, &pkg->installed);
varbuf_reset(&namesarg);
for (tp = pkg->trigpend_head; tp; tp = tp->next) {
varbuf_add_char(&namesarg, ' ');
varbuf_add_str(&namesarg, tp->name);
}
varbuf_end_str(&namesarg);
/* Setting the status to half-configured
* causes modstatdb_note to clear pending triggers. */
pkg_set_status(pkg, PKG_STAT_HALFCONFIGURED);
modstatdb_note(pkg);
if (!f_noact) {
sincenothing = 0;
maintscript_postinst(pkg, "triggered",
namesarg.buf + 1, NULL);
}
post_postinst_tasks(pkg, PKG_STAT_INSTALLED);
} else {
/* In other branch is done by modstatdb_note(), from inside
* post_postinst_tasks(). */
trig_clear_awaiters(pkg);
}
}
int
setselections(const char *const *argv)
{
const struct namevalue *nv;
struct pkginfo *pkg;
const char *e;
int c, lno;
struct varbuf namevb = VARBUF_INIT;
struct varbuf selvb = VARBUF_INIT;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
modstatdb_open(msdbrw_write | msdbrw_available_readonly);
lno= 1;
for (;;) {
do { c= getchar(); if (c == '\n') lno++; } while (c != EOF && isspace(c));
if (c == EOF) break;
if (c == '#') {
do { c= getchar(); if (c == '\n') lno++; } while (c != EOF && c != '\n');
continue;
}
varbuf_reset(&namevb);
while (!isspace(c)) {
varbuf_add_char(&namevb, c);
c= getchar();
if (c == EOF) ohshit(_("unexpected eof in package name at line %d"),lno);
if (c == '\n') ohshit(_("unexpected end of line in package name at line %d"),lno);
}
varbuf_end_str(&namevb);
while (c != EOF && isspace(c)) {
c= getchar();
if (c == EOF) ohshit(_("unexpected eof after package name at line %d"),lno);
if (c == '\n') ohshit(_("unexpected end of line after package name at line %d"),lno);
}
varbuf_reset(&selvb);
while (c != EOF && !isspace(c)) {
varbuf_add_char(&selvb, c);
c= getchar();
}
varbuf_end_str(&selvb);
while (c != EOF && c != '\n') {
c= getchar();
if (!isspace(c))
ohshit(_("unexpected data after package and selection at line %d"),lno);
}
e = pkg_name_is_illegal(namevb.buf);
if (e) ohshit(_("illegal package name at line %d: %.250s"),lno,e);
nv = namevalue_find_by_name(wantinfos, selvb.buf);
if (nv == NULL)
ohshit(_("unknown wanted status at line %d: %.250s"), lno, selvb.buf);
pkg = pkg_db_find(namevb.buf);
pkg_set_want(pkg, nv->value);
if (c == EOF) break;
lno++;
}
if (ferror(stdin)) ohshite(_("read error on standard input"));
modstatdb_shutdown();
varbuf_destroy(&namevb);
varbuf_destroy(&selvb);
return 0;
}
void process_archive(const char *filename) {
static const struct tar_operations tf = {
.read = tarfileread,
.extract_file = tarobject,
.link = tarobject,
.symlink = tarobject,
.mkdir = tarobject,
.mknod = tarobject,
};
/* These need to be static so that we can pass their addresses to
* push_cleanup as arguments to the cu_xxx routines; if an error occurs
* we unwind the stack before processing the cleanup list, and these
* variables had better still exist ... */
static int p1[2];
static char *cidir = NULL;
static struct fileinlist *newconffiles, *newfileslist;
static enum pkgstatus oldversionstatus;
static struct varbuf depprobwhy;
static struct tarcontext tc;
int r, i;
pid_t pid;
struct pkgiterator *it;
struct pkginfo *pkg, *otherpkg;
char *cidirrest, *p;
char conffilenamebuf[MAXCONFFILENAME];
char *psize;
const char *pfilename;
struct fileinlist *newconff, **newconffileslastp;
struct fileinlist *cfile;
struct reversefilelistiter rlistit;
struct conffile *searchconff, **iconffileslastp, *newiconff;
struct dependency *dsearch, *newdeplist, **newdeplistlastp;
struct dependency *newdep, *dep, *providecheck;
struct deppossi *psearch, **newpossilastp, *possi, *newpossi, *pdep;
FILE *conff;
struct filenamenode *namenode;
struct stat stab, oldfs;
struct pkg_deconf_list *deconpil, *deconpiltemp;
struct pkginfo *fixbytrigaw;
cleanup_pkg_failed= cleanup_conflictor_failed= 0;
pfilename = summarize_filename(filename);
if (stat(filename,&stab)) ohshite(_("cannot access archive"));
/* We can't ‘tentatively-reassemble’ packages. */
if (!f_noact) {
if (!deb_reassemble(&filename, &pfilename))
return;
}
/* Verify the package. */
if (!f_nodebsig)
deb_verify(filename);
/* Get the control information directory. */
cidir = get_control_dir(cidir);
cidirrest = cidir + strlen(cidir);
push_cleanup(cu_cidir, ~0, NULL, 0, 2, (void *)cidir, (void *)cidirrest);
pid = subproc_fork();
if (pid == 0) {
cidirrest[-1] = '\0';
execlp(BACKEND, BACKEND, "--control", filename, cidir, NULL);
ohshite(_("unable to execute %s (%s)"),
_("package control information extraction"), BACKEND);
}
subproc_wait_check(pid, BACKEND " --control", 0);
/* We want to guarantee the extracted files are on the disk, so that the
* subsequent renames to the info database do not end up with old or zero
* length files in case of a system crash. As neither dpkg-deb nor tar do
* explicit fsync()s, we have to do them here.
* XXX: This could be avoided by switching to an internal tar extractor. */
dir_sync_contents(cidir);
strcpy(cidirrest,CONTROLFILE);
parsedb(cidir, pdb_parse_binary | pdb_ignorefiles | parsedb_force_flags(),
&pkg);
if (!pkg->files) {
pkg->files= nfmalloc(sizeof(struct filedetails));
pkg->files->next = NULL;
pkg->files->name = pkg->files->msdosname = pkg->files->md5sum = NULL;
}
/* Always nfmalloc. Otherwise, we may overwrite some other field (like
* md5sum). */
psize = nfmalloc(30);
sprintf(psize, "%jd", (intmax_t)stab.st_size);
pkg->files->size = psize;
if (cipaction->arg_int == act_avail) {
printf(_("Recorded info about %s from %s.\n"),
pkgbin_name(pkg, &pkg->available, pnaw_nonambig), pfilename);
pop_cleanup(ehflag_normaltidy);
return;
}
if (pkg->available.arch->type != arch_all &&
pkg->available.arch->type != arch_native)
forcibleerr(fc_architecture,
_("package architecture (%s) does not match system (%s)"),
pkg->available.arch->name, dpkg_arch_get(arch_native)->name);
for (deconpil= deconfigure;
deconpil;
deconpil= deconpiltemp) {
deconpiltemp= deconpil->next;
free(deconpil);
}
deconfigure = NULL;
clear_istobes();
if (!wanttoinstall(pkg)) {
pop_cleanup(ehflag_normaltidy);
return;
}
/* Check if anything is installed that we conflict with, or not installed
* that we need. */
pkg->clientdata->istobe= itb_installnew;
for (dsearch= pkg->available.depends; dsearch; dsearch= dsearch->next) {
switch (dsearch->type) {
case dep_conflicts:
/* Look for things we conflict with. */
check_conflict(dsearch, pkg, pfilename);
break;
case dep_breaks:
/* Look for things we break. */
check_breaks(dsearch, pkg, pfilename);
break;
case dep_provides:
/* Look for things that conflict with what we provide. */
for (psearch = dsearch->list->ed->depended.installed;
psearch;
psearch = psearch->rev_next) {
if (psearch->up->type != dep_conflicts)
continue;
check_conflict(psearch->up, pkg, pfilename);
}
break;
case dep_suggests:
case dep_recommends:
case dep_depends:
case dep_replaces:
case dep_enhances:
/* Ignore these here. */
break;
case dep_predepends:
if (!depisok(dsearch, &depprobwhy, NULL, &fixbytrigaw, true)) {
if (fixbytrigaw) {
while (fixbytrigaw->trigaw.head)
trigproc(fixbytrigaw->trigaw.head->pend);
} else {
varbuf_end_str(&depprobwhy);
fprintf(stderr, _("dpkg: regarding %s containing %s, pre-dependency problem:\n%s"),
pfilename, pkgbin_name(pkg, &pkg->available, pnaw_nonambig),
depprobwhy.buf);
if (!force_depends(dsearch->list))
ohshit(_("pre-dependency problem - not installing %.250s"),
pkgbin_name(pkg, &pkg->available, pnaw_nonambig));
warning(_("ignoring pre-dependency problem!"));
}
}
}
}
/* Look for things that conflict with us. */
for (psearch = pkg->set->depended.installed; psearch; psearch = psearch->rev_next) {
if (psearch->up->type != dep_conflicts) continue;
check_conflict(psearch->up, pkg, pfilename);
}
ensure_allinstfiles_available();
filesdbinit();
trig_file_interests_ensure();
if (pkg->status != stat_notinstalled && pkg->status != stat_configfiles) {
printf(_("Preparing to replace %s %s (using %s) ...\n"),
pkg_name(pkg, pnaw_nonambig),
versiondescribe(&pkg->installed.version,vdew_nonambig),
pfilename);
log_action("upgrade", pkg, &pkg->installed);
} else {
printf(_("Unpacking %s (from %s) ...\n"),
pkgbin_name(pkg, &pkg->available, pnaw_nonambig), pfilename);
log_action("install", pkg, &pkg->available);
}
if (f_noact) {
pop_cleanup(ehflag_normaltidy);
return;
}
/*
* OK, we're going ahead.
*/
trig_activate_packageprocessing(pkg);
strcpy(cidirrest, TRIGGERSCIFILE);
trig_parse_ci(cidir, NULL, trig_cicb_statuschange_activate, pkg, &pkg->available);
/* Read the conffiles, and copy the hashes across. */
newconffiles = NULL;
newconffileslastp = &newconffiles;
push_cleanup(cu_fileslist, ~0, NULL, 0, 0);
strcpy(cidirrest,CONFFILESFILE);
conff= fopen(cidir,"r");
if (conff) {
push_cleanup(cu_closestream, ehflag_bombout, NULL, 0, 1, (void *)conff);
while (fgets(conffilenamebuf,MAXCONFFILENAME-2,conff)) {
struct filepackages_iterator *iter;
p= conffilenamebuf + strlen(conffilenamebuf);
assert(p != conffilenamebuf);
if (p[-1] != '\n')
ohshit(_("name of conffile (starting `%.250s') is too long (>%d characters)"),
conffilenamebuf, MAXCONFFILENAME);
while (p > conffilenamebuf && isspace(p[-1])) --p;
if (p == conffilenamebuf) continue;
*p = '\0';
namenode= findnamenode(conffilenamebuf, 0);
namenode->oldhash= NEWCONFFILEFLAG;
newconff= newconff_append(&newconffileslastp, namenode);
/* Let's see if any packages have this file. If they do we
* check to see if they listed it as a conffile, and if they did
* we copy the hash across. Since (for plain file conffiles,
* which is the only kind we are supposed to have) there will
* only be one package which ‘has’ the file, this will usually
* mean we only look in the package which we're installing now.
* The ‘conffiles’ data in the status file is ignored when a
* package isn't also listed in the file ownership database as
* having that file. If several packages are listed as owning
* the file we pick one at random. */
searchconff = NULL;
iter = filepackages_iter_new(newconff->namenode);
while ((otherpkg = filepackages_iter_next(iter))) {
debug(dbg_conffdetail,
"process_archive conffile `%s' in package %s - conff ?",
newconff->namenode->name, pkg_name(otherpkg, pnaw_nonambig));
for (searchconff = otherpkg->installed.conffiles;
searchconff && strcmp(newconff->namenode->name, searchconff->name);
searchconff = searchconff->next)
debug(dbg_conffdetail,
"process_archive conffile `%s' in package %s - conff ? not `%s'",
newconff->namenode->name, pkg_name(otherpkg, pnaw_nonambig),
searchconff->name);
if (searchconff) {
debug(dbg_conff,
"process_archive conffile `%s' package=%s %s hash=%s",
newconff->namenode->name, pkg_name(otherpkg, pnaw_nonambig),
otherpkg == pkg ? "same" : "different!",
searchconff->hash);
if (otherpkg == pkg)
break;
}
}
filepackages_iter_free(iter);
if (searchconff) {
newconff->namenode->oldhash= searchconff->hash;
/* We don't copy ‘obsolete’; it's not obsolete in the new package. */
} else {
debug(dbg_conff,"process_archive conffile `%s' no package, no hash",
newconff->namenode->name);
}
newconff->namenode->flags |= fnnf_new_conff;
}
if (ferror(conff)) ohshite(_("read error in %.250s"),cidir);
pop_cleanup(ehflag_normaltidy); /* conff = fopen() */
if (fclose(conff)) ohshite(_("error closing %.250s"),cidir);
} else {
if (errno != ENOENT) ohshite(_("error trying to open %.250s"),cidir);
}
/* All the old conffiles are marked with a flag, so that we don't delete
* them if they seem to disappear completely. */
oldconffsetflags(pkg->installed.conffiles);
for (i = 0 ; i < cflict_index ; i++) {
oldconffsetflags(conflictor[i]->installed.conffiles);
}
oldversionstatus= pkg->status;
assert(oldversionstatus <= stat_installed);
debug(dbg_general,"process_archive oldversionstatus=%s",
statusstrings[oldversionstatus]);
if (oldversionstatus == stat_halfconfigured ||
oldversionstatus == stat_triggersawaited ||
oldversionstatus == stat_triggerspending ||
oldversionstatus == stat_installed) {
pkg_set_eflags(pkg, eflag_reinstreq);
pkg_set_status(pkg, stat_halfconfigured);
modstatdb_note(pkg);
push_cleanup(cu_prermupgrade, ~ehflag_normaltidy, NULL, 0, 1, (void *)pkg);
if (versioncompare(&pkg->available.version,
&pkg->installed.version) >= 0) /* Upgrade or reinstall */
maintainer_script_alternative(pkg, PRERMFILE, "pre-removal", cidir, cidirrest,
"upgrade", "failed-upgrade");
else /* Downgrade => no fallback */
maintainer_script_installed(pkg, PRERMFILE, "pre-removal", "upgrade",
versiondescribe(&pkg->available.version,
vdew_nonambig), NULL);
pkg_set_status(pkg, stat_unpacked);
oldversionstatus= stat_unpacked;
modstatdb_note(pkg);
}
for (deconpil= deconfigure; deconpil; deconpil= deconpil->next) {
struct pkginfo *removing = deconpil->pkg_removal;
if (removing)
printf(_("De-configuring %s, to allow removal of %s ...\n"),
pkg_name(deconpil->pkg, pnaw_nonambig),
pkg_name(removing, pnaw_nonambig));
else
printf(_("De-configuring %s ...\n"),
pkg_name(deconpil->pkg, pnaw_nonambig));
trig_activate_packageprocessing(deconpil->pkg);
pkg_set_status(deconpil->pkg, stat_halfconfigured);
modstatdb_note(deconpil->pkg);
/* This means that we *either* go and run postinst abort-deconfigure,
* *or* queue the package for later configure processing, depending
* on which error cleanup route gets taken. */
push_cleanup(cu_prermdeconfigure, ~ehflag_normaltidy,
ok_prermdeconfigure, ehflag_normaltidy,
3, (void*)deconpil->pkg, (void*)removing, (void*)pkg);
if (removing) {
maintainer_script_installed(deconpil->pkg, PRERMFILE, "pre-removal",
"deconfigure", "in-favour", pkg->set->name,
versiondescribe(&pkg->available.version,
vdew_nonambig),
"removing", removing->set->name,
versiondescribe(&removing->installed.version,
vdew_nonambig),
NULL);
} else {
maintainer_script_installed(deconpil->pkg, PRERMFILE, "pre-removal",
"deconfigure", "in-favour", pkg->set->name,
versiondescribe(&pkg->available.version,
vdew_nonambig),
NULL);
}
}
for (i = 0 ; i < cflict_index; i++) {
if (!(conflictor[i]->status == stat_halfconfigured ||
conflictor[i]->status == stat_triggersawaited ||
conflictor[i]->status == stat_triggerspending ||
conflictor[i]->status == stat_installed)) continue;
trig_activate_packageprocessing(conflictor[i]);
pkg_set_status(conflictor[i], stat_halfconfigured);
modstatdb_note(conflictor[i]);
push_cleanup(cu_prerminfavour, ~ehflag_normaltidy, NULL, 0,
2,(void*)conflictor[i],(void*)pkg);
maintainer_script_installed(conflictor[i], PRERMFILE, "pre-removal",
"remove", "in-favour", pkg->set->name,
versiondescribe(&pkg->available.version,
vdew_nonambig),
NULL);
pkg_set_status(conflictor[i], stat_halfinstalled);
modstatdb_note(conflictor[i]);
}
pkg_set_eflags(pkg, eflag_reinstreq);
if (pkg->status == stat_notinstalled)
pkg->installed.version= pkg->available.version;
pkg_set_status(pkg, stat_halfinstalled);
modstatdb_note(pkg);
if (oldversionstatus == stat_notinstalled) {
push_cleanup(cu_preinstverynew, ~ehflag_normaltidy, NULL, 0,
3,(void*)pkg,(void*)cidir,(void*)cidirrest);
maintainer_script_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
"install", NULL);
} else if (oldversionstatus == stat_configfiles) {
push_cleanup(cu_preinstnew, ~ehflag_normaltidy, NULL, 0,
3,(void*)pkg,(void*)cidir,(void*)cidirrest);
maintainer_script_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
"install", versiondescribe(&pkg->installed.version,
vdew_nonambig),
NULL);
} else {
push_cleanup(cu_preinstupgrade, ~ehflag_normaltidy, NULL, 0,
4,(void*)pkg,(void*)cidir,(void*)cidirrest,(void*)&oldversionstatus);
maintainer_script_new(pkg, PREINSTFILE, "pre-installation", cidir, cidirrest,
"upgrade", versiondescribe(&pkg->installed.version,
vdew_nonambig),
NULL);
printf(_("Unpacking replacement %.250s ...\n"),
pkgbin_name(pkg, &pkg->available, pnaw_nonambig));
}
/*
* Now we unpack the archive, backing things up as we go.
* For each file, we check to see if it already exists.
* There are several possibilities:
*
* + We are trying to install a non-directory ...
* - It doesn't exist. In this case we simply extract it.
* - It is a plain file, device, symlink, &c. We do an ‘atomic
* overwrite’ using link() and rename(), but leave a backup copy.
* Later, when we delete the backup, we remove it from any other
* packages' lists.
* - It is a directory. In this case it depends on whether we're
* trying to install a symlink or something else.
* = If we're not trying to install a symlink we move the directory
* aside and extract the node. Later, when we recursively remove
* the backed-up directory, we remove it from any other packages'
* lists.
* = If we are trying to install a symlink we do nothing - ie,
* dpkg will never replace a directory tree with a symlink. This
* is to avoid embarrassing effects such as replacing a directory
* tree with a link to a link to the original directory tree.
* + We are trying to install a directory ...
* - It doesn't exist. We create it with the appropriate modes.
* - It exists as a directory or a symlink to one. We do nothing.
* - It is a plain file or a symlink (other than to a directory).
* We move it aside and create the directory. Later, when we
* delete the backup, we remove it from any other packages' lists.
*
* Install non-dir Install symlink Install dir
* Exists not X X X
* File/node/symlink LXR LXR BXR
* Directory BXR - -
*
* X: extract file/node/link/directory
* LX: atomic overwrite leaving backup
* B: ordinary backup
* R: later remove from other packages' lists
* -: do nothing
*
* After we've done this we go through the remaining things in the
* lists of packages we're trying to remove (including the old
* version of the current package). This happens in reverse order,
* so that we process files before the directories (or symlinks-to-
* directories) containing them.
*
* + If the thing is a conffile then we leave it alone for the purge
* operation.
* + Otherwise, there are several possibilities too:
* - The listed thing does not exist. We ignore it.
* - The listed thing is a directory or a symlink to a directory.
* We delete it only if it isn't listed in any other package.
* - The listed thing is not a directory, but was part of the package
* that was upgraded, we check to make sure the files aren't the
* same ones from the old package by checking dev/inode
* - The listed thing is not a directory or a symlink to one (ie,
* it's a plain file, device, pipe, &c, or a symlink to one, or a
* dangling symlink). We delete it.
*
* The removed packages' list becomes empty (of course, the new
* version of the package we're installing will have a new list,
* which replaces the old version's list).
*
* If at any stage we remove a file from a package's list, and the
* package isn't one we're already processing, and the package's
* list becomes empty as a result, we ‘vanish’ the package. This
* means that we run its postrm with the ‘disappear’ argument, and
* put the package in the ‘not-installed’ state. If it had any
* conffiles, their hashes and ownership will have been transferred
* already, so we just ignore those and forget about them from the
* point of view of the disappearing package.
*
* NOTE THAT THE OLD POSTRM IS RUN AFTER THE NEW PREINST, since the
* files get replaced ‘as we go’.
*/
m_pipe(p1);
push_cleanup(cu_closepipe, ehflag_bombout, NULL, 0, 1, (void *)&p1[0]);
pid = subproc_fork();
if (pid == 0) {
m_dup2(p1[1],1); close(p1[0]); close(p1[1]);
execlp(BACKEND, BACKEND, "--fsys-tarfile", filename, NULL);
ohshite(_("unable to execute %s (%s)"),
_("package filesystem archive extraction"), BACKEND);
}
close(p1[1]);
p1[1] = -1;
newfileslist = NULL;
tc.newfilesp = &newfileslist;
push_cleanup(cu_fileslist, ~0, NULL, 0, 0);
tc.pkg= pkg;
tc.backendpipe= p1[0];
r = tar_extractor(&tc, &tf);
if (r) {
if (errno) {
ohshite(_("error reading dpkg-deb tar output"));
} else {
ohshit(_("corrupted filesystem tarfile - corrupted package archive"));
}
}
fd_skip(p1[0], -1, _("dpkg-deb: zap possible trailing zeros"));
close(p1[0]);
p1[0] = -1;
subproc_wait_check(pid, BACKEND " --fsys-tarfile", PROCPIPE);
tar_deferred_extract(newfileslist, pkg);
if (oldversionstatus == stat_halfinstalled || oldversionstatus == stat_unpacked) {
/* Packages that were in ‘installed’ and ‘postinstfailed’ have been
* reduced to ‘unpacked’ by now, by the running of the prerm script. */
pkg_set_status(pkg, stat_halfinstalled);
modstatdb_note(pkg);
push_cleanup(cu_postrmupgrade, ~ehflag_normaltidy, NULL, 0, 1, (void *)pkg);
maintainer_script_alternative(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
"upgrade", "failed-upgrade");
}
/* If anything goes wrong while tidying up it's a bit late to do
* anything about it. However, we don't install the new status
* info yet, so that a future dpkg installation will put everything
* right (we hope).
*
* If something does go wrong later the ‘conflictor’ package will be
* left in the ‘removal_failed’ state. Removing or installing it
* will be impossible if it was required because of the conflict with
* the package we're installing now and (presumably) the dependency
* by other packages. This means that the files it contains in
* common with this package will hang around until we successfully
* get this package installed, after which point we can trust the
* conflicting package's file list, which will have been updated to
* remove any files in this package. */
push_checkpoint(~ehflag_bombout, ehflag_normaltidy);
/* Now we delete all the files that were in the old version of
* the package only, except (old or new) conffiles, which we leave
* alone. */
reversefilelist_init(&rlistit,pkg->clientdata->files);
while ((namenode= reversefilelist_next(&rlistit))) {
struct filenamenode *usenode;
if ((namenode->flags & fnnf_new_conff) ||
(namenode->flags & fnnf_new_inarchive))
continue;
usenode = namenodetouse(namenode, pkg, &pkg->installed);
trig_file_activate(usenode, pkg);
varbuf_trunc(&fnamevb, fnameidlu);
varbuf_add_str(&fnamevb, usenode->name);
varbuf_end_str(&fnamevb);
if (!stat(namenode->name,&stab) && S_ISDIR(stab.st_mode)) {
debug(dbg_eachfiledetail, "process_archive: %s is a directory",
namenode->name);
if (dir_is_used_by_others(namenode, pkg))
continue;
}
if (lstat(fnamevb.buf, &oldfs)) {
if (!(errno == ENOENT || errno == ELOOP || errno == ENOTDIR))
warning(_("could not stat old file '%.250s' so not deleting it: %s"),
fnamevb.buf, strerror(errno));
continue;
}
if (S_ISDIR(oldfs.st_mode)) {
if (rmdir(fnamevb.buf)) {
warning(_("unable to delete old directory '%.250s': %s"),
namenode->name, strerror(errno));
} else if ((namenode->flags & fnnf_old_conff)) {
warning(_("old conffile '%.250s' was an empty directory "
"(and has now been deleted)"), namenode->name);
}
} else {
struct fileinlist *sameas = NULL;
static struct stat empty_stat;
struct varbuf cfilename = VARBUF_INIT;
/*
* Ok, it's an old file, but is it really not in the new package?
* It might be known by a different name because of symlinks.
*
* We need to check to make sure, so we stat the file, then compare
* it to the new list. If we find a dev/inode match, we assume they
* are the same file, and leave it alone. NOTE: we don't check in
* other packages for sanity reasons (we don't want to stat _all_
* the files on the system).
*
* We run down the list of _new_ files in this package. This keeps
* the process a little leaner. We are only worried about new ones
* since ones that stayed the same don't really apply here.
*/
/* If we can't stat the old or new file, or it's a directory,
* we leave it up to the normal code. */
debug(dbg_eachfile, "process_archive: checking %s for same files on "
"upgrade/downgrade", fnamevb.buf);
for (cfile= newfileslist; cfile; cfile= cfile->next) {
/* If the file has been filtered then treat it as if it didn't exist
* on the file system. */
if (cfile->namenode->flags & fnnf_filtered)
continue;
if (!cfile->namenode->filestat) {
struct stat tmp_stat;
varbuf_reset(&cfilename);
varbuf_add_str(&cfilename, instdir);
varbuf_add_char(&cfilename, '/');
varbuf_add_str(&cfilename, cfile->namenode->name);
varbuf_end_str(&cfilename);
if (lstat(cfilename.buf, &tmp_stat) == 0) {
cfile->namenode->filestat = nfmalloc(sizeof(struct stat));
memcpy(cfile->namenode->filestat, &tmp_stat, sizeof(struct stat));
} else {
if (!(errno == ENOENT || errno == ELOOP || errno == ENOTDIR))
ohshite(_("unable to stat other new file `%.250s'"),
cfile->namenode->name);
cfile->namenode->filestat = &empty_stat;
continue;
}
}
if (cfile->namenode->filestat == &empty_stat)
continue;
if (oldfs.st_dev == cfile->namenode->filestat->st_dev &&
oldfs.st_ino == cfile->namenode->filestat->st_ino) {
if (sameas)
warning(_("old file '%.250s' is the same as several new files! "
"(both '%.250s' and '%.250s')"), fnamevb.buf,
sameas->namenode->name, cfile->namenode->name);
sameas= cfile;
debug(dbg_eachfile, "process_archive: not removing %s,"
" since it matches %s", fnamevb.buf, cfile->namenode->name);
}
}
varbuf_destroy(&cfilename);
if ((namenode->flags & fnnf_old_conff)) {
if (sameas) {
if (sameas->namenode->flags & fnnf_new_conff) {
if (!strcmp(sameas->namenode->oldhash, NEWCONFFILEFLAG)) {
sameas->namenode->oldhash= namenode->oldhash;
debug(dbg_eachfile, "process_archive: old conff %s"
" is same as new conff %s, copying hash",
namenode->name, sameas->namenode->name);
} else {
debug(dbg_eachfile, "process_archive: old conff %s"
" is same as new conff %s but latter already has hash",
namenode->name, sameas->namenode->name);
}
}
} else {
debug(dbg_eachfile, "process_archive: old conff %s"
" is disappearing", namenode->name);
namenode->flags |= fnnf_obs_conff;
newconff_append(&newconffileslastp, namenode);
addfiletolist(&tc, namenode);
}
continue;
}
if (sameas)
continue;
if (secure_unlink_statted(fnamevb.buf, &oldfs)) {
warning(_("unable to securely remove old file '%.250s': %s"),
namenode->name, strerror(errno));
}
} /* !S_ISDIR */
}
/* OK, now we can write the updated files-in-this package list,
* since we've done away (hopefully) with all the old junk. */
write_filelist_except(pkg, &pkg->available, newfileslist, 0);
/* Trigger interests may have changed.
* Firstly we go through the old list of interests deleting them.
* Then we go through the new list adding them. */
strcpy(cidirrest, TRIGGERSCIFILE);
trig_parse_ci(pkgadminfile(pkg, &pkg->installed, TRIGGERSCIFILE),
trig_cicb_interest_delete, NULL, pkg, &pkg->installed);
trig_parse_ci(cidir, trig_cicb_interest_add, NULL, pkg, &pkg->available);
trig_file_interests_save();
/* We also install the new maintainer scripts, and any other
* cruft that may have come along with the package. First
* we go through the existing scripts replacing or removing
* them as appropriate; then we go through the new scripts
* (any that are left) and install them. */
debug(dbg_general, "process_archive updating info directory");
pkg_infodb_update(pkg, cidir, cidirrest);
/*
* Update the status database.
*
* This involves copying each field across from the ‘available’
* to the ‘installed’ half of the pkg structure.
* For some of the fields we have to do a complicated construction
* operation; for others we can just copy the value.
* We tackle the fields in the order they appear, so that
* we don't miss any out :-).
* At least we don't have to copy any strings that are referred
* to, because these are never modified and never freed.
*/
/* The dependencies are the most difficult. We have to build
* a whole new forward dependency tree. At least the reverse
* links (linking our deppossi's into the reverse chains)
* can be done by copy_dependency_links. */
newdeplist = NULL;
newdeplistlastp = &newdeplist;
for (dep= pkg->available.depends; dep; dep= dep->next) {
newdep= nfmalloc(sizeof(struct dependency));
newdep->up= pkg;
newdep->next = NULL;
newdep->list = NULL;
newpossilastp = &newdep->list;
for (possi= dep->list; possi; possi= possi->next) {
newpossi= nfmalloc(sizeof(struct deppossi));
newpossi->up= newdep;
newpossi->ed= possi->ed;
newpossi->next = NULL;
newpossi->rev_next = newpossi->rev_prev = NULL;
newpossi->arch_is_implicit = possi->arch_is_implicit;
newpossi->arch = possi->arch;
newpossi->verrel= possi->verrel;
if (possi->verrel != dvr_none)
newpossi->version= possi->version;
else
blankversion(&newpossi->version);
newpossi->cyclebreak = false;
*newpossilastp= newpossi;
newpossilastp= &newpossi->next;
}
newdep->type= dep->type;
*newdeplistlastp= newdep;
newdeplistlastp= &newdep->next;
}
/* Right, now we've replicated the forward tree, we
* get copy_dependency_links to remove all the old dependency
* structures from the reverse links and add the new dependency
* structures in instead. It also copies the new dependency
* structure pointer for this package into the right field. */
copy_dependency_links(pkg,&pkg->installed.depends,newdeplist,0);
/* We copy the text fields. */
pkg->installed.essential= pkg->available.essential;
pkg->installed.multiarch = pkg->available.multiarch;
pkg->installed.description= pkg->available.description;
pkg->installed.maintainer= pkg->available.maintainer;
pkg->installed.source= pkg->available.source;
pkg->installed.arch = pkg->available.arch;
pkg->installed.installedsize= pkg->available.installedsize;
pkg->installed.version= pkg->available.version;
pkg->installed.origin = pkg->available.origin;
pkg->installed.bugs = pkg->available.bugs;
/* We have to generate our own conffiles structure. */
pkg->installed.conffiles = NULL;
iconffileslastp = &pkg->installed.conffiles;
for (cfile= newconffiles; cfile; cfile= cfile->next) {
newiconff= nfmalloc(sizeof(struct conffile));
newiconff->next = NULL;
newiconff->name= nfstrsave(cfile->namenode->name);
newiconff->hash= nfstrsave(cfile->namenode->oldhash);
newiconff->obsolete= !!(cfile->namenode->flags & fnnf_obs_conff);
*iconffileslastp= newiconff;
iconffileslastp= &newiconff->next;
}
/* We can just copy the arbitrary fields list, because it is
* never even rearranged. Phew! */
pkg->installed.arbs= pkg->available.arbs;
/* Check for disappearing packages:
* We go through all the packages on the system looking for ones
* whose files are entirely part of the one we've just unpacked
* (and which actually *have* some files!).
*
* Any that we find are removed - we run the postrm with ‘disappear’
* as an argument, and remove their info/... files and status info.
* Conffiles are ignored (the new package had better do something
* with them!). */
it = pkg_db_iter_new();
while ((otherpkg = pkg_db_iter_next_pkg(it)) != NULL) {
ensure_package_clientdata(otherpkg);
if (otherpkg == pkg ||
otherpkg->status == stat_notinstalled ||
otherpkg->status == stat_configfiles ||
otherpkg->clientdata->istobe == itb_remove ||
!otherpkg->clientdata->files) continue;
debug(dbg_veryverbose, "process_archive checking disappearance %s",
pkg_name(otherpkg, pnaw_nonambig));
assert(otherpkg->clientdata->istobe == itb_normal ||
otherpkg->clientdata->istobe == itb_deconfigure);
for (cfile= otherpkg->clientdata->files;
cfile && !strcmp(cfile->namenode->name,"/.");
cfile= cfile->next);
if (!cfile) {
debug(dbg_stupidlyverbose, "process_archive no non-root, no disappear");
continue;
}
for (cfile= otherpkg->clientdata->files;
cfile && !filesavespackage(cfile,otherpkg,pkg);
cfile= cfile->next);
if (cfile) continue;
/* So dependency things will give right answers ... */
otherpkg->clientdata->istobe= itb_remove;
debug(dbg_veryverbose, "process_archive disappear checking dependencies");
for (pdep = otherpkg->set->depended.installed;
pdep;
pdep = pdep->rev_next) {
if (pdep->up->type != dep_depends && pdep->up->type != dep_predepends &&
pdep->up->type != dep_recommends) continue;
if (depisok(pdep->up, &depprobwhy, NULL, NULL, false))
continue;
varbuf_end_str(&depprobwhy);
debug(dbg_veryverbose,"process_archive cannot disappear: %s",depprobwhy.buf);
break;
}
if (!pdep) {
/* If we haven't found a reason not to yet, let's look some more. */
for (providecheck= otherpkg->installed.depends;
providecheck;
providecheck= providecheck->next) {
if (providecheck->type != dep_provides) continue;
for (pdep = providecheck->list->ed->depended.installed;
pdep;
pdep = pdep->rev_next) {
if (pdep->up->type != dep_depends && pdep->up->type != dep_predepends &&
pdep->up->type != dep_recommends)
continue;
if (depisok(pdep->up, &depprobwhy, NULL, NULL, false))
continue;
varbuf_end_str(&depprobwhy);
debug(dbg_veryverbose,"process_archive cannot disappear (provides %s): %s",
providecheck->list->ed->name, depprobwhy.buf);
goto break_from_both_loops_at_once;
}
}
break_from_both_loops_at_once:;
}
otherpkg->clientdata->istobe= itb_normal;
if (pdep) continue;
/* No, we're disappearing it. This is the wrong time to go and
* run maintainer scripts and things, as we can't back out. But
* what can we do ? It has to be run this late. */
pkg_disappear(otherpkg, pkg);
} /* while (otherpkg= ... */
pkg_db_iter_free(it);
/* Delete files from any other packages' lists.
* We have to do this before we claim this package is in any
* sane kind of state, as otherwise we might delete by mistake
* a file that we overwrote, when we remove the package which
* had the version we overwrote. To prevent this we make
* sure that we don't claim this package is OK until we
* have claimed ‘ownership’ of all its files. */
for (cfile= newfileslist; cfile; cfile= cfile->next) {
struct filepackages_iterator *iter;
struct pkgset *divpkgset;
if (!(cfile->namenode->flags & fnnf_elide_other_lists)) continue;
if (cfile->namenode->divert && cfile->namenode->divert->useinstead) {
divpkgset = cfile->namenode->divert->pkgset;
if (divpkgset == pkg->set) {
debug(dbg_eachfile,
"process_archive not overwriting any `%s' (overriding, `%s')",
cfile->namenode->name, cfile->namenode->divert->useinstead->name);
continue;
} else {
debug(dbg_eachfile,
"process_archive looking for overwriting `%s' (overridden by %s)",
cfile->namenode->name, divpkgset ? divpkgset->name : "<local>");
}
} else {
divpkgset = NULL;
debug(dbg_eachfile, "process_archive looking for overwriting `%s'",
cfile->namenode->name);
}
iter = filepackages_iter_new(cfile->namenode);
while ((otherpkg = filepackages_iter_next(iter))) {
debug(dbg_eachfiledetail, "process_archive ... found in %s",
pkg_name(otherpkg, pnaw_nonambig));
/* If !fileslistvalid then it's one of the disappeared packages above
* and we don't bother with it here, clearly. */
if (otherpkg == pkg || !otherpkg->clientdata->fileslistvalid)
continue;
if (otherpkg->set == divpkgset) {
debug(dbg_eachfiledetail, "process_archive ... diverted, skipping");
continue;
}
/* Found one. We delete remove the list entry for this file,
* (and any others in the same package) and then mark the package
* as requiring a reread. */
write_filelist_except(otherpkg, &otherpkg->installed,
otherpkg->clientdata->files, fnnf_elide_other_lists);
ensure_package_clientdata(otherpkg);
debug(dbg_veryverbose, "process_archive overwrote from %s",
pkg_name(otherpkg, pnaw_nonambig));
}
filepackages_iter_free(iter);
}
/* Right, the package we've unpacked is now in a reasonable state.
* The only thing that we have left to do with it is remove
* backup files, and we can leave the user to fix that if and when
* it happens (we leave the reinstall required flag, of course). */
pkg_set_status(pkg, stat_unpacked);
modstatdb_note(pkg);
/* Now we delete all the backup files that we made when
* extracting the archive - except for files listed as conffiles
* in the new package.
* This time we count it as an error if something goes wrong.
*
* Note that we don't ever delete things that were in the old
* package as a conffile and don't appear at all in the new.
* They stay recorded as obsolete conffiles and will eventually
* (if not taken over by another package) be forgotten. */
for (cfile= newfileslist; cfile; cfile= cfile->next) {
if (cfile->namenode->flags & fnnf_new_conff) continue;
varbuf_trunc(&fnametmpvb, fnameidlu);
varbuf_add_str(&fnametmpvb,
namenodetouse(cfile->namenode, pkg, &pkg->installed)->name);
varbuf_add_str(&fnametmpvb, DPKGTEMPEXT);
varbuf_end_str(&fnametmpvb);
ensure_pathname_nonexisting(fnametmpvb.buf);
}
/* OK, we're now fully done with the main package.
* This is quite a nice state, so we don't unwind past here. */
pkg_reset_eflags(pkg);
modstatdb_note(pkg);
push_checkpoint(~ehflag_bombout, ehflag_normaltidy);
/* Only the removal of the conflictor left to do.
* The files list for the conflictor is still a little inconsistent in-core,
* as we have not yet updated the filename->packages mappings; however,
* the package->filenames mapping is. */
for (i = 0 ; i < cflict_index ; i++) {
/* We need to have the most up-to-date info about which files are
* what ... */
ensure_allinstfiles_available();
removal_bulk(conflictor[i]);
}
if (cipaction->arg_int == act_install)
add_to_queue(pkg);
}
int
setselections(const char *const *argv)
{
enum modstatdb_rw msdbflags;
const struct namevalue *nv;
struct pkginfo *pkg;
int c, lno;
struct varbuf namevb = VARBUF_INIT;
struct varbuf selvb = VARBUF_INIT;
bool db_possibly_outdated = false;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
msdbflags = msdbrw_available_readonly;
if (f_noact)
msdbflags |= msdbrw_readonly;
else
msdbflags |= msdbrw_write;
modstatdb_open(msdbflags);
pkg_infodb_upgrade();
lno= 1;
for (;;) {
struct dpkg_error err;
do { c= getchar(); if (c == '\n') lno++; } while (c != EOF && isspace(c));
if (c == EOF) break;
if (c == '#') {
do { c= getchar(); if (c == '\n') lno++; } while (c != EOF && c != '\n');
continue;
}
varbuf_reset(&namevb);
while (!isspace(c)) {
varbuf_add_char(&namevb, c);
c= getchar();
if (c == EOF) ohshit(_("unexpected eof in package name at line %d"),lno);
if (c == '\n') ohshit(_("unexpected end of line in package name at line %d"),lno);
}
varbuf_end_str(&namevb);
while (c != EOF && isspace(c)) {
c= getchar();
if (c == EOF) ohshit(_("unexpected eof after package name at line %d"),lno);
if (c == '\n') ohshit(_("unexpected end of line after package name at line %d"),lno);
}
varbuf_reset(&selvb);
while (c != EOF && !isspace(c)) {
varbuf_add_char(&selvb, c);
c= getchar();
}
varbuf_end_str(&selvb);
while (c != EOF && c != '\n') {
c= getchar();
if (!isspace(c))
ohshit(_("unexpected data after package and selection at line %d"),lno);
}
pkg = pkg_spec_parse_pkg(namevb.buf, &err);
if (pkg == NULL)
ohshit(_("illegal package name at line %d: %.250s"), lno, err.str);
if (!pkg_is_informative(pkg, &pkg->installed) &&
!pkg_is_informative(pkg, &pkg->available)) {
db_possibly_outdated = true;
warning(_("package not in database at line %d: %.250s"), lno, namevb.buf);
continue;
}
nv = namevalue_find_by_name(wantinfos, selvb.buf);
if (nv == NULL)
ohshit(_("unknown wanted status at line %d: %.250s"), lno, selvb.buf);
pkg_set_want(pkg, nv->value);
if (c == EOF) break;
lno++;
}
if (ferror(stdin)) ohshite(_("read error on standard input"));
modstatdb_shutdown();
varbuf_destroy(&namevb);
varbuf_destroy(&selvb);
if (db_possibly_outdated)
warning(_("found unknown packages; this might mean the available database\n"
"is outdated, and needs to be updated through a frontend method"));
return 0;
}