Minix/pkgsrc-ng
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Import of pkgsrc-2013Q2

Browse Source
This commit is contained in:
Lionel Sambuc
2013-09-26 17:14:40 +02:00
commit 785076ae39
74991 changed files with 4380255 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
pkgtools/pkg_install/files/delete/Makefile.in Normal file
View File

@@ -0,0 +1,54 @@
# $NetBSD: Makefile.in,v 1.20 2012/10/21 09:08:56 joerg Exp $
srcdir= @srcdir@
prefix= @prefix@
exec_prefix= @exec_prefix@
sbindir= @sbindir@
mandir= @mandir@
datarootdir= @datarootdir@
man1dir= $(mandir)/man1
cat1dir= $(mandir)/cat1
SSL_SUPPORT= @ssl_support@
CC= @CC@
CCLD= $(CC)
LIBS= -linstall -lfetch @LIBS@
.if !empty(SSL_SUPPORT)
LIBS+= -lssl -lcrypto
.endif
CPPFLAGS= @CPPFLAGS@ -I. -I$(srcdir) -I../lib -DBINDIR=\"$(sbindir)\"
DEFS= @DEFS@
CFLAGS= @CFLAGS@
LDFLAGS= @LDFLAGS@ -L../lib
INSTALL= @INSTALL@
PROG= pkg_delete
OBJS= pkg_delete.o
all: $(PROG)
.c.o:
$(CC) $(DEFS) $(CPPFLAGS) $(CFLAGS) -c $<
$(PROG): $(OBJS)
$(CCLD) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
clean:
rm -f $(OBJS) $(PROG)
install:
$(INSTALL) -m 755 -d ${DESTDIR}$(sbindir)
$(INSTALL) -m 755 -d ${DESTDIR}$(man1dir)
$(INSTALL) $(PROG) ${DESTDIR}$(sbindir)/$(PROG)
$(INSTALL) -m 444 $(PROG).1 ${DESTDIR}$(man1dir)/$(PROG).1
.if defined(MANINSTALL) && !empty(MANINSTALL:Mcatinstall)
$(INSTALL) -m 755 -d ${DESTDIR}$(cat1dir)
$(INSTALL) -m 444 $(PROG).cat ${DESTDIR}$(cat1dir)/$(PROG).0
.endif

300
pkgtools/pkg_install/files/delete/pkg_delete.1 Normal file
View File

