[dpkg] / src / cleanup.c

/*
 * dpkg - main program for package management
 * cleanup.c - cleanup functions, used when we need to unwind
 *
 * Copyright © 1995 Ian Jackson <ijackson@chiark.greenend.org.uk>
 * Copyright © 2007-2015 Guillem Jover <guillem@debian.org>
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <compat.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <errno.h>
#include <string.h>
#include <time.h>
#include <utime.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

#include <dpkg/i18n.h>
#include <dpkg/dpkg.h>
#include <dpkg/dpkg-db.h>
#include <dpkg/pkg.h>
#include <dpkg/path.h>
#include <dpkg/options.h>

#include "filesdb.h"
#include "main.h"
#include "archives.h"

int cleanup_pkg_failed=0, cleanup_conflictor_failed=0;

/**
 * Something went wrong and we're undoing.
 *
 * We have the following possible situations for non-conffiles:
 *   «pathname».dpkg-tmp exists - in this case we want to remove
 *    «pathname» if it exists and replace it with «pathname».dpkg-tmp.
 *    This undoes the backup operation.
 *   «pathname».dpkg-tmp does not exist - «pathname» may be on the disk,
 *    as a new file which didn't fail, remove it if it is.
 *
 * In both cases, we also make sure we delete «pathname».dpkg-new in
 * case that's still hanging around.
 *
 * For conffiles, we simply delete «pathname».dpkg-new. For these,
 * «pathname».dpkg-tmp shouldn't exist, as we don't make a backup
 * at this stage. Just to be on the safe side, though, we don't
 * look for it.
 */
void cu_installnew(int argc, void **argv) {
  struct filenamenode *namenode = argv[0];
  struct stat stab;

  cleanup_pkg_failed++; cleanup_conflictor_failed++;

  debug(dbg_eachfile, "cu_installnew '%s' flags=%o",
        namenode->name, namenode->flags);

  setupfnamevbs(namenode->name);

  if (!(namenode->flags & fnnf_new_conff) && !lstat(fnametmpvb.buf,&stab)) {
    /* OK, «pathname».dpkg-tmp exists. Remove «pathname» and
     * restore «pathname».dpkg-tmp ... */
    if (namenode->flags & fnnf_no_atomic_overwrite) {
      /* If we can't do an atomic overwrite we have to delete first any
       * link to the new version we may have created. */
      debug(dbg_eachfiledetail,"cu_installnew restoring nonatomic");
      if (secure_remove(fnamevb.buf) && errno != ENOENT && errno != ENOTDIR)
        ohshite(_("unable to remove newly-installed version of '%.250s' to allow"
                " reinstallation of backup copy"),namenode->name);
    } else {
      debug(dbg_eachfiledetail,"cu_installnew restoring atomic");
    }
    /* Either we can do an atomic restore, or we've made room: */
    if (rename(fnametmpvb.buf,fnamevb.buf))
      ohshite(_("unable to restore backup version of '%.250s'"), namenode->name);
    /* If «pathname».dpkg-tmp was still a hard link to «pathname», then the
     * atomic rename did nothing, so we make sure to remove the backup. */
    else if (unlink(fnametmpvb.buf) && errno != ENOENT)
      ohshite(_("unable to remove backup copy of '%.250s'"), namenode->name);
  } else if (namenode->flags & fnnf_placed_on_disk) {
    debug(dbg_eachfiledetail,"cu_installnew removing new file");
    if (secure_remove(fnamevb.buf) && errno != ENOENT && errno != ENOTDIR)
      ohshite(_("unable to remove newly-installed version of '%.250s'"),
	      namenode->name);
  } else {
    debug(dbg_eachfiledetail,"cu_installnew not restoring");
  }
  /* Whatever, we delete «pathname».dpkg-new now, if it still exists. */
  if (secure_remove(fnamenewvb.buf) && errno != ENOENT && errno != ENOTDIR)
    ohshite(_("unable to remove newly-extracted version of '%.250s'"),
            namenode->name);

  cleanup_pkg_failed--; cleanup_conflictor_failed--;
}

