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 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);
}
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);
}
static int
convert_from_old(const char *pkg_add_dbdir, bool dry_run)
{
DIR *d;
struct dirent *dp;
struct pkg *p = NULL;
char path[MAXPATHLEN];
struct pkgdb *db = NULL;
if ((d = opendir(pkg_add_dbdir)) == NULL)
err(EX_NOINPUT, "%s", pkg_add_dbdir);
if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK) {
return (EX_IOERR);
}
while ((dp = readdir(d)) != NULL) {
if (dp->d_type == DT_DIR) {
if (strcmp(dp->d_name, ".") == 0 ||
strcmp(dp->d_name, "..") == 0)
continue;
if (p == NULL) {
if (pkg_new(&p, PKG_OLD_FILE) != EPKG_OK)
err(EX_OSERR, "malloc");
} else
pkg_reset(p, PKG_OLD_FILE);
printf("Converting %s...\n", dp->d_name);
snprintf(path, MAXPATHLEN, "%s/%s", pkg_add_dbdir, dp->d_name);
if (pkg_old_load_from_path(p, path) != EPKG_OK) {
fprintf(stderr, "Skipping invalid package: %s\n", path);
continue;
}
pkg_from_old(p);
if (!dry_run)
pkgdb_register_ports(db, p);
}
}
pkg_free(p);
pkgdb_close(db);
return (EX_OK);
}
int
pkgdb_it_next(struct pkgdb_it *it, struct pkg **pkg_p, int flags)
{
struct pkg *pkg;
int ret;
if (it == NULL)
return (ERROR_BAD_ARG("it"));
switch (sqlite3_step(it->stmt)) {
case SQLITE_ROW:
if (*pkg_p == NULL)
pkg_new(pkg_p, PKG_INSTALLED);
else
pkg_reset(*pkg_p, PKG_INSTALLED);
pkg = *pkg_p;
pkg->rowid = sqlite3_column_int64(it->stmt, 0);
pkg_set(pkg, PKG_ORIGIN, sqlite3_column_text(it->stmt, 1));
pkg_set(pkg, PKG_NAME, sqlite3_column_text(it->stmt, 2));
pkg_set(pkg, PKG_VERSION, sqlite3_column_text(it->stmt, 3));
pkg_set(pkg, PKG_COMMENT, sqlite3_column_text(it->stmt, 4));
pkg_set(pkg, PKG_DESC, sqlite3_column_text(it->stmt, 5));
pkg_set(pkg, PKG_MESSAGE, sqlite3_column_text(it->stmt, 6));
pkg_set(pkg, PKG_ARCH, sqlite3_column_text(it->stmt, 7));
pkg_set(pkg, PKG_OSVERSION, sqlite3_column_text(it->stmt, 8));
pkg_set(pkg, PKG_MAINTAINER, sqlite3_column_text(it->stmt, 9));
pkg_set(pkg, PKG_WWW, sqlite3_column_text(it->stmt, 10));
pkg_set(pkg, PKG_PREFIX, sqlite3_column_text(it->stmt, 11));
pkg_setflatsize(pkg, sqlite3_column_int64(it->stmt, 12));
if (it->type == IT_UPGRADE) {
pkg->type = PKG_UPGRADE;
pkg_set(pkg, PKG_NEWVERSION, sqlite3_column_text(it->stmt, 13));
pkg_setnewflatsize(pkg, sqlite3_column_int64(it->stmt, 14));
pkg_setnewpkgsize(pkg, sqlite3_column_int64(it->stmt, 15));
pkg_set(pkg, PKG_REPOPATH, sqlite3_column_text(it->stmt, 16));
}
if (flags & PKG_LOAD_DEPS)
if ((ret = pkgdb_loaddeps(it->db, pkg)) != EPKG_OK)
return (ret);
if (flags & PKG_LOAD_RDEPS)
if ((ret = pkgdb_loadrdeps(it->db, pkg)) != EPKG_OK)
return (ret);
if (flags & PKG_LOAD_CONFLICTS)
if ((ret = pkgdb_loadconflicts(it->db, pkg)) != EPKG_OK)
return (ret);
if (flags & PKG_LOAD_FILES)
if ((ret = pkgdb_loadfiles(it->db, pkg)) != EPKG_OK)
return (ret);
if (flags & PKG_LOAD_SCRIPTS)
if ((ret = pkgdb_loadscripts(it->db, pkg)) != EPKG_OK)
return (ret);
if (flags & PKG_LOAD_OPTIONS)
if ((ret = pkgdb_loadoptions(it->db, pkg)) != EPKG_OK)
return (ret);
if (flags & PKG_LOAD_MTREE)
if ((ret = pkgdb_loadmtree(it->db, pkg)) != EPKG_OK)
return (ret);
return (EPKG_OK);
case SQLITE_DONE:
return (EPKG_END);
default:
return (ERROR_SQLITE(it->db->sqlite));
}
}