@@ -0,0 +1,300 @@
.\" $NetBSD: pkg_delete.1,v 1.30 2010/02/25 06:56:23 wiz Exp $
.\"
.\" FreeBSD install - a package for the installation and maintenance
.\" of non-core utilities.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\" notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\" notice, this list of conditions and the following disclaimer in the
.\" documentation and/or other materials provided with the distribution.
.\"
.\" Jordan K. Hubbard
.\"
.\"
.\" from FreeBSD: @(#)pkg_delete.1
.\"
.Dd January 20, 2010
.Dt PKG_DELETE 1
.Os
.Sh NAME
.Nm pkg_delete
.Nd a utility for deleting previously installed software package distributions
.Sh SYNOPSIS
.Nm
.Op Fl ADFfkNnORrVv
.Op Fl K Ar pkg_dbdir
.Op Fl P Ar destdir
.Op Fl p Ar prefix
.Ar pkg-name ...
.Sh DESCRIPTION
The
.Nm
command is used to delete packages that have been previously installed
with the
.Xr pkg_add 1
command.
The given packages are sorted, so that the dependencies needed by a
package are deleted after the package.
Before any action is executed,
.Nm
checks for packages that are marked as
.Cm preserved
or have depending packages left.
If the
.Fl k
flag is given, preserved packages are skipped and not removed.
Unless the
.Fl f
flag is given,
.Nm
stops on the first error.
.Sh WARNING
.Bf -emphasis
Since the
.Nm
command may execute scripts or programs provided by a package file,
your system may be susceptible to
.Dq Trojan horses
or other subtle
attacks from miscreants who create dangerous package files.
.Pp
You are advised to verify the competence and identity of those who
provide installable package files.
For extra protection, examine all the package control files in the
package record directory
.Pa \*[Lt]PKG_DBDIR\*[Gt]/\*[Lt]pkg-name\*[Gt]/ ) .
Pay particular
attention to any
.Pa +INSTALL
or
.Pa +DEINSTALL
files, and inspect the
.Pa +CONTENTS
file for
.Cm @cwd ,
.Cm @mode
(check for setuid),
.Cm @dirrm ,
.Cm @exec ,
and
.Cm @unexec
directives, and/or use the
.Xr pkg_info 1
command to examine the installed package control files.
.Ef
.Sh OPTIONS
The following command line options are supported:
.Bl -tag -width indent
.It Ar pkg-name ...
The named packages are deinstalled, wildcards can be used, see
.Xr pkg_info 1 .
If no version is given, the one currently installed
will be removed.
If the
.Fl F
flag is given, one or more (absolute) filenames may be specified and
the package database will be consulted for the package to which the
given file belongs.
These packages are then deinstalled.
.It Fl A
Recursively remove all automatically installed packages that were needed
by the given packages and are no longer required.
Does not remove manually installed packages; see also the
.Fl R
flag.
.It Fl D
If a deinstallation script exists for a given package, do not execute it.
.It Fl F
Any
.Ar pkg-name
given will be interpreted as pathname which is
subsequently transformed in a (real) package name via the package
database.
That way, packages can be deleted by giving a filename
instead of the package-name.
.It Fl f
Force removal of the package, even if a dependency is recorded or the
deinstall script fails.
This might break the package database; see
.Xr pkg_admin 1
on how to repair it.
.It Fl ff
Force removal of the package, even if the package is marked as a
.Cm preserved
package.
Note that this is a dangerous operation.
See also the
.Fl k
option.
.It Fl K Ar pkg_dbdir
Override the value of the
.Dv PKG_DBDIR
configuration option with the value
.Ar pkg_dbdir .
.It Fl k
Silently skip all packages that are marked as
.Cm preserved .
.It Fl N
Remove the package's registration and its entries from the package database,
but leave the files installed.
Don't run any deinstall scripts or
.Cm @unexec
lines either.
.It Fl n
Don't actually deinstall a package, just report the steps that
would be taken.
.It Fl O
Only delete the package's entries from the package database; do not
touch the package or its files itself.
.It Fl P Ar destdir
Prefix all file and directory names with
.Ar destdir .
For packages without install scripts this has the same behavior as
using
.Xr chroot 8 .
.It Fl p Ar prefix
Set
.Ar prefix
as the directory in which to delete files from any installed packages
which do not explicitly set theirs.
For most packages, the prefix will
be set automatically to the installed location by
.Xr pkg_add 1 .
.It Fl R
Recursively remove all packages that were needed by the given packages
and are no longer required.
This option overrides the
.Fl A
flag.
.It Fl r
Recursively remove all packages that require one of the packages given.
.It Fl V
Print version number and exit.
.It Fl v
Turn on verbose output.
.El
.Sh TECHNICAL DETAILS
.Nm
does pretty much what it says.
It examines installed package records in
.Pa \*[Lt]PKG_DBDIR\*[Gt]/\*[Lt]pkg-name\*[Gt] ,
deletes the package contents, and finally removes the package records.
.Pp
If a package is required by other installed packages,
.Nm
will list those dependent packages and refuse to delete the package
(unless the
.Fl f
option is given).
.Pp
If a package has been marked as a
.Cm preserved
package, it will not be able to be deleted
(unless more than one occurrence of the
.Fl f
option is given).
.Pp
If a filename is given instead of a package name, the package of which
the given file belongs to can be deleted if the
.Fl F
flag is given.
The filename needs to be absolute, see the output produced by the
.Xr pkg_info 1
.Fl aF
command.
.Pp
If a
.Cm deinstall
script exists for the package, it is executed before and after
any files are removed.
It is this script's responsibility to clean up any additional messy details
around the package's installation, since all
.Nm
knows how to do is delete the files created in the original distribution.
The
.Ic deinstall
script is called as:
.Bd -filled -offset indent -compact
.Cm deinstall
.Aq Ar pkg-name
.Ar VIEW-DEINSTALL
.Ed
before removing the package from a view, and as:
.Bd -filled -offset indent -compact
.Cm deinstall
.Aq Ar pkg-name
.Ar DEINSTALL
.Ed
before deleting all files and as:
.Bd -filled -offset indent -compact
.Cm deinstall
.Aq Ar pkg-name
.Ar POST-DEINSTALL
.Ed
after deleting them.
Passing the keywords
.Ar VIEW-DEINSTALL ,
.Ar DEINSTALL ,
and
.Ar POST-DEINSTALL
lets you potentially write only one program/script that handles all
aspects of installation and deletion.
.Pp
All scripts are called with the environment variable
.Ev PKG_PREFIX
set to the installation prefix (see the
.Fl p
option above).
This allows a package author to write a script
that reliably performs some action on the directory where the package
is installed, even if the user might have changed it by specifying the
.Fl p
option when running
.Nm
or
.Xr pkg_add 1 .
The scripts are also called with the
.Ev PKG_METADATA_DIR
environment variable set to the location of the
.Pa +*
meta-data files, and with the
.Ev PKG_REFCOUNT_DBDIR
environment variable set to the location of the package reference counts
database directory.
If the
.Fl P
flag was given to
.Nm ,
.Ev PKG_DESTDIR
will be set to
.Ar destdir .
.Sh ENVIRONMENT
See
.Xr pkg_install.conf 5
for options, that can also be specified using the environment.
.Sh SEE ALSO
.Xr pkg_add 1 ,
.Xr pkg_admin 1 ,
.Xr pkg_create 1 ,
.Xr pkg_info 1 ,
.Xr pkg_install.conf 5
.Xr pkgsrc 7
.Sh AUTHORS
.Bl -tag -width indent -compact
.It "Jordan Hubbard"
most of the work
.It "John Kohl"
refined it for
.Nx
.It "Hubert Feyrer"
.Nx
wildcard dependency processing, pkgdb, recursive "down"
delete, etc.
.It Joerg Sonnenberger
Rewrote most of the code to compute correct order of deinstallation
and to improve error handling.
.El

928
pkgtools/pkg_install/files/delete/pkg_delete.c Normal file
View File

