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 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 assert_version_support(const char *const *argv, struct dpkg_version *version, const char *feature_name) { struct pkginfo *pkg; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); modstatdb_open(msdbrw_readonly); pkg = pkg_db_find_singleton("dpkg"); switch (pkg->status) { case stat_installed: case stat_triggerspending: return 0; case stat_unpacked: case stat_halfconfigured: case stat_halfinstalled: case stat_triggersawaited: if (dpkg_version_relate(&pkg->configversion, dpkg_relation_ge, version)) return 0; printf(_("Version of dpkg with working %s support not yet configured.\n" " Please use 'dpkg --configure dpkg', and then try again.\n"), feature_name); return 1; default: printf(_("dpkg not recorded as installed, cannot check for %s support!\n"), feature_name); return 1; } }
static int assert_version_support(const char *const *argv, struct dpkg_version *version, const char *feature_name) { struct pkginfo *pkg; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); modstatdb_open(msdbrw_readonly); pkg = pkg_db_find_singleton("dpkg"); switch (pkg->status) { case PKG_STAT_INSTALLED: case PKG_STAT_TRIGGERSPENDING: return 0; case PKG_STAT_UNPACKED: case PKG_STAT_HALFCONFIGURED: case PKG_STAT_HALFINSTALLED: case PKG_STAT_TRIGGERSAWAITED: if (dpkg_version_relate(&pkg->configversion, DPKG_RELATION_GE, version)) return 0; printf(_("Version of dpkg with working %s support not yet configured.\n" " Please use 'dpkg --configure dpkg', and then try again.\n"), feature_name); return 1; default: printf(_("dpkg not recorded as installed, cannot check for %s support!\n"), feature_name); return 1; } }
static int assert_version_support(const char *const *argv, struct versionrevision *version, const char *feature_name) { struct pkginfo *pkg; enum modstatdb_rw msdb_status; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); msdb_status = modstatdb_open(msdbrw_readonly); pkg_infodb_init(msdb_status); pkg = pkg_db_find_pkg("dpkg", NULL); switch (pkg->status) { case stat_installed: case stat_triggerspending: return 0; case stat_unpacked: case stat_halfconfigured: case stat_halfinstalled: case stat_triggersawaited: if (versionsatisfied3(&pkg->configversion, version, dvr_laterequal)) return 0; printf(_("Version of dpkg with working %s support not yet configured.\n" " Please use 'dpkg --configure dpkg', and then try again.\n"), feature_name); return 1; default: printf(_("dpkg not recorded as installed, cannot check for %s support!\n"), feature_name); return 1; } }
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; }
/** * @brief Initialize dpkg and load packages into memory */ void dpkg_setup(struct pkg_array *packages) { dpkg_set_progname("osquery"); push_error_context(); dpkg_db_set_dir("/var/lib/dpkg/"); modstatdb_init(); modstatdb_open(msdbrw_readonly); pkg_array_init_from_db(packages); pkg_array_sort(packages, pkg_sorter); }
int audit(const char *const *argv) { const struct audit_problem *problem; struct pkg_array array; bool head_running = false; int i; modstatdb_open(msdbrw_readonly); if (!*argv) pkg_array_init_from_db(&array); else pkg_array_init_from_names(&array, pkg_array_mapper, (const char **)argv); pkg_array_sort(&array, pkg_sorter_by_nonambig_name_arch); for (problem = audit_problems; problem->check; problem++) { bool head = false; for (i = 0; i < array.n_pkgs; i++) { struct pkginfo *pkg = array.pkgs[i]; if (!problem->check(pkg, problem)) continue; if (!head_running) { if (modstatdb_is_locked()) puts(_( "Another process has locked the database for writing, and might currently be\n" "modifying it, some of the following problems might just be due to that.\n")); head_running = true; } if (!head) { fputs(gettext(problem->explanation), stdout); head = true; } describebriefly(pkg); } if (head) putchar('\n'); } pkg_array_destroy(&array); m_output(stdout, _("<standard output>")); return 0; }
int getselections(const char *const *argv) { struct pkg_array array; struct pkginfo *pkg; const char *thisarg; int i, found; modstatdb_open(msdbrw_readonly); pkg_array_init_from_db(&array); pkg_array_sort(&array, pkg_sorter_by_nonambig_name_arch); if (!*argv) { for (i = 0; i < array.n_pkgs; i++) { pkg = array.pkgs[i]; if (pkg->status == PKG_STAT_NOTINSTALLED) continue; getsel1package(pkg); } } else { while ((thisarg= *argv++)) { struct pkg_spec pkgspec; found= 0; pkg_spec_init(&pkgspec, PKG_SPEC_PATTERNS | PKG_SPEC_ARCH_WILDCARD); pkg_spec_parse(&pkgspec, thisarg); for (i = 0; i < array.n_pkgs; i++) { pkg = array.pkgs[i]; if (!pkg_spec_match_pkg(&pkgspec, pkg, &pkg->installed)) continue; getsel1package(pkg); found++; } if (!found) notice(_("no packages found matching %s"), thisarg); pkg_spec_destroy(&pkgspec); } } m_output(stdout, _("<standard output>")); m_output(stderr, _("<standard error>")); pkg_array_destroy(&array); 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; }
int audit(const char *const *argv) { const struct badstatinfo *bsi; bool head_running = false; enum modstatdb_rw msdb_status; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); msdb_status = modstatdb_open(msdbrw_readonly); pkg_infodb_init(msdb_status); for (bsi= badstatinfos; bsi->yesno; bsi++) { struct pkgiterator *it; struct pkginfo *pkg; bool head = false; it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { if (!bsi->yesno(pkg,bsi)) continue; if (!head_running) { if (modstatdb_is_locked()) puts(_( "Another process has locked the database for writing, and might currently be\n" "modifying it, some of the following problems might just be due to that.\n")); head_running = true; } if (!head) { fputs(gettext(bsi->explanation),stdout); head = true; } describebriefly(pkg); } pkg_db_iter_free(it); if (head) putchar('\n'); } m_output(stdout, _("<standard output>")); return 0; }
int getselections(const char *const *argv) { struct pkg_array array; struct pkginfo *pkg; const char *thisarg; int i, found; modstatdb_open(msdbrw_readonly); pkg_array_init_from_db(&array); pkg_array_sort(&array, pkg_sorter_by_name); if (!*argv) { for (i = 0; i < array.n_pkgs; i++) { pkg = array.pkgs[i]; if (pkg->status == stat_notinstalled) continue; getsel1package(pkg); } } else { while ((thisarg= *argv++)) { found= 0; for (i = 0; i < array.n_pkgs; i++) { pkg = array.pkgs[i]; if (fnmatch(thisarg, pkg->set->name, 0)) continue; getsel1package(pkg); found++; } if (!found) fprintf(stderr,_("No packages found matching %s.\n"),thisarg); } } m_output(stdout, _("<standard output>")); m_output(stderr, _("<standard error>")); pkg_array_destroy(&array); return 0; }
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; }
/** * Print a single package which: * (a) is the target of one or more relevant predependencies. * (b) has itself no unsatisfied pre-dependencies. * * If such a package is present output is the Packages file entry, * which can be massaged as appropriate. * * Exit status: * 0 = a package printed, OK * 1 = no suitable package available * 2 = error */ int predeppackage(const char *const *argv) { static struct varbuf vb; struct pkgiterator *it; struct pkginfo *pkg = NULL, *startpkg, *trypkg; struct dependency *dep; struct deppossi *possi, *provider; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); modstatdb_open(msdbrw_readonly | msdbrw_available_readonly); /* We use clientdata->istobe to detect loops. */ clear_istobes(); dep = NULL; it = pkg_db_iter_new(); while (!dep && (pkg = pkg_db_iter_next_pkg(it))) { /* Ignore packages user doesn't want. */ if (pkg->want != PKG_WANT_INSTALL) continue; /* Ignore packages not available. */ if (!pkg->files) continue; pkg->clientdata->istobe = PKG_ISTOBE_PREINSTALL; for (dep= pkg->available.depends; dep; dep= dep->next) { if (dep->type != dep_predepends) continue; if (depisok(dep, &vb, NULL, NULL, true)) continue; /* This will leave dep non-NULL, and so exit the loop. */ break; } pkg->clientdata->istobe = PKG_ISTOBE_NORMAL; /* If dep is NULL we go and get the next package. */ } pkg_db_iter_free(it); if (!dep) return 1; /* Not found. */ assert(pkg); startpkg= pkg; pkg->clientdata->istobe = PKG_ISTOBE_PREINSTALL; /* OK, we have found an unsatisfied predependency. * Now go and find the first thing we need to install, as a first step * towards satisfying it. */ do { /* We search for a package which would satisfy dep, and put it in pkg. */ for (possi = dep->list, pkg = NULL; !pkg && possi; possi=possi->next) { struct deppossi_pkg_iterator *possi_iter; possi_iter = deppossi_pkg_iter_new(possi, wpb_available); while (!pkg && (trypkg = deppossi_pkg_iter_next(possi_iter))) { if (trypkg->files && trypkg->clientdata->istobe == PKG_ISTOBE_NORMAL && versionsatisfied(&trypkg->available, possi)) { pkg = trypkg; break; } for (provider = possi->ed->depended.available; !pkg && provider; provider = provider->next) { if (provider->up->type != dep_provides) continue; if (!pkg_virtual_deppossi_satisfied(possi, provider)) continue; trypkg = provider->up->up; if (!trypkg->files) continue; if (trypkg->clientdata->istobe == PKG_ISTOBE_NORMAL) { pkg = trypkg; break; } } } deppossi_pkg_iter_free(possi_iter); } if (!pkg) { varbuf_reset(&vb); describedepcon(&vb,dep); varbuf_end_str(&vb); notice(_("cannot see how to satisfy pre-dependency:\n %s"), vb.buf); ohshit(_("cannot satisfy pre-dependencies for %.250s (wanted due to %.250s)"), pkgbin_name(dep->up, &dep->up->available, pnaw_nonambig), pkgbin_name(startpkg, &startpkg->available, pnaw_nonambig)); } pkg->clientdata->istobe = PKG_ISTOBE_PREINSTALL; for (dep= pkg->available.depends; dep; dep= dep->next) { if (dep->type != dep_predepends) continue; if (depisok(dep, &vb, NULL, NULL, true)) continue; /* This will leave dep non-NULL, and so exit the loop. */ break; } } while (dep); /* OK, we've found it - pkg has no unsatisfied pre-dependencies! */ writerecord(stdout, _("<standard output>"), pkg, &pkg->available); m_output(stdout, _("<standard output>")); return 0; }
int unpackchk(const char *const *argv) { int totalcount, sects; struct sectionentry *sectionentries, *se, **sep; struct pkgiterator *it; struct pkginfo *pkg; const char *thissect; char buf[20]; int width; if (*argv) badusage(_("--%s takes no arguments"), cipaction->olong); modstatdb_open(msdbrw_readonly); totalcount= 0; sectionentries = NULL; sects= 0; it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { if (!yettobeunpacked(pkg, &thissect)) continue; for (se= sectionentries; se && strcasecmp(thissect,se->name); se= se->next); if (!se) { se= nfmalloc(sizeof(struct sectionentry)); for (sep= §ionentries; *sep && strcasecmp(thissect,(*sep)->name) > 0; sep= &(*sep)->next); se->name= thissect; se->count= 0; se->next= *sep; *sep= se; sects++; } se->count++; totalcount++; } pkg_db_iter_free(it); if (totalcount == 0) return 0; if (totalcount <= 12) { it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { if (!yettobeunpacked(pkg, NULL)) continue; describebriefly(pkg); } pkg_db_iter_free(it); } else if (sects <= 12) { for (se= sectionentries; se; se= se->next) { sprintf(buf,"%d",se->count); printf(_(" %d in %s: "),se->count,se->name); width= 70-strlen(se->name)-strlen(buf); while (width > 59) { putchar(' '); width--; } it = pkg_db_iter_new(); while ((pkg = pkg_db_iter_next_pkg(it))) { const char *pkgname; if (!yettobeunpacked(pkg,&thissect)) continue; if (strcasecmp(thissect,se->name)) continue; pkgname = pkg_name(pkg, pnaw_nonambig); width -= strlen(pkgname); width--; if (width < 4) { printf(" ..."); break; } printf(" %s", pkgname); } pkg_db_iter_free(it); putchar('\n'); } } else { printf(P_(" %d package, from the following section:", " %d packages, from the following sections:", totalcount), totalcount); width= 0; for (se= sectionentries; se; se= se->next) { sprintf(buf,"%d",se->count); width -= (6 + strlen(se->name) + strlen(buf)); if (width < 0) { putchar('\n'); width= 73 - strlen(se->name) - strlen(buf); } printf(" %s (%d)",se->name,se->count); } putchar('\n'); } m_output(stdout, _("<standard output>")); return 0; }
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; }
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; }