static int
do_add(struct pkgdb *db, struct pkg *pkg, const char *tag, const char *value)
{
const char *pkgname, *pkgversion;
int ret = EPKG_OK;
if (yes || query_tty_yesno(false, "%n-%v: Add annotation tagged: %S with "
"value: %S? [y/N]: ", pkg, pkg, tag, value)) {
ret = pkgdb_add_annotation(db, pkg, tag, value);
if (ret == EPKG_OK) {
if (!quiet)
pkg_printf("%n-%v: added annotation tagged:"
" %S\n", pkg, pkg, tag);
} else if (ret == EPKG_WARN) {
if (!quiet) {
pkg_get(pkg, PKG_NAME, &pkgname,
PKG_VERSION, &pkgversion);
warnx("%s-%s: Cannot add annotation tagged: "
"%s -- already exists", pkgname,
pkgversion, tag);
}
} else {
pkg_get(pkg, PKG_NAME, &pkgname,
PKG_VERSION, &pkgversion);
warnx("%s-%s: Failed to add annotation tagged: %s",
pkgname, pkgversion, tag);
}
}
return (ret);
}
static struct packing *
pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format, int required_flags)
{
char *pkg_path = NULL;
struct packing *pkg_archive = NULL;
/*
* Ensure that we have all the information we need
*/
if ((pkg->flags & required_flags) != required_flags) {
printf("error: required flags not set\n");
return NULL;
}
if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION)) == -1) {
perror("asprintf");
return NULL; /* XXX do better */
}
if (packing_init(&pkg_archive, pkg_path, format) != EPKG_OK) {
perror("packing_init");
return NULL;
}
if (pkg_path != NULL)
free(pkg_path);
return pkg_archive;
}
static int
do_delete(struct pkgdb *db, struct pkg *pkg, const char *tag)
{
const char *pkgname, *pkgversion;
int ret = EPKG_OK;
if (yes || query_tty_yesno(false, "%n-%v: Delete annotation tagged: %S? "
"[y/N]: ", pkg, pkg, tag)) {
ret = pkgdb_delete_annotation(db, pkg, tag);
if (ret == EPKG_OK) {
if (!quiet)
pkg_printf("%n-%v: Deleted annotation "
"tagged: %S\n", pkg, pkg, tag);
} else if (ret == EPKG_WARN) {
if (!quiet) {
pkg_get(pkg, PKG_NAME, &pkgname,
PKG_VERSION, &pkgversion);
warnx("%s-%s: Cannot delete annotation "
"tagged: %s -- because there is none",
pkgname, pkgversion, tag);
}
} else {
pkg_get(pkg, PKG_NAME, &pkgname,
PKG_VERSION, &pkgversion);
warnx("%s-%s: Failed to delete annotation tagged: %s",
pkgname, pkgversion, tag);
}
}
return (ret);
}
static int
setprefix(struct plist *p, char *line, struct file_attr *a)
{
char *pkgprefix;
/* if no arguments then set default prefix */
if (line[0] == '\0') {
pkg_get(p->pkg, PKG_PREFIX, &pkgprefix);
strlcpy(p->prefix, pkgprefix, sizeof(p->prefix));
}
else
strlcpy(p->prefix, line, sizeof(p->prefix));
pkg_get(p->pkg, PKG_PREFIX, &pkgprefix);
if (pkgprefix == NULL || *pkgprefix == '\0')
pkg_set(p->pkg, PKG_PREFIX, line);
p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/";
exec_append(p->post_install_buf, "cd %s\n", p->prefix);
pre_unexec_append(p->pre_deinstall_buf, "cd %s\n", p->prefix);
post_unexec_append(p->post_deinstall_buf, "cd %s\n", p->prefix);
free(a);
return (EPKG_OK);
}
static int
test_depends(void *actdata, struct pkg *pkg, const char *fpath,
const char *name, bool is_shlib)
{
struct pkgdb *db = actdata;
struct pkg_dep *dep = NULL;
struct pkgdb_it *it = NULL;
struct pkg *d;
const char *deporigin, *depname, *depversion;
const char *pkgname, *pkgversion;
bool deplocked;
char pathbuf[MAXPATHLEN];
assert(db != NULL);
switch(filter_system_shlibs(name, pathbuf, sizeof(pathbuf))) {
case EPKG_OK: /* A non-system library */
break;
case EPKG_END: /* A system library */
return (EPKG_OK);
default:
/* Ignore link resolution errors if we're analysing a
shared library. */
if (is_shlib)
return (EPKG_OK);
pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
warnx("(%s-%s) %s - shared library %s not found",
pkgname, pkgversion, fpath, name);
return (EPKG_FATAL);
}
pkg_addshlib_required(pkg, name);
if ((it = pkgdb_query_which(db, pathbuf, false)) == NULL)
return (EPKG_OK);
d = NULL;
if (pkgdb_it_next(it, &d, PKG_LOAD_BASIC) == EPKG_OK) {
pkg_get(d, PKG_ORIGIN, &deporigin,
PKG_NAME, &depname,
PKG_VERSION, &depversion,
PKG_LOCKED, &deplocked);
dep = pkg_dep_lookup(pkg, deporigin);
if (dep == NULL) {
pkg_debug(1, "Autodeps: adding unlisted depends (%s): %s-%s",
pathbuf, depname, depversion);
pkg_adddep(pkg, depname, deporigin, depversion,
deplocked);
}
pkg_free(d);
}
pkgdb_it_free(it);
return (EPKG_OK);
}
int
pkg_script_run(struct pkg *pkg, pkg_script_t type)
{
struct pkg_script *script = NULL;
pkg_script_t stype;
struct sbuf *script_cmd = sbuf_new_auto();
size_t i;
struct {
const char *arg;
const pkg_script_t b;
const pkg_script_t a;
} const map[] = {
/* a implies b with argument arg */
{"PRE-INSTALL", PKG_SCRIPT_INSTALL, PKG_SCRIPT_PRE_INSTALL},
{"POST-INSTALL", PKG_SCRIPT_INSTALL, PKG_SCRIPT_POST_INSTALL},
{"PRE-UPGRADE", PKG_SCRIPT_UPGRADE, PKG_SCRIPT_PRE_UPGRADE},
{"POST-UPGRADE", PKG_SCRIPT_UPGRADE, PKG_SCRIPT_POST_UPGRADE},
{"DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_PRE_DEINSTALL},
{"POST-DEINSTALL", PKG_SCRIPT_DEINSTALL, PKG_SCRIPT_POST_DEINSTALL},
};
for (i = 0; i < sizeof(map) / sizeof(map[0]); i++) {
if (map[i].a == type)
break;
}
if (map[i].a != type)
return (ERROR_BAD_ARG("type"));
while (pkg_scripts(pkg, &script) == EPKG_OK) {
stype = pkg_script_type(script);
if (stype == map[i].a || stype == map[i].b) {
sbuf_reset(script_cmd);
sbuf_printf(script_cmd, "PKG_PREFIX=%s\nset -- %s-%s",
pkg_get(pkg, PKG_PREFIX), pkg_get(pkg, PKG_NAME),
pkg_get(pkg, PKG_VERSION));
if (stype == map[i].b) {
/* add arg **/
sbuf_cat(script_cmd, " ");
sbuf_cat(script_cmd, map[i].arg);
}
sbuf_cat(script_cmd, "\n");
sbuf_cat(script_cmd, pkg_script_data(script));
sbuf_finish(script_cmd);
system(sbuf_data(script_cmd));
}
}
sbuf_delete(script_cmd);
return (EPKG_OK);
}
int
pkg_delete(struct pkg *pkg, struct pkgdb *db, int force)
{
struct pkg **rdeps;
int i, ret;
struct sbuf *rdep_msg;
if (pkg == NULL)
return (ERROR_BAD_ARG("pkg"));
if (db == NULL)
return (ERROR_BAD_ARG("db"));
/*
* Ensure that we have all the informations we need
*/
if ((ret = pkgdb_loadrdeps(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_loadfiles(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_loadscripts(db, pkg)) != EPKG_OK)
return (ret);
if ((ret = pkgdb_loadmtree(db, pkg)) != EPKG_OK)
return (ret);
rdeps = pkg_rdeps(pkg);
if (rdeps[0] != NULL) {
rdep_msg = sbuf_new_auto();
sbuf_printf(rdep_msg, "%s-%s is required by other packages:", pkg_get(pkg, PKG_NAME), pkg_get(pkg, PKG_VERSION));
for (i = 0;rdeps[i] != NULL; i++) {
sbuf_cat(rdep_msg, " ");
sbuf_printf(rdep_msg, "%s-%s", pkg_get(rdeps[i], PKG_NAME), pkg_get(rdeps[i], PKG_VERSION));
}
if (!force) {
sbuf_finish(rdep_msg);
ret = pkg_error_set(EPKG_REQUIRED, "%s", sbuf_get(rdep_msg));
sbuf_free(rdep_msg);
return ret;
}
sbuf_cat(rdep_msg, ", deleting anyway");
sbuf_finish(rdep_msg);
fprintf(stderr, "%s\n", sbuf_get(rdep_msg));
sbuf_free(rdep_msg);
}
if ((ret = pkg_script_pre_deinstall(pkg)) != EPKG_OK)
return (ret);
if ((ret = pkg_delete_files(pkg, force)) != EPKG_OK)
return (ret);
if ((ret = pkg_script_post_deinstall(pkg)) != EPKG_OK)
return (ret);
return (pkgdb_unregister_pkg(db, pkg_get(pkg, PKG_ORIGIN)));
}
static int
pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const char * const outdir, const char * const rootdir)
{
int i, ret = EPKG_OK, retcode = EPKG_OK;
struct pkgdb *db = NULL;
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
int query_flags = PKG_LOAD_DEPS | PKG_LOAD_CONFLICTS | PKG_LOAD_FILES | PKG_LOAD_CATEGORIES |
PKG_LOAD_DIRS | PKG_LOAD_SCRIPTS | PKG_LOAD_OPTIONS |
PKG_LOAD_MTREE | PKG_LOAD_LICENSES;
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
pkgdb_close(db);
return (EX_IOERR);
}
if (match != MATCH_ALL) {
for (i = 0;i < argc; i++) {
if ((it = pkgdb_query(db, argv[i], match)) == NULL) {
goto cleanup;
}
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME),
pkg_get(pkg, PKG_VERSION));
if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK) {
retcode++;
}
}
}
} else {
if ((it = pkgdb_query(db, NULL, match)) == NULL) {
goto cleanup;
}
while ((ret = pkgdb_it_next(it, &pkg, query_flags)) == EPKG_OK) {
printf("Creating package for %s-%s\n", pkg_get(pkg, PKG_NAME),
pkg_get(pkg, PKG_VERSION));
if (pkg_create_installed(outdir, fmt, rootdir, pkg) != EPKG_OK) {
retcode++;
}
}
}
cleanup:
if (ret != EPKG_END) {
retcode++;
}
pkg_free(pkg);
pkgdb_it_free(it);
pkgdb_close(db);
return (retcode);
}
static int
pkg_conflicts_chain_cmp_cb(struct pkg_conflict_chain *a, struct pkg_conflict_chain *b)
{
const char *vera, *verb;
if (a->req->skip || b->req->skip) {
return (a->req->skip - b->req->skip);
}
pkg_get(a->req->item->pkg, PKG_VERSION, &vera);
pkg_get(b->req->item->pkg, PKG_VERSION, &verb);
/* Inverse sort to get the maximum version as the first element */
return (pkg_version_cmp(vera, verb));
}
void
pkg_emit_upgrade_finished(struct pkg *p)
{
struct pkg_event ev;
bool syslog_enabled = false;
char *name, *version, *newversion;
ev.type = PKG_EVENT_UPGRADE_FINISHED;
ev.e_upgrade_finished.pkg = p;
pkg_config_bool(PKG_CONFIG_SYSLOG, &syslog_enabled);
if (syslog_enabled) {
const char *actions[] = {
"upgraded", "reinstalled", "downgraded"
};
int num_actions = sizeof(actions) / sizeof(*actions);
int action;
pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version,
PKG_NEWVERSION, &newversion);
action = pkg_version_cmp(version, newversion) + 1;
if (action >= 0 && action < num_actions)
syslog(LOG_NOTICE, "%s %s: %s -> %s ",
name, actions[action], version, newversion);
}
pkg_emit_event(&ev);
}
static int
pkg_repo_binary_add_from_manifest(char *buf, const char *origin, const char *digest,
long offset, sqlite3 *sqlite,
struct pkg_manifest_key **keys, struct pkg **p, bool is_legacy,
struct pkg_repo *repo)
{
int rc = EPKG_OK;
struct pkg *pkg;
const char *local_origin, *pkg_arch;
if (*p == NULL) {
rc = pkg_new(p, PKG_REMOTE);
if (rc != EPKG_OK)
return (EPKG_FATAL);
} else {
pkg_reset(*p, PKG_REMOTE);
}
pkg = *p;
pkg_manifest_keys_new(keys);
rc = pkg_parse_manifest(pkg, buf, offset, *keys);
if (rc != EPKG_OK) {
goto cleanup;
}
rc = pkg_is_valid(pkg);
if (rc != EPKG_OK) {
goto cleanup;
}
/* Ensure that we have a proper origin and arch*/
pkg_get(pkg, PKG_ORIGIN, &local_origin, PKG_ARCH, &pkg_arch);
if (local_origin == NULL || strcmp(local_origin, origin) != 0) {
pkg_emit_error("manifest contains origin %s while we wanted to add origin %s",
local_origin ? local_origin : "NULL", origin);
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_arch == NULL || !is_valid_abi(pkg_arch, true)) {
rc = EPKG_FATAL;
pkg_emit_error("repository %s contains packages with wrong ABI: %s",
repo->name, pkg_arch);
goto cleanup;
}
pkg_set(pkg, PKG_REPONAME, repo->name);
if (is_legacy) {
pkg_set(pkg, PKG_OLD_DIGEST, digest);
pkg_checksum_calculate(pkg, NULL);
}
else {
pkg_set(pkg, PKG_DIGEST, digest);
}
rc = pkg_repo_binary_add_pkg(pkg, NULL, sqlite, true);
cleanup:
return (rc);
}
static kh_sum_t *
populate_sums(struct pkgdb *db)
{
struct pkg *p = NULL;
struct pkgdb_it *it = NULL;
const char *sum;
char *cksum;
size_t slen;
kh_sum_t *suml = NULL;
khint_t k;
int ret;
suml = kh_init_sum();
it = pkgdb_repo_search(db, "*", MATCH_GLOB, FIELD_NAME, FIELD_NONE, NULL);
while (pkgdb_it_next(it, &p, PKG_LOAD_BASIC) == EPKG_OK) {
pkg_get(p, PKG_CKSUM, &sum);
slen = MIN(strlen(sum), PKG_FILE_CKSUM_CHARS);
cksum = strndup(sum, slen);
k = kh_put_sum(suml, cksum, &ret);
if (ret != 0)
kh_value(suml, k) = cksum;
}
return (suml);
}
/* ARGSUSED */
static int
add_shlibs_to_pkg(__unused void *actdata, struct pkg *pkg, const char *fpath,
const char *name, bool is_shlib)
{
const char *pkgname, *pkgversion;
struct pkg_file *file = NULL;
const char *filepath;
switch(filter_system_shlibs(name, NULL, 0)) {
case EPKG_OK: /* A non-system library */
pkg_addshlib_required(pkg, name);
return (EPKG_OK);
case EPKG_END: /* A system library */
return (EPKG_OK);
default:
/* Ignore link resolution errors if we're analysing a
shared library. */
if (is_shlib)
return (EPKG_OK);
while (pkg_files(pkg, &file) == EPKG_OK) {
filepath = pkg_file_path(file);
if (strcmp(&filepath[strlen(filepath) - strlen(name)], name) == 0) {
pkg_addshlib_required(pkg, name);
return (EPKG_OK);
}
}
pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
warnx("(%s-%s) %s - shared library %s not found",
pkgname, pkgversion, fpath, name);
return (EPKG_FATAL);
}
}
static int
check_deps(struct pkgdb *db, struct pkg *p, struct deps_head *dh, bool noinstall)
{
struct pkg_dep *dep = NULL;
char *name, *version, *origin;
int nbpkgs = 0;
assert(db != NULL);
assert(p != NULL);
name = version = origin = NULL;
pkg_get(p, PKG_NAME, &name, PKG_VERSION, &version, PKG_ORIGIN, &origin);
while (pkg_deps(p, &dep) == EPKG_OK) {
/* do we have a missing dependency? */
if (pkg_is_installed(db, pkg_dep_origin(dep)) != EPKG_OK) {
if (noinstall)
printf("%s\n", pkg_dep_origin(dep));
else
printf("%s has a missing dependency: %s\n", origin,
pkg_dep_origin(dep));
add_missing_dep(dep, dh, &nbpkgs);
}
}
return (nbpkgs);
}
static struct packing *
pkg_create_archive(const char *outdir, struct pkg *pkg, pkg_formats format,
unsigned required_flags)
{
char *pkg_path = NULL;
struct packing *pkg_archive = NULL;
const char *pkgname, *pkgversion;
/*
* Ensure that we have all the information we need
*/
if (pkg->type != PKG_OLD_FILE)
assert((pkg->flags & required_flags) == required_flags);
if (mkdirs(outdir) != EPKG_OK)
return NULL;
pkg_get(pkg, PKG_NAME, &pkgname, PKG_VERSION, &pkgversion);
if (asprintf(&pkg_path, "%s/%s-%s", outdir, pkgname, pkgversion) == -1) {
pkg_emit_errno("asprintf", "");
return (NULL);
}
if (packing_init(&pkg_archive, pkg_path, format) != EPKG_OK)
pkg_archive = NULL;
free(pkg_path);
return pkg_archive;
}
static int
pkgs_providing_lib(struct pkgdb *db, const char *libname)
{
struct pkgdb_it *it = NULL;
struct pkg *pkg = NULL;
const char *name, *version;
int ret = EPKG_OK;
int count = 0;
if ((it = pkgdb_query_shlib_provided(db, libname)) == NULL) {
return (EPKG_FATAL);
}
while ((ret = pkgdb_it_next(it, &pkg, PKG_LOAD_BASIC)) == EPKG_OK) {
if (count == 0)
printf("%s is provided by the following packages:\n",
libname);
count++;
pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);
printf("%s-%s\n", name, version);
}
if (ret == EPKG_END) {
if (count == 0)
printf("No packages provide %s.\n", libname);
ret = EPKG_OK;
}
pkg_free(pkg);
pkgdb_it_free(it);
return (ret);
}
void
pkg_delete_dir(struct pkg *pkg, struct pkg_dir *dir)
{
const char *path;
const char *prefix_rel;
size_t len;
pkg_open_root_fd(pkg);
path = pkg_dir_path(dir);
/* remove the first / */
path++;
pkg_get(pkg, PKG_PREFIX, &prefix_rel);
prefix_rel++;
len = strlen(prefix_rel);
if ((strncmp(prefix_rel, path, len) == 0) && path[len] == '/') {
pkg_add_dir_to_del(pkg, NULL, path);
} else {
if (pkg->dir_to_del_len + 1 > pkg->dir_to_del_cap) {
pkg->dir_to_del_cap += 64;
pkg->dir_to_del = reallocf(pkg->dir_to_del,
pkg->dir_to_del_cap * sizeof(char *));
}
pkg->dir_to_del[pkg->dir_to_del_len++] = strdup(path);
}
}
int
pkgdb_loadfiles(struct pkgdb *db, struct pkg *pkg)
{
sqlite3_stmt *stmt;
struct pkg_file *f;
int ret;
const char sql[] = ""
"SELECT path, sha256 "
"FROM files "
"WHERE package_id = ?1 "
"ORDER BY PATH ASC";
const char sqldir[] = ""
"SELECT path "
"FROM pkg_dirs "
"WHERE origin = ?1 "
"ORDER by path DESC";
if (pkg->type != PKG_INSTALLED)
return (ERROR_BAD_ARG("pkg"));
if (pkg->flags & PKG_LOAD_FILES)
return (EPKG_OK);
array_init(&pkg->files, 10);
if (sqlite3_prepare_v2(db->sqlite, sql, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_int64(stmt, 1, pkg->rowid);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_file_new(&f);
strlcpy(f->path, sqlite3_column_text(stmt, 0), sizeof(f->path));
strlcpy(f->sha256, sqlite3_column_text(stmt, 1), sizeof(f->sha256));
array_append(&pkg->files, f);
}
sqlite3_finalize(stmt);
if (ret != SQLITE_DONE) {
array_reset(&pkg->files, &free);
return (ERROR_SQLITE(db->sqlite));
}
if (sqlite3_prepare_v2(db->sqlite, sqldir, -1, &stmt, NULL) != SQLITE_OK)
return (ERROR_SQLITE(db->sqlite));
sqlite3_bind_text(stmt, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
while ((ret = sqlite3_step(stmt)) == SQLITE_ROW) {
pkg_file_new(&f);
strlcpy(f->path, sqlite3_column_text(stmt, 0), sizeof(f->path));
array_append(&pkg->files, f);
}
sqlite3_finalize(stmt);
pkg->flags |= PKG_LOAD_FILES;
return (EPKG_OK);
}
int
pkg_old_load_from_path(struct pkg *pkg, const char *path)
{
char *desc;
char *www;
char fpath[MAXPATHLEN];
regex_t preg;
regmatch_t pmatch[2];
int i;
size_t size;
char myarch[BUFSIZ];
if (!is_dir(path))
return (EPKG_FATAL);
snprintf(fpath, sizeof(fpath), "%s/+CONTENTS", path);
if (ports_parse_plist(pkg, fpath, NULL) != EPKG_OK)
return (EPKG_FATAL);
snprintf(fpath, sizeof(fpath), "%s/+COMMENT", path);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_COMMENT, fpath, true);
snprintf(fpath, sizeof(fpath), "%s/+DESC", path);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_DESC, fpath, false);
snprintf(fpath, sizeof(fpath), "%s/+DISPLAY", path);
if (access(fpath, F_OK) == 0)
pkg_set_from_file(pkg, PKG_MESSAGE, fpath, false);
snprintf(fpath, sizeof(fpath), "%s/+MTREE_DIRS", path);
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", path, scripts[i]);
if (access(fpath, F_OK) == 0)
pkg_addscript_file(pkg, fpath);
}
pkg_get_myarch(myarch, BUFSIZ);
pkg_set(pkg, PKG_ARCH, myarch);
pkg_set(pkg, PKG_MAINTAINER, "unknown");
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);
return (EPKG_OK);
}
static int
pkg_add_from_manifest(FILE *f, char *buf, const char *origin, long offset,
const char *manifest_digest, const char *local_arch, sqlite3 *sqlite,
struct pkg_manifest_parser **parser, struct pkg **p)
{
int rc = EPKG_OK;
struct pkg *pkg;
const char *local_origin, *pkg_arch;
if (buf == NULL && fseek(f, offset, SEEK_SET) == -1) {
pkg_emit_errno("fseek", "invalid manifest offset");
return (EPKG_FATAL);
}
if (*p == NULL) {
rc = pkg_new(p, PKG_REMOTE);
if (rc != EPKG_OK)
return (EPKG_FATAL);
} else {
pkg_reset(*p, PKG_REMOTE);
}
pkg = *p;
pkg_manifest_parser_new(parser);
if (buf == NULL) {
rc = pkg_parse_manifest_file_ev(pkg, f, *parser);
} else {
rc = pkg_parse_manifest_ev(pkg, buf, offset, *parser);
}
if (rc != EPKG_OK) {
goto cleanup;
}
rc = pkg_is_valid(pkg);
if (rc != EPKG_OK) {
goto cleanup;
}
/* Ensure that we have a proper origin and arch*/
pkg_get(pkg, PKG_ORIGIN, &local_origin, PKG_ARCH, &pkg_arch);
if (local_origin == NULL || strcmp(local_origin, origin) != 0) {
pkg_emit_error("manifest contains origin %s while we wanted to add origin %s",
local_origin ? local_origin : "NULL", origin);
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_arch == NULL || strcmp(pkg_arch, local_arch) != 0) {
pkg_emit_error("package %s is built for %s arch, and local arch is %s",
origin, pkg_arch ? pkg_arch : "NULL", local_arch);
rc = EPKG_FATAL;
goto cleanup;
}
rc = pkgdb_repo_add_package(pkg, NULL, sqlite, manifest_digest, true, false);
cleanup:
return (rc);
}
/*
* Gets the PackageKit repository name for the (remote) package.
*
* Currently this is the pkgng repository name (not the ident as was previously
* the case).
*
* This does not need to be freed (possibly, TODO: check).
*/
static const char *
repo_of_remote_package(struct pkg *pkg)
{
const char *repo_name;
assert(pkg != NULL);
assert(pkg_type(pkg) == PKG_REMOTE);
repo_name = NULL;
pkg_get(pkg, PKG_REPONAME, &repo_name);
return repo_name;
}
static int
pkg_conflicts_request_resolve_chain(struct pkg *req, struct pkg_conflict_chain *chain)
{
struct pkg_conflict_chain *elt, *selected = NULL;
const char *name, *origin, *slash_pos;
pkg_get(req, PKG_NAME, &name);
/*
* First of all prefer pure origins, where the last element of
* an origin is pkg name
*/
LL_FOREACH(chain, elt) {
pkg_get(elt->req->item->pkg, PKG_ORIGIN, &origin);
slash_pos = strrchr(origin, '/');
if (slash_pos != NULL) {
if (strcmp(slash_pos + 1, name) == 0) {
selected = elt;
break;
}
}
}
static int
setprefix(struct plist *p, char *line, struct file_attr *a)
{
char *pkgprefix;
/* if no arguments then set default prefix */
if (line[0] == '\0')
pkg_get(p->pkg, PKG_PREFIX, &p->prefix);
else
p->prefix = line;
pkg_get(p->pkg, PKG_PREFIX, &pkgprefix);
if (pkgprefix == NULL || *pkgprefix == '\0')
pkg_set(p->pkg, PKG_PREFIX, line);
p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/";
free(a);
return (EPKG_OK);
}
static void
pkg_effective_rmdir(struct pkgdb *db, struct pkg *pkg)
{
char prefix_r[MAXPATHLEN];
const char *prefix;
size_t i;
pkg_get(pkg, PKG_PREFIX, &prefix);
snprintf(prefix_r, sizeof(prefix_r), "%s/", prefix + 1);
for (i = 0; i < pkg->dir_to_del_len; i++)
rmdir_p(db, pkg, pkg->dir_to_del[i], prefix_r);
}
static int
setprefix(struct plist *p, char *line)
{
/* if no arguments then set default prefix */
if (line[0] == '\0')
pkg_get(p->pkg, PKG_PREFIX, &p->prefix);
else
p->prefix = line;
p->slash = p->prefix[strlen(p->prefix) -1] == '/' ? "" : "/";
return (EPKG_OK);
}
void
pkg_delete_file(struct pkg *pkg, struct pkg_file *file, unsigned force)
{
const char *sum = pkg_file_cksum(file);
const char *path;
const char *prefix_rel;
struct stat st;
size_t len;
char sha256[SHA256_DIGEST_LENGTH * 2 + 1];
pkg_open_root_fd(pkg);
path = pkg_file_path(file);
path++;
pkg_get(pkg, PKG_PREFIX, &prefix_rel);
prefix_rel++;
len = strlen(prefix_rel);
/* Regular files and links */
/* check sha256 */
if (!force && sum[0] != '\0') {
if (fstatat(pkg->rootfd, path, &st, AT_SYMLINK_NOFOLLOW) == -1) {
pkg_emit_error("cannot stat %s: %s", path, strerror(errno));
return;
}
if (S_ISLNK(st.st_mode)) {
if (pkg_symlink_cksumat(pkg->rootfd, path, NULL,
sha256) != EPKG_OK)
return;
}
else {
if (sha256_fileat(pkg->rootfd, path, sha256) != EPKG_OK)
return;
}
if (strcmp(sha256, sum)) {
pkg_emit_error("%s fails original SHA256 "
"checksum, not removing", path);
return;
}
}
if (unlinkat(pkg->rootfd, path, 0) == -1) {
if (force < 2)
pkg_emit_errno("unlinkat", path);
return;
}
/* do not bother about directories not in prefix */
if ((strncmp(prefix_rel, path, len) == 0) && path[len] == '/')
pkg_add_dir_to_del(pkg, path, NULL);
}
static void
add_to_check(kh_pkgs_t *check, struct pkg *pkg)
{
const char *uid;
int ret;
khint_t k;
pkg_get(pkg, PKG_UNIQUEID, &uid);
k = kh_put_pkgs(check, uid, &ret);
if (ret != 0)
kh_value(check, k) = pkg;
}
static void
print_index(struct pkg *pkg, const char *portsdir)
{
const pkg_object *obj, *list;
pkg_iter iter = NULL;
pkg_printf("%n-%v|%S/%o|%p|%c|%S/%o/pkg-descr|%m|",
pkg, pkg, portsdir, pkg, pkg, pkg, portsdir, pkg, pkg);
pkg_get(pkg, PKG_CATEGORIES, &list);
while ((obj = pkg_object_iterate(list, &iter)))
pkg_printf("%Cn ", obj);
printf("\n");
}
static int
pkg_repo_add_from_manifest(char *buf, const char *origin, long offset,
const char *manifest_digest, sqlite3 *sqlite,
struct pkg_manifest_key **keys, struct pkg **p)
{
int rc = EPKG_OK;
struct pkg *pkg;
const char *local_origin, *pkg_arch;
if (*p == NULL) {
rc = pkg_new(p, PKG_REMOTE);
if (rc != EPKG_OK)
return (EPKG_FATAL);
} else {
pkg_reset(*p, PKG_REMOTE);
}
pkg = *p;
pkg_manifest_keys_new(keys);
rc = pkg_parse_manifest(pkg, buf, offset, *keys);
if (rc != EPKG_OK) {
goto cleanup;
}
rc = pkg_is_valid(pkg);
if (rc != EPKG_OK) {
goto cleanup;
}
/* Ensure that we have a proper origin and arch*/
pkg_get(pkg, PKG_ORIGIN, &local_origin, PKG_ARCH, &pkg_arch);
if (local_origin == NULL || strcmp(local_origin, origin) != 0) {
pkg_emit_error("manifest contains origin %s while we wanted to add origin %s",
local_origin ? local_origin : "NULL", origin);
rc = EPKG_FATAL;
goto cleanup;
}
if (pkg_arch == NULL || !is_valid_abi(pkg_arch, true)) {
rc = EPKG_FATAL;
goto cleanup;
}
rc = pkgdb_repo_add_package(pkg, NULL, sqlite, manifest_digest, true);
cleanup:
return (rc);
}
/* The "no concessions to old pkg_tools" variant: just get everything
* from the manifest */
int
pkg_create_from_manifest(const char *outdir, pkg_formats format,
const char *rootdir, const char *manifest, bool old)
{
struct pkg *pkg = NULL;
struct packing *pkg_archive = NULL;
char arch[BUFSIZ];
int ret = ENOMEM;
char *buf;
struct pkg_manifest_key *keys = NULL;
pkg_debug(1, "Creating package from stage directory: '%s'", rootdir);
if(pkg_new(&pkg, old ? PKG_OLD_FILE : PKG_FILE) != EPKG_OK) {
ret = EPKG_FATAL;
goto cleanup;
}
pkg_manifest_keys_new(&keys);
if ((ret = pkg_parse_manifest_file(pkg, manifest, keys)) != EPKG_OK) {
ret = EPKG_FATAL;
goto cleanup;
}
/* if no arch autodetermine it */
pkg_get(pkg, PKG_ARCH, &buf);
if (buf == NULL) {
pkg_get_myarch(arch, BUFSIZ);
pkg_set(pkg, PKG_ARCH, arch);
}
/* Create the archive */
pkg_archive = pkg_create_archive(outdir, pkg, format, 0);
if (pkg_archive == NULL) {
ret = EPKG_FATAL; /* XXX do better */
goto cleanup;
}
pkg_create_from_dir(pkg, rootdir, pkg_archive);
ret = EPKG_OK;
cleanup:
free(pkg);
pkg_manifest_keys_free(keys);
if (ret == EPKG_OK)
ret = packing_finish(pkg_archive);
return (ret);
}