@@ -0,0 +1,928 @@
/*-
* Copyright (c) 2009 Joerg Sonnenberger <joerg@NetBSD.org>.
* Copyright (c) 2003 Johnny Lam <jlam@NetBSD.org>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include <nbcompat.h>
#if HAVE_SYS_CDEFS_H
#include <sys/cdefs.h>
#endif
__RCSID("$NetBSD: pkg_delete.c,v 1.12 2011/09/29 23:30:21 wiz Exp $");
#if HAVE_ERR_H
#include <err.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include "lib.h"
static const char *pkgdb;
static const char *destdir;
static const char *prefix;
static int keep_preserve;
static int no_deinstall;
static int find_by_filename;
static int unregister_only;
static int pkgdb_update_only;
static int delete_recursive;
static int delete_new_leaves;
static int delete_automatic_leaves;
static void
usage(void)
{
fprintf(stderr, "usage: pkg_delete [-DFfkNnORrVv] [-K pkg_dbdir]"
" [-P destdir] [-p prefix] pkg-name ...\n");
exit(1);
}
static int
add_by_filename(lpkg_head_t *pkgs, const char *filename)
{
lpkg_t *lpp;
char *s;
if ((s = pkgdb_retrieve(filename)) == NULL) {
warnx("No matching package for file `%s' in pkgdb", filename);
return 1;
}
/* XXX Verify that pkgdb is consistent? Trust it for now... */
lpp = alloc_lpkg(s);
TAILQ_INSERT_TAIL(pkgs, lpp, lp_link);
return 0;
}
static int
add_by_pattern(lpkg_head_t *pkgs, const char *pattern)
{
switch (add_installed_pkgs_by_pattern(pattern, pkgs)) {
case 0:
warnx("No package matching `%s' found", pattern);
return 1;
case -1:
warnx("Error while iterating package database for `%s'",
pattern);
return 1;
default:
return 0;
}
}
/*
* The argument is either a fixed package name or an absolute path.
* The latter is recognized for legacy compatibility and must point
* into the package database.
*/
static int
add_by_pkgname(lpkg_head_t *pkgs, char *pkg)
{
char *s;
lpkg_t *lpp;
size_t l;
const char *orig_pkg = pkg;
if (pkg[0] == '/') {
l = strlen(pkgdb);
if (strncmp(pkg, pkgdb, l) || pkg[l] != '/') {
warnx("Absolute path is not relative to "
"package database, skipping: %s", pkg);
return 1;
}
pkg += l + 1;
}
l = strcspn(pkg, "/");
if (pkg[l + strspn(pkg + l, "/")] != '\0') {
warnx("`%s' is not a package name, skipping", orig_pkg);
return 1;
}
pkg[l] = '\0';
s = pkgdb_pkg_file(pkg, CONTENTS_FNAME);
if (fexists(s)) {
free(s);
lpp = alloc_lpkg(pkg);
TAILQ_INSERT_TAIL(pkgs, lpp, lp_link);
return 0;
}
free(s);
switch (add_installed_pkgs_by_basename(pkg, pkgs)) {
case 0:
warnx("No matching package for basename `%s' of `%s'",
pkg, orig_pkg);
return 1;
case -1:
warnx("Error expanding basename `%s' of `%s'",
pkg, orig_pkg);
return 1;
default:
return 0;
}
}
/*
* Evaluate +REQUIRED_BY. This function is used for four different
* tasks:
* 0: check if no depending packages remain
* 1: like 0, but prepend the depending packages to pkgs if they exist
* 2: print remaining packages to stderr
* 3: check all and at least one depending packages have been removed
*/
static int
process_required_by(const char *pkg, lpkg_head_t *pkgs,
lpkg_head_t *sorted_pkgs, int action)
{
char line[MaxPathSize], *eol, *fname;
FILE *fp;
lpkg_t *lpp;
int got_match, got_miss;
fname = pkgdb_pkg_file(pkg, REQUIRED_BY_FNAME);
if (!fexists(fname)) {
free(fname);
return 0;
}
if ((fp = fopen(fname, "r")) == NULL) {
warn("Failed to open `%s'", fname);
free(fname);
return -1;
}
free(fname);
got_match = 0;
got_miss = 0;
while (fgets(line, sizeof(line), fp)) {
if ((eol = strrchr(line, '\n')) != NULL)
*eol = '\0';
TAILQ_FOREACH(lpp, sorted_pkgs, lp_link) {
if (strcmp(lpp->lp_name, line) == 0)
break;
}
if (lpp != NULL) {
got_match = 1;
continue;
}
got_miss = 1;
if (pkgs) {
TAILQ_FOREACH(lpp, pkgs, lp_link) {
if (strcmp(lpp->lp_name, line) == 0)
break;
}
if (lpp != NULL)
continue;
}
switch (action) {
case 0:
fclose(fp);
return 1;
case 1:
lpp = alloc_lpkg(line);
TAILQ_INSERT_HEAD(pkgs, lpp, lp_link);
break;
case 2:
fprintf(stderr, "\t%s\n", line);
break;
case 3:
fclose(fp);
return 0;
}
}
fclose(fp);
return (action == 3 ? got_match : got_miss);
}
/*
* Main function to order the patterns from the command line and
* add the subtrees for -r processing as needed.
*
* The first part ensures that all packages are listed at most once
* in pkgs. Afterwards the list is scanned for packages without depending
* packages. Each such package is moved to sorted_pkgs in order.
* If -r is given, all dependencies are inserted at the head of pkgs.
* The loop has to continue as long as progress is made. This can happen
* either because another package has been added to pkgs due to recursion
* (head of pkgs changed) or because a package has no more depending packages
* (tail of sorted_pkgs changed).
*
* If no progress is made, the remaining packages are moved to sorted_pkgs
* and an error is returned for the !Force case.
*/
static int
sort_and_recurse(lpkg_head_t *pkgs, lpkg_head_t *sorted_pkgs)
{
lpkg_t *lpp, *lpp2, *lpp_next, *lpp_old_tail, *lpp_old_head;
int rv;
TAILQ_FOREACH_SAFE(lpp, pkgs, lp_link, lpp_next) {
TAILQ_FOREACH(lpp2, pkgs, lp_link) {
if (lpp != lpp2 &&
strcmp(lpp->lp_name, lpp2->lp_name) == 0)
break;
}
if (lpp2 == NULL)
continue;
TAILQ_REMOVE(pkgs, lpp, lp_link);
free_lpkg(lpp);
}
while (!TAILQ_EMPTY(pkgs)) {
lpp_old_tail = TAILQ_LAST(sorted_pkgs, _lpkg_head_t);
lpp_old_head = TAILQ_FIRST(pkgs);
TAILQ_FOREACH_SAFE(lpp, pkgs, lp_link, lpp_next) {
rv = process_required_by(lpp->lp_name, pkgs,
sorted_pkgs, delete_recursive ? 1 : 0);
if (rv)
continue;
TAILQ_REMOVE(pkgs, lpp, lp_link);
TAILQ_INSERT_TAIL(sorted_pkgs, lpp, lp_link);
}
if (lpp_old_tail == TAILQ_LAST(sorted_pkgs, _lpkg_head_t) &&
lpp_old_head == TAILQ_FIRST(pkgs))
break;
}
if (TAILQ_EMPTY(pkgs))
return 0;
while (!TAILQ_EMPTY(pkgs)) {
lpp = TAILQ_FIRST(pkgs);
TAILQ_REMOVE(pkgs, lpp, lp_link);
fprintf(stderr,
"Package `%s' is still required by other packages:\n",
lpp->lp_name);
process_required_by(lpp->lp_name, NULL, sorted_pkgs, 2);
if (Force) {
TAILQ_INSERT_TAIL(sorted_pkgs, lpp, lp_link);
} else
free_lpkg(lpp);
}
return !Force;
}
struct find_leaves_data {
lpkg_head_t *pkgs;
int progress;
};
/*
* Iterator for finding leaf packages.
* Packages that are marked as not for deletion are not considered as
* leaves. For all other packages it is checked if at least one package
* that depended on them is to be removed AND no depending package remains.
* If that is the case, the package is appended to the sorted list.
* As this package can't have depending packages left, the topological order
* remains consistent.
*/
static int
find_new_leaves_iter(const char *pkg, void *cookie)
{
char *fname;
struct find_leaves_data *data = cookie;
lpkg_t *lpp;
fname = pkgdb_pkg_file(pkg, PRESERVE_FNAME);
if (fexists(fname)) {
free(fname);
return 0;
}
free(fname);
if (delete_automatic_leaves && !delete_new_leaves &&
!is_automatic_installed(pkg))
return 0;
/* Check whether this package is already on the list first. */
TAILQ_FOREACH(lpp, data->pkgs, lp_link) {
if (strcmp(lpp->lp_name, pkg) == 0)
return 0;
}
if (process_required_by(pkg, NULL, data->pkgs, 3) == 1) {
lpp = alloc_lpkg(pkg);
TAILQ_INSERT_TAIL(data->pkgs, lpp, lp_link);
data->progress = 1;
}
return 0;
}
/*
* Iterate over all installed packages and look for new leaf packages.
* As long as the loop adds one new leaf package, processing continues.
*/
static void
find_new_leaves(lpkg_head_t *pkgs)
{
struct find_leaves_data data;
data.pkgs = pkgs;
do {
data.progress = 0;
iterate_pkg_db(find_new_leaves_iter, &data);
} while (data.progress);
}
/*
* Check that no entry on the package list is marked as not for deletion.
*/
static int
find_preserve_pkgs(lpkg_head_t *pkgs)
{
lpkg_t *lpp, *lpp_next;
char *fname;
int found_preserve;
found_preserve = 0;
TAILQ_FOREACH_SAFE(lpp, pkgs, lp_link, lpp_next) {
fname = pkgdb_pkg_file(lpp->lp_name, PRESERVE_FNAME);
if (!fexists(fname)) {
free(fname);
continue;
}
free(fname);
if (keep_preserve) {
TAILQ_REMOVE(pkgs, lpp, lp_link);
free_lpkg(lpp);
continue;
}
if (!found_preserve)
warnx("The following packages are marked as not "
"for deletion:");
found_preserve = 1;
fprintf(stderr, "\t%s\n", lpp->lp_name);
}
if (!found_preserve)
return 0;
if (Force == 0 || (!unregister_only && Force == 1))
return 1;
fprintf(stderr, "...but will delete them anyway\n");
return 0;
}
/*
* Remove package from view. This is calling pkg_deinstall again.
*/
static int
remove_pkg_from_view(const char *pkg)
{
char line[MaxPathSize], *fname, *eol;
FILE *fp;
fname = pkgdb_pkg_file(pkg, VIEWS_FNAME);
if (isemptyfile(fname)) {
free(fname);
return 0;
}
if ((fp = fopen(fname, "r")) == NULL) {
warn("Unable to open `%s', aborting", fname);
free(fname);
return 1;
}
free(fname);
while (fgets(line, sizeof(line), fp) != NULL) {
if ((eol = strrchr(line, '\n')) != NULL)
*eol = '\0';
if (Verbose || Fake)
printf("Deleting package `%s' instance from `%s' view\n",
pkg, line);
if (Fake)
continue;
if (fexec_skipempty(BINDIR "/pkg_delete", "-K", line,
Fake ? "-n" : "",
(Force > 1) ? "-f" : "",
(Force > 0) ? "-f" : "",
pkg, NULL) != 0) {
warnx("Unable to delete package `%s' from view `%s'",
pkg, line);
fclose(fp);
return 1;
}
}
fclose(fp);
return 0;
}
/*
* Run the +DEINSTALL script. Depending on whether this is
* a depoted package and whether this pre- or post-deinstall phase,
* different arguments are passed down.
*/
static int
run_deinstall_script(const char *pkg, int do_postdeinstall)
{
const char *target, *text;
char *fname, *fname2, *pkgdir;
int rv;
fname = pkgdb_pkg_file(pkg, DEINSTALL_FNAME);
if (!fexists(fname)) {
free(fname);
return 0;
}
fname2 = pkgdb_pkg_file(pkg, DEPOT_FNAME);
if (fexists(fname2)) {
if (do_postdeinstall) {
free(fname);
free(fname2);
return 0;
}
target = "VIEW-DEINSTALL";
text = "view deinstall";
} else if (do_postdeinstall) {
target = "POST-DEINSTALL";
text = "post-deinstall";
} else {
target = "DEINSTALL";
text = "deinstall";
}
free(fname2);
if (Fake) {
printf("Would execute %s script with argument %s now\n",
text, target);
free(fname);
return 0;
}
pkgdir = pkgdb_pkg_dir(pkg);
if (chmod(fname, 0555))
warn("chmod of `%s' failed", fname);
rv = fcexec(pkgdir, fname, pkg, target, NULL);
if (rv)
warnx("%s script returned error status", text);
free(pkgdir);
free(fname);
return rv;
}
/*
* Copy lines from fname to fname_tmp, filtering out lines equal to text.
* Afterwards rename fname_tmp to fname;
*/
static int
remove_line(const char *fname, const char *fname_tmp, const char *text)
{
FILE *fp, *fp_out;
char line[MaxPathSize], *eol;
int rv;
if ((fp = fopen(fname, "r")) == NULL) {
warn("Unable to open `%s'", fname);
return 1;
}
if ((fp_out = fopen(fname_tmp, "w")) == NULL) {
warn("Unable to open `%s'", fname_tmp);
fclose(fp);
return 1;
}
while (fgets(line, sizeof(line), fp) != NULL) {
if ((eol = strrchr(line, '\n')) != NULL)
*eol = '\0';
if (strcmp(line, text) == 0)
continue;
fprintf(fp_out, "%s\n", line);
}
fclose(fp);
if (fclose(fp_out) == EOF) {
remove(fname_tmp);
warnx("Failure while closing `%s' temp file", fname_tmp);
return 1;
}
if (rename(fname_tmp, fname) == -1) {
warn("Unable to rename `%s' to `%s'", fname_tmp, fname);
rv = 1;
} else
rv = 0;
remove(fname_tmp);
return rv;
}
/*
* Unregister the package from the depot it is registered in.
*/
static int
remove_pkg_from_depot(const char *pkg)
{
FILE *fp;
char line[MaxPathSize], *eol;
char *fname, *fname2;
int rv;
fname = pkgdb_pkg_file(pkg, DEPOT_FNAME);
if (isemptyfile(fname)) {
free(fname);
return 0;
}
if (Verbose)
printf("Attempting to remove the `%s' registration "
"on package `%s'\n", fname, pkg);
if (Fake) {
free(fname);
return 1;
}
if ((fp = fopen(fname, "r")) == NULL) {
warn("Unable to open `%s' file", fname);
free(fname);
return 1;
}
if (fgets(line, sizeof(line), fp) == NULL) {
fclose(fp);
warnx("Empty depot file `%s'", fname);
free(fname);
return 1;
}
if ((eol = strrchr(line, '\n')) != NULL)
*eol = '\0';
fclose(fp);
free(fname);
fname = pkgdb_pkg_file(pkg, VIEWS_FNAME);
fname2 = pkgdb_pkg_file(pkg, VIEWS_FNAME_TMP);
rv = remove_line(fname, fname2, line);
free(fname2);
free(fname);
return rv;
}
/*
* remove_depend is used as iterator function below.
* The passed-in package name should be removed from the
* +REQUIRED_BY list of the dependency. Such an entry
* can miss in a fully correct package database, if the pattern
* matches more than one package.
*/
static int
remove_depend(const char *cur_pkg, void *cookie)
{
const char *pkg = cookie;
char *fname, *fname2;
int rv;
fname = pkgdb_pkg_file(cur_pkg, REQUIRED_BY_FNAME);
if (isemptyfile(fname)) {
free(fname);
return 0;
}
fname2 = pkgdb_pkg_file(cur_pkg, REQUIRED_BY_FNAME_TMP);
rv = remove_line(fname, fname2, pkg);
free(fname2);
free(fname);
return rv;
}
static int
remove_pkg(const char *pkg)
{
FILE *fp;
char *fname, *pkgdir;
package_t plist;
plist_t *p;
int is_depoted_pkg, rv, late_error;
if (pkgdb_update_only)
return pkgdb_remove_pkg(pkg) ? 0 : 1;
fname = pkgdb_pkg_file(pkg, CONTENTS_FNAME);
if (!fexists(fname)) {
warnx("package `%s' is not installed, `%s' missing", pkg, fname);
free(fname);
return 1;
}
free(fname);
/* +REQUIRED_BY and +PRESERVE already checked */
if (remove_pkg_from_view(pkg))
return 1;
/*
* The views related code has bad error handling, if e.g.
* the deinstall script fails, the package remains unregistered.
*/
fname = pkgdb_pkg_file(pkg, CONTENTS_FNAME);
if ((fp = fopen(fname, "r")) == NULL) {
warnx("Failed to open `%s'", fname);
free(fname);
return 1;
}
read_plist(&plist, fp);
fclose(fp);
/*
* If a prefix has been provided, remove the first @cwd and
* prepend that prefix. This allows removing packages without
* @cwd if really necessary. pkg_admin rebuild is likely needed
* afterwards though.
*/
if (prefix) {
delete_plist(&plist, FALSE, PLIST_CWD, NULL);
add_plist_top(&plist, PLIST_CWD, prefix);
}
if ((p = find_plist(&plist, PLIST_CWD)) == NULL) {
warnx("Package `%s' doesn't have a prefix", pkg);
return 1;
}
if (find_plist(&plist, PLIST_NAME) == NULL) {
/* Cheat a bit to allow removal of such bad packages. */
warnx("Package `%s' doesn't have a name", pkg);
add_plist_top(&plist, PLIST_NAME, pkg);
}
setenv(PKG_REFCOUNT_DBDIR_VNAME, config_pkg_refcount_dbdir, 1);
fname = pkgdb_pkg_dir(pkg);
setenv(PKG_METADATA_DIR_VNAME, fname, 1);
free(fname);
setenv(PKG_PREFIX_VNAME, p->name, 1);
if (!no_deinstall && !unregister_only) {
if (run_deinstall_script(pkg, 0) && !Force)
return 1;
}
late_error = 0;
if (Fake)
printf("Attempting to delete package `%s'\n", pkg);
else if (delete_package(FALSE, &plist, unregister_only,
destdir) == FAIL) {
warnx("couldn't entirely delete package `%s'", pkg);
/*
* XXX It could be nice to error out here explicitly,
* XXX but this is problematic for missing or changed files.
* XXX At least the inability to remove files at all should
* XXX be handled though.
*/
}
/*
* Past the point of no return. Files are gone, all that is left
* is cleaning up registered dependencies and removing the meta data.
* Errors in the remaining part are counted, but don't stop the
* processing.
*/
fname = pkgdb_pkg_file(pkg, DEPOT_FNAME);
if (fexists(fname)) {
late_error |= remove_pkg_from_depot(pkg);
/* XXX error checking */
} else {
for (p = plist.head; p; p = p->next) {
if (p->type != PLIST_PKGDEP)
continue;
if (Verbose)
printf("Attempting to remove dependency "
"on package `%s'\n", p->name);
if (Fake)
continue;
match_installed_pkgs(p->name, remove_depend,
__UNCONST(pkg));
}
}
free(fname);
free_plist(&plist);
if (!no_deinstall && !unregister_only)
late_error |= run_deinstall_script(pkg, 1);
fname = pkgdb_pkg_file(pkg, VIEWS_FNAME);
if (fexists(fname))
is_depoted_pkg = TRUE;
else
is_depoted_pkg = FALSE;
free(fname);
if (Fake)
return 0;
/*
* Kill the pkgdb subdirectory. The files have been removed, so
* this is way beyond the point of no return.
*/
pkgdir = pkgdb_pkg_dir(pkg);
(void) remove_files(pkgdir, "+*");
rv = 1;
if (isemptydir(pkgdir)&& rmdir(pkgdir) == 0)
rv = 0;
else if (is_depoted_pkg)
warnx("Depot directory `%s' is not empty", pkgdir);
else if (!Force)
warnx("Couldn't remove package directory in `%s'", pkgdir);
else if (recursive_remove(pkgdir, 1))
warn("Couldn't remove package directory `%s'", pkgdir);
else
warnx("Package directory `%s' forcefully removed", pkgdir);
free(pkgdir);
return rv | late_error;
}
int
main(int argc, char *argv[])
{
lpkg_head_t pkgs, sorted_pkgs;
int ch, r, has_error;
unsigned long bad_count;
TAILQ_INIT(&pkgs);
TAILQ_INIT(&sorted_pkgs);
setprogname(argv[0]);
while ((ch = getopt(argc, argv, "ADFfK:kNnOP:p:RrVv")) != -1) {
switch (ch) {
case 'A':
delete_automatic_leaves = 1;
break;
case 'D':
no_deinstall = 1;
break;
case 'F':
find_by_filename = 1;
break;
case 'f':
++Force;
break;
case 'K':
pkgdb_set_dir(optarg, 3);
break;
case 'k':
keep_preserve = 1;
break;
case 'N':
unregister_only = 1;
break;
case 'n':
Fake = 1;
break;
case 'O':
pkgdb_update_only = 1;
break;
case 'P':
destdir = optarg;
break;
case 'p':
prefix = optarg;
break;
case 'R':
delete_new_leaves = 1;
break;
case 'r':
delete_recursive = 1;
break;
case 'V':
show_version();
/* NOTREACHED */
case 'v':
++Verbose;
break;
default:
usage();
break;
}
}
pkg_install_config();
pkgdb = xstrdup(pkgdb_get_dir());
if (destdir != NULL) {
char *pkgdbdir;
pkgdbdir = xasprintf("%s/%s", destdir, pkgdb);
pkgdb_set_dir(pkgdbdir, 4);
free(pkgdbdir);
}
argc -= optind;
argv += optind;
if (argc == 0) {
if (find_by_filename)
warnx("Missing filename(s)");
else
warnx("Missing package name(s)");
usage();
}
if (Fake)
r = pkgdb_open(ReadOnly);
else
r = pkgdb_open(ReadWrite);
if (!r)
errx(EXIT_FAILURE, "Opening pkgdb failed");
/* First, process all command line options. */
has_error = 0;
for (; argc != 0; --argc, ++argv) {
if (find_by_filename)
has_error |= add_by_filename(&pkgs, *argv);
else if (ispkgpattern(*argv))
has_error |= add_by_pattern(&pkgs, *argv);
else
has_error |= add_by_pkgname(&pkgs, *argv);
}
if (has_error && !Force) {
pkgdb_close();
return EXIT_FAILURE;
}
/* Second, reorder and recursive if necessary. */
if (sort_and_recurse(&pkgs, &sorted_pkgs)) {
pkgdb_close();
return EXIT_FAILURE;
}
/* Third, add leaves if necessary. */
if (delete_new_leaves || delete_automatic_leaves)
find_new_leaves(&sorted_pkgs);
/*
* Now that all packages to remove are known, check
* if all are removable. After that, start the actual
* removal.
*/
if (find_preserve_pkgs(&sorted_pkgs)) {
pkgdb_close();
return EXIT_FAILURE;
}
setenv(PKG_REFCOUNT_DBDIR_VNAME, pkgdb_refcount_dir(), 1);
bad_count = 0;
while (!TAILQ_EMPTY(&sorted_pkgs)) {
lpkg_t *lpp;
lpp = TAILQ_FIRST(&sorted_pkgs);
TAILQ_REMOVE(&sorted_pkgs, lpp, lp_link);
if (remove_pkg(lpp->lp_name)) {
++bad_count;
if (!Force)
break;
}
free_lpkg(lpp);
}
pkgdb_close();
if (Force && bad_count && Verbose)
warnx("Removal of %lu packages failed", bad_count);
return bad_count > 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}