void cu_prermupgrade(int argc, void **argv) {
  struct pkginfo *pkg= (struct pkginfo*)argv[0];

  if (cleanup_pkg_failed++) return;
  maintscript_postinst(pkg, "abort-upgrade",
                       versiondescribe(&pkg->available.version, vdew_nonambig),
                       NULL);
  pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
  post_postinst_tasks(pkg, PKG_STAT_INSTALLED);
  cleanup_pkg_failed--;
}

/*
 * Also has conflictor in argv[1] and infavour in argv[2].
 * conflictor may be NULL if deconfigure was due to Breaks.
 */
void ok_prermdeconfigure(int argc, void **argv) {
  struct pkginfo *deconf= (struct pkginfo*)argv[0];

  if (cipaction->arg_int == act_install)
    enqueue_package(deconf);
}

/*
 * conflictor may be NULL.
 */
void cu_prermdeconfigure(int argc, void **argv) {
  struct pkginfo *deconf= (struct pkginfo*)argv[0];
  struct pkginfo *conflictor = (struct pkginfo *)argv[1];
  struct pkginfo *infavour= (struct pkginfo*)argv[2];

  if (conflictor) {
    maintscript_postinst(deconf, "abort-deconfigure",
                         "in-favour",
                         pkgbin_name(infavour, &infavour->available,
                                     pnaw_nonambig),
                         versiondescribe(&infavour->available.version,
                                         vdew_nonambig),
                         "removing",
                         pkg_name(conflictor, pnaw_nonambig),
                         versiondescribe(&conflictor->installed.version,
                                         vdew_nonambig),
                         NULL);
  } else {
    maintscript_postinst(deconf, "abort-deconfigure",
                         "in-favour",
                         pkgbin_name(infavour, &infavour->available,
                                     pnaw_nonambig),
                         versiondescribe(&infavour->available.version,
                                         vdew_nonambig),
                         NULL);
  }

  post_postinst_tasks(deconf, PKG_STAT_INSTALLED);
}

void cu_prerminfavour(int argc, void **argv) {
  struct pkginfo *conflictor= (struct pkginfo*)argv[0];
  struct pkginfo *infavour= (struct pkginfo*)argv[1];

  if (cleanup_conflictor_failed++) return;
  maintscript_postinst(conflictor, "abort-remove",
                       "in-favour",
                       pkgbin_name(infavour, &infavour->available,
                                   pnaw_nonambig),
                       versiondescribe(&infavour->available.version,
                                       vdew_nonambig),
                       NULL);
  pkg_clear_eflags(conflictor, PKG_EFLAG_REINSTREQ);
  post_postinst_tasks(conflictor, PKG_STAT_INSTALLED);
  cleanup_conflictor_failed--;
}

void cu_preinstverynew(int argc, void **argv) {
  struct pkginfo *pkg= (struct pkginfo*)argv[0];
  char *cidir= (char*)argv[1];
  char *cidirrest= (char*)argv[2];

  if (cleanup_pkg_failed++) return;
  maintscript_new(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
                  "abort-install", NULL);
  pkg_set_status(pkg, PKG_STAT_NOTINSTALLED);
  pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
  pkgbin_blank(&pkg->installed);
  modstatdb_note(pkg);
  cleanup_pkg_failed--;
}

void cu_preinstnew(int argc, void **argv) {
  struct pkginfo *pkg= (struct pkginfo*)argv[0];
  char *cidir= (char*)argv[1];
  char *cidirrest= (char*)argv[2];

  if (cleanup_pkg_failed++) return;
  maintscript_new(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
                  "abort-install",
                  versiondescribe(&pkg->installed.version, vdew_nonambig),
                  versiondescribe(&pkg->available.version, vdew_nonambig),
                  NULL);
  pkg_set_status(pkg, PKG_STAT_CONFIGFILES);
  pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
  modstatdb_note(pkg);
  cleanup_pkg_failed--;
}

