void
set_globals(void)
{
yes = pkg_object_bool(pkg_config_get("ASSUME_ALWAYS_YES"));
dry_run = 0;
auto_update = pkg_object_bool(pkg_config_get("REPO_AUTOUPDATE"));
case_sensitive = pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH"));
force = 0;
quiet = 0;
newpkgversion = 0;
}
static int
filter_system_shlibs(const char *name, char *path, size_t pathlen)
{
const char *shlib_path;
shlib_path = shlib_list_find_by_name(name);
if (shlib_path == NULL) {
/* dynamic linker could not resolve */
return (EPKG_FATAL);
}
if (pkg_object_bool(pkg_config_get("ALLOW_BASE_SHLIBS"))) {
if (strstr(shlib_path, "/lib32/") != NULL)
return (EPKG_END);
} else {
/* match /lib, /lib32, /usr/lib and /usr/lib32 */
if (strncmp(shlib_path, "/lib", 4) == 0 ||
strncmp(shlib_path, "/usr/lib", 8) == 0)
return (EPKG_END); /* ignore libs from base */
}
if (path != NULL)
strncpy(path, shlib_path, pathlen);
return (EPKG_OK);
}
void
pkg_cache_full_clean(void)
{
const char *cachedir;
if (!pkg_object_bool(pkg_config_get("AUTOCLEAN")))
return;
pkg_debug(1, "Cleaning up cachedir");
cachedir = pkg_object_string(pkg_config_get("PKG_CACHEDIR"));
return (rm_rf(cachedir));
}
void
pkg_emit_deinstall_finished(struct pkg *p)
{
struct pkg_event ev;
bool syslog_enabled = false;
ev.type = PKG_EVENT_DEINSTALL_FINISHED;
ev.e_deinstall_finished.pkg = p;
syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG"));
if (syslog_enabled) {
syslog(LOG_NOTICE, "%s-%s deinstalled",
p->name, p->version);
}
pkg_emit_event(&ev);
}
void
pkg_emit_install_finished(struct pkg *p)
{
struct pkg_event ev;
bool syslog_enabled = false;
char *name, *version;
ev.type = PKG_EVENT_INSTALL_FINISHED;
ev.e_install_finished.pkg = p;
syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG"));
if (syslog_enabled) {
pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version);
syslog(LOG_NOTICE, "%s-%s installed", name, version);
}
pkg_emit_event(&ev);
}
int
exec_create(int argc, char **argv)
{
match_t match = MATCH_EXACT;
const char *outdir = NULL;
const char *format = NULL;
const char *rootdir = NULL;
const char *metadatadir = NULL;
const char *manifest = NULL;
char *plist = NULL;
pkg_formats fmt;
int ch;
bool overwrite = true;
bool hash = false;
/* POLA: pkg create is quiet by default, unless
* PKG_CREATE_VERBOSE is set in pkg.conf. This is for
* historical reasons. */
quiet = !pkg_object_bool(pkg_config_get("PKG_CREATE_VERBOSE"));
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "format", required_argument, NULL, 'f' },
{ "glob", no_argument, NULL, 'g' },
{ "hash", no_argument, NULL, 'h' },
{ "regex", no_argument, NULL, 'x' },
{ "root-dir", required_argument, NULL, 'r' },
{ "metadata", required_argument, NULL, 'm' },
{ "manifest", required_argument, NULL, 'M' },
{ "no-clobber", no_argument, NULL, 'n' },
{ "out-dir", required_argument, NULL, 'o' },
{ "plist", required_argument, NULL, 'p' },
{ "quiet", no_argument, NULL, 'q' },
{ "verbose", no_argument, NULL, 'v' },
{ NULL, 0, NULL, 0 },
};
while ((ch = getopt_long(argc, argv, "+aghxf:r:m:M:o:np:qv", longopts, NULL)) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'f':
format = optarg;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'h':
hash = true;
break;
case 'm':
metadatadir = optarg;
break;
case 'M':
manifest = optarg;
break;
case 'n':
overwrite = false;
break;
case 'o':
outdir = optarg;
break;
case 'p':
plist = optarg;
break;
case 'q':
quiet = true;
break;
case 'r':
rootdir = optarg;
break;
case 'v':
quiet = false;
break;
case 'x':
match = MATCH_REGEX;
break;
default:
usage_create();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (match != MATCH_ALL && metadatadir == NULL && manifest == NULL &&
argc == 0) {
usage_create();
return (EX_USAGE);
}
if (metadatadir == NULL && manifest == NULL && rootdir != NULL) {
warnx("Do not specify a rootdir without also specifying "
"either a metadatadir or manifest");
usage_create();
return (EX_USAGE);
}
if (outdir == NULL)
outdir = "./";
if (format == NULL) {
fmt = TXZ;
} else {
if (format[0] == '.')
++format;
if (strcmp(format, "txz") == 0)
fmt = TXZ;
else if (strcmp(format, "tbz") == 0)
fmt = TBZ;
else if (strcmp(format, "tgz") == 0)
fmt = TGZ;
else if (strcmp(format, "tar") == 0)
fmt = TAR;
else {
warnx("unknown format %s, using txz", format);
fmt = TXZ;
}
}
if (metadatadir == NULL && manifest == NULL) {
return (pkg_create_matches(argc, argv, match, fmt, outdir,
overwrite) == EPKG_OK ? EX_OK : EX_SOFTWARE);
} else if (metadatadir != NULL) {
return (pkg_create_staged(outdir, fmt, rootdir, metadatadir,
plist, hash) == EPKG_OK ? EX_OK : EX_SOFTWARE);
} else { /* (manifest != NULL) */
return (pkg_create_from_manifest(outdir, fmt, rootdir,
manifest, plist) == EPKG_OK ? EX_OK : EX_SOFTWARE);
}
}
int
exec_upgrade(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkg_jobs *jobs = NULL;
const char *reponame = NULL;
int retcode;
int updcode;
int ch;
int lock_type = PKGDB_LOCK_ADVISORY;
bool yes = true, yes_arg = false;
bool dry_run = false;
bool auto_update;
int done = 0;
nbactions = nbdone = 0;
pkg_flags f = PKG_FLAG_NONE | PKG_FLAG_PKG_VERSION_TEST;
yes_arg = pkg_object_bool(pkg_config_get("ASSUME_ALWAYS_YES"));
auto_update = pkg_object_bool(pkg_config_get("REPO_AUTOUPDATE"));
while ((ch = getopt(argc, argv, "fInqFr:Uy")) != -1) {
switch (ch) {
case 'f':
f |= PKG_FLAG_FORCE;
break;
case 'I':
f |= PKG_FLAG_NOSCRIPT;
break;
case 'U':
auto_update = false;
break;
case 'n':
f |= PKG_FLAG_DRY_RUN;
lock_type = PKGDB_LOCK_READONLY;
dry_run = true;
break;
case 'F':
f |= PKG_FLAG_SKIP_INSTALL;
lock_type = PKGDB_LOCK_READONLY;
break;
case 'q':
quiet = true;
break;
case 'r':
reponame = optarg;
break;
case 'y':
yes_arg = true;
break;
default:
usage_upgrade();
return (EX_USAGE);
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc != 0) {
usage_upgrade();
return (EX_USAGE);
}
if (dry_run && !auto_update)
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
else
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
if (retcode == EPKG_ENOACCESS && dry_run) {
auto_update = false;
retcode = pkgdb_access(PKGDB_MODE_READ,
PKGDB_DB_LOCAL|PKGDB_DB_REPO);
}
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privilege to upgrade packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_SOFTWARE;
/* first update the remote repositories if needed */
if (auto_update &&
(updcode = pkgcli_update(false, reponame)) != EPKG_OK)
return (updcode);
if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, lock_type, 0, 0) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (pkg_jobs_new(&jobs, PKG_JOBS_UPGRADE, db) != EPKG_OK)
goto cleanup;
if (reponame != NULL && pkg_jobs_set_repository(jobs, reponame) != EPKG_OK)
goto cleanup;
pkg_jobs_set_flags(jobs, f);
if (pkg_jobs_solve(jobs) != EPKG_OK)
goto cleanup;
while ((nbactions = pkg_jobs_count(jobs)) > 0) {
/* print a summary before applying the jobs */
yes = yes_arg;
if (!quiet || dry_run) {
print_jobs_summary(jobs,
"The following %d packages will be affected (of %d checked):\n\n",
nbactions, pkg_jobs_total(jobs));
if (!yes && !dry_run)
yes = query_yesno(false, "\nProceed with this action [y/N]: ");
if (dry_run)
yes = false;
}
if (yes) {
retcode = pkg_jobs_apply(jobs);
done = 1;
if (retcode == EPKG_CONFLICT) {
printf ("The conflicts with the existing packages have been found.\n"
"We need to run one more solver iteration to resolve them.\n");
continue;
}
else if (retcode != EPKG_OK)
goto cleanup;
}
if (messages != NULL) {
sbuf_finish(messages);
printf("%s", sbuf_data(messages));
}
break;
}
if (done == 0 && yes)
printf("Your packages are up to date\n");
retcode = EX_OK;
cleanup:
pkg_jobs_free(jobs);
pkgdb_release_lock(db, lock_type);
pkgdb_close(db);
if (!yes && newpkgversion)
newpkgversion = false;
return (retcode);
}
int
packing_append_file_attr(struct packing *pack, const char *filepath,
const char *newpath, const char *uname, const char *gname, mode_t perm,
u_long fflags)
{
int fd;
char *map;
int retcode = EPKG_OK;
int ret;
struct stat st;
struct archive_entry *entry, *sparse_entry;
bool unset_timestamp;
entry = archive_entry_new();
archive_entry_copy_sourcepath(entry, filepath);
pkg_debug(2, "Packing file '%s'", filepath);
if (lstat(filepath, &st) != 0) {
pkg_emit_errno("lstat", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
ret = archive_read_disk_entry_from_file(pack->aread, entry, -1,
&st);
if (ret != ARCHIVE_OK) {
pkg_emit_error("%s: %s", filepath,
archive_error_string(pack->aread));
retcode = EPKG_FATAL;
goto cleanup;
}
if (newpath != NULL)
archive_entry_set_pathname(entry, newpath);
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_entry_set_size(entry, 0);
}
if (uname != NULL && uname[0] != '\0') {
if (pack->pass) {
struct passwd* pw = getpwnam(uname);
if (pw == NULL) {
pkg_emit_error("Unknown user: '******'", uname);
retcode = EPKG_FATAL;
goto cleanup;
}
archive_entry_set_uid(entry, pw->pw_uid);
}
archive_entry_set_uname(entry, uname);
}
if (gname != NULL && gname[0] != '\0') {
if (pack->pass) {
struct group *gr = (getgrnam(gname));
if (gr == NULL) {
pkg_emit_error("Unknown group: '%s'", gname);
retcode = EPKG_FATAL;
goto cleanup;
}
archive_entry_set_gid(entry, gr->gr_gid);
}
archive_entry_set_gname(entry, gname);
}
if (fflags > 0)
archive_entry_set_fflags(entry, fflags, 0);
if (perm != 0)
archive_entry_set_perm(entry, perm);
unset_timestamp = pkg_object_bool(pkg_config_get("UNSET_TIMESTAMP"));
if (unset_timestamp) {
archive_entry_unset_atime(entry);
archive_entry_unset_ctime(entry);
archive_entry_unset_mtime(entry);
archive_entry_unset_birthtime(entry);
}
archive_entry_linkify(pack->resolver, &entry, &sparse_entry);
if (sparse_entry != NULL && entry == NULL)
entry = sparse_entry;
archive_write_header(pack->awrite, entry);
if (archive_entry_size(entry) > 0) {
if ((fd = open(filepath, O_RDONLY)) < 0) {
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
if (st.st_size > SSIZE_MAX) {
char buf[BUFSIZ];
int len;
while ((len = read(fd, buf, sizeof(buf))) > 0)
if (archive_write_data(pack->awrite, buf, len) == -1) {
pkg_emit_errno("archive_write_data", "archive write error");
retcode = EPKG_FATAL;
break;
}
if (len == -1) {
pkg_emit_errno("read", "file read error");
retcode = EPKG_FATAL;
}
close(fd);
}
else {
if ((map = mmap(NULL, st.st_size, PROT_READ,
MAP_SHARED, fd, 0)) != MAP_FAILED) {
close(fd);
if (archive_write_data(pack->awrite, map, st.st_size) == -1) {
pkg_emit_errno("archive_write_data", "archive write error");
retcode = EPKG_FATAL;
}
munmap(map, st.st_size);
}
else {
close(fd);
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
}
}
cleanup:
archive_entry_free(entry);
return (retcode);
}
int
packing_append_file_attr(struct packing *pack, const char *filepath,
const char *newpath, const char *uname, const char *gname, mode_t perm,
u_long fflags)
{
int fd;
int retcode = EPKG_OK;
int ret;
time_t source_time;
struct stat st;
struct archive_entry *entry, *sparse_entry;
bool unset_timestamp;
const char *source_date_epoch;
char buf[32768];
int len;
entry = archive_entry_new();
archive_entry_copy_sourcepath(entry, filepath);
pkg_debug(2, "Packing file '%s'", filepath);
if (lstat(filepath, &st) != 0) {
pkg_emit_errno("lstat", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
ret = archive_read_disk_entry_from_file(pack->aread, entry, -1,
&st);
if (ret != ARCHIVE_OK) {
pkg_emit_error("%s: %s", filepath,
archive_error_string(pack->aread));
retcode = EPKG_FATAL;
goto cleanup;
}
if (newpath != NULL)
archive_entry_set_pathname(entry, newpath);
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_entry_set_size(entry, 0);
}
if (uname != NULL && uname[0] != '\0') {
archive_entry_set_uname(entry, uname);
}
if (gname != NULL && gname[0] != '\0') {
archive_entry_set_gname(entry, gname);
}
if (fflags > 0)
archive_entry_set_fflags(entry, fflags, 0);
if (perm != 0)
archive_entry_set_perm(entry, perm);
unset_timestamp = pkg_object_bool(pkg_config_get("UNSET_TIMESTAMP"));
if (unset_timestamp) {
archive_entry_unset_atime(entry);
archive_entry_unset_ctime(entry);
archive_entry_unset_mtime(entry);
archive_entry_unset_birthtime(entry);
}
if ((source_date_epoch = getenv("SOURCE_DATE_EPOCH")) != NULL) {
if (source_date_epoch[strspn(source_date_epoch, "0123456789")] != '\0') {
pkg_emit_error("Bad environment variable "
"SOURCE_DATE_EPOCH: %s", source_date_epoch);
retcode = EPKG_FATAL;
goto cleanup;
}
source_time = strtoll(source_date_epoch, NULL, 10);
archive_entry_set_atime(entry, source_time, 0);
archive_entry_set_ctime(entry, source_time, 0);
archive_entry_set_mtime(entry, source_time, 0);
archive_entry_set_birthtime(entry, source_time, 0);
}
archive_entry_linkify(pack->resolver, &entry, &sparse_entry);
if (sparse_entry != NULL && entry == NULL)
entry = sparse_entry;
archive_write_header(pack->awrite, entry);
if (archive_entry_size(entry) <= 0)
goto cleanup;
if ((fd = open(filepath, O_RDONLY)) < 0) {
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
while ((len = read(fd, buf, sizeof(buf))) > 0) {
if (archive_write_data(pack->awrite, buf, len) == -1) {
pkg_emit_errno("archive_write_data", "archive write error");
retcode = EPKG_FATAL;
break;
}
}
if (len == -1) {
pkg_emit_errno("read", "file read error");
retcode = EPKG_FATAL;
}
close(fd);
cleanup:
archive_entry_free(entry);
return (retcode);
}
retcode = EPKG_OK;
cleanup:
pkg_emit_add_deps_finished(pkg);
return (retcode);
}
static int
pkg_add_cleanup_old(struct pkgdb *db, struct pkg *old, struct pkg *new, int flags)
{
struct pkg_file *f;
int ret = EPKG_OK;
bool handle_rc;
handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS"));
if (handle_rc)
pkg_start_stop_rc_scripts(old, PKG_RC_STOP);
/*
* Execute pre deinstall scripts
*/
if ((flags & PKG_ADD_NOSCRIPT) == 0) {
if ((flags & PKG_ADD_USE_UPGRADE_SCRIPTS) == PKG_ADD_USE_UPGRADE_SCRIPTS)
ret = pkg_script_run(old, PKG_SCRIPT_PRE_UPGRADE);
else
ret = pkg_script_run(old, PKG_SCRIPT_PRE_DEINSTALL);
if (ret != EPKG_OK)
return (ret);
}
int
exec_info(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
int query_flags;
struct pkg *pkg = NULL;
uint64_t opt = INFO_TAG_NAMEVER;
match_t match = MATCH_GLOB;
char *pkgname;
char *pkgversion = NULL, *pkgversion2 = NULL;
const char *file = NULL;
int ch, fd;
int ret = EPKG_OK;
int retcode = 0;
bool gotone = false;
int i, j;
int sign = 0;
int sign2 = 0;
int open_flags = 0;
bool pkg_exists = false;
bool origin_search = false;
bool e_flag = false;
struct pkg_manifest_key *keys = NULL;
#ifdef HAVE_CAPSICUM
cap_rights_t rights;
#endif
/* Set default case sensitivity for searching */
pkgdb_set_case_sensitivity(
pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH")));
/* TODO: exclusive opts ? */
while ((ch = getopt(argc, argv, "aACDegixEIdrklbBsqopOfF:R")) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'A':
opt |= INFO_ANNOTATIONS;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'O':
origin_search = true; /* only for ports compat */
break;
case 'e':
pkg_exists = true;;
retcode = 1;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'x':
match = MATCH_REGEX;
break;
case 'D':
opt |= INFO_MESSAGE;
break;
case 'd':
opt |= INFO_DEPS;
break;
case 'I':
opt |= INFO_COMMENT;
break;
case 'r':
opt |= INFO_RDEPS;
break;
case 'k':
opt |= INFO_LOCKED;
break;
case 'l':
opt |= INFO_FILES;
break;
case 'b':
opt |= INFO_SHLIBS_PROVIDED;
break;
case 'B':
opt |= INFO_SHLIBS_REQUIRED;
break;
case 's':
opt |= INFO_FLATSIZE;
break;
case 'E': /* ports compatibility */
e_flag = true;
break;
case 'q':
quiet = true;
break;
case 'o':
opt |= INFO_ORIGIN;
break;
case 'p':
opt |= INFO_PREFIX;
break;
case 'f':
opt |= INFO_FULL;
break;
case 'F':
file = optarg;
break;
case 'R':
opt |= INFO_RAW;
break;
default:
usage_info();
return(EX_USAGE);
}
}
if (argc == 1 || (argc == 2 && quiet))
match = MATCH_ALL;
argc -= optind;
argv += optind;
if (argc == 0 && file == NULL && match != MATCH_ALL) {
/* which -O bsd.*.mk always execpt clean output */
if (origin_search)
return (EX_OK);
usage_info();
return (EX_USAGE);
}
/* When no other data is requested, default is to print
* 'name-ver comment' For -O, just print name-ver */
if (!origin_search && (opt & INFO_ALL) == 0 && match == MATCH_ALL &&
!quiet)
opt |= INFO_COMMENT;
/* Special compatibility: handle -O and -q -O */
if (origin_search) {
if (quiet) {
opt = INFO_TAG_NAMEVER;
quiet = false;
} else {
opt = INFO_TAG_NAMEVER|INFO_COMMENT;
}
}
if (match == MATCH_ALL && opt == INFO_TAG_NAMEVER)
quiet = false;
if (file != NULL) {
if ((fd = open(file, O_RDONLY)) == -1) {
warn("Unable to open %s", file);
return (EX_IOERR);
}
#ifdef HAVE_CAPSICUM
cap_rights_init(&rights, CAP_READ, CAP_FSTAT);
if (cap_rights_limit(fd, &rights) < 0 && errno != ENOSYS ) {
warn("cap_rights_limit() failed");
return (EX_SOFTWARE);
}
if (cap_enter() < 0 && errno != ENOSYS) {
warn("cap_enter() failed");
return (EX_SOFTWARE);
}
#endif
if (opt == INFO_TAG_NAMEVER)
opt |= INFO_FULL;
pkg_manifest_keys_new(&keys);
if ((opt & (INFO_RAW | INFO_FILES |
INFO_DIRS)) == 0)
open_flags = PKG_OPEN_MANIFEST_COMPACT;
if (pkg_open_fd(&pkg, fd, keys, open_flags) != EPKG_OK) {
close(fd);
return (1);
}
pkg_manifest_keys_free(keys);
print_info(pkg, opt);
close(fd);
pkg_free(pkg);
return (EX_OK);
}
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to query the package database");
return (EX_NOPERM);
} else if (ret == EPKG_ENODB) {
if (match == MATCH_ALL)
return (EX_OK);
if (origin_search)
return (EX_OK);
if (!quiet)
warnx("No packages installed");
return (EX_UNAVAILABLE);
} else if (ret != EPKG_OK)
return (EX_IOERR);
ret = pkgdb_open(&db, PKGDB_DEFAULT);
if (ret != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get a read lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
i = 0;
do {
gotone = false;
pkgname = argv[i];
/*
* allow to search for origin with a trailing /
* likes audio/linux-vsound depending on ${PORTSDIR}/audio/sox/
*/
if (argc > 0 && pkgname[strlen(pkgname) -1] == '/')
pkgname[strlen(pkgname) -1] = '\0';
if (argc > 0) {
j=0;
while (pkgname[j] != '\0') {
if (pkgname[j] == '<') {
if (pkgversion) {
pkgversion2 = pkgname + j;
sign2 = LT;
pkgversion2[0] = '\0';
pkgversion2++;
if (pkgversion2[0] == '=') {
pkgversion2++;
sign=LE;
j++;
}
} else {
pkgversion = pkgname + j;
sign = LT;
pkgversion[0] = '\0';
pkgversion++;
if (pkgversion[0] == '=') {
pkgversion++;
sign=LE;
j++;
}
}
} else if (pkgname[j] == '>') {
if (pkgversion) {
pkgversion2 = pkgname + j;
sign2 = GT;
pkgversion2[0] = '\0';
pkgversion2++;
if (pkgversion2[0] == '=') {
pkgversion2++;
sign=GE;
j++;
}
} else {
pkgversion = pkgname + j;
sign = GT;
pkgversion[0] = '\0';
pkgversion++;
if (pkgversion[0] == '=') {
pkgversion++;
sign=GE;
j++;
}
}
} else if (pkgname[j] == '=') {
if (pkgversion) {
pkgversion2 = pkgname + j;
sign2 = EQ;
pkgversion2[0] = '\0';
pkgversion2++;
if (pkgversion2[0] == '=') {
pkgversion2++;
sign=EQ;
j++;
}
} else {
pkgversion = pkgname + j;
sign = EQ;
pkgversion[0] = '\0';
pkgversion++;
if (pkgversion[0] == '=') {
pkgversion++;
sign=EQ;
j++;
}
}
}
j++;
}
}
if (match != MATCH_ALL && pkgname[0] == '\0') {
fprintf(stderr, "Pattern must not be empty.\n");
i++;
continue;
}
if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
goto cleanup;
}
/* this is place for compatibility hacks */
/* ports infrastructure expects pkg info -q -O to always return 0 even
* if the ports doesn't exists */
if (origin_search)
gotone = true;
/* end of compatibility hacks */
/*
* only show full version in case of match glob with a single argument specified
* which does not contains any glob pattern
*/
if (argc == 1 && !origin_search && !quiet && !e_flag &&
match == MATCH_GLOB &&
strcspn(pkgname, "*[]{}()") == strlen(pkgname) &&
opt == INFO_TAG_NAMEVER)
opt |= INFO_FULL;
query_flags = info_flags(opt, false);
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
gotone = true;
const char *version;
pkg_get(pkg, PKG_VERSION, &version);
if (pkgversion != NULL) {
switch (pkg_version_cmp(version, pkgversion)) {
case -1:
if (sign != LT && sign != LE) {
gotone = false;
continue;
}
break;
case 0:
if (sign != LE &&
sign != GE &&
sign != EQ) {
gotone = false;
continue;
}
break;
case 1:
if (sign != GT && sign != GE) {
gotone = false;
continue;
}
break;
}
}
if (pkgversion2 != NULL) {
switch (pkg_version_cmp(version, pkgversion2)) {
case -1:
if (sign2 != LT && sign2 != LE) {
gotone = false;
continue;
}
break;
case 0:
if (sign2 != LE &&
sign2 != GE &&
sign2 != EQ) {
gotone = false;
continue;
}
break;
case 1:
if (sign2 != GT && sign2 != GE) {
gotone = false;
continue;
}
break;
}
}
if (pkg_exists)
retcode = EX_OK;
else
print_info(pkg, opt);
}
if (ret != EPKG_END) {
retcode = EX_IOERR;
}
if (retcode == EX_OK && !gotone && match != MATCH_ALL) {
if (!quiet)
warnx("No package(s) matching %s", argv[i]);
retcode = EX_SOFTWARE;
}
pkgdb_it_free(it);
i++;
} while (i < argc);
cleanup:
if (pkg != NULL)
pkg_free(pkg);
pkgdb_release_lock(db, PKGDB_LOCK_READONLY);
pkgdb_close(db);
return (retcode);
}
int
exec_annotate(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
enum action action = NONE;
const char *tag;
const char *value;
const char *pkgname;
struct sbuf *input = NULL;
int ch;
int match = MATCH_EXACT;
int retcode;
int exitcode = EX_OK;
int flags = 0;
struct option longopts[] = {
{ "all", no_argument, NULL, 'a' },
{ "add", no_argument, NULL, 'A' },
{ "case-insensitive", no_argument, NULL, 'C' },
{ "delete", no_argument, NULL, 'D' },
{ "glob", no_argument, NULL, 'g' },
{ "case-insensitive", no_argument, NULL, 'i' },
{ "modify", no_argument, NULL, 'M' },
{ "quiet", no_argument, NULL, 'q' },
{ "show", no_argument, NULL, 'S' },
{ "regex", no_argument, NULL, 'x' },
{ "yes", no_argument, NULL, 'y' },
{ NULL, 0, NULL, 0 },
};
/* Set default case sensitivity for searching */
pkgdb_set_case_sensitivity(
pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH"))
);
while ((ch = getopt_long(argc, argv, "+aACDgiMqSxy", longopts, NULL))
!= -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'A':
action = ADD;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'D':
action = DELETE;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'M':
action = MODIFY;
break;
case 'q':
quiet = true;
break;
case 'S':
action = SHOW;
flags |= PKG_LOAD_ANNOTATIONS;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_annotate();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (action == NONE ||
(match == MATCH_ALL && argc < 1) ||
(match != MATCH_ALL && argc < 2)) {
usage_annotate();
return (EX_USAGE);
}
if (match == MATCH_ALL) {
pkgname = NULL;
tag = argv[0];
value = (argc > 1) ? argv[1] : NULL;
} else {
pkgname = argv[0];
tag = argv[1];
value = (argc > 2) ? argv[2] : NULL;
}
if ((action == ADD || action == MODIFY) && value == NULL) {
/* try and read data for the value from stdin. */
input = read_input();
value = sbuf_data(input);
}
retcode = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE,
PKGDB_DB_LOCAL);
if (retcode == EPKG_ENODB) {
if (match == MATCH_ALL) {
exitcode = EX_OK;
goto cleanup;
}
if (!quiet)
warnx("No packages installed. Nothing to do!");
exitcode = EX_OK;
goto cleanup;
} else if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to modify the package database");
exitcode = EX_NOPERM;
goto cleanup;
} else if (retcode != EPKG_OK) {
warnx("Error accessing the package database");
exitcode = EX_SOFTWARE;
goto cleanup;
}
retcode = pkgdb_open(&db, PKGDB_DEFAULT);
if (retcode != EPKG_OK) {
return (EX_IOERR);
}
if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an exclusive lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if ((it = pkgdb_query(db, pkgname, match)) == NULL) {
exitcode = EX_IOERR;
goto cleanup;
}
while ((retcode = pkgdb_it_next(it, &pkg, flags)) == EPKG_OK) {
switch(action) {
case NONE: /* Should never happen */
usage_annotate();
exitcode = EX_USAGE;
break;
case ADD:
retcode = do_add(db, pkg, tag, value);
break;
case MODIFY:
retcode = do_modify(db, pkg, tag, value);
break;
case DELETE:
retcode = do_delete(db, pkg, tag);
break;
case SHOW:
retcode = do_show(pkg, tag);
break;
}
if (retcode == EPKG_WARN)
exitcode = EX_DATAERR;
if (retcode != EPKG_OK && retcode != EPKG_WARN) {
exitcode = EX_IOERR;
goto cleanup;
}
}
cleanup:
pkg_free(pkg);
pkgdb_it_free(it);
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
pkgdb_close(db);
if (input != NULL)
sbuf_delete(input);
return (exitcode);
}
int
exec_check(int argc, char **argv)
{
struct pkg *pkg = NULL;
struct pkgdb_it *it = NULL;
struct pkgdb *db = NULL;
match_t match = MATCH_EXACT;
int flags = PKG_LOAD_BASIC;
int ret, rc = EX_OK;
int ch;
bool yes;
bool dcheck = false;
bool checksums = false;
bool recompute = false;
bool reanalyse_shlibs = false;
bool noinstall = false;
int nbpkgs = 0;
int i;
int verbose = 0;
yes = pkg_object_bool(pkg_config_get("ASSUME_ALWAYS_YES"));
/* Set default case sensitivity for searching */
pkgdb_set_case_sensitivity(
pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH"))
);
struct deps_head dh = STAILQ_HEAD_INITIALIZER(dh);
while ((ch = getopt(argc, argv, "aBCdginrsvxy")) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'B':
reanalyse_shlibs = true;
flags |= PKG_LOAD_FILES;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'd':
dcheck = true;
flags |= PKG_LOAD_DEPS;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'n':
noinstall = true;
break;
case 'r':
recompute = true;
flags |= PKG_LOAD_FILES;
break;
case 's':
checksums = true;
flags |= PKG_LOAD_FILES;
break;
case 'v':
verbose = 1;
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
usage_check();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
/* Default to all packages if no pkg provided */
if (argc == 0 && (dcheck || checksums || recompute || reanalyse_shlibs)) {
match = MATCH_ALL;
} else if ((argc == 0 && match != MATCH_ALL) || !(dcheck || checksums || recompute || reanalyse_shlibs)) {
usage_check();
return (EX_USAGE);
}
if (recompute || reanalyse_shlibs)
ret = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE,
PKGDB_DB_LOCAL);
else
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_LOCAL);
if (ret == EPKG_ENODB) {
warnx("No packages installed. Nothing to do!");
return (EX_OK);
} else if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to access the package database");
return (EX_NOPERM);
} else if (ret != EPKG_OK) {
warnx("Error accessing the package database");
return (EX_SOFTWARE);
}
ret = pkgdb_open(&db, PKGDB_DEFAULT);
if (ret != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY, 0, 0) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an advisory lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
i = 0;
do {
if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
rc = EX_IOERR;
goto cleanup;
}
while (pkgdb_it_next(it, &pkg, flags) == EPKG_OK) {
/* check for missing dependencies */
if (dcheck) {
if (verbose)
pkg_printf("Checking dependencies: %n\n", pkg);
nbpkgs += check_deps(db, pkg, &dh, noinstall);
if (noinstall && nbpkgs > 0) {
rc = EX_UNAVAILABLE;
}
}
if (checksums) {
if (verbose)
pkg_printf("Checking checksums: %n\n", pkg);
if (pkg_test_filesum(pkg) != EPKG_OK) {
rc = EX_DATAERR;
}
}
if (recompute) {
if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
PKGDB_LOCK_EXCLUSIVE, 0.5, 20) == EPKG_OK) {
if (verbose)
pkg_printf("Recomputing size and checksums: %n\n", pkg);
if (pkg_recompute(db, pkg) != EPKG_OK) {
rc = EX_DATAERR;
}
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
}
else {
rc = EX_TEMPFAIL;
}
}
if (reanalyse_shlibs) {
if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
PKGDB_LOCK_EXCLUSIVE, 0.5, 20) == EPKG_OK) {
if (verbose)
pkg_printf("Reanalyzing files for shlibs: %n\n", pkg);
if (pkgdb_reanalyse_shlibs(db, pkg) != EPKG_OK) {
pkg_printf("Failed to reanalyse for shlibs: %n\n", pkg);
rc = EX_UNAVAILABLE;
}
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
}
else {
rc = EX_TEMPFAIL;
}
}
}
if (dcheck && nbpkgs > 0 && !noinstall) {
printf("\n>>> Missing package dependencies were detected.\n");
printf(">>> Found %d issue(s) in the package database.\n\n", nbpkgs);
if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
PKGDB_LOCK_EXCLUSIVE, 0.5, 20) == EPKG_OK) {
ret = fix_deps(db, &dh, nbpkgs, yes);
if (ret == EPKG_OK)
check_summary(db, &dh);
else if (ret == EPKG_ENODB) {
db = NULL;
rc = EX_IOERR;
}
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
if (rc == EX_IOERR)
goto cleanup;
}
else {
rc = EX_TEMPFAIL;
goto cleanup;
}
}
pkgdb_it_free(it);
i++;
} while (i < argc);
cleanup:
deps_free(&dh);
pkg_free(pkg);
pkgdb_release_lock(db, PKGDB_LOCK_ADVISORY);
pkgdb_close(db);
return (rc);
}
int
pkg_add(struct pkgdb *db, const char *path, unsigned flags,
struct pkg_manifest_key *keys, const char *location)
{
const char *arch;
const char *origin;
const char *name;
struct archive *a;
struct archive_entry *ae;
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
struct pkg *pkg_inst = NULL;
bool extract = true;
bool handle_rc = false;
bool disable_mtree;
char dpath[MAXPATHLEN];
const char *basedir;
const char *ext;
char *mtree;
char *prefix;
int retcode = EPKG_OK;
int ret;
assert(path != NULL);
/*
* Open the package archive file, read all the meta files and set the
* current archive_entry to the first non-meta file.
* If there is no non-meta files, EPKG_END is returned.
*/
ret = pkg_open2(&pkg, &a, &ae, path, keys, 0, -1);
if (ret == EPKG_END)
extract = false;
else if (ret != EPKG_OK) {
retcode = ret;
goto cleanup;
}
if ((flags & PKG_ADD_UPGRADE) == 0)
pkg_emit_install_begin(pkg);
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
if (flags & PKG_ADD_AUTOMATIC)
pkg_set(pkg, PKG_AUTOMATIC, (bool)true);
/*
* Check the architecture
*/
pkg_get(pkg, PKG_ARCH, &arch, PKG_ORIGIN, &origin, PKG_NAME, &name);
if (!is_valid_abi(arch, true)) {
if ((flags & PKG_ADD_FORCE) == 0) {
retcode = EPKG_FATAL;
goto cleanup;
}
}
/*
* Check if the package is already installed
*/
ret = pkg_try_installed(db, origin, &pkg_inst, PKG_LOAD_BASIC);
if (ret == EPKG_OK) {
if ((flags & PKG_ADD_FORCE) == 0) {
pkg_emit_already_installed(pkg_inst);
retcode = EPKG_INSTALLED;
pkg_free(pkg_inst);
pkg_inst = NULL;
goto cleanup;
}
else {
pkg_emit_notice("package %s is already installed, forced install", name);
pkg_free(pkg_inst);
pkg_inst = NULL;
}
} else if (ret != EPKG_END) {
retcode = ret;
goto cleanup;
}
/*
* Check for dependencies by searching the same directory as
* the package archive we're reading. Of course, if we're
* reading from a file descriptor or a unix domain socket or
* somesuch, there's no valid directory to search.
*/
if (strncmp(path, "-", 2) != 0 && (flags & PKG_ADD_UPGRADE) == 0) {
basedir = dirname(path);
if ((ext = strrchr(path, '.')) == NULL) {
pkg_emit_error("%s has no extension", path);
retcode = EPKG_FATAL;
goto cleanup;
}
} else {
basedir = NULL;
ext = NULL;
}
while (pkg_deps(pkg, &dep) == EPKG_OK) {
if (pkg_is_installed(db, pkg_dep_origin(dep)) == EPKG_OK)
continue;
if (basedir != NULL) {
const char *dep_name = pkg_dep_name(dep);
const char *dep_ver = pkg_dep_version(dep);
snprintf(dpath, sizeof(dpath), "%s/%s-%s%s", basedir,
dep_name, dep_ver, ext);
if ((flags & PKG_ADD_UPGRADE) == 0 &&
access(dpath, F_OK) == 0) {
ret = pkg_add(db, dpath, PKG_ADD_AUTOMATIC, keys, location);
if (ret != EPKG_OK) {
retcode = EPKG_FATAL;
goto cleanup;
}
} else {
pkg_emit_error("Missing dependency matching "
"Origin: '%s' Version: '%s'",
pkg_dep_get(dep, PKG_DEP_ORIGIN),
pkg_dep_get(dep, PKG_DEP_VERSION));
if ((flags & PKG_ADD_FORCE_MISSING) == 0) {
retcode = EPKG_FATAL;
goto cleanup;
}
}
} else {
retcode = EPKG_FATAL;
pkg_emit_missing_dep(pkg, dep);
goto cleanup;
}
}
if (location != NULL)
pkg_addannotation(pkg, "relocated", location);
/* register the package before installing it in case there are
* problems that could be caught here. */
retcode = pkgdb_register_pkg(db, pkg, flags & PKG_ADD_UPGRADE, flags & PKG_ADD_FORCE);
if (retcode != EPKG_OK)
goto cleanup;
/* MTREE replicates much of the standard functionality
* inplicit in the way pkg works. It has to remain available
* in the ports for compatibility with the old pkg_tools, but
* ultimately, MTREE should be made redundant. Use this for
* experimantal purposes and to develop MTREE-free versions of
* packages. */
disable_mtree = pkg_object_bool(pkg_config_get("DISABLE_MTREE"));
if (!disable_mtree) {
pkg_get(pkg, PKG_PREFIX, &prefix, PKG_MTREE, &mtree);
if ((retcode = do_extract_mtree(mtree, prefix)) != EPKG_OK)
goto cleanup_reg;
}
/*
* Execute pre-install scripts
*/
if ((flags & (PKG_ADD_NOSCRIPT | PKG_ADD_USE_UPGRADE_SCRIPTS)) == 0)
pkg_script_run(pkg, PKG_SCRIPT_PRE_INSTALL);
/* add the user and group if necessary */
/* pkg_add_user_group(pkg); */
/*
* Extract the files on disk.
*/
if (extract && (retcode = do_extract(a, ae, location)) != EPKG_OK) {
/* If the add failed, clean up (silently) */
pkg_delete_files(pkg, 2);
pkg_delete_dirs(db, pkg, 1);
goto cleanup_reg;
}
/*
* Execute post install scripts
*/
if ((flags & PKG_ADD_NOSCRIPT) == 0) {
if ((flags & PKG_ADD_USE_UPGRADE_SCRIPTS) == PKG_ADD_USE_UPGRADE_SCRIPTS)
pkg_script_run(pkg, PKG_SCRIPT_POST_UPGRADE);
else
pkg_script_run(pkg, PKG_SCRIPT_POST_INSTALL);
}
/*
* start the different related services if the users do want that
* and that the service is running
*/
handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS"));
if (handle_rc)
pkg_start_stop_rc_scripts(pkg, PKG_RC_START);
cleanup_reg:
if ((flags & PKG_ADD_UPGRADE) == 0)
pkgdb_register_finale(db, retcode);
if (retcode == EPKG_OK && (flags & PKG_ADD_UPGRADE) == 0)
pkg_emit_install_finished(pkg);
cleanup:
if (a != NULL) {
archive_read_close(a);
archive_read_free(a);
}
pkg_free(pkg);
if (pkg_inst != NULL)
pkg_free(pkg_inst);
return (retcode);
}
static int
pkg_create_from_dir(struct pkg *pkg, const char *root,
struct packing *pkg_archive)
{
char fpath[MAXPATHLEN];
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
char *m;
int ret;
bool developer;
struct stat st;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
int64_t flatsize = 0;
const char *relocation;
struct hardlinks *hardlinks = NULL;
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
relocation = pkg_kv_get(&pkg->annotations, "relocated");
if (relocation == NULL)
relocation = "";
/*
* Get / compute size / checksum if not provided in the manifest
*/
while (pkg_files(pkg, &file) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, file->path);
if (lstat(fpath, &st) == -1) {
pkg_emit_error("file '%s' is missing", fpath);
return (EPKG_FATAL);
}
if (file->size == 0)
file->size = (int64_t)st.st_size;
if (st.st_nlink == 1 || !check_for_hardlink(&hardlinks, &st)) {
flatsize += file->size;
}
if (S_ISLNK(st.st_mode)) {
if (file->sum[0] == '\0') {
if (pkg_symlink_cksum(fpath, root, sha256) == EPKG_OK)
strlcpy(file->sum, sha256, sizeof(file->sum));
else
return (EPKG_FATAL);
}
}
else {
if (file->sum[0] == '\0') {
if (pkg->type == PKG_OLD_FILE) {
if (md5_file(fpath, sha256) != EPKG_OK)
return (EPKG_FATAL);
} else {
if (sha256_file(fpath, sha256) != EPKG_OK)
return (EPKG_FATAL);
}
strlcpy(file->sum, sha256, sizeof(file->sum));
}
}
}
pkg->flatsize = flatsize;
HASH_FREE(hardlinks, free);
if (pkg->type == PKG_OLD_FILE) {
char oldcomment[BUFSIZ];
pkg_old_emit_content(pkg, &m);
packing_append_buffer(pkg_archive, m, "+CONTENTS", strlen(m));
free(m);
packing_append_buffer(pkg_archive, pkg->desc, "+DESC", strlen(pkg->desc));
packing_append_buffer(pkg_archive, pkg->message, "+DISPLAY", strlen(pkg->message));
pkg_snprintf(oldcomment, sizeof(oldcomment), "%c\n", pkg);
packing_append_buffer(pkg_archive, oldcomment, "+COMMENT", strlen(oldcomment));
} else {
/*
* Register shared libraries used by the package if
* SHLIBS enabled in conf. Deletes shlib info if not.
*/
struct sbuf *b = sbuf_new_auto();
pkg_analyse_files(NULL, pkg, root);
pkg_emit_manifest_sbuf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL);
packing_append_buffer(pkg_archive, sbuf_data(b), "+COMPACT_MANIFEST", sbuf_len(b));
sbuf_clear(b);
pkg_emit_manifest_sbuf(pkg, b, 0, NULL);
sbuf_finish(b);
packing_append_buffer(pkg_archive, sbuf_data(b), "+MANIFEST", sbuf_len(b));
sbuf_delete(b);
}
while (pkg_files(pkg, &file) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, file->path);
ret = packing_append_file_attr(pkg_archive, fpath, file->path,
file->uname, file->gname, file->perm);
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (developer && ret != EPKG_OK)
return (ret);
}
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
relocation, dir->path);
ret = packing_append_file_attr(pkg_archive, fpath, dir->path,
dir->uname, dir->gname, dir->perm);
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (developer && ret != EPKG_OK)
return (ret);
}
return (EPKG_OK);
}
int
exec_set(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
int ch;
int i;
bool yes;
match_t match = MATCH_EXACT;
int64_t newautomatic = -1;
bool automatic = false;
const char *errstr;
char *neworigin = NULL;
char *oldorigin = NULL;
unsigned int loads = PKG_LOAD_BASIC;
unsigned int sets = 0;
int retcode;
yes = pkg_object_bool(pkg_config_get("ASSUME_ALWAYS_YES"));
while ((ch = getopt(argc, argv, "A:agio:xy")) != -1) {
switch (ch) {
case 'A':
sets |= AUTOMATIC;
newautomatic = strtonum(optarg, 0, 1, &errstr);
if (errstr)
errx(EX_USAGE, "Wrong value for -A. "
"Expecting 0 or 1, got: %s (%s)",
optarg, errstr);
break;
case 'a':
match = MATCH_ALL;
break;
case 'g':
match = MATCH_GLOB;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'o':
sets |= ORIGIN;
loads |= PKG_LOAD_DEPS;
match = MATCH_ALL;
oldorigin = strdup(optarg);
neworigin = strrchr(oldorigin, ':');
if (neworigin == NULL) {
free(oldorigin);
errx(EX_USAGE, "Wrong format for -o. "
"Expecting oldorigin:neworigin, got: %s",
optarg);
}
*neworigin = '\0';
neworigin++;
if (strrchr(oldorigin, '/') == NULL ||
strrchr(neworigin, '/') == NULL) {
free(oldorigin);
errx(EX_USAGE,
"Bad origin format, got: %s", optarg);
}
break;
case 'x':
match = MATCH_REGEX;
break;
case 'y':
yes = true;
break;
default:
if (oldorigin != NULL)
free(oldorigin);
usage_set();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if ((argc < 1 && match != MATCH_ALL) || (newautomatic == -1 && neworigin == NULL)) {
usage_set();
return (EX_USAGE);
}
retcode = pkgdb_access(PKGDB_MODE_READ|PKGDB_MODE_WRITE,
PKGDB_DB_LOCAL);
if (retcode == EPKG_ENODB) {
if (match == MATCH_ALL)
return (EX_OK);
if (!quiet)
warnx("No packages installed. Nothing to do!");
return (EX_OK);
} else if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to modify the package database");
return (EX_NOPERM);
} else if (retcode != EPKG_OK) {
warnx("Error accessing package database");
return (EX_SOFTWARE);
}
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an exclusive lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
if (oldorigin != NULL) {
match = MATCH_ALL;
if ((it = pkgdb_query(db, oldorigin, MATCH_EXACT)) == NULL) {
retcode = EX_IOERR;
goto cleanup;
}
if (pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC) != EPKG_OK) {
pkg = NULL;
/* fprintf(stderr, "%s not installed\n", oldorigin);
free(oldorigin);
pkgdb_it_free(it);
pkgdb_close(db);
return (EX_SOFTWARE);*/
}
if (!yes) {
if (pkg != NULL)
yes = query_yesno(false, "Change origin from %S to %S for %n-%v? [y/N]: ",
oldorigin, neworigin, pkg, pkg);
else
yes = query_yesno(false, "Change origin from %S to %S for all dependencies? "
"[y/N]: ", oldorigin, neworigin);
}
if (pkg != NULL && yes) {
if (pkgdb_set(db, pkg, PKG_SET_ORIGIN, neworigin) != EPKG_OK) {
retcode = EX_IOERR;
goto cleanup;
}
}
pkgdb_it_free(it);
}
i = 0;
do {
bool save_yes = yes;
if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
retcode = EX_IOERR;
goto cleanup;
}
while (pkgdb_it_next(it, &pkg, loads) == EPKG_OK) {
if ((sets & AUTOMATIC) == AUTOMATIC) {
pkg_get(pkg, PKG_AUTOMATIC, &automatic);
if (automatic == newautomatic)
continue;
if (!yes) {
if (newautomatic)
yes = query_yesno(false, "Mark %n-%v as automatically installed? [y/N]: ", pkg, pkg);
else
yes = query_yesno(false, "Mark %n-%v as not automatically installed? [y/N]: ", pkg, pkg);
}
if (yes)
pkgdb_set(db, pkg, PKG_SET_AUTOMATIC, newautomatic);
yes = save_yes;
}
if ((sets & ORIGIN) == ORIGIN) {
struct pkg_dep *d = NULL;
while (pkg_deps(pkg, &d) == EPKG_OK) {
/*
* Do not query user when he has already
* been queried.
*/
if (pkgdb_set(db, pkg, PKG_SET_DEPORIGIN, oldorigin, neworigin) != EPKG_OK) {
retcode = EX_IOERR;
goto cleanup;
}
}
}
}
pkgdb_it_free(it);
i++;
} while (i < argc);
cleanup:
if (oldorigin)
free(oldorigin);
if (pkg != NULL)
pkg_free(pkg);
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
pkgdb_close(db);
return (retcode);
}
int
pkg_analyse_files(struct pkgdb *db, struct pkg *pkg, const char *stage)
{
struct pkg_file *file = NULL;
char *sh;
khint_t k;
int ret = EPKG_OK;
char fpath[MAXPATHLEN];
const char *lib;
bool failures = false;
if (kh_count(pkg->shlibs_required) != 0)
pkg_list_free(pkg, PKG_SHLIBS_REQUIRED);
if (kh_count(pkg->shlibs_provided) != 0)
pkg_list_free(pkg, PKG_SHLIBS_PROVIDED);
if (elf_version(EV_CURRENT) == EV_NONE)
return (EPKG_FATAL);
shlib_list_init();
if (stage != NULL && pkg_object_bool(pkg_config_get("ALLOW_BASE_SHLIBS"))) {
/* Do not check the return */
shlib_list_from_stage(stage);
}
ret = shlib_list_from_elf_hints(_PATH_ELF_HINTS);
if (ret != EPKG_OK)
goto cleanup;
/* Assume no architecture dependence, for contradiction */
if (developer_mode)
pkg->flags &= ~(PKG_CONTAINS_ELF_OBJECTS |
PKG_CONTAINS_STATIC_LIBS |
PKG_CONTAINS_H_OR_LA);
while (pkg_files(pkg, &file) == EPKG_OK) {
if (stage != NULL)
snprintf(fpath, sizeof(fpath), "%s/%s", stage, file->path);
else
strlcpy(fpath, file->path, sizeof(fpath));
ret = analyse_elf(pkg, fpath);
if (developer_mode) {
if (ret != EPKG_OK && ret != EPKG_END) {
failures = true;
continue;
}
analyse_fpath(pkg, fpath);
}
}
/*
* Do not depend on libraries that a package provides itself
*/
kh_each_value(pkg->shlibs_required, sh, {
if (kh_contains(strings, pkg->shlibs_provided, sh)) {
pkg_debug(2, "remove %s from required shlibs as the "
"package %s provides this library itself",
sh, pkg->name);
k = kh_get_strings(pkg->shlibs_required, sh);
kh_del_strings(pkg->shlibs_required, k);
continue;
}
file = NULL;
while (pkg_files(pkg, &file) == EPKG_OK) {
if ((lib = strstr(file->path, sh)) != NULL &&
strlen(lib) == strlen(sh) && lib[-1] == '/') {
pkg_debug(2, "remove %s from required shlibs as "
"the package %s provides this library itself",
sh, pkg->name);
k = kh_get_strings(pkg->shlibs_required, sh);
kh_del_strings(pkg->shlibs_required, k);
break;
}
}
});
int
pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags)
{
struct ucl_parser *p = NULL;
size_t i;
const char *val = NULL;
const char *buf, *walk, *value, *key, *k;
const char *evkey = NULL;
const char *nsname = NULL;
const char *useragent = NULL;
const char *evpipe = NULL;
const ucl_object_t *cur, *object;
ucl_object_t *obj = NULL, *o, *ncfg;
ucl_object_iter_t it = NULL;
struct sbuf *ukey = NULL;
bool fatal_errors = false;
char *rootedpath = NULL;
char *tmp = NULL;
k = NULL;
o = NULL;
pkg_get_myarch(myabi, BUFSIZ);
pkg_get_myarch_legacy(myabi_legacy, BUFSIZ);
if (parsed != false) {
pkg_emit_error("pkg_init() must only be called once");
return (EPKG_FATAL);
}
if (((flags & PKG_INIT_FLAG_USE_IPV4) == PKG_INIT_FLAG_USE_IPV4) &&
((flags & PKG_INIT_FLAG_USE_IPV6) == PKG_INIT_FLAG_USE_IPV6)) {
pkg_emit_error("Invalid flags for pkg_init()");
return (EPKG_FATAL);
}
config = ucl_object_typed_new(UCL_OBJECT);
for (i = 0; i < c_size; i++) {
switch (c[i].type) {
case PKG_STRING:
tmp = NULL;
if (c[i].def != NULL && c[i].def[0] == '/' &&
pkg_rootdir != NULL) {
asprintf(&tmp, "%s%s", pkg_rootdir, c[i].def);
}
obj = ucl_object_fromstring_common(
c[i].def != NULL ? tmp != NULL ? tmp : c[i].def : "", 0, UCL_STRING_TRIM);
free(tmp);
ucl_object_insert_key(config, obj,
c[i].key, strlen(c[i].key), false);
break;
case PKG_INT:
ucl_object_insert_key(config,
ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_INT),
c[i].key, strlen(c[i].key), false);
break;
case PKG_BOOL:
ucl_object_insert_key(config,
ucl_object_fromstring_common(c[i].def, 0, UCL_STRING_PARSE_BOOLEAN),
c[i].key, strlen(c[i].key), false);
break;
case PKG_OBJECT:
obj = ucl_object_typed_new(UCL_OBJECT);
if (c[i].def != NULL) {
walk = buf = c[i].def;
while ((buf = strchr(buf, ',')) != NULL) {
key = walk;
value = walk;
while (*value != ',') {
if (*value == '=')
break;
value++;
}
ucl_object_insert_key(obj,
ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM),
key, value - key, false);
buf++;
walk = buf;
}
key = walk;
value = walk;
while (*value != ',') {
if (*value == '=')
break;
value++;
}
if (o == NULL)
o = ucl_object_typed_new(UCL_OBJECT);
ucl_object_insert_key(o,
ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM),
key, value - key, false);
}
ucl_object_insert_key(config, obj,
c[i].key, strlen(c[i].key), false);
break;
case PKG_ARRAY:
obj = ucl_object_typed_new(UCL_ARRAY);
if (c[i].def != NULL) {
walk = buf = c[i].def;
while ((buf = strchr(buf, ',')) != NULL) {
ucl_array_append(obj,
ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM));
buf++;
walk = buf;
}
ucl_array_append(obj,
ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM));
}
ucl_object_insert_key(config, obj,
c[i].key, strlen(c[i].key), false);
break;
}
}
if (path == NULL)
path = PREFIX"/etc/pkg.conf";
if (pkg_rootdir != NULL)
asprintf(&rootedpath, "%s/%s", pkg_rootdir, path);
p = ucl_parser_new(0);
ucl_parser_register_variable (p, "ABI", myabi);
ucl_parser_register_variable (p, "ALTABI", myabi_legacy);
errno = 0;
obj = NULL;
if (!ucl_parser_add_file(p, rootedpath != NULL ? rootedpath : path)) {
if (errno != ENOENT)
pkg_emit_error("Invalid configuration file: %s", ucl_parser_get_error(p));
} else {
obj = ucl_parser_get_object(p);
}
ncfg = NULL;
while (obj != NULL && (cur = ucl_iterate_object(obj, &it, true))) {
sbuf_init(&ukey);
key = ucl_object_key(cur);
for (i = 0; key[i] != '\0'; i++)
sbuf_putc(ukey, toupper(key[i]));
sbuf_finish(ukey);
object = ucl_object_find_keyl(config, sbuf_data(ukey), sbuf_len(ukey));
if (strncasecmp(sbuf_data(ukey), "PACKAGESITE", sbuf_len(ukey))
== 0 || strncasecmp(sbuf_data(ukey), "PUBKEY",
sbuf_len(ukey)) == 0 || strncasecmp(sbuf_data(ukey),
"MIRROR_TYPE", sbuf_len(ukey)) == 0) {
pkg_emit_error("%s in pkg.conf is no longer "
"supported. Convert to the new repository style."
" See pkg.conf(5)", sbuf_data(ukey));
fatal_errors = true;
continue;
}
/* ignore unknown keys */
if (object == NULL)
continue;
if (object->type != cur->type) {
pkg_emit_error("Malformed key %s, ignoring", key);
continue;
}
if (ncfg == NULL)
ncfg = ucl_object_typed_new(UCL_OBJECT);
ucl_object_insert_key(ncfg, ucl_object_copy(cur), sbuf_data(ukey), sbuf_len(ukey), true);
}
if (fatal_errors) {
ucl_object_unref(ncfg);
ucl_parser_free(p);
free(rootedpath);
return (EPKG_FATAL);
}
if (ncfg != NULL) {
it = NULL;
while (( cur = ucl_iterate_object(ncfg, &it, true))) {
key = ucl_object_key(cur);
ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true);
}
ucl_object_unref(ncfg);
}
ncfg = NULL;
it = NULL;
while ((cur = ucl_iterate_object(config, &it, true))) {
o = NULL;
key = ucl_object_key(cur);
val = getenv(key);
if (val == NULL)
continue;
switch (cur->type) {
case UCL_STRING:
o = ucl_object_fromstring_common(val, 0, UCL_STRING_TRIM);
break;
case UCL_INT:
o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_INT);
if (o->type != UCL_INT) {
pkg_emit_error("Invalid type for environment "
"variable %s, got %s, while expecting an integer",
key, val);
ucl_object_unref(o);
continue;
}
break;
case UCL_BOOLEAN:
o = ucl_object_fromstring_common(val, 0, UCL_STRING_PARSE_BOOLEAN);
if (o->type != UCL_BOOLEAN) {
pkg_emit_error("Invalid type for environment "
"variable %s, got %s, while expecting a boolean",
key, val);
ucl_object_unref(o);
continue;
}
break;
case UCL_OBJECT:
o = ucl_object_typed_new(UCL_OBJECT);
walk = buf = val;
while ((buf = strchr(buf, ',')) != NULL) {
k = walk;
value = walk;
while (*value != ',') {
if (*value == '=')
break;
value++;
}
ucl_object_insert_key(o,
ucl_object_fromstring_common(value + 1, buf - value - 1, UCL_STRING_TRIM),
k, value - k, false);
buf++;
walk = buf;
}
k = walk;
value = walk;
while (*value != '\0') {
if (*value == '=')
break;
value++;
}
ucl_object_insert_key(o,
ucl_object_fromstring_common(value + 1, strlen(value + 1), UCL_STRING_TRIM),
k, value - k, false);
break;
case UCL_ARRAY:
o = ucl_object_typed_new(UCL_ARRAY);
walk = buf = val;
while ((buf = strchr(buf, ',')) != NULL) {
ucl_array_append(o,
ucl_object_fromstring_common(walk, buf - walk, UCL_STRING_TRIM));
buf++;
walk = buf;
}
ucl_array_append(o,
ucl_object_fromstring_common(walk, strlen(walk), UCL_STRING_TRIM));
break;
default:
/* ignore other types */
break;
}
if (o != NULL) {
if (ncfg == NULL)
ncfg = ucl_object_typed_new(UCL_OBJECT);
ucl_object_insert_key(ncfg, o, key, strlen(key), true);
}
}
if (ncfg != NULL) {
it = NULL;
while (( cur = ucl_iterate_object(ncfg, &it, true))) {
key = ucl_object_key(cur);
ucl_object_replace_key(config, ucl_object_ref(cur), key, strlen(key), true);
}
ucl_object_unref(ncfg);
}
disable_plugins_if_static();
parsed = true;
ucl_object_unref(obj);
ucl_parser_free(p);
free(rootedpath);
if (strcmp(pkg_object_string(pkg_config_get("ABI")), "unknown") == 0) {
pkg_emit_error("Unable to determine ABI");
return (EPKG_FATAL);
}
pkg_debug(1, "%s", "pkg initialized");
/* Start the event pipe */
evpipe = pkg_object_string(pkg_config_get("EVENT_PIPE"));
if (evpipe != NULL)
connect_evpipe(evpipe);
debug_level = pkg_object_int(pkg_config_get("DEBUG_LEVEL"));
developer_mode = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
it = NULL;
object = ucl_object_find_key(config, "PKG_ENV");
while ((cur = ucl_iterate_object(object, &it, true))) {
evkey = ucl_object_key(cur);
pkg_debug(1, "Setting env var: %s", evkey);
if (evkey != NULL && evkey[0] != '\0')
setenv(evkey, ucl_object_tostring_forced(cur), 1);
}
/* Set user-agent */
useragent = pkg_object_string(pkg_config_get("HTTP_USER_AGENT"));
setenv("HTTP_USER_AGENT", useragent, 1);
/* load the repositories */
load_repositories(reposdir, flags);
/* bypass resolv.conf with specified NAMESERVER if any */
nsname = pkg_object_string(pkg_config_get("NAMESERVER"));
if (nsname != NULL) {
if (set_nameserver(ucl_object_tostring_forced(o)) != 0) {
pkg_emit_error("Unable to set nameserver");
return (EPKG_FATAL);
}
}
return (EPKG_OK);
}
int
exec_register(int argc, char **argv)
{
struct pkg *pkg = NULL;
struct pkgdb *db = NULL;
struct pkg_manifest_key *keys = NULL;
regex_t preg;
regmatch_t pmatch[2];
char *arch = NULL;
char myarch[BUFSIZ];
char *www = NULL;
char fpath[MAXPATHLEN];
const char *plist = NULL;
const char *mdir = NULL;
const char *mfile = NULL;
const char *input_path = NULL;
const char *desc = NULL;
const char *location = NULL;
size_t size;
bool developer;
bool legacy = false;
bool old = false;
bool __unused metadata_only = false;
bool testing_mode = false;
int ch;
int i;
int ret = EPKG_OK;
int retcode = EX_OK;
/* options descriptor */
struct option longopts[] = {
{ "automatic", no_argument, NULL, 'A' },
{ "plist", required_argument, NULL, 'f' },
{ "root", required_argument, NULL, 'i' },
{ "legacy", no_argument, NULL, 'l' },
{ "manifest", required_argument, NULL, 'M' },
{ "metadata", required_argument, NULL, 'm' },
{ "old", no_argument, NULL, 'O' },
{ "test", no_argument, NULL, 't' },
{ "relocate", required_argument, NULL, 1 },
{ NULL, 0, NULL, 0},
};
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (pkg_new(&pkg, PKG_INSTALLED) != EPKG_OK)
err(EX_OSERR, "malloc");
while ((ch = getopt_long(argc, argv, "Adf:i:lM:m:Ot", longopts, NULL)) != -1) {
switch (ch) {
case 'A':
case 'd':
pkg_set(pkg, PKG_AUTOMATIC, (bool)true);
break;
case 'f':
plist = optarg;
break;
case 'i':
input_path = optarg;
break;
case 'l':
legacy = true;
break;
case 'M':
metadata_only = true;
mfile = optarg;
break;
case 'm':
mdir = optarg;
break;
case 'O':
old = true;
break;
case 't':
testing_mode = true;
break;
case 1:
location = optarg;
break;
default:
warnx("Unrecognised option -%c\n", ch);
usage_register();
return (EX_USAGE);
}
}
if (!old) {
retcode = pkgdb_access(PKGDB_MODE_READ |
PKGDB_MODE_WRITE |
PKGDB_MODE_CREATE,
PKGDB_DB_LOCAL);
if (retcode == EPKG_ENOACCESS) {
warnx("Insufficient privileges to register packages");
return (EX_NOPERM);
} else if (retcode != EPKG_OK)
return (EX_IOERR);
else
retcode = EX_OK;
}
/*
* Ideally, the +MANIFEST should be all that is necessary,
* since it can contain all of the meta-data supplied by the
* other files mentioned below. These are here for backwards
* compatibility with the way the ports tree works with
* pkg_tools.
*
* The -M option specifies one manifest file to read the
* meta-data from, and overrides the use of legacy meta-data
* inputs.
*
* Dependencies, shlibs, files etc. may be derived by
* analysing the package files (maybe discovered as the
* content of the staging directory) unless -t (testing_mode)
* is used.
*/
if (mfile != NULL && mdir != NULL) {
warnx("Cannot use both -m and -M together");
usage_register();
return (EX_USAGE);
}
if (mfile == NULL && mdir == NULL) {
warnx("One of either -m or -M flags is required");
usage_register();
return (EX_USAGE);
}
if (mfile != NULL && plist != NULL) {
warnx("-M incompatible with -f option");
usage_register();
return (EX_USAGE);
}
if (testing_mode && input_path != NULL) {
warnx("-i incompatible with -t option");
usage_register();
return (EX_USAGE);
}
pkg_manifest_keys_new(&keys);
if (mfile != NULL) {
ret = pkg_parse_manifest_file(pkg, mfile, keys);
pkg_manifest_keys_free(keys);
if (ret != EPKG_OK)
return (EX_IOERR);
} else {
snprintf(fpath, sizeof(fpath), "%s/+MANIFEST", mdir);
ret = pkg_parse_manifest_file(pkg, fpath, keys);
pkg_manifest_keys_free(keys);
if (ret != EPKG_OK)
return (EX_IOERR);
snprintf(fpath, sizeof(fpath), "%s/+DESC", mdir);
pkg_set_from_file(pkg, PKG_DESC, fpath, false);
snprintf(fpath, sizeof(fpath), "%s/+DISPLAY", mdir);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MESSAGE, fpath, false);
snprintf(fpath, sizeof(fpath), "%s/+MTREE_DIRS", mdir);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MTREE, fpath, false);
for (i = 0; scripts[i] != NULL; i++) {
snprintf(fpath, sizeof(fpath), "%s/%s", mdir,
scripts[i]);
if (access(fpath, F_OK) == 0)
pkg_addscript_file(pkg, fpath);
}
if (www != NULL) {
pkg_set(pkg, PKG_WWW, www);
free(www);
}
pkg_get(pkg, PKG_WWW, &www);
/*
* if www is not given then try to determine it from
* description
*/
if (www == NULL) {
pkg_get(pkg, PKG_DESC, &desc);
regcomp(&preg, "^WWW:[[:space:]]*(.*)$",
REG_EXTENDED|REG_ICASE|REG_NEWLINE);
if (regexec(&preg, desc, 2, pmatch, 0) == 0) {
size = pmatch[1].rm_eo - pmatch[1].rm_so;
www = strndup(&desc[pmatch[1].rm_so], size);
pkg_set(pkg, PKG_WWW, www);
free(www);
} else {
pkg_set(pkg, PKG_WWW, "UNKNOWN");
}
regfree(&preg);
}
if (plist != NULL)
ret += ports_parse_plist(pkg, plist, input_path);
}
if (ret != EPKG_OK) {
return (EX_IOERR);
}
if (!old) {
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
return (EX_IOERR);
if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
pkgdb_close(db);
warnx("Cannot get an exclusive lock on a database, it is locked by another process");
return (EX_TEMPFAIL);
}
}
/*
* testing_mode allows updating the local package database
* without any check that the files etc. listed in the meta
* data actually exist on the system. Inappropriate use of
* testing_mode can really screw things up.
*/
if (!testing_mode)
pkg_analyse_files(db, pkg, input_path);
pkg_get(pkg, PKG_ARCH, &arch);
if (arch == NULL) {
/*
* do not take the one from configuration on purpose
* but the real abi of the package.
*/
pkg_get_myarch(myarch, BUFSIZ);
if (developer)
pkg_suggest_arch(pkg, myarch, true);
pkg_set(pkg, PKG_ARCH, myarch);
} else {
if (developer)
pkg_suggest_arch(pkg, arch, false);
}
if (!testing_mode && input_path != NULL)
pkg_copy_tree(pkg, input_path, location ? location : "/");
if (location != NULL)
pkg_addannotation(pkg, "relocated", location);
if (old) {
if (pkg_register_old(pkg) != EPKG_OK)
retcode = EX_SOFTWARE;
} else {
if (pkgdb_register_ports(db, pkg) != EPKG_OK)
retcode = EX_SOFTWARE;
}
if (!legacy && pkg_has_message(pkg))
pkg_printf("%M\n", pkg);
if (!old) {
pkgdb_release_lock(db, PKGDB_LOCK_EXCLUSIVE);
pkgdb_close(db);
}
pkg_free(pkg);
return (retcode);
}
int
pkg_delete(struct pkg *pkg, struct pkgdb *db, unsigned flags)
{
int ret;
bool handle_rc = false;
int64_t id;
const unsigned load_flags = PKG_LOAD_RDEPS|PKG_LOAD_FILES|PKG_LOAD_DIRS|
PKG_LOAD_SCRIPTS|PKG_LOAD_MTREE|PKG_LOAD_ANNOTATIONS;
assert(pkg != NULL);
assert(db != NULL);
if (pkgdb_ensure_loaded(db, pkg, load_flags) != EPKG_OK)
return (EPKG_FATAL);
if ((flags & PKG_DELETE_UPGRADE) == 0)
pkg_emit_deinstall_begin(pkg);
/* If the package is locked */
if (pkg_is_locked(pkg)) {
pkg_emit_locked(pkg);
return (EPKG_LOCKED);
}
/*
* stop the different related services if the users do want that
* and that the service is running
*/
handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS"));
if (handle_rc)
pkg_start_stop_rc_scripts(pkg, PKG_RC_STOP);
if ((flags & PKG_DELETE_NOSCRIPT) == 0) {
if (flags & PKG_DELETE_UPGRADE) {
ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_UPGRADE);
if (ret != EPKG_OK)
return (ret);
} else {
ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL);
if (ret != EPKG_OK)
return (ret);
}
}
if ((ret = pkg_delete_files(pkg, flags & PKG_DELETE_FORCE ? 1 : 0))
!= EPKG_OK)
return (ret);
if ((flags & (PKG_DELETE_NOSCRIPT | PKG_DELETE_UPGRADE)) == 0) {
ret = pkg_script_run(pkg, PKG_SCRIPT_POST_DEINSTALL);
if (ret != EPKG_OK)
return (ret);
}
ret = pkg_delete_dirs(db, pkg);
if (ret != EPKG_OK)
return (ret);
if ((flags & PKG_DELETE_UPGRADE) == 0)
pkg_emit_deinstall_finished(pkg);
pkg_get(pkg, PKG_ROWID, &id);
return (pkgdb_unregister_pkg(db, id));
}
static int
do_extract(struct archive *a, struct archive_entry *ae, const char *location,
int nfiles, struct pkg *pkg, struct pkg *local)
{
int retcode = EPKG_OK;
int ret = 0, cur_file = 0;
char path[MAXPATHLEN], pathname[MAXPATHLEN], rpath[MAXPATHLEN];
struct stat st;
const struct stat *aest;
bool renamed = false;
const struct pkg_file *rf;
struct pkg_config_file *rcf;
struct sbuf *newconf;
bool automerge = pkg_object_bool(pkg_config_get("AUTOMERGE"));
unsigned long set, clear;
#ifndef HAVE_ARC4RANDOM
srand(time(NULL));
#endif
if (nfiles == 0)
return (EPKG_OK);
pkg_emit_extract_begin(pkg);
pkg_emit_progress_start(NULL);
newconf = sbuf_new_auto();
do {
ret = ARCHIVE_OK;
sbuf_clear(newconf);
rf = NULL;
rcf = NULL;
pkg_absolutepath(archive_entry_pathname(ae), path, sizeof(path));
snprintf(pathname, sizeof(pathname), "%s%s%s",
location ? location : "", *path == '/' ? "" : "/",
path
);
strlcpy(rpath, pathname, sizeof(rpath));
aest = archive_entry_stat(ae);
archive_entry_fflags(ae, &set, &clear);
if (lstat(rpath, &st) != -1) {
/*
* We have an existing file on the path, so handle it
*/
if (!S_ISDIR(aest->st_mode)) {
pkg_debug(2, "Old version found, renaming");
pkg_add_file_random_suffix(rpath, sizeof(rpath), 12);
renamed = true;
}
if (!S_ISDIR(st.st_mode) && S_ISDIR(aest->st_mode)) {
if (S_ISLNK(st.st_mode)) {
if (stat(rpath, &st) == -1) {
pkg_emit_error("Dead symlink %s", rpath);
} else {
pkg_debug(2, "Directory is a symlink, use it");
pkg_emit_progress_tick(cur_file++, nfiles);
continue;
}
}
}
}
archive_entry_set_pathname(ae, rpath);
/* load in memory the content of config files */
if (pkg_is_config_file(pkg, path, &rf, &rcf)) {
pkg_debug(1, "Populating config_file %s", pathname);
size_t len = archive_entry_size(ae);
rcf->content = malloc(len);
archive_read_data(a, rcf->content, len);
if (renamed && (!automerge || local == NULL))
strlcat(pathname, ".pkgnew", sizeof(pathname));
}
/*
* check if the file is already provided by previous package
*/
if (!automerge)
attempt_to_merge(renamed, rcf, local, pathname, path, newconf);
if (sbuf_len(newconf) == 0 && (rcf == NULL || rcf->content == NULL)) {
pkg_debug(1, "Extracting: %s", archive_entry_pathname(ae));
int install_as_user = (getenv("INSTALL_AS_USER") != NULL);
int extract_flags = EXTRACT_ARCHIVE_FLAGS;
if (install_as_user) {
/* when installing as user don't try to set file ownership */
extract_flags &= ~ARCHIVE_EXTRACT_OWNER;
}
ret = archive_read_extract(a, ae, extract_flags);
} else {
if (sbuf_len(newconf) == 0) {
sbuf_cat(newconf, rcf->content);
sbuf_finish(newconf);
}
pkg_debug(2, "Writing conf in %s", pathname);
unlink(rpath);
FILE *f = fopen(rpath, "w+");
fprintf(f, "%s", sbuf_data(newconf));
fclose(f);
}
if (ret != ARCHIVE_OK) {
/*
* show error except when the failure is during
* extracting a directory and that the directory already
* exists.
* this allow to install packages linux_base from
* package for example
*/
if (archive_entry_filetype(ae) != AE_IFDIR ||
!is_dir(pathname)) {
pkg_emit_error("archive_read_extract(): %s",
archive_error_string(a));
retcode = EPKG_FATAL;
goto cleanup;
}
}
/* Reapply modes to the directories to work around a problem on FreeBSD 9 */
if (archive_entry_filetype(ae) == AE_IFDIR)
chmod(pathname, aest->st_mode);
pkg_emit_progress_tick(cur_file++, nfiles);
/* Rename old file */
if (renamed) {
pkg_debug(1, "Renaming %s -> %s", rpath, pathname);
#ifdef HAVE_CHFLAGS
bool old = false;
if (set & NOCHANGESFLAGS)
chflags(rpath, 0);
if (lstat(pathname, &st) != -1) {
old = true;
if (st.st_flags & NOCHANGESFLAGS)
chflags(pathname, 0);
}
#endif
if (rename(rpath, pathname) == -1) {
#ifdef HAVE_CHFLAGS
/* restore flags */
if (old)
chflags(pathname, st.st_flags);
#endif
pkg_emit_error("cannot rename %s to %s: %s", rpath, pathname,
strerror(errno));
retcode = EPKG_FATAL;
goto cleanup;
}
#ifdef HAVE_CHFLAGS
/* Restore flags */
chflags(pathname, set);
#endif
}
if (string_end_with(pathname, ".pkgnew"))
pkg_emit_notice("New configuration file: %s", pathname);
renamed = false;
} while ((ret = archive_read_next_header(a, &ae)) == ARCHIVE_OK);
if (ret != ARCHIVE_EOF) {
pkg_emit_error("archive_read_next_header(): %s",
archive_error_string(a));
retcode = EPKG_FATAL;
}
cleanup:
pkg_emit_progress_tick(nfiles, nfiles);
pkg_emit_extract_finished(pkg);
if (renamed && retcode == EPKG_FATAL) {
#ifdef HAVE_CHFLAGS
if (set & NOCHANGESFLAGS)
chflags(rpath, set & ~NOCHANGESFLAGS);
#endif
unlink(rpath);
}
return (retcode);
}
int
exec_rquery(int argc, char **argv)
{
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
char *pkgname = NULL;
int query_flags = PKG_LOAD_BASIC;
match_t match = MATCH_EXACT;
int ch;
int ret = EPKG_OK;
int retcode = EX_OK;
int i;
char multiline = 0;
char *condition = NULL;
const char *portsdir;
struct sbuf *sqlcond = NULL;
const unsigned int q_flags_len = (sizeof(accepted_rquery_flags)/sizeof(accepted_rquery_flags[0]));
const char *reponame = NULL;
bool auto_update;
bool onematched = false;
bool old_quiet;
bool index_output = false;
auto_update = pkg_object_bool(pkg_config_get("REPO_AUTOUPDATE"));
portsdir = pkg_object_string(pkg_config_get("PORTSDIR"));
/* Set default case sensitivity for searching */
pkgdb_set_case_sensitivity(
pkg_object_bool(pkg_config_get("CASE_SENSITIVE_MATCH"))
);
while ((ch = getopt(argc, argv, "aCgiIxe:r:U")) != -1) {
switch (ch) {
case 'a':
match = MATCH_ALL;
break;
case 'C':
pkgdb_set_case_sensitivity(true);
break;
case 'g':
match = MATCH_GLOB;
break;
case 'I':
index_output = true;
break;
case 'i':
pkgdb_set_case_sensitivity(false);
break;
case 'x':
match = MATCH_REGEX;
break;
case 'e':
match = MATCH_CONDITION;
condition = optarg;
break;
case 'r':
reponame = optarg;
break;
case 'U':
auto_update = false;
break;
default:
usage_rquery();
return (EX_USAGE);
}
}
argc -= optind;
argv += optind;
if (argc == 0 && !index_output) {
usage_rquery();
return (EX_USAGE);
}
/* Default to all packages if no pkg provided */
if (!index_output) {
if (argc == 1 && condition == NULL && match == MATCH_EXACT) {
match = MATCH_ALL;
} else if ((argc == 1) ^ (match == MATCH_ALL ) && condition == NULL) {
usage_rquery();
return (EX_USAGE);
}
} else {
if (argc == 0)
match = MATCH_ALL;
}
if (!index_output && analyse_query_string(argv[0], accepted_rquery_flags, q_flags_len, &query_flags, &multiline) != EPKG_OK)
return (EX_USAGE);
if (condition != NULL) {
sqlcond = sbuf_new_auto();
if (format_sql_condition(condition, sqlcond, true) != EPKG_OK)
return (EX_USAGE);
sbuf_finish(sqlcond);
}
ret = pkgdb_access(PKGDB_MODE_READ, PKGDB_DB_REPO);
if (ret == EPKG_ENOACCESS) {
warnx("Insufficient privileges to query the package database");
return (EX_NOPERM);
} else if (ret != EPKG_OK)
return (EX_IOERR);
/* first update the remote repositories if needed */
old_quiet = quiet;
quiet = true;
if (auto_update && (ret = pkgcli_update(false, reponame)) != EPKG_OK)
return (ret);
quiet = old_quiet;
ret = pkgdb_open_all(&db, PKGDB_REMOTE, reponame);
if (ret != EPKG_OK)
return (EX_IOERR);
if (index_output)
query_flags = PKG_LOAD_BASIC|PKG_LOAD_CATEGORIES;
if (match == MATCH_ALL || match == MATCH_CONDITION) {
const char *condition_sql = NULL;
if (match == MATCH_CONDITION && sqlcond)
condition_sql = sbuf_data(sqlcond);
if ((it = pkgdb_rquery(db, condition_sql, match, reponame)) == NULL)
return (EX_IOERR);
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
if (index_output)
print_index(pkg, portsdir);
else
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END)
retcode = EX_SOFTWARE;
pkgdb_it_free(it);
} else {
for (i = (index_output ? 0 : 1); i < argc; i++) {
pkgname = argv[i];
if ((it = pkgdb_rquery(db, pkgname, match, reponame)) == NULL)
return (EX_IOERR);
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
onematched = true;
if (index_output)
print_index(pkg, portsdir);
else
print_query(pkg, argv[0], multiline);
}
if (ret != EPKG_END) {
retcode = EX_SOFTWARE;
break;
}
pkgdb_it_free(it);
}
if (!onematched && retcode == EX_OK)
retcode = EX_UNAVAILABLE;
}
pkg_free(pkg);
pkgdb_close(db);
return (retcode);
}
static int
pkg_create_from_dir(struct pkg *pkg, const char *root,
struct packing *pkg_archive)
{
char fpath[MAXPATHLEN];
struct pkg_file *file = NULL;
struct pkg_dir *dir = NULL;
char *m;
int ret;
const char *mtree;
bool developer;
struct stat st;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
int64_t flatsize = 0;
ucl_object_t *obj;
if (pkg_is_valid(pkg) != EPKG_OK) {
pkg_emit_error("the package is not valid");
return (EPKG_FATAL);
}
obj = pkg_annotation_lookup(pkg, "relocated");
/*
* Get / compute size / checksum if not provided in the manifest
*/
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *pkg_path = pkg_file_path(file);
const char *pkg_sum = pkg_file_cksum(file);
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
obj ? pkg_object_string(obj) : "", pkg_path);
if (lstat(fpath, &st) != 0 || S_ISLNK(st.st_mode))
continue;
if (file->size == 0)
file->size = (int64_t)st.st_size;
flatsize += file->size;
if (pkg_sum == NULL || pkg_sum[0] == '\0') {
if (pkg->type == PKG_OLD_FILE) {
if (md5_file(fpath, sha256) != EPKG_OK)
return (EPKG_FATAL);
} else {
if (sha256_file(fpath, sha256) != EPKG_OK)
return (EPKG_FATAL);
}
strlcpy(file->sum, sha256, sizeof(file->sum));
}
}
pkg_set(pkg, PKG_FLATSIZE, flatsize);
if (pkg->type == PKG_OLD_FILE) {
const char *desc, *display, *comment;
char oldcomment[BUFSIZ];
pkg_old_emit_content(pkg, &m);
packing_append_buffer(pkg_archive, m, "+CONTENTS", strlen(m));
free(m);
pkg_get(pkg, PKG_DESC, &desc, PKG_MESSAGE, &display, PKG_COMMENT, &comment);
packing_append_buffer(pkg_archive, desc, "+DESC", strlen(desc));
packing_append_buffer(pkg_archive, display, "+DISPLAY", strlen(display));
snprintf(oldcomment, sizeof(oldcomment), "%s\n", comment);
packing_append_buffer(pkg_archive, oldcomment, "+COMMENT", strlen(oldcomment));
} else {
/*
* Register shared libraries used by the package if
* SHLIBS enabled in conf. Deletes shlib info if not.
*/
struct sbuf *b = sbuf_new_auto();
pkg_register_shlibs(pkg, root);
pkg_emit_manifest_sbuf(pkg, b, PKG_MANIFEST_EMIT_COMPACT, NULL);
packing_append_buffer(pkg_archive, sbuf_data(b), "+COMPACT_MANIFEST", sbuf_len(b));
sbuf_clear(b);
pkg_emit_manifest_sbuf(pkg, b, 0, NULL);
sbuf_finish(b);
packing_append_buffer(pkg_archive, sbuf_data(b), "+MANIFEST", sbuf_len(b));
sbuf_delete(b);
}
pkg_get(pkg, PKG_MTREE, &mtree);
if (mtree != NULL)
packing_append_buffer(pkg_archive, mtree, "+MTREE_DIRS",
strlen(mtree));
while (pkg_files(pkg, &file) == EPKG_OK) {
const char *pkg_path = pkg_file_path(file);
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
obj ? pkg_object_string(obj) : "", pkg_path);
ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
file->uname, file->gname, file->perm);
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (developer && ret != EPKG_OK)
return (ret);
}
while (pkg_dirs(pkg, &dir) == EPKG_OK) {
const char *pkg_path = pkg_dir_path(dir);
snprintf(fpath, sizeof(fpath), "%s%s%s", root ? root : "",
obj ? pkg_object_string(obj) : "", pkg_path);
ret = packing_append_file_attr(pkg_archive, fpath, pkg_path,
dir->uname, dir->gname, dir->perm);
developer = pkg_object_bool(pkg_config_get("DEVELOPER_MODE"));
if (developer && ret != EPKG_OK)
return (ret);
}
return (EPKG_OK);
}
int
pkg_delete(struct pkg *pkg, struct pkgdb *db, unsigned flags)
{
struct pkg_dep *rdep = NULL;
int ret;
bool handle_rc = false;
const char *origin;
assert(pkg != NULL);
assert(db != NULL);
/*
* Do not trust the existing entries as it may have changed if we
* delete packages in batch.
*/
pkg_list_free(pkg, PKG_RDEPS);
/*
* Ensure that we have all the informations we need
*/
if ((ret = pkgdb_load_rdeps(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_load_files(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_load_dirs(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_load_scripts(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_load_mtree(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_load_annotations(db, pkg)) != EPKG_OK)
return (ret);
if ((flags & PKG_DELETE_UPGRADE) == 0)
pkg_emit_deinstall_begin(pkg);
/* If the package is locked */
if (pkg_is_locked(pkg)) {
pkg_emit_locked(pkg);
return (EPKG_LOCKED);
}
/* If there are dependencies */
if ((flags & (PKG_DELETE_UPGRADE|PKG_DELETE_CONFLICT)) == 0) {
if (pkg_rdeps(pkg, &rdep) == EPKG_OK) {
pkg_emit_required(pkg, flags & PKG_DELETE_FORCE);
if ((flags & PKG_DELETE_FORCE) == 0)
return (EPKG_REQUIRED);
}
}
/*
* stop the different related services if the users do want that
* and that the service is running
*/
handle_rc = pkg_object_bool(pkg_config_get("HANDLE_RC_SCRIPTS"));
if (handle_rc)
pkg_start_stop_rc_scripts(pkg, PKG_RC_STOP);
if ((flags & PKG_DELETE_NOSCRIPT) == 0) {
if (flags & PKG_DELETE_UPGRADE) {
ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_UPGRADE);
if (ret != EPKG_OK)
return (ret);
} else {
ret = pkg_script_run(pkg, PKG_SCRIPT_PRE_DEINSTALL);
if (ret != EPKG_OK)
return (ret);
}
}
if ((ret = pkg_delete_files(pkg, flags & PKG_DELETE_FORCE ? 1 : 0))
!= EPKG_OK)
return (ret);
if ((flags & (PKG_DELETE_NOSCRIPT | PKG_DELETE_UPGRADE)) == 0) {
ret = pkg_script_run(pkg, PKG_SCRIPT_POST_DEINSTALL);
if (ret != EPKG_OK)
return (ret);
}
ret = pkg_delete_dirs(db, pkg, flags & PKG_DELETE_FORCE);
if (ret != EPKG_OK)
return (ret);
if ((flags & PKG_DELETE_UPGRADE) == 0)
pkg_emit_deinstall_finished(pkg);
pkg_get(pkg, PKG_ORIGIN, &origin);
return (pkgdb_unregister_pkg(db, origin));
}
