int
clearselections(const char *const *argv)
{
enum modstatdb_rw msdbflags;
struct pkgiterator *it;
struct pkginfo *pkg;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
if (f_noact)
msdbflags = msdbrw_readonly;
else
msdbflags = msdbrw_write;
modstatdb_open(msdbflags);
pkg_infodb_upgrade();
it = pkg_db_iter_new();
while ((pkg = pkg_db_iter_next_pkg(it))) {
if (!pkg->installed.essential)
pkg_set_want(pkg, PKG_WANT_DEINSTALL);
}
pkg_db_iter_free(it);
modstatdb_shutdown();
return 0;
}
int dpkg_psys_unregister(const char *vendor, const char *name, psys_err_t *err)
{
int ret;
jmp_buf buf;
char *dpkgname;
struct pkginfo *dpkg;
init_error_handler(err, buf, out);
modstatdb_init(ADMINDIR, msdbrw_needsuperuser);
dpkgname = dpkg_name(vendor, name);
dpkg = findpackage(dpkgname);
if (ensure_installed(dpkg, err)) {
ret = -1;
goto out;
}
remove_info_files(dpkg);
dpkg->want = want_purge;
dpkg->status = stat_notinstalled;
blankpackageperfile(&dpkg->installed);
modstatdb_note(dpkg);
ret = 0;
out:
modstatdb_shutdown();
cleanup();
return ret;
}
int
main(int argc, const char * const *argv)
{
const char *env_pkgname;
int ret;
dpkg_locales_init(PACKAGE);
dpkg_program_init("dpkg-divert");
dpkg_options_parse(&argv, cmdinfos, printforhelp);
admindir = dpkg_db_set_dir(admindir);
instdir = dpkg_fsys_set_dir(instdir);
env_pkgname = getenv("DPKG_MAINTSCRIPT_PACKAGE");
if (opt_pkgname_match_any && env_pkgname)
set_package(NULL, env_pkgname);
if (!cipaction)
setaction(&cmdinfo_add, NULL);
modstatdb_open(msdbrw_readonly);
fsys_hash_init();
ensure_diversions();
ret = cipaction->action(argv);
modstatdb_shutdown();
dpkg_program_done();
return ret;
}
int
packages(const char *const *argv)
{
trigproc_install_hooks();
modstatdb_open(f_noact ? msdbrw_readonly :
in_force(FORCE_NON_ROOT) ? msdbrw_write :
msdbrw_needsuperuser);
checkpath();
pkg_infodb_upgrade();
log_message("startup packages %s", cipaction->olong);
if (f_pending) {
if (*argv)
badusage(_("--%s --pending does not take any non-option arguments"),cipaction->olong);
enqueue_pending();
} else {
if (!*argv)
badusage(_("--%s needs at least one package name argument"), cipaction->olong);
enqueue_specified(argv);
}
ensure_diversions();
process_queue();
trigproc_run_deferred();
modstatdb_shutdown();
return 0;
}
static int
arch_remove(const char *const *argv)
{
const char *archname = *argv++;
struct dpkg_arch *arch;
struct pkgiterator *iter;
struct pkginfo *pkg;
if (archname == NULL || *argv)
badusage(_("--%s takes exactly one argument"), cipaction->olong);
modstatdb_open(msdbrw_readonly);
arch = dpkg_arch_find(archname);
if (arch->type != DPKG_ARCH_FOREIGN) {
warning(_("cannot remove non-foreign architecture '%s'"), arch->name);
return 0;
}
/* Check if it's safe to remove the architecture from the db. */
iter = pkg_db_iter_new();
while ((pkg = pkg_db_iter_next_pkg(iter))) {
if (pkg->status < PKG_STAT_HALFINSTALLED)
continue;
if (pkg->installed.arch == arch) {
if (fc_architecture)
warning(_("removing architecture '%s' currently in use by database"),
arch->name);
else
ohshit(_("cannot remove architecture '%s' currently in use by the database"),
arch->name);
break;
}
}
pkg_db_iter_free(iter);
dpkg_arch_unmark(arch);
dpkg_arch_save_list();
modstatdb_shutdown();
return 0;
}
void clearselections(const char *const *argv)
{
struct pkgiterator *it;
struct pkginfo *pkg;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
modstatdb_init(admindir, msdbrw_write);
it = pkg_db_iter_new();
while ((pkg = pkg_db_iter_next(it))) {
if (!pkg->installed.essential)
pkg->want = want_deinstall;
}
pkg_db_iter_free(it);
modstatdb_shutdown();
}
int dpkg_psys_announce(psys_pkg_t pkg, psys_err_t *err)
{
int ret;
jmp_buf buf;
char *dpkgname = NULL;
struct pkginfo *dpkg;
pkg = psys_pkg_copy(pkg);
if (!pkg) {
psys_err_set_nomem(err);
return -1;
}
psys_pkg_assert_valid(pkg);
init_error_handler(err, buf, out);
modstatdb_init(ADMINDIR, msdbrw_needsuperuser);
dpkgname = dpkg_name(psys_pkg_vendor(pkg), psys_pkg_name(pkg));
dpkg = findpackage(dpkgname);
if (ensure_not_installed(dpkg, err)) {
ret = -1;
goto out;
}
if (ensure_dependencies_met(pkg, err)) {
ret = -1;
goto out;
}
if (ensure_no_conflicting_extras(pkg, err)) {
ret = -1;
goto out;
}
ret = 0;
out:
modstatdb_shutdown();
cleanup();
psys_pkg_free(pkg);
return ret;
}
int dpkg_psys_register(psys_pkg_t pkg, psys_err_t *err)
{
int ret;
jmp_buf buf;
pkg = psys_pkg_copy(pkg);
if (!pkg) {
psys_err_set_nomem(err);
return -1;
}
psys_pkg_assert_valid(pkg);
init_error_handler(err, buf, out);
modstatdb_init(ADMINDIR, msdbrw_needsuperuser);
ret = do_register(pkg, err, &buf);
out:
modstatdb_shutdown();
cleanup();
psys_pkg_free(pkg);
return ret;
}
int
clearselections(const char *const *argv)
{
struct pkgiterator *it;
struct pkginfo *pkg;
if (*argv)
badusage(_("--%s takes no arguments"), cipaction->olong);
modstatdb_open(msdbrw_write);
it = pkg_db_iter_new();
while ((pkg = pkg_db_iter_next_pkg(it))) {
if (!pkg->installed.essential)
pkg_set_want(pkg, want_deinstall);
}
pkg_db_iter_free(it);
modstatdb_shutdown();
return 0;
}
int
verify(const char *const *argv)
{
struct pkginfo *pkg;
int rc = 0;
modstatdb_open(msdbrw_readonly);
ensure_diversions();
if (!*argv) {
struct pkgiterator *it;
it = pkg_db_iter_new();
while ((pkg = pkg_db_iter_next_pkg(it)))
verify_package(pkg);
pkg_db_iter_free(it);
} else {
const char *thisarg;
while ((thisarg = *argv++)) {
pkg = dpkg_options_parse_pkgname(cipaction, thisarg);
if (pkg->status == PKG_STAT_NOTINSTALLED) {
notice(_("package '%s' is not installed"),
pkg_name(pkg, pnaw_nonambig));
rc = 1;
continue;
}
verify_package(pkg);
}
}
modstatdb_shutdown();
m_output(stdout, _("<standard output>"));
return rc;
}
int dpkg_psys_unannounce(const char *vendor, const char *name, psys_err_t *err)
{
int ret;
jmp_buf buf;
char *dpkgname;
struct pkginfo *dpkg;
init_error_handler(err, buf, out);
modstatdb_init(ADMINDIR, msdbrw_needsuperuser);
dpkgname = dpkg_name(vendor, name);
dpkg = findpackage(dpkgname);
if (ensure_installed(dpkg, err)) {
ret = -1;
goto out;
}
ret = 0;
out:
modstatdb_shutdown();
cleanup();
return ret;
}
int dpkg_psys_register_update(psys_pkg_t pkg, psys_err_t *err)
{
int ret;
jmp_buf buf;
char *dpkgname;
struct pkginfo *dpkg;
pkg = psys_pkg_copy(pkg);
if (!pkg) {
psys_err_set_nomem(err);
return -1;
}
psys_pkg_assert_valid(pkg);
init_error_handler(err, buf, out);
modstatdb_init(ADMINDIR, msdbrw_needsuperuser);
dpkgname = dpkg_name(psys_pkg_vendor(pkg), psys_pkg_name(pkg));
dpkg = findpackage(dpkgname);
if (ensure_installed(dpkg, err)) {
ret = -1;
goto out;
}
if (ensure_version_newer(pkg, dpkg, err)) {
ret = -1;
goto out;
}
dpkg->status = stat_notinstalled;
ret = do_register(pkg, err, &buf);
out:
modstatdb_shutdown();
cleanup();
psys_pkg_free(pkg);
return ret;
}
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 archivefiles(const char *const *argv) {
const char *volatile thisarg;
const char *const *volatile argp;
jmp_buf ejbuf;
int pi[2], fc, nfiles, c, i, r;
FILE *pf;
static struct varbuf findoutput;
const char **arglist;
char *p;
trigproc_install_hooks();
modstatdb_init(admindir,
f_noact ? msdbrw_readonly
: cipaction->arg == act_avail ? msdbrw_write
: fc_nonroot ? msdbrw_write
: msdbrw_needsuperuser);
checkpath();
log_message("startup archives %s", cipaction->olong);
if (f_recursive) {
if (!*argv)
badusage(_("--%s --recursive needs at least one path argument"),cipaction->olong);
m_pipe(pi);
fc = subproc_fork();
if (!fc) {
struct command cmd;
const char *const *ap;
m_dup2(pi[1],1); close(pi[0]); close(pi[1]);
command_init(&cmd, FIND, _("find for dpkg --recursive"));
command_add_args(&cmd, FIND, "-L", NULL);
for (ap = argv; *ap; ap++) {
if (strchr(FIND_EXPRSTARTCHARS,(*ap)[0])) {
char *a;
a= m_malloc(strlen(*ap)+10);
strcpy(a,"./");
strcat(a,*ap);
command_add_arg(&cmd, a);
} else {
command_add_arg(&cmd, (const char *)*ap);
}
}
command_add_args(&cmd, "-name", "*.deb", "-type", "f", "-print0", NULL);
command_exec(&cmd);
}
close(pi[1]);
nfiles= 0;
pf= fdopen(pi[0],"r"); if (!pf) ohshite(_("failed to fdopen find's pipe"));
varbufreset(&findoutput);
while ((c= fgetc(pf)) != EOF) {
varbufaddc(&findoutput,c);
if (!c) nfiles++;
}
if (ferror(pf)) ohshite(_("error reading find's pipe"));
if (fclose(pf)) ohshite(_("error closing find's pipe"));
r = subproc_wait_check(fc, "find", PROCNOERR);
if (r != 0)
ohshit(_("find for --recursive returned unhandled error %i"),r);
if (!nfiles)
ohshit(_("searched, but found no packages (files matching *.deb)"));
varbufaddc(&findoutput,0);
varbufaddc(&findoutput,0);
arglist= m_malloc(sizeof(char*)*(nfiles+1));
p= findoutput.buf; i=0;
while (*p) {
arglist[i++]= p;
while (*p++ != '\0') ;
}
arglist[i] = NULL;
argp= arglist;
} else {
if (!*argv) badusage(_("--%s needs at least one package archive file argument"),
cipaction->olong);
argp= argv;
}
currenttime = time(NULL);
/* Initialize fname variables contents. */
varbufreset(&fnamevb);
varbufreset(&fnametmpvb);
varbufreset(&fnamenewvb);
varbufaddstr(&fnamevb,instdir); varbufaddc(&fnamevb,'/');
varbufaddstr(&fnametmpvb,instdir); varbufaddc(&fnametmpvb,'/');
varbufaddstr(&fnamenewvb,instdir); varbufaddc(&fnamenewvb,'/');
fnameidlu= fnamevb.used;
ensure_diversions();
ensure_statoverrides();
while ((thisarg = *argp++) != NULL) {
if (setjmp(ejbuf)) {
pop_error_context(ehflag_bombout);
if (abort_processing)
break;
continue;
}
push_error_context_jump(&ejbuf, print_error_perpackage, thisarg);
process_archive(thisarg);
onerr_abort++;
m_output(stdout, _("<standard output>"));
m_output(stderr, _("<standard error>"));
onerr_abort--;
pop_error_context(ehflag_normaltidy);
}
switch (cipaction->arg) {
case act_install:
case act_configure:
case act_triggers:
case act_remove:
case act_purge:
process_queue();
case act_unpack:
case act_avail:
break;
default:
internerr("unknown action '%d'", cipaction->arg);
}
trigproc_run_deferred();
modstatdb_shutdown();
}
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;
}
