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); }
static int pkg_create_from_dir(struct pkg *pkg, const char *root, struct packing *pkg_archive) { char fpath[MAXPATHLEN]; struct pkg_file **files; struct pkg_script **scripts; char *m; int i; const char *scriptname = NULL; pkg_emit_manifest(pkg, &m); packing_append_buffer(pkg_archive, m, "+MANIFEST", strlen(m)); free(m); packing_append_buffer(pkg_archive, pkg_get(pkg, PKG_DESC), "+DESC", strlen(pkg_get(pkg, PKG_DESC))); packing_append_buffer(pkg_archive, pkg_get(pkg, PKG_MTREE), "+MTREE_DIRS", strlen(pkg_get(pkg, PKG_MTREE))); if ((scripts = pkg_scripts(pkg)) != NULL) { for (i = 0; scripts[i] != NULL; i++) { switch (pkg_script_type(scripts[i])) { case PKG_SCRIPT_PRE_INSTALL: scriptname = "+PRE_INSTALL"; break; case PKG_SCRIPT_POST_INSTALL: scriptname = "+POST_INSTALL"; break; case PKG_SCRIPT_INSTALL: scriptname = "+INSTALL"; break; case PKG_SCRIPT_PRE_DEINSTALL: scriptname = "+PRE_DEINSTALL"; break; case PKG_SCRIPT_POST_DEINSTALL: scriptname = "+POST_DEINSTALL"; break; case PKG_SCRIPT_DEINSTALL: scriptname = "+DEINSTALL"; break; case PKG_SCRIPT_PRE_UPGRADE: scriptname = "+PRE_UPGRADE"; break; case PKG_SCRIPT_POST_UPGRADE: scriptname = "+POST_UPGRADE"; break; case PKG_SCRIPT_UPGRADE: scriptname = "+UPGRADE"; break; } packing_append_buffer(pkg_archive, pkg_script_data(scripts[i]), scriptname, strlen(pkg_script_data(scripts[i]))); } } if ((files = pkg_files(pkg)) != NULL) { for (i = 0; files[i] != NULL; i++) { if (root != NULL) snprintf(fpath, sizeof(MAXPATHLEN), "%s%s", root, pkg_file_path(files[i])); else strlcpy(fpath, pkg_file_path(files[i]), MAXPATHLEN); packing_append_file(pkg_archive, fpath, pkg_file_path(files[i])); } } return (EPKG_OK); }
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); }