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); }