void
pkg_jobs_update_conflict_priority(struct pkg_jobs_universe *universe,
struct pkg_solved *req)
{
struct pkg_conflict *c = NULL;
struct pkg *lp = req->items[1]->pkg;
struct pkg_job_universe_item *found, *cur, *rit = NULL;
while (pkg_conflicts(lp, &c) == EPKG_OK) {
rit = NULL;
HASH_FIND_STR(universe->items, c->uid, found);
assert(found != NULL);
LL_FOREACH(found, cur) {
if (cur->pkg->type != PKG_INSTALLED) {
rit = cur;
break;
}
}
assert(rit != NULL);
if (rit->priority >= req->items[1]->priority) {
pkg_jobs_update_universe_item_priority(universe, req->items[1],
rit->priority + 1, PKG_PRIORITY_UPDATE_CONFLICT);
/*
* Update priorities for a remote part as well
*/
pkg_jobs_update_universe_item_priority(universe, req->items[0],
req->items[0]->priority, PKG_PRIORITY_UPDATE_REQUEST);
}
}
}
static void __pkg_hash_fetch_conflictees(pkg_t * pkg,
pkg_vec_t * installed_conflicts)
{
int i;
pkg_vec_t *available_pkgs = pkg_vec_alloc();
pkg_hash_fetch_all_installed(available_pkgs);
for (i = 0; i < available_pkgs->len; i++) {
pkg_t *cpkg = available_pkgs->pkgs[i];
int is_new_conflict = pkg_conflicts(cpkg, pkg)
&& !is_pkg_a_provides(cpkg, pkg)
&& !is_pkg_in_pkg_vec(installed_conflicts, cpkg)
&& !pkg_replaces(pkg, cpkg);
if (is_new_conflict)
pkg_vec_insert(installed_conflicts, cpkg);
}
pkg_vec_free(available_pkgs);
}
void
test_manifest(void)
{
struct pkg *p = NULL;
struct pkg_dep *dep = NULL;
struct pkg_conflict *conflict = NULL;
struct pkg_option *option = NULL;
struct pkg_category *category = NULL;
struct pkg_file *file = NULL;
struct pkg_manifest_key *keys = NULL;
const char *pkg_str;
int64_t pkg_int;
int i;
pkg_manifest_keys_new(&keys);
ATF_REQUIRE(keys != NULL);
ATF_REQUIRE_EQ(EPKG_OK, pkg_new(&p, PKG_FILE));
ATF_REQUIRE(p != NULL);
ATF_REQUIRE_EQ(EPKG_OK, pkg_parse_manifest(p, manifest, strlen(manifest), keys));
pkg_manifest_keys_free(keys);
ATF_REQUIRE(pkg_get(p, PKG_NAME, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "foobar") == 0);
ATF_REQUIRE(pkg_get(p, PKG_VERSION, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "0.3") == 0);
ATF_REQUIRE(pkg_get(p, PKG_ORIGIN, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "foo/bar") == 0);
ATF_REQUIRE(pkg_get(p, PKG_COMMENT, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "A dummy manifest") == 0);
ATF_REQUIRE(pkg_get(p, PKG_ARCH, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "amd64") == 0);
ATF_REQUIRE(pkg_get(p, PKG_WWW, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "http://www.foobar.com") == 0);
ATF_REQUIRE(pkg_get(p, PKG_MAINTAINER, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "*****@*****.**") == 0);
ATF_REQUIRE(pkg_get(p, PKG_PREFIX, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "/opt/prefix") == 0);
ATF_REQUIRE(pkg_get(p, PKG_DESC, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "port description") == 0);
ATF_REQUIRE(pkg_get(p, PKG_MESSAGE, &pkg_str) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_str, "pkg message") == 0);
ATF_REQUIRE(pkg_get(p, PKG_FLATSIZE, &pkg_int) == EPKG_OK);
ATF_REQUIRE(pkg_int == 10000);
i = 0;
while (pkg_deps(p, &dep) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depfoo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/foo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "1.2") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depbar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/bar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "3.4") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
i = 0;
#if 0
while (pkg_conflicts(p, &conflict) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "foo-*") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "bar-*") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
#endif
i = 0;
while (pkg_options(p, &option) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "foo") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "true") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "bar") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "false") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
i = 0;
while (pkg_categories(p, &category) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_category_name(category), "foo") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_category_name(category), "bar") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
ATF_REQUIRE(pkg_files(p, &file) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_file_path(file), "/usr/local/bin/foo") ==
0);
#if 0
ATF_REQUIRE(strcmp(pkg_file_sha256(file),
"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b")
== 0);
#endif
pkg_free(p);
/* p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest1) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest2) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest3) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest4) == EPKG_FATAL);
pkg_free(p);
*/
}
static void
pkg_jobs_update_universe_item_priority(struct pkg_jobs_universe *universe,
struct pkg_job_universe_item *item, int priority,
enum pkg_priority_update_type type)
{
struct pkg_dep *d = NULL;
struct pkg_conflict *c = NULL;
struct pkg_job_universe_item *found, *cur, *it;
const char *is_local;
int maxpri;
int (*deps_func)(const struct pkg *pkg, struct pkg_dep **d);
int (*rdeps_func)(const struct pkg *pkg, struct pkg_dep **d);
if (priority > RECURSION_LIMIT) {
pkg_debug(1, "recursion limit has been reached, something is bad"
" with dependencies/conflicts graph");
return;
}
else if (priority + 10 > RECURSION_LIMIT) {
pkg_debug(2, "approaching recursion limit at %d, while processing of"
" package %s", priority, item->pkg->uid);
}
LL_FOREACH(item, it) {
if ((item->next != NULL || item->prev != NULL) &&
it->pkg->type != PKG_INSTALLED &&
(type == PKG_PRIORITY_UPDATE_CONFLICT ||
type == PKG_PRIORITY_UPDATE_DELETE)) {
/*
* We do not update priority of a remote part of conflict, as we know
* that remote packages should not contain conflicts (they should be
* resolved in request prior to calling of this function)
*/
pkg_debug(4, "skip update priority for %s-%s",
it->pkg->uid, it->pkg->digest);
continue;
}
if (it->priority > priority)
continue;
is_local = it->pkg->type == PKG_INSTALLED ? "local" : "remote";
pkg_debug(2, "universe: update %s priority of %s(%s): %d -> %d, reason: %d",
is_local, it->pkg->uid, it->pkg->digest, it->priority, priority, type);
it->priority = priority;
if (type == PKG_PRIORITY_UPDATE_DELETE) {
/*
* For delete requests we inverse deps and rdeps logic
*/
deps_func = pkg_rdeps;
rdeps_func = pkg_deps;
}
else {
deps_func = pkg_deps;
rdeps_func = pkg_rdeps;
}
while (deps_func(it->pkg, &d) == EPKG_OK) {
HASH_FIND_STR(universe->items, d->uid, found);
if (found == NULL)
continue;
LL_FOREACH(found, cur) {
if (cur->priority < priority + 1)
pkg_jobs_update_universe_item_priority(universe, cur,
priority + 1, type);
}
}
d = NULL;
maxpri = priority;
while (rdeps_func(it->pkg, &d) == EPKG_OK) {
HASH_FIND_STR(universe->items, d->uid, found);
if (found == NULL)
continue;
LL_FOREACH(found, cur) {
if (cur->priority >= maxpri) {
maxpri = cur->priority + 1;
}
}
}
if (maxpri != priority) {
pkg_jobs_update_universe_item_priority(universe, it,
maxpri, type);
return;
}
if (it->pkg->type == PKG_INSTALLED)
continue;
while (pkg_conflicts(it->pkg, &c) == EPKG_OK) {
HASH_FIND_STR(universe->items, c->uid, found);
if (found == NULL)
continue;
LL_FOREACH(found, cur) {
if (cur->pkg->type != PKG_INSTALLED)
continue;
/*
* Move delete requests to be done before installing
*/
if (cur->priority <= it->priority)
pkg_jobs_update_universe_item_priority(universe, cur,
it->priority + 1, PKG_PRIORITY_UPDATE_CONFLICT);
}
}
}
}
void
test_manifest(void)
{
struct pkg *p = NULL;
struct pkg_dep *dep = NULL;
struct pkg_conflict *conflict = NULL;
struct pkg_option *option = NULL;
struct pkg_file *file = NULL;
int i;
ATF_REQUIRE_EQ(EPKG_OK, pkg_new(&p, PKG_FILE));
ATF_REQUIRE(p != NULL);
ATF_REQUIRE_EQ(EPKG_OK, pkg_parse_manifest(p, manifest));
#if 0
ATF_REQUIRE(strcmp(pkg_get(p, PKG_NAME), "foobar") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_VERSION), "0.3") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_ORIGIN), "foo/bar") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_COMMENT), "A dummy manifest") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_ARCH), "amd64") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_VERSION), "800500") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_WWW), "http://www.foobar.com") == 0);
ATF_REQUIRE(strcmp(pkg_get(p, PKG_MAINTAINER), "*****@*****.**") == 0);
#endif
i = 0;
while (pkg_deps(p, &dep) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depfoo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/foo") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "1.2") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_dep_name(dep), "depbar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_origin(dep), "dep/bar") == 0);
ATF_REQUIRE(strcmp(pkg_dep_version(dep), "3.4") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
i = 0;
#if 0
while (pkg_conflicts(p, &conflict) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "foo-*") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_conflict_glob(conflict), "bar-*") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
#endif
i = 0;
while (pkg_options(p, &option) == EPKG_OK) {
if (i == 0) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "foo") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "true") == 0);
} else if (i == 1) {
ATF_REQUIRE(strcmp(pkg_option_opt(option), "bar") == 0);
ATF_REQUIRE(strcmp(pkg_option_value(option), "false") == 0);
}
i++;
}
ATF_REQUIRE(i == 2);
ATF_REQUIRE(pkg_files(p, &file) == EPKG_OK);
ATF_REQUIRE(strcmp(pkg_file_path(file), "/usr/local/bin/foo") ==
0);
#if 0
ATF_REQUIRE(strcmp(pkg_file_sha256(file),
"01ba4719c80b6fe911b091a7c05124b64eeece964e09c058ef8f9805daca546b")
== 0);
#endif
pkg_free(p);
/* p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest1) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest2) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest3) == EPKG_FATAL);
pkg_free(p);
p = NULL;
ATF_REQUIRE(pkg_new(&p, PKG_FILE) == EPKG_OK);
ATF_REQUIRE(pkg_parse_manifest(p, wrong_manifest4) == EPKG_FATAL);
pkg_free(p);
*/
}
int
pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg)
{
struct pkg **deps;
struct pkg_file **files;
struct pkg_conflict **conflicts;
struct pkg_script **scripts;
struct pkg_option **options;
sqlite3 *s;
sqlite3_stmt *stmt_pkg = NULL;
sqlite3_stmt *stmt_sel_pkg = NULL;
sqlite3_stmt *stmt_dep = NULL;
sqlite3_stmt *stmt_conflict = NULL;
sqlite3_stmt *stmt_file = NULL;
sqlite3_stmt *stmt_script = NULL;
sqlite3_stmt *stmt_option = NULL;
sqlite3_stmt *stmt_dirs = NULL;
int i;
int ret;
int retcode = EPKG_OK;
const char *path;
int64_t package_id;
char *errmsg;
const char sql_begin[] = "BEGIN TRANSACTION;";
const char sql_pkg[] = ""
"INSERT INTO pkg_mtree( "
"origin, name, version, comment, desc, mtree, message, arch, "
"osversion, maintainer, www, prefix, flatsize) "
"VALUES( ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13);";
const char sql_sel_pkg[] = ""
"SELECT id FROM packages "
"WHERE origin = ?1;";
const char sql_dep[] = ""
"INSERT INTO deps (origin, name, version, package_id) "
"VALUES (?1, ?2, ?3, ?4);";
const char sql_conflict[] = ""
"INSERT INTO conflicts (name, package_id) "
"VALUES (?1, ?2);";
const char sql_file[] = ""
"INSERT INTO files (path, sha256, package_id) "
"VALUES (?1, ?2, ?3);";
const char sql_script[] = ""
"INSERT INTO scripts (script, type, package_id) "
"VALUES (?1, ?2, ?3);";
const char sql_option[] = ""
"INSERT INTO options (option, value, package_id) "
"VALUES (?1, ?2, ?3);";
const char sql_dir[] = ""
"INSERT INTO pkg_dirs(origin, path) "
"VALUES (?1, ?2);";
if (pkgdb_has_flag(db, PKGDB_FLAG_IN_FLIGHT)) {
pkg_error_set(EPKG_FATAL, "tried to register a package with an in-flight SQL command");
return (EPKG_FATAL);
}
s = db->sqlite;
if (sqlite3_exec(s, sql_begin, NULL, NULL, &errmsg) != SQLITE_OK) {
pkg_error_set(EPKG_FATAL, "sqlite: %s", errmsg);
sqlite3_free(errmsg);
return (EPKG_FATAL);
}
PKGDB_SET_FLAG(db, PKGDB_FLAG_IN_FLIGHT);
/*
* Insert package record
*/
if (sqlite3_prepare_v2(s, sql_pkg, -1, &stmt_pkg, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_bind_text(stmt_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 2, pkg_get(pkg, PKG_NAME), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 3, pkg_get(pkg, PKG_VERSION), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 4, pkg_get(pkg, PKG_COMMENT), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 5, pkg_get(pkg, PKG_DESC), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 6, pkg_get(pkg, PKG_MTREE), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 7, pkg_get(pkg, PKG_MESSAGE), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 8, pkg_get(pkg, PKG_ARCH), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 9, pkg_get(pkg, PKG_OSVERSION), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 10, pkg_get(pkg, PKG_MAINTAINER), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 11, pkg_get(pkg, PKG_WWW), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 12, pkg_get(pkg, PKG_PREFIX), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_pkg, 13, pkg_flatsize(pkg));
if ((ret = sqlite3_step(stmt_pkg)) != SQLITE_DONE) {
if ( ret == SQLITE_CONSTRAINT)
retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "
"pkg with %s", pkg_get(pkg, PKG_ORIGIN));
else
retcode = ERROR_SQLITE(s);
goto cleanup;
}
/*
* Get the generated package_id
*/
if (sqlite3_prepare_v2(s, sql_sel_pkg, -1, &stmt_sel_pkg, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_bind_text(stmt_sel_pkg, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
ret = sqlite3_step(stmt_sel_pkg);
if (ret == SQLITE_ROW) {
package_id = sqlite3_column_int64(stmt_sel_pkg, 0);
ret = SQLITE_DONE;
} else {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
/*
* Insert dependencies list
*/
if (sqlite3_prepare_v2(s, sql_dep, -1, &stmt_dep, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
deps = pkg_deps(pkg);
for (i = 0; deps[i] != NULL; i++) {
sqlite3_bind_text(stmt_dep, 1, pkg_get(deps[i], PKG_ORIGIN), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_dep, 2, pkg_get(deps[i], PKG_NAME), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_dep, 3, pkg_get(deps[i], PKG_VERSION), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_dep, 4, package_id);
if ((ret = sqlite3_step(stmt_dep)) != SQLITE_DONE) {
if ( ret == SQLITE_CONSTRAINT)
retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "
"deps with %s", pkg_get(deps[i], PKG_ORIGIN));
else
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_reset(stmt_dep);
}
/*
* Insert conflicts list
*/
if (sqlite3_prepare_v2(s, sql_conflict, -1, &stmt_conflict, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
conflicts = pkg_conflicts(pkg);
for (i = 0; conflicts[i] != NULL; i++) {
sqlite3_bind_text(stmt_conflict, 1, pkg_conflict_glob(conflicts[i]), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_conflict, 2, package_id);
if ((ret = sqlite3_step(stmt_conflict)) != SQLITE_DONE) {
if ( ret == SQLITE_CONSTRAINT)
retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "
"conflicts with %s", pkg_conflict_glob(conflicts[i]));
else
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_reset(stmt_conflict);
}
/*
* Insert file
* and dirs
*/
if (sqlite3_prepare_v2(s, sql_file, -1, &stmt_file, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
if (sqlite3_prepare_v2(s, sql_dir, -1, &stmt_dirs, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
files = pkg_files(pkg);
for (i = 0; files[i] != NULL; i++) {
path = pkg_file_path(files[i]);
if (path[strlen(path) - 1 ] != '/') {
sqlite3_bind_text(stmt_file, 1, pkg_file_path(files[i]), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_file, 2, pkg_file_sha256(files[i]), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_file, 3, package_id);
if ((ret = sqlite3_step(stmt_file)) != SQLITE_DONE) {
if ( ret == SQLITE_CONSTRAINT)
retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "
"path with %s", pkg_file_path(files[i]));
else
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_reset(stmt_file);
} else {
sqlite3_bind_text(stmt_dirs, 1, pkg_get(pkg, PKG_ORIGIN), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_dirs, 2, pkg_file_path(files[i]), -1, SQLITE_STATIC);
if ((ret = sqlite3_step(stmt_dirs)) != SQLITE_DONE) {
if ( ret == SQLITE_CONSTRAINT)
retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "
"dirs with %s", pkg_file_path(files[i]));
else
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_reset(stmt_dirs);
}
}
/*
* Insert scripts
*/
if (sqlite3_prepare_v2(s, sql_script, -1, &stmt_script, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
scripts = pkg_scripts(pkg);
for (i = 0; scripts[i] != NULL; i++) {
sqlite3_bind_text(stmt_script, 1, pkg_script_data(scripts[i]), -1, SQLITE_STATIC);
sqlite3_bind_int(stmt_script, 2, pkg_script_type(scripts[i]));
sqlite3_bind_int64(stmt_script, 3, package_id);
if (sqlite3_step(stmt_script) != SQLITE_DONE) {
if ( ret == SQLITE_CONSTRAINT)
retcode = pkg_error_set(EPKG_FATAL, "constraint violation on "
"scripts with %s", pkg_script_data(scripts[i]));
else
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_reset(stmt_script);
}
/*
* Insert options
*/
options = pkg_options(pkg);
if (sqlite3_prepare_v2(s, sql_option, -1, &stmt_option, NULL) != SQLITE_OK) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
for (i = 0; options[i] != NULL; i++) {
sqlite3_bind_text(stmt_option, 1, pkg_option_opt(options[i]), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_option, 2, pkg_option_value(options[i]), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_option, 3, package_id);
if (sqlite3_step(stmt_option) != SQLITE_DONE) {
retcode = ERROR_SQLITE(s);
goto cleanup;
}
sqlite3_reset(stmt_option);
}
cleanup:
if (stmt_pkg != NULL)
sqlite3_finalize(stmt_pkg);
if (stmt_sel_pkg != NULL)
sqlite3_finalize(stmt_sel_pkg);
if (stmt_dep != NULL)
sqlite3_finalize(stmt_dep);
if (stmt_conflict != NULL)
sqlite3_finalize(stmt_conflict);
if (stmt_file != NULL)
sqlite3_finalize(stmt_file);
if (stmt_script != NULL)
sqlite3_finalize(stmt_script);
if (stmt_option != NULL)
sqlite3_finalize(stmt_option);
if (stmt_dirs != NULL)
sqlite3_finalize(stmt_dirs);
return (retcode);
}
