static void
statdb_write(void)
{
char *dbname;
struct atomic_file *dbfile;
struct fileiterator *iter;
struct filenamenode *file;
dbname = dpkg_db_get_path(STATOVERRIDEFILE);
dbfile = atomic_file_new(dbname, aff_backup);
atomic_file_open(dbfile);
iter = files_db_iter_new();
while ((file = files_db_iter_next(iter)))
statdb_node_print(dbfile->fp, file);
files_db_iter_free(iter);
atomic_file_sync(dbfile);
atomic_file_close(dbfile);
atomic_file_commit(dbfile);
atomic_file_free(dbfile);
dir_sync_path(dpkg_db_get_dir());
free(dbname);
}
/**
* 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;
}
enum modstatdb_rw
modstatdb_open(enum modstatdb_rw readwritereq)
{
modstatdb_init();
cflags = readwritereq & msdbrw_available_mask;
readwritereq &= ~msdbrw_available_mask;
switch (readwritereq) {
case msdbrw_needsuperuser:
case msdbrw_needsuperuserlockonly:
if (getuid() || geteuid())
ohshit(_("requested operation requires superuser privilege"));
/* Fall through. */
case msdbrw_write:
case msdbrw_writeifposs:
if (access(dpkg_db_get_dir(), W_OK)) {
if (errno != EACCES)
ohshite(_("unable to access dpkg status area"));
else if (readwritereq == msdbrw_write)
ohshit(_("operation requires read/write access to dpkg status area"));
cstatus= msdbrw_readonly;
} else {
modstatdb_lock();
cstatus= (readwritereq == msdbrw_needsuperuserlockonly ?
msdbrw_needsuperuserlockonly :
msdbrw_write);
}
break;
case msdbrw_readonly:
cstatus= msdbrw_readonly;
break;
default:
internerr("unknown modstatdb_rw '%d'", readwritereq);
}
dpkg_arch_load_list();
if (cstatus != msdbrw_needsuperuserlockonly) {
cleanupdates();
if (cflags >= msdbrw_available_readonly)
parsedb(availablefile, pdb_parse_available, NULL);
}
if (cstatus >= msdbrw_write) {
createimptmp();
varbuf_init(&uvb, 10240);
}
trig_fixup_awaiters(cstatus);
trig_incorporate(cstatus);
return cstatus;
}
static char *
get_control_dir(char *cidir)
{
if (f_noact) {
char *tmpdir;
tmpdir = mkdtemp(path_make_temp_template("dpkg"));
if (tmpdir == NULL)
ohshite(_("unable to create temporary directory"));
cidir = m_realloc(cidir, strlen(tmpdir) + MAXCONTROLFILENAME + 10);
strcpy(cidir, tmpdir);
free(tmpdir);
} else {
const char *admindir;
admindir = dpkg_db_get_dir();
/* The admindir length is always constant on a dpkg execution run. */
if (cidir == NULL)
cidir = m_malloc(strlen(admindir) + sizeof(CONTROLDIRTMP) +
MAXCONTROLFILENAME + 10);
/* We want it to be on the same filesystem so that we can
* use rename(2) to install the postinst &c. */
strcpy(cidir, admindir);
strcat(cidir, "/" CONTROLDIRTMP);
/* Make sure the control information directory is empty. */
ensure_pathname_nonexisting(cidir);
}
strcat(cidir, "/");
return cidir;
}
int
updateavailable(const char *const *argv)
{
const char *sourcefile= argv[0];
char *availfile;
int count= 0;
modstatdb_init();
switch (cipaction->arg_int) {
case act_avclear:
if (sourcefile) badusage(_("--%s takes no arguments"),cipaction->olong);
break;
case act_avreplace: case act_avmerge:
if (!sourcefile || argv[1])
badusage(_("--%s needs exactly one Packages-file argument"),
cipaction->olong);
break;
default:
internerr("unknown action '%d'", cipaction->arg_int);
}
if (!f_noact) {
if (access(dpkg_db_get_dir(), W_OK)) {
if (errno != EACCES)
ohshite(_("unable to access dpkg status area for bulk available update"));
else
ohshit(_("bulk available update requires write access to dpkg status area"));
}
modstatdb_lock();
}
switch (cipaction->arg_int) {
case act_avreplace:
printf(_("Replacing available packages info, using %s.\n"),sourcefile);
break;
case act_avmerge:
printf(_("Updating available packages info, using %s.\n"),sourcefile);
break;
case act_avclear:
break;
default:
internerr("unknown action '%d'", cipaction->arg_int);
}
availfile = dpkg_db_get_path(AVAILFILE);
if (cipaction->arg_int == act_avmerge)
parsedb(availfile, pdb_parse_available, NULL);
if (cipaction->arg_int != act_avclear)
count += parsedb(sourcefile, pdb_parse_available | pdb_ignoreolder, NULL);
if (!f_noact) {
writedb(availfile, wdb_dump_available);
modstatdb_unlock();
}
free(availfile);
if (cipaction->arg_int != act_avclear)
printf(P_("Information about %d package was updated.\n",
"Information about %d packages was updated.\n", count), count);
modstatdb_done();
return 0;
}