165
pkgtools/pkg_install/files/delete/pkg_delete.cat Normal file
View File

@@ -0,0 +1,165 @@
PKG_DELETE(1) NetBSD General Commands Manual PKG_DELETE(1)
NNAAMMEE
ppkkgg__ddeelleettee -- a utility for deleting previously installed software pack-
age distributions
SSYYNNOOPPSSIISS
ppkkgg__ddeelleettee [--AADDFFffkkNNnnOORRrrVVvv] [--KK _p_k_g___d_b_d_i_r] [--PP _d_e_s_t_d_i_r] [--pp _p_r_e_f_i_x]
_p_k_g_-_n_a_m_e _._._.
DDEESSCCRRIIPPTTIIOONN
The ppkkgg__ddeelleettee command is used to delete packages that have been previ-
ously installed with the pkg_add(1) command. The given packages are
sorted, so that the dependencies of a package are deleted after the pack-
age. Before any action is executed, ppkkgg__ddeelleettee checks for packages that
are marked as pprreesseerrvveedd or have depending packages left. If the --kk flag
is given, preserved packages are removed from the list of packages to
remove. Unless the --ff flag is given, ppkkgg__ddeelleettee stops on the first
error.
WWAARRNNIINNGG
_S_i_n_c_e _t_h_e ppkkgg__ddeelleettee _c_o_m_m_a_n_d _m_a_y _e_x_e_c_u_t_e _s_c_r_i_p_t_s _o_r _p_r_o_g_r_a_m_s _p_r_o_v_i_d_e_d _b_y
_a _p_a_c_k_a_g_e _f_i_l_e_, _y_o_u_r _s_y_s_t_e_m _m_a_y _b_e _s_u_s_c_e_p_t_i_b_l_e _t_o _`_`_T_r_o_j_a_n _h_o_r_s_e_s_'_' _o_r
_o_t_h_e_r _s_u_b_t_l_e _a_t_t_a_c_k_s _f_r_o_m _m_i_s_c_r_e_a_n_t_s _w_h_o _c_r_e_a_t_e _d_a_n_g_e_r_o_u_s _p_a_c_k_a_g_e _f_i_l_e_s_.
_Y_o_u _a_r_e _a_d_v_i_s_e_d _t_o _v_e_r_i_f_y _t_h_e _c_o_m_p_e_t_e_n_c_e _a_n_d _i_d_e_n_t_i_t_y _o_f _t_h_o_s_e _w_h_o _p_r_o_-
_v_i_d_e _i_n_s_t_a_l_l_a_b_l_e _p_a_c_k_a_g_e _f_i_l_e_s_. _F_o_r _e_x_t_r_a _p_r_o_t_e_c_t_i_o_n_, _e_x_a_m_i_n_e _a_l_l _t_h_e
_p_a_c_k_a_g_e _c_o_n_t_r_o_l _f_i_l_e_s _i_n _t_h_e _p_a_c_k_a_g_e _r_e_c_o_r_d _d_i_r_e_c_t_o_r_y
_<_P_K_G___D_B_D_I_R_>_/_<_p_k_g_-_n_a_m_e_>_/_)_. _P_a_y _p_a_r_t_i_c_u_l_a_r _a_t_t_e_n_t_i_o_n _t_o _a_n_y _+_I_N_S_T_A_L_L _o_r
_+_D_E_I_N_S_T_A_L_L _f_i_l_e_s_, _a_n_d _i_n_s_p_e_c_t _t_h_e _+_C_O_N_T_E_N_T_S _f_i_l_e _f_o_r @@ccwwdd_, @@mmooddee _(_c_h_e_c_k
_f_o_r _s_e_t_u_i_d_)_, @@ddiirrrrmm_, @@eexxeecc_, _a_n_d @@uunneexxeecc _d_i_r_e_c_t_i_v_e_s_, _a_n_d_/_o_r _u_s_e _t_h_e
pkg_info(_1) _c_o_m_m_a_n_d _t_o _e_x_a_m_i_n_e _t_h_e _i_n_s_t_a_l_l_e_d _p_a_c_k_a_g_e _c_o_n_t_r_o_l _f_i_l_e_s_.
OOPPTTIIOONNSS
The following command line options are supported:
_p_k_g_-_n_a_m_e _._._.
The named packages are deinstalled, wildcards can be used, see
pkg_info(1). If no version is given, the one currently installed
will be removed. If the --FF flag is given, one or more (absolute)
filenames may be specified and the Package Database will be con-
sulted for the package to which the given file belongs. These
packages are then deinstalled.
--AA Recursively remove all automatically installed packages that were
needed by the given packages and are no longer required. See
also the --RR flag.
--DD If a deinstallation script exists for a given package, do not
execute it.
--FF Any pkg-name given will be interpreted as pathname which is sub-
sequently transformed in a (real) package name via the Package
Database. That way, packages can be deleted by giving a filename
instead of the package-name.
--ff Force removal of the package, even if a dependency is recorded or
the deinstall script fails.
--ffff Force removal of the package, even if the package is marked as a
pprreesseerrvveedd package. Note that this is a dangerous operation. See
also the --kk option.
--KK _p_k_g___d_b_d_i_r
Override the value of the PKG_DBDIR configuration option with the
value _p_k_g___d_b_d_i_r.
--kk Silently skip all packages that are marked as pprreesseerrvveedd.
--NN Remove the package's registration and its entries from the pack-
age database, but leave the files installed. Don't run any dein-
stall scripts or @unexec lines either.
--nn Don't actually deinstall a package, just report the steps that
would be taken if it were.
--OO Only delete the package's entries from the package database, do
not touch the package or its files itself.
--pp _d_e_s_t_d_i_r
Prefix all file and directory names with _d_e_s_t_d_i_r. For packages
without install scripts this has the same behavior as using
chroot.
--pp _p_r_e_f_i_x
Set _p_r_e_f_i_x as the directory in which to delete files from any
installed packages which do not explicitly set theirs. For most
packages, the prefix will be set automatically to the installed
location by pkg_add(1).
--RR Recursively remove all packages that were needed by the given
packages and that have no other dependencies left. This option
overrides the --AA flag.
--rr Recursively remove all packages that require one of the packages
given.
--VV Print version number and exit.
--vv Turn on verbose output.
TTEECCHHNNIICCAALL DDEETTAAIILLSS
ppkkgg__ddeelleettee does pretty much what it says. It examines installed package
records in _<_P_K_G___D_B_D_I_R_>_/_<_p_k_g_-_n_a_m_e_>, deletes the package contents, and
finally removes the package records.
If a package is required by other installed packages, ppkkgg__ddeelleettee will
list those dependent packages and refuse to delete the package (unless
the --ff option is given).
If a package has been marked as a pprreesseerrvveedd package, it will not be able
to be deleted (unless more than one occurrence of the --ff option is
given).
If a filename is given instead of a package name, the package of which
the given file belongs to can be deleted if the --FF Flag is given. The
filename needs to be absolute, see the output produced by the pkg_info
--aaFF command.
If a ddeeiinnssttaallll script exists for the package, it is executed before and
after any files are removed. It is this script's responsibility to clean
up any additional messy details around the package's installation, since
all ppkkgg__ddeelleettee knows how to do is delete the files created in the origi-
nal distribution. The ddeeiinnssttaallll script is called as:
ddeeiinnssttaallll <_p_k_g_-_n_a_m_e> _V_I_E_W_-_D_E_I_N_S_T_A_L_L
before removing the package from a view, and as:
ddeeiinnssttaallll <_p_k_g_-_n_a_m_e> _D_E_I_N_S_T_A_L_L
before deleting all files and as:
ddeeiinnssttaallll <_p_k_g_-_n_a_m_e> _P_O_S_T_-_D_E_I_N_S_T_A_L_L
after deleting them. Passing the keywords _V_I_E_W_-_D_E_I_N_S_T_A_L_L, _D_E_I_N_S_T_A_L_L and
_P_O_S_T_-_D_E_I_N_S_T_A_L_L lets you potentially write only one program/script that
handles all aspects of installation and deletion.
All scripts are called with the environment variable PKG_PREFIX set to
the installation prefix (see the --pp option above). This allows a package
author to write a script that reliably performs some action on the direc-
tory where the package is installed, even if the user might have changed
it by specifying the --pp option when running ppkkgg__ddeelleettee or pkg_add(1).
The scripts are also called with the PKG_METADATA_DIR environment vari-
able set to the location of the _+_* meta-data files, and with the
PKG_REFCOUNT_DBDIR environment variable set to the location of the pack-
age reference counts database directory. If the --PP flag was given to
ppkkgg__ddeelleettee, PKG_DESTDIR will be set to _d_e_s_t_d_i_r.
EENNVVIIRROONNMMEENNTT
See pkg_install.conf(5) for options, that can also be specified using the
environment.
SSEEEE AALLSSOO
pkg_add(1), pkg_admin(1), pkg_create(1), pkg_info(1), pkg_install.conf(5)
pkgsrc(7)
AAUUTTHHOORRSS
Jordan Hubbard
most of the work
John Kohl
refined it for NetBSD
Hubert Feyrer
NetBSD wildcard dependency processing, pkgdb, recursive "down"
delete, etc.
Joerg Sonnenberger
Rewrote most of the code to compute correct order of deinstalla-
tion and to improve error handling.
NetBSD 5.0 January 20, 2010 NetBSD 5.0