void
delete_pkgdir(const char *pkg, const char *prefix, const char *path)
{
size_t pkg_len, len;
char *fullpath, *oldvalue, *newvalue, *iter;
fullpath = xasprintf("%s/%s", prefix, path);
oldvalue = pkgdb_retrieve(fullpath);
if (oldvalue && strncmp(oldvalue, "@pkgdir ", 8) == 0) {
newvalue = xstrdup(oldvalue);
iter = newvalue + 8;
pkg_len = strlen(pkg);
while (*iter) {
if (strncmp(iter, pkg, pkg_len) == 0 &&
(iter[pkg_len] == ' ' || iter[pkg_len] == '\0')) {
len = strlen(iter + pkg_len);
memmove(iter, iter + pkg_len + 1, len);
if (len == 0)
*iter = '\0';
} else {
iter += strcspn(iter, " ");
iter += strspn(iter, " ");
}
}
pkgdb_remove(fullpath);
if (iter != newvalue + 8)
pkgdb_store(fullpath, newvalue);
free(newvalue);
}
free(fullpath);
}
int
has_pkgdir(const char *path)
{
const char *value;
value = pkgdb_retrieve(path);
if (value && strncmp(value, "@pkgdir ", 8) == 0)
return 1;
else
return 0;
}
void
add_pkgdir(const char *pkg, const char *prefix, const char *path)
{
char *fullpath, *oldvalue, *newvalue;
fullpath = xasprintf("%s/%s", prefix, path);
oldvalue = pkgdb_retrieve(fullpath);
if (oldvalue) {
if (strncmp(oldvalue, "@pkgdir ", 8) != 0)
errx(EXIT_FAILURE, "Internal error while processing pkgdb, run pkg_admin rebuild");
newvalue = xasprintf("%s %s", oldvalue, pkg);
pkgdb_remove(fullpath);
} else {
newvalue = xasprintf("@pkgdir %s", pkg);
}
pkgdb_store(fullpath, newvalue);
free(fullpath);
free(newvalue);
}
/*
* Check a list for files that require preconversion
*/
void
check_list(package_t *pkg, const char *PkgName)
{
struct stat st;
plist_t *tmp;
plist_t *p;
char buf[ChecksumHeaderLen + LegibleChecksumLen];
char target[MaxPathSize + SymlinkHeaderLen];
char name[MaxPathSize];
char *cwd = NULL;
char *srcdir = NULL;
int dirc;
int cc;
/* Open Package Database for writing */
if (update_pkgdb && !pkgdb_open(ReadWrite))
err(EXIT_FAILURE, "can't open pkgdb");
for (dirc = 0, p = pkg->head; p; p = p->next) {
switch (p->type) {
case PLIST_CWD:
cwd = p->name;
break;
case PLIST_IGNORE:
p = p->next;
break;
case PLIST_SRC:
srcdir = p->name;
break;
case PLIST_DIR_RM:
dirc++;
break;
case PLIST_FILE:
/*
* pkgdb handling - usually, we enter files
* into the pkgdb as soon as they hit the disk,
* but as they are present before pkg_create
* starts, it's ok to do this somewhere here
*/
if (cwd == NULL)
errx(2, "file without preceding @cwd found");
if (update_pkgdb) {
char *s, t[MaxPathSize];
(void) snprintf(t, sizeof(t), "%s%s%s",
cwd,
(strcmp(cwd, "/") == 0) ? "" : "/",
p->name);
s = pkgdb_retrieve(t);
if (s && PlistOnly)
warnx("Overwriting %s - "
"pkg %s bogus/conflicting?", t, s);
else {
pkgdb_store(t, PkgName);
}
}
/* prepend DESTDIR if set? - HF */
(void) snprintf(name, sizeof(name), "%s%s%s",
cwd,
(strcmp(cwd, "/") == 0) ? "" : "/",
p->name);
if (lstat(name, &st) < 0) {
warnx("can't stat `%s'", name);
continue;
}
switch (st.st_mode & S_IFMT) {
case S_IFDIR:
p->type = PLIST_DIR_RM;
dirc++;
continue;
case S_IFLNK:
if (RelativeLinks) {
CheckSymlink(name, cwd, strlen(cwd));
}
(void) strlcpy(target, SYMLINK_HEADER,
sizeof(target));
if ((cc = readlink(name, &target[SymlinkHeaderLen],
sizeof(target) - SymlinkHeaderLen - 1)) < 0) {
warnx("can't readlink `%s'", name);
continue;
}
target[SymlinkHeaderLen + cc] = 0x0;
tmp = new_plist_entry();
tmp->name = xstrdup(target);
tmp->type = PLIST_COMMENT;
tmp->next = p->next;
tmp->prev = p;
if (p == pkg->tail) {
pkg->tail = tmp;
}
p->next = tmp;
p = tmp;
break;
case S_IFCHR:
warnx("Warning - char special device `%s' in PLIST", name);
break;
case S_IFBLK:
warnx("Warning - block special device `%s' in PLIST", name);
break;
default:
(void) strlcpy(buf, CHECKSUM_HEADER,
sizeof(buf));
if (MD5File(name, &buf[ChecksumHeaderLen]) != (char *) NULL) {
tmp = new_plist_entry();
tmp->name = xstrdup(buf);
tmp->type = PLIST_COMMENT; /* PLIST_MD5 - HF */
tmp->next = p->next;
tmp->prev = p;
if (p == pkg->tail) {
pkg->tail = tmp;
}
p->next = tmp;
p = tmp;
}
break;
}
break;
default:
break;
}
}
if (update_pkgdb) {
pkgdb_close();
}
if (ReorderDirs && dirc > 0) {
reorder(pkg, dirc);
}
}
int
main(int argc, char **argv)
{
char *CheckPkg = NULL;
char *BestCheckPkg = NULL;
lpkg_t *lpp;
int ch;
int rc;
setprogname(argv[0]);
while ((ch = getopt(argc, argv, Options)) != -1)
switch (ch) {
case '.': /* for backward compatibility */
break;
case 'a':
Which = WHICH_ALL;
break;
case 'B':
Flags |= SHOW_BUILD_INFO;
break;
case 'b':
Flags |= SHOW_BUILD_VERSION;
break;
case 'c':
Flags |= SHOW_COMMENT;
break;
case 'D':
Flags |= SHOW_DISPLAY;
break;
case 'd':
Flags |= SHOW_DESC;
break;
case 'E':
BestCheckPkg = optarg;
break;
case 'e':
CheckPkg = optarg;
break;
case 'f':
Flags |= SHOW_PLIST;
break;
case 'F':
File2Pkg = 1;
break;
case 'I':
Flags |= SHOW_INDEX;
break;
case 'i':
Flags |= SHOW_INSTALL;
break;
case 'K':
pkgdb_set_dir(optarg, 3);
break;
case 'k':
Flags |= SHOW_DEINSTALL;
break;
case 'L':
Flags |= SHOW_FILES;
break;
case 'l':
InfoPrefix = optarg;
break;
case 'm':
Flags |= SHOW_MTREE;
break;
case 'N':
Flags |= SHOW_BLD_DEPENDS;
break;
case 'n':
Flags |= SHOW_DEPENDS;
break;
case 'p':
Flags |= SHOW_PREFIX;
break;
case 'Q':
Flags |= SHOW_BI_VAR;
BuildInfoVariable = optarg;
break;
case 'q':
Quiet = TRUE;
break;
case 'r':
Flags |= SHOW_FULL_REQBY;
break;
case 'R':
Flags |= SHOW_REQBY;
break;
case 's':
Flags |= SHOW_PKG_SIZE;
break;
case 'S':
Flags |= SHOW_ALL_SIZE;
break;
case 'u':
Which = WHICH_USER;
break;
case 'v':
Verbose = TRUE;
/* Reasonable definition of 'everything' */
Flags = SHOW_COMMENT | SHOW_DESC | SHOW_PLIST | SHOW_INSTALL |
SHOW_DEINSTALL | SHOW_DISPLAY | SHOW_MTREE |
SHOW_REQBY | SHOW_BLD_DEPENDS | SHOW_DEPENDS | SHOW_PKG_SIZE | SHOW_ALL_SIZE;
break;
case 'V':
show_version();
/* NOTREACHED */
case 'X':
Flags |= SHOW_SUMMARY;
break;
case 'h':
case '?':
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
pkg_install_config();
if (argc == 0 && !Flags && !CheckPkg) {
/* No argument or relevant flags specified - assume -I */
Flags = SHOW_INDEX;
/* assume -a if neither -u nor -a is given */
if (Which == WHICH_LIST)
Which = WHICH_ALL;
}
if (CheckPkg != NULL && BestCheckPkg != NULL) {
warnx("-E and -e are mutally exlusive");
usage();
}
if (argc != 0 && CheckPkg != NULL) {
warnx("can't give any additional arguments to -e");
usage();
}
if (argc != 0 && BestCheckPkg != NULL) {
warnx("can't give any additional arguments to -E");
usage();
}
if (argc != 0 && Which != WHICH_LIST) {
warnx("can't use both -a/-u and package name");
usage();
}
/* Set some reasonable defaults */
if (!Flags)
Flags = SHOW_COMMENT | SHOW_DESC | SHOW_REQBY
| SHOW_DEPENDS | SHOW_DISPLAY;
/* -Fe /filename -> change CheckPkg to real packagename */
if (CheckPkg) {
if (File2Pkg) {
char *s;
if (!pkgdb_open(ReadOnly))
err(EXIT_FAILURE, "cannot open pkgdb");
s = pkgdb_retrieve(CheckPkg);
if (s == NULL)
errx(EXIT_FAILURE, "No matching pkg for %s.", CheckPkg);
CheckPkg = xstrdup(s);
pkgdb_close();
}
return CheckForPkg(CheckPkg);
}
if (BestCheckPkg)
return CheckForBestPkg(BestCheckPkg);
TAILQ_INIT(&pkgs);
/* Get all the remaining package names, if any */
if (File2Pkg && Which == WHICH_LIST)
if (!pkgdb_open(ReadOnly)) {
err(EXIT_FAILURE, "cannot open pkgdb");
}
while (*argv) {
/* pkgdb: if -F flag given, don't add pkgnames to the "pkgs"
* queue but rather resolve the given filenames to pkgnames
* using pkgdb_retrieve, then add them. */
if (File2Pkg) {
char *s;
s = pkgdb_retrieve(*argv);
if (s) {
lpp = alloc_lpkg(s);
TAILQ_INSERT_TAIL(&pkgs, lpp, lp_link);
} else
errx(EXIT_FAILURE, "No matching pkg for %s.", *argv);
} else {
if (ispkgpattern(*argv)) {
switch (add_installed_pkgs_by_pattern(*argv, &pkgs)) {
case 0:
errx(EXIT_FAILURE, "No matching pkg for %s.", *argv);
case -1:
errx(EXIT_FAILURE, "Error during search in pkgdb for %s", *argv);
}
} else {
const char *dbdir;
dbdir = pkgdb_get_dir();
if (**argv == '/' && strncmp(*argv, dbdir, strlen(dbdir)) == 0) {
*argv += strlen(dbdir) + 1;
if ((*argv)[strlen(*argv) - 1] == '/') {
(*argv)[strlen(*argv) - 1] = 0;
}
}
lpp = alloc_lpkg(*argv);
TAILQ_INSERT_TAIL(&pkgs, lpp, lp_link);
}
}
argv++;
}
if (File2Pkg)
pkgdb_close();
/* If no packages, yelp */
if (TAILQ_FIRST(&pkgs) == NULL && Which == WHICH_LIST && !CheckPkg)
warnx("missing package name(s)"), usage();
rc = pkg_perform(&pkgs);
exit(rc);
/* NOTREACHED */
}