void cu_preinstupgrade(int argc, void **argv) {
  struct pkginfo *pkg= (struct pkginfo*)argv[0];
  char *cidir= (char*)argv[1];
  char *cidirrest= (char*)argv[2];
  enum pkgstatus *oldstatusp= (enum pkgstatus*)argv[3];

  if (cleanup_pkg_failed++) return;
  maintscript_new(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
                  "abort-upgrade",
                  versiondescribe(&pkg->installed.version, vdew_nonambig),
                  versiondescribe(&pkg->available.version, vdew_nonambig),
                  NULL);
  pkg_set_status(pkg, *oldstatusp);
  pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
  modstatdb_note(pkg);
  cleanup_pkg_failed--;
}

void cu_postrmupgrade(int argc, void **argv) {
  struct pkginfo *pkg= (struct pkginfo*)argv[0];

  if (cleanup_pkg_failed++) return;
  maintscript_installed(pkg, PREINSTFILE, "pre-installation",
                        "abort-upgrade",
                        versiondescribe(&pkg->available.version, vdew_nonambig),
                        NULL);
  cleanup_pkg_failed--;
}

void cu_prermremove(int argc, void **argv) {
  struct pkginfo *pkg= (struct pkginfo*)argv[0];
  enum pkgstatus *oldpkgstatus= (enum pkgstatus*)argv[1];

  if (cleanup_pkg_failed++) return;
  maintscript_postinst(pkg, "abort-remove", NULL);
  pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
  post_postinst_tasks(pkg, *oldpkgstatus);
  cleanup_pkg_failed--;
}
Commit	Line	Data
1479465f GJ	1	/*
	2	* dpkg - main program for package management
	3	* cleanup.c - cleanup functions, used when we need to unwind
	4	*
	5	* Copyright © 1995 Ian Jackson <ijackson@chiark.greenend.org.uk>
	6	* Copyright © 2007-2015 Guillem Jover <guillem@debian.org>
	7	*
	8	* This is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program. If not, see <https://www.gnu.org/licenses/>.
	20	*/
	21
	22	#include <config.h>
	23	#include <compat.h>
	24
	25	#include <sys/types.h>
	26	#include <sys/stat.h>
	27
	28	#include <errno.h>
	29	#include <string.h>
	30	#include <time.h>
	31	#include <utime.h>
	32	#include <fcntl.h>
	33	#include <unistd.h>
	34	#include <stdlib.h>
	35	#include <stdio.h>
	36
	37	#include <dpkg/i18n.h>
	38	#include <dpkg/dpkg.h>
	39	#include <dpkg/dpkg-db.h>
	40	#include <dpkg/pkg.h>
	41	#include <dpkg/path.h>
	42	#include <dpkg/options.h>
	43
	44	#include "filesdb.h"
	45	#include "main.h"
	46	#include "archives.h"
	47
	48	int cleanup_pkg_failed=0, cleanup_conflictor_failed=0;
	49
	50	/**
	51	* Something went wrong and we're undoing.
	52	*
	53	* We have the following possible situations for non-conffiles:
	54	* «pathname».dpkg-tmp exists - in this case we want to remove
	55	* «pathname» if it exists and replace it with «pathname».dpkg-tmp.
	56	* This undoes the backup operation.
	57	* «pathname».dpkg-tmp does not exist - «pathname» may be on the disk,
	58	* as a new file which didn't fail, remove it if it is.
	59	*
	60	* In both cases, we also make sure we delete «pathname».dpkg-new in
	61	* case that's still hanging around.
	62	*
	63	* For conffiles, we simply delete «pathname».dpkg-new. For these,
	64	* «pathname».dpkg-tmp shouldn't exist, as we don't make a backup
65	* at this stage. Just to be on the safe side, though, we don't
66	* look for it.
67	*/
68	void cu_installnew(int argc, void **argv) {
69	struct filenamenode *namenode = argv[0];
70	struct stat stab;
71
72	cleanup_pkg_failed++; cleanup_conflictor_failed++;
73
74	debug(dbg_eachfile, "cu_installnew '%s' flags=%o",
75	namenode->name, namenode->flags);
76
77	setupfnamevbs(namenode->name);
78
79	if (!(namenode->flags & fnnf_new_conff) && !lstat(fnametmpvb.buf,&stab)) {
80	/* OK, «pathname».dpkg-tmp exists. Remove «pathname» and
81	* restore «pathname».dpkg-tmp ... */
82	if (namenode->flags & fnnf_no_atomic_overwrite) {
83	/* If we can't do an atomic overwrite we have to delete first any
84	* link to the new version we may have created. */
85	debug(dbg_eachfiledetail,"cu_installnew restoring nonatomic");
86	if (secure_remove(fnamevb.buf) && errno != ENOENT && errno != ENOTDIR)
87	ohshite(_("unable to remove newly-installed version of '%.250s' to allow"
88	" reinstallation of backup copy"),namenode->name);
89	} else {
90	debug(dbg_eachfiledetail,"cu_installnew restoring atomic");
91	}
92	/* Either we can do an atomic restore, or we've made room: */
93	if (rename(fnametmpvb.buf,fnamevb.buf))
94	ohshite(_("unable to restore backup version of '%.250s'"), namenode->name);
95	/* If «pathname».dpkg-tmp was still a hard link to «pathname», then the
96	* atomic rename did nothing, so we make sure to remove the backup. */
97	else if (unlink(fnametmpvb.buf) && errno != ENOENT)
98	ohshite(_("unable to remove backup copy of '%.250s'"), namenode->name);
99	} else if (namenode->flags & fnnf_placed_on_disk) {
100	debug(dbg_eachfiledetail,"cu_installnew removing new file");
101	if (secure_remove(fnamevb.buf) && errno != ENOENT && errno != ENOTDIR)
102	ohshite(_("unable to remove newly-installed version of '%.250s'"),
103	namenode->name);
104	} else {
105	debug(dbg_eachfiledetail,"cu_installnew not restoring");
106	}
107	/* Whatever, we delete «pathname».dpkg-new now, if it still exists. */
108	if (secure_remove(fnamenewvb.buf) && errno != ENOENT && errno != ENOTDIR)
109	ohshite(_("unable to remove newly-extracted version of '%.250s'"),
110	namenode->name);
111
112	cleanup_pkg_failed--; cleanup_conflictor_failed--;
113	}
114
115	void cu_prermupgrade(int argc, void **argv) {
116	struct pkginfo pkg= (struct pkginfo)argv[0];
117
118	if (cleanup_pkg_failed++) return;
119	maintscript_postinst(pkg, "abort-upgrade",
120	versiondescribe(&pkg->available.version, vdew_nonambig),
121	NULL);
122	pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
123	post_postinst_tasks(pkg, PKG_STAT_INSTALLED);
124	cleanup_pkg_failed--;
125	}
126
127	/*
128	* Also has conflictor in argv[1] and infavour in argv[2].
129	* conflictor may be NULL if deconfigure was due to Breaks.
130	*/
131	void ok_prermdeconfigure(int argc, void **argv) {
132	struct pkginfo deconf= (struct pkginfo)argv[0];
133
134	if (cipaction->arg_int == act_install)
135	enqueue_package(deconf);
136	}
137
138	/*
139	* conflictor may be NULL.
140	*/
141	void cu_prermdeconfigure(int argc, void **argv) {
142	struct pkginfo deconf= (struct pkginfo)argv[0];
143	struct pkginfo conflictor = (struct pkginfo )argv[1];
144	struct pkginfo infavour= (struct pkginfo)argv[2];
145
146	if (conflictor) {
147	maintscript_postinst(deconf, "abort-deconfigure",
148	"in-favour",
149	pkgbin_name(infavour, &infavour->available,
150	pnaw_nonambig),
151	versiondescribe(&infavour->available.version,
152	vdew_nonambig),
153	"removing",
154	pkg_name(conflictor, pnaw_nonambig),
155	versiondescribe(&conflictor->installed.version,
156	vdew_nonambig),
157	NULL);
158	} else {
159	maintscript_postinst(deconf, "abort-deconfigure",
160	"in-favour",
161	pkgbin_name(infavour, &infavour->available,
162	pnaw_nonambig),
163	versiondescribe(&infavour->available.version,
164	vdew_nonambig),
165	NULL);
166	}
167
168	post_postinst_tasks(deconf, PKG_STAT_INSTALLED);
169	}
170
171	void cu_prerminfavour(int argc, void **argv) {
172	struct pkginfo conflictor= (struct pkginfo)argv[0];
173	struct pkginfo infavour= (struct pkginfo)argv[1];
174
175	if (cleanup_conflictor_failed++) return;
176	maintscript_postinst(conflictor, "abort-remove",
177	"in-favour",
178	pkgbin_name(infavour, &infavour->available,
179	pnaw_nonambig),
180	versiondescribe(&infavour->available.version,
181	vdew_nonambig),
182	NULL);
183	pkg_clear_eflags(conflictor, PKG_EFLAG_REINSTREQ);
184	post_postinst_tasks(conflictor, PKG_STAT_INSTALLED);
185	cleanup_conflictor_failed--;
186	}
187
188	void cu_preinstverynew(int argc, void **argv) {
189	struct pkginfo pkg= (struct pkginfo)argv[0];
190	char cidir= (char)argv[1];
191	char cidirrest= (char)argv[2];
192
193	if (cleanup_pkg_failed++) return;
194	maintscript_new(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
195	"abort-install", NULL);
196	pkg_set_status(pkg, PKG_STAT_NOTINSTALLED);
197	pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
198	pkgbin_blank(&pkg->installed);
199	modstatdb_note(pkg);
200	cleanup_pkg_failed--;
201	}
202
203	void cu_preinstnew(int argc, void **argv) {
204	struct pkginfo pkg= (struct pkginfo)argv[0];
205	char cidir= (char)argv[1];
206	char cidirrest= (char)argv[2];
207
208	if (cleanup_pkg_failed++) return;
209	maintscript_new(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
210	"abort-install",
211	versiondescribe(&pkg->installed.version, vdew_nonambig),
212	versiondescribe(&pkg->available.version, vdew_nonambig),
213	NULL);
214	pkg_set_status(pkg, PKG_STAT_CONFIGFILES);
215	pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
216	modstatdb_note(pkg);
217	cleanup_pkg_failed--;
218	}
219
220	void cu_preinstupgrade(int argc, void **argv) {
221	struct pkginfo pkg= (struct pkginfo)argv[0];
222	char cidir= (char)argv[1];
223	char cidirrest= (char)argv[2];
224	enum pkgstatus oldstatusp= (enum pkgstatus)argv[3];
225
226	if (cleanup_pkg_failed++) return;
227	maintscript_new(pkg, POSTRMFILE, "post-removal", cidir, cidirrest,
228	"abort-upgrade",
229	versiondescribe(&pkg->installed.version, vdew_nonambig),
230	versiondescribe(&pkg->available.version, vdew_nonambig),
231	NULL);
232	pkg_set_status(pkg, *oldstatusp);
233	pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
234	modstatdb_note(pkg);
235	cleanup_pkg_failed--;
236	}
237
238	void cu_postrmupgrade(int argc, void **argv) {
239	struct pkginfo pkg= (struct pkginfo)argv[0];
240
241	if (cleanup_pkg_failed++) return;
242	maintscript_installed(pkg, PREINSTFILE, "pre-installation",
243	"abort-upgrade",
244	versiondescribe(&pkg->available.version, vdew_nonambig),
245	NULL);
246	cleanup_pkg_failed--;
247	}
248
249	void cu_prermremove(int argc, void **argv) {
250	struct pkginfo pkg= (struct pkginfo)argv[0];
251	enum pkgstatus oldpkgstatus= (enum pkgstatus)argv[1];
252
253	if (cleanup_pkg_failed++) return;
254	maintscript_postinst(pkg, "abort-remove", NULL);
255	pkg_clear_eflags(pkg, PKG_EFLAG_REINSTREQ);
256	post_postinst_tasks(pkg, *oldpkgstatus);
257	cleanup_pkg_failed--;
258	}