static void installInitWrappers(void){
sqlite3_mutex_methods mutexmethods = {
wrMutexInit, wrMutexEnd, wrMutexAlloc,
wrMutexFree, wrMutexEnter, wrMutexTry,
wrMutexLeave, wrMutexHeld, wrMutexNotheld
};
sqlite3_pcache_methods pcachemethods = {
0,
wrPCacheInit, wrPCacheShutdown, wrPCacheCreate,
wrPCacheCachesize, wrPCachePagecount, wrPCacheFetch,
wrPCacheUnpin, wrPCacheRekey, wrPCacheTruncate,
wrPCacheDestroy
};
sqlite3_mem_methods memmethods = {
wrMemMalloc, wrMemFree, wrMemRealloc,
wrMemSize, wrMemRoundup, wrMemInit,
wrMemShutdown,
0
};
memset(&wrapped, 0, sizeof(wrapped));
sqlite3_shutdown();
sqlite3_config(SQLITE_CONFIG_GETMUTEX, &wrapped.mutex);
sqlite3_config(SQLITE_CONFIG_GETMALLOC, &wrapped.mem);
sqlite3_config(SQLITE_CONFIG_GETPCACHE, &wrapped.pcache);
sqlite3_config(SQLITE_CONFIG_MUTEX, &mutexmethods);
sqlite3_config(SQLITE_CONFIG_MALLOC, &memmethods);
sqlite3_config(SQLITE_CONFIG_PCACHE, &pcachemethods);
}
static void
jfs_destroy(void *arg)
{
int rc;
/* stop all reads */
jfs_pool_destroy(jfs_read_pool);
/* let writes propogate */
jfs_pool_wait(jfs_write_pool);
jfs_pool_destroy(jfs_write_pool);
rc = sqlite3_shutdown();
if(rc != SQLITE_OK) {
log_error("SQLITE shutdown FAILED!!!\n");
}
jfs_datapath_cache_destroy();
jfs_key_cache_destroy();
jfs_meta_cache_destroy();
jfs_dynamic_hierarchy_destroy();
free(joinfs_context.querypath);
free(joinfs_context.mountpath);
free(joinfs_context.logpath);
free(joinfs_context.dbpath);
log_msg("joinFS shutdown completed successfully.\n", arg);
log_destroy();
}
int main( int argc, char **argv )
{
char *file = ""; /* default to temp db */
const char *data = NULL;
sqlite3 *db = NULL;
sqlite3_stmt *stmt = NULL;
int rc = 0;
if ( argc > 1 )
file = argv[1];
sqlite3_initialize( );
rc = sqlite3_open_v2( file, &db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL );
if ( rc != SQLITE_OK) {
sqlite3_close( db );
exit( -1 );
}
rc = sqlite3_prepare_v2( db, "SELECT str FROM tbl ORDER BY 1", -1, &stmt, NULL );
if ( rc != SQLITE_OK) exit( -1 );
while( sqlite3_step( stmt ) == SQLITE_ROW ) {
data = (const char*)sqlite3_column_text( stmt, 0 );
printf( "%s\n", data ? data : "[NULL]" );
}
sqlite3_finalize( stmt );
sqlite3_close( db );
sqlite3_shutdown( );
}
int
CSQLiteDE::CloseDatabase(bool bNoIndexes)
{
int TblIdx;
int Rslt = 0;
tsDEStmSQL *pStms;
pStms = m_StmSQL;
if(m_pDB != NULL)
{
if(!bNoIndexes)
{
for(TblIdx = 0; TblIdx < 4; TblIdx++,pStms++)
{
if(pStms->pPrepInsert == NULL)
continue;
sqlite3_finalize(pStms->pPrepInsert);
pStms->pPrepInsert = NULL;
}
}
Rslt = sqlite3_close_v2(m_pDB);
sqlite3_shutdown();
m_pDB = NULL;
}
return(Rslt);
}
/*
** COMMAND: sqlite3
**
** Usage: %fossil sqlite3 ?DATABASE? ?OPTIONS?
**
** Run the standalone sqlite3 command-line shell on DATABASE with OPTIONS.
** If DATABASE is omitted, then the repository that serves the working
** directory is opened.
**
** WARNING: Careless use of this command can corrupt a Fossil repository
** in ways that are unrecoverable. Be sure you know what you are doing before
** running any SQL commands that modifies the repository database.
*/
void sqlite3_cmd(void){
extern int sqlite3_shell(int, char**);
db_find_and_open_repository(OPEN_ANY_SCHEMA, 0);
db_close(1);
sqlite3_shutdown();
sqlite3_shell(g.argc-1, g.argv+1);
}
int main(int argc, char *argv[]) {
sqlite3 *db = NULL;
int res = 0;
if (argc != 2) {
fprintf(stderr, "Usage: %s <database name>\n", argv[0]);
exit(EXIT_FAILURE);
}
// Inizializzazione della libreria
if (sqlite3_initialize() != SQLITE_OK) {
fprintf(stderr, "Err. Unable to initialize the library\n");
exit(EXIT_FAILURE);
}
// Creazione della connessione al database
res = sqlite3_open(argv[1], &db);
if (res != SQLITE_OK) {
fprintf(stderr, "Err. can't create database: %s\n", sqlite3_errmsg(db));
sqlite3_close(db);
exit(EXIT_FAILURE);
}
printf("Library \'%s\' successfully initialized..\n", sqlite3_libversion());
printf("Database \'%s\' successfully created.\n", argv[1]);
// Close database connection
if (sqlite3_close(db) == SQLITE_OK)
puts("Closed database connection");
sqlite3_shutdown();
return(EXIT_SUCCESS);
}
static void hb_sqlt3dd_exit( void * cargo )
{
HB_SYMBOL_UNUSED( cargo );
#if SQLITE_VERSION_NUMBER >= 3006000
sqlite3_shutdown();
#endif
}
/*
* create_db --
* Creates the database schema.
*/
static int
create_db(sqlite3 *db)
{
const char *sqlstr = NULL;
char *schemasql;
char *errmsg = NULL;
/*------------------------ Create the tables------------------------------*/
#if NOTYET
sqlite3_exec(db, "PRAGMA journal_mode = WAL", NULL, NULL, NULL);
#else
sqlite3_exec(db, "PRAGMA journal_mode = DELETE", NULL, NULL, NULL);
#endif
schemasql = sqlite3_mprintf("PRAGMA user_version = %d",
APROPOS_SCHEMA_VERSION);
sqlite3_exec(db, schemasql, NULL, NULL, &errmsg);
if (errmsg != NULL)
goto out;
sqlite3_free(schemasql);
sqlstr =
//mandb
"CREATE VIRTUAL TABLE mandb USING fts4(section, name, "
"name_desc, desc, lib, return_vals, env, files, "
"exit_status, diagnostics, errors, md5_hash UNIQUE, machine, "
"compress=zip, uncompress=unzip, tokenize=porter); "
//mandb_meta
"CREATE TABLE IF NOT EXISTS mandb_meta(device, inode, mtime, "
"file UNIQUE, md5_hash UNIQUE, id INTEGER PRIMARY KEY); "
//mandb_links
"CREATE TABLE IF NOT EXISTS mandb_links(link, target, section, "
"machine, md5_hash); ";
sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg);
if (errmsg != NULL)
goto out;
sqlstr =
"CREATE INDEX IF NOT EXISTS index_mandb_links ON mandb_links "
"(link); "
"CREATE INDEX IF NOT EXISTS index_mandb_meta_dev ON mandb_meta "
"(device, inode); "
"CREATE INDEX IF NOT EXISTS index_mandb_links_md5 ON mandb_links "
"(md5_hash);";
sqlite3_exec(db, sqlstr, NULL, NULL, &errmsg);
if (errmsg != NULL)
goto out;
return 0;
out:
warnx("%s", errmsg);
free(errmsg);
sqlite3_close(db);
sqlite3_shutdown();
return -1;
}
void SqliteFinalize(TPerfTestMode aMode)
{
if(aMode == EPerfTestSqliteSqlMode)
{
(void)sqlite3_enable_shared_cache(0);
sqlite3_soft_heap_limit(0);
}
sqlite3_shutdown();
}
CSQLiteDE::~CSQLiteDE(void)
{
if(m_pDB != NULL)
{
sqlite3_close_v2(m_pDB);
sqlite3_shutdown();
m_pDB = NULL;
}
}
SWIGEXPORT jint JNICALL Java_com_almworks_sqlite4java__1SQLiteSwiggedJNI_sqlite3_1shutdown(JNIEnv *jenv, jclass jcls) {
jint jresult = 0 ;
int result;
(void)jenv;
(void)jcls;
result = (int)sqlite3_shutdown();
jresult = (jint)result;
return jresult;
}
ULONG
SqlShutdown(
VOID
)
{
ULONG Status;
Status = sqlite3_shutdown();
return Status;
}
EXPORTED int sqldb_done(void)
{
if (!--sqldb_active) {
sqlite3_shutdown();
/* XXX - report the problems? */
assert(!open_sqldbs);
}
return 0;
}
int
pkgdb_repo_open(const char *repodb, bool force, sqlite3 **sqlite,
bool *incremental)
{
bool db_not_open;
int reposcver;
int retcode = EPKG_OK;
if (access(repodb, R_OK) == 0)
*incremental = true;
else
*incremental = false;
sqlite3_initialize();
db_not_open = true;
while (db_not_open) {
if (sqlite3_open(repodb, sqlite) != SQLITE_OK) {
sqlite3_shutdown();
return (EPKG_FATAL);
}
db_not_open = false;
/* If the schema is too old, or we're forcing a full
update, then we cannot do an incremental update.
Delete the existing repo, and promote this to a
full update */
if (!*incremental)
continue;
retcode = get_repo_user_version(*sqlite, "main", &reposcver);
if (retcode != EPKG_OK)
return (EPKG_FATAL);
if (force || reposcver != REPO_SCHEMA_VERSION) {
if (reposcver != REPO_SCHEMA_VERSION)
pkg_emit_error("re-creating repo to upgrade schema version "
"from %d to %d", reposcver,
REPO_SCHEMA_VERSION);
sqlite3_close(*sqlite);
unlink(repodb);
*incremental = false;
db_not_open = true;
}
}
sqlite3_create_function(*sqlite, "file_exists", 2, SQLITE_ANY, NULL,
file_exists, NULL, NULL);
if (!*incremental) {
retcode = sql_exec(*sqlite, initsql, REPO_SCHEMA_VERSION);
if (retcode != EPKG_OK)
return (retcode);
}
return (EPKG_OK);
}
void KprDBDispose(KprDB self)
{
if (self) {
if (self->data) {
sqlite3_close(self->data);
gDBCount--;
if (!gDBCount)
sqlite3_shutdown();
}
FskInstrumentedItemDispose(self);
KprMemPtrDispose(self);
}
}
sqlite3 *
init_db()
{
sqlite3 *db;
int rc = 0;
sqlite3_initialize();
rc = sqlite3_open_v2(DBPATH, &db,
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
if (rc != SQLITE_OK) {
warnx("%s", sqlite3_errmsg(db));
sqlite3_shutdown();
exit(EXIT_FAILURE);
}
sqlite3_extended_result_codes(db, 1);
/* Register the zip and unzip functions for FTS compression */
rc = sqlite3_create_function(db, "zip", 1, SQLITE_ANY, NULL,
zip, NULL, NULL);
if (rc != SQLITE_OK) {
sqlite3_close(db);
sqlite3_shutdown();
errx(EXIT_FAILURE, "Unable to register function: compress");
}
rc = sqlite3_create_function(db, "unzip", 1, SQLITE_ANY, NULL,
unzip, NULL, NULL);
if (rc != SQLITE_OK) {
sqlite3_close(db);
sqlite3_shutdown();
errx(EXIT_FAILURE, "Unable to register function: uncompress");
}
return db;
}
int main(void) {
/* Determina l'opzione di configurazione relativa al multithreading, che
non necessita peraltro di ulteriore argomento */
sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
// Inizializzazione della libreria
if (sqlite3_initialize() == SQLITE_OK)
printf("Library: \'%s\' initialized\n", sqlite3_libversion());
// Rilascio delle risorse
if (sqlite3_shutdown() == SQLITE_OK)
printf("Library: freed\n");
return(EXIT_SUCCESS);
}
bool Utility::setThreadMode(int mode)
{
#if (SQLITE_THREADSAFE != 0)
if (SQLITE_OK == sqlite3_shutdown())
{
if (SQLITE_OK == sqlite3_config(mode))
{
_threadMode = mode;
if (SQLITE_OK == sqlite3_initialize())
return true;
}
sqlite3_initialize();
}
#endif
return false;
}
void Shutdown()
{
EAW_ASSERT_MSG( (GetWebKitStatus() == kWebKitStatusActive), "Init() needs to have been called or Shutdown() was called twice");
SET_AUTO_COLLECTOR_STACK_BASE(); // 9/4/09 - CSidhall - Added to get approximate stack base
SetWebKitStatus(kWebKitStatusShuttingDown);
WebCore::pageCache()->setCapacity(0);
WebCore::pageCache()->releaseAutoreleasedPagesNow();
#if ENABLE(INSPECTOR)
WebCore::InspectorSettingsEA::finalize(); // This saves inspector settings
#endif
WebCore::PageGroup::closeLocalStorage();
if(WebCore::PageGroup* pageGroup = WebCore::PageGroup::pageGroup(kDefaultPageGroupName))
pageGroup->removeUserStyleSheetsFromWorld(WebCore::mainThreadNormalWorld());
WTF::waitForAllThreadsCompletion(); // Needed because if dll is freed before this, it would crash
// These are statics but we want to have them destruct so that any open file handles they hold are released.
#if ENABLE(OFFLINE_WEB_APPLICATIONS)
WebCore::cacheStorage().~ApplicationCacheStorage();
#endif
#if ENABLE(DATABASE)
WebCore::DatabaseTracker::tracker().~DatabaseTracker();
// This is so that the local sqlite3_os_end is called on exit.
// Shutdown before the thread system shutdown.
sqlite3_shutdown();
#endif
if(ownsSocketTransportHandler)
{
spSocketTransportHandler->Shutdown();
spSocketTransportHandler = NULL;
}
WebCore::ResourceHandleManager::finalize(); // Needed to free DirtySDK related resources
EA::WebKit::GetTextSystem()->Shutdown(); // Needed to free EAText related resources
#if ENABLE(EATEXT_IN_DLL)
EA::WebKit::ShutdownFontSystem();
#endif
EA::WebKit::GetThreadSystem()->Shutdown(); // Needed to free any thread related resources. Call at last since some timer stuff uses it to query main thread.
SetWebKitStatus(kWebKitStatusInactive);
}
int
duf_sqlite_close( void )
{
int r3 = 0;
/* */ DEBUG_START( );
if ( pDb )
r3 = sqlite3_close_v2( pDb );
pDb = NULL;
DUF_TRACE( action, 0, "DB Close %s (%d)", r3 == SQLITE_OK ? "OK" : "FAIL", r3 );
r3 = sqlite3_shutdown( );
DUF_TRACE( action, 0, "DB Shutdown %s (%d)", r3 == SQLITE_OK ? "OK" : "FAIL", r3 );
/* */ DEBUG_END( );
return ( r3 );
}
int main(int argc, char **argv)
{
char *pError;
int nResponse;
// intialise the SQLite library
sqlite3_initialize( );
// open the database
nResponse = sqlite3_open_v2( "KnowledgeBase.sl3", &knowledgeDB, SQLITE_OPEN_READWRITE, NULL );
// if it didn't open OK, shutdown and exit
if ( nResponse != SQLITE_OK) {
printf("%s Couldn't open KnowledgeBase database.\n", argv[0]);
sqlite3_close( knowledgeDB );
exit (-1);
}
else
printf("Opened KnowledgeBase database OK\n");
nResponse = sqlite3_exec(knowledgeDB, "DELETE FROM facts", NULL, NULL, &pError);
if ( nResponse != SQLITE_OK ) {
printf("Couldn't delete old facts.\n");
return (-1);
}
else
printf("Zapped old facts.\n");
ReadInFactsFile();
// shut down and exit
sqlite3_close( knowledgeDB );
sqlite3_shutdown( );
return (0);
} // end of main
int main(int argc, char **argv)
{
int nResponse;
char strSearchPhrase[200];
// did we get a source phrase to work with?
if (argc != 2) {
printf("Usage: %s SourcePhrase <enter>\n", argv[0]);
exit(1);
}
// intialise the SQLite library
sqlite3_initialize( );
// open the database
nResponse = sqlite3_open_v2( "WordsDb.sl3", &WordsDb, SQLITE_OPEN_READWRITE, NULL );
// if it didn't open OK, shutdown and exit
if ( nResponse != SQLITE_OK) {
printf("%s Couldn't open database.\n", argv[0]);
sqlite3_close( WordsDb );
exit (-1);
}
// take a working copy of the text to search for anagrams for
strcpy(strSearchPhrase, argv[1]);
// look for anagrams
StartAnagramSearch( strSearchPhrase );
// shout down and exit
sqlite3_close( WordsDb );
sqlite3_shutdown( );
return (0);
} // end of main
/*
* run_query --
* Performs the searches for the keywords entered by the user.
* The 2nd param: snippet_args is an array of strings providing values for the
* last three parameters to the snippet function of sqlite. (Look at the docs).
* The 3rd param: args contains rest of the search parameters. Look at
* arpopos-utils.h for the description of individual fields.
*
*/
int
run_query(sqlite3 *db, const char *snippet_args[3], query_args *args)
{
const char *default_snippet_args[3];
char *section_clause = NULL;
char *limit_clause = NULL;
char *machine_clause = NULL;
char *query;
const char *section;
char *name;
const char *name_desc;
const char *machine;
const char *snippet;
const char *name_temp;
char *slash_ptr;
char *m = NULL;
int rc;
inverse_document_frequency idf = {0, 0};
sqlite3_stmt *stmt;
if (args->machine)
easprintf(&machine_clause, "AND machine = \'%s\' ", args->machine);
/* Register the rank function */
rc = sqlite3_create_function(db, "rank_func", 1, SQLITE_ANY, (void *)&idf,
rank_func, NULL, NULL);
if (rc != SQLITE_OK) {
warnx("Unable to register the ranking function: %s",
sqlite3_errmsg(db));
sqlite3_close(db);
sqlite3_shutdown();
exit(EXIT_FAILURE);
}
/* We want to build a query of the form: "select x,y,z from mandb where
* mandb match :query [AND (section LIKE '1' OR section LIKE '2' OR...)]
* ORDER BY rank DESC..."
* NOTES: 1. The portion in square brackets is optional, it will be there
* only if the user has specified an option on the command line to search in
* one or more specific sections.
* 2. I am using LIKE operator because '=' or IN operators do not seem to be
* working with the compression option enabled.
*/
if (args->sec_nums) {
char *temp;
int i;
for (i = 0; i < SECMAX; i++) {
if (args->sec_nums[i] == 0)
continue;
easprintf(&temp, " OR section = \'%d\'", i + 1);
if (section_clause) {
concat(§ion_clause, temp);
free(temp);
} else {
section_clause = temp;
}
}
if (section_clause) {
/*
* At least one section requested, add glue for query.
*/
temp = section_clause;
/* Skip " OR " before first term. */
easprintf(§ion_clause, " AND (%s)", temp + 4);
free(temp);
}
}
if (args->nrec >= 0) {
/* Use the provided number of records and offset */
easprintf(&limit_clause, " LIMIT %d OFFSET %d",
args->nrec, args->offset);
}
if (snippet_args == NULL) {
default_snippet_args[0] = "";
default_snippet_args[1] = "";
default_snippet_args[2] = "...";
snippet_args = default_snippet_args;
}
query = sqlite3_mprintf("SELECT section, name, name_desc, machine,"
" snippet(mandb, %Q, %Q, %Q, -1, 40 ),"
" rank_func(matchinfo(mandb, \"pclxn\")) AS rank"
" FROM mandb"
" WHERE mandb MATCH %Q %s "
"%s"
" ORDER BY rank DESC"
"%s",
snippet_args[0], snippet_args[1], snippet_args[2], args->search_str,
machine_clause ? machine_clause : "",
section_clause ? section_clause : "",
limit_clause ? limit_clause : "");
free(machine_clause);
free(section_clause);
free(limit_clause);
if (query == NULL) {
*args->errmsg = estrdup("malloc failed");
return -1;
}
rc = sqlite3_prepare_v2(db, query, -1, &stmt, NULL);
if (rc == SQLITE_IOERR) {
warnx("Corrupt database. Please rerun makemandb");
sqlite3_free(query);
return -1;
} else if (rc != SQLITE_OK) {
warnx("%s", sqlite3_errmsg(db));
sqlite3_free(query);
return -1;
}
while (sqlite3_step(stmt) == SQLITE_ROW) {
section = (const char *) sqlite3_column_text(stmt, 0);
name_temp = (const char *) sqlite3_column_text(stmt, 1);
name_desc = (const char *) sqlite3_column_text(stmt, 2);
machine = (const char *) sqlite3_column_text(stmt, 3);
snippet = (const char *) sqlite3_column_text(stmt, 4);
if ((slash_ptr = strrchr(name_temp, '/')) != NULL)
name_temp = slash_ptr + 1;
if (machine && machine[0]) {
m = estrdup(machine);
easprintf(&name, "%s/%s", lower(m),
name_temp);
free(m);
} else {
name = estrdup((const char *) sqlite3_column_text(stmt, 1));
}
(args->callback)(args->callback_data, section, name, name_desc, snippet,
strlen(snippet));
free(name);
}
sqlite3_finalize(stmt);
sqlite3_free(query);
return *(args->errmsg) == NULL ? 0 : -1;
}
/* init_db --
* Prepare the database. Register the compress/uncompress functions and the
* stopword tokenizer.
* db_flag specifies the mode in which to open the database. 3 options are
* available:
* 1. DB_READONLY: Open in READONLY mode. An error if db does not exist.
* 2. DB_READWRITE: Open in read-write mode. An error if db does not exist.
* 3. DB_CREATE: Open in read-write mode. It will try to create the db if
* it does not exist already.
* RETURN VALUES:
* The function will return NULL in case the db does not exist and DB_CREATE
* was not specified. And in case DB_CREATE was specified and yet NULL is
* returned, then there was some other error.
* In normal cases the function should return a handle to the db.
*/
sqlite3 *
init_db(int db_flag, const char *manconf)
{
sqlite3 *db = NULL;
sqlite3_stmt *stmt;
struct stat sb;
int rc;
int create_db_flag = 0;
char *dbpath = get_dbpath(manconf);
if (dbpath == NULL)
errx(EXIT_FAILURE, "_mandb entry not found in man.conf");
/* Check if the database exists or not */
if (!(stat(dbpath, &sb) == 0 && S_ISREG(sb.st_mode))) {
/* Database does not exist, check if DB_CREATE was specified, and set
* flag to create the database schema
*/
if (db_flag != (MANDB_CREATE)) {
warnx("Missing apropos database. "
"Please run makemandb to create it.");
return NULL;
}
create_db_flag = 1;
}
/* Now initialize the database connection */
sqlite3_initialize();
rc = sqlite3_open_v2(dbpath, &db, db_flag, NULL);
if (rc != SQLITE_OK) {
warnx("%s", sqlite3_errmsg(db));
sqlite3_shutdown();
return NULL;
}
if (create_db_flag && create_db(db) < 0) {
warnx("%s", "Unable to create database schema");
goto error;
}
rc = sqlite3_prepare_v2(db, "PRAGMA user_version", -1, &stmt, NULL);
if (rc != SQLITE_OK) {
warnx("Unable to query schema version: %s",
sqlite3_errmsg(db));
goto error;
}
if (sqlite3_step(stmt) != SQLITE_ROW) {
sqlite3_finalize(stmt);
warnx("Unable to query schema version: %s",
sqlite3_errmsg(db));
goto error;
}
if (sqlite3_column_int(stmt, 0) != APROPOS_SCHEMA_VERSION) {
sqlite3_finalize(stmt);
warnx("Incorrect schema version found. "
"Please run makemandb -f.");
goto error;
}
sqlite3_finalize(stmt);
sqlite3_extended_result_codes(db, 1);
/* Register the zip and unzip functions for FTS compression */
rc = sqlite3_create_function(db, "zip", 1, SQLITE_ANY, NULL, zip, NULL, NULL);
if (rc != SQLITE_OK) {
warnx("Unable to register function: compress: %s",
sqlite3_errmsg(db));
goto error;
}
rc = sqlite3_create_function(db, "unzip", 1, SQLITE_ANY, NULL,
unzip, NULL, NULL);
if (rc != SQLITE_OK) {
warnx("Unable to register function: uncompress: %s",
sqlite3_errmsg(db));
goto error;
}
return db;
error:
sqlite3_close(db);
sqlite3_shutdown();
return NULL;
}
void
close_db(sqlite3 *db)
{
sqlite3_close(db);
sqlite3_shutdown();
}
int
pkg_update(const char *name, const char *packagesite, bool force)
{
char url[MAXPATHLEN];
struct archive *a = NULL;
struct archive_entry *ae = NULL;
char repofile[MAXPATHLEN];
char repofile_unchecked[MAXPATHLEN];
char tmp[MAXPATHLEN];
const char *dbdir = NULL;
const char *repokey;
unsigned char *sig = NULL;
int siglen = 0;
int fd, rc = EPKG_FATAL, ret;
struct stat st;
time_t t = 0;
sqlite3 *sqlite;
char *archreq = NULL;
const char *myarch;
int64_t res;
const char *tmpdir;
snprintf(url, MAXPATHLEN, "%s/repo.txz", packagesite);
tmpdir = getenv("TMPDIR");
if (tmpdir == NULL)
tmpdir = "/tmp";
strlcpy(tmp, tmpdir, sizeof(tmp));
strlcat(tmp, "/repo.txz.XXXXXX", sizeof(tmp));
fd = mkstemp(tmp);
if (fd == -1) {
pkg_emit_error("Could not create temporary file %s, "
"aborting update.\n", tmp);
return (EPKG_FATAL);
}
if (pkg_config_string(PKG_CONFIG_DBDIR, &dbdir) != EPKG_OK) {
pkg_emit_error("Cant get dbdir config entry");
return (EPKG_FATAL);
}
snprintf(repofile, sizeof(repofile), "%s/%s.sqlite", dbdir, name);
if (force)
t = 0; /* Always fetch */
else {
if (stat(repofile, &st) != -1) {
t = st.st_mtime;
/* add 1 minute to the timestamp because
* repo.sqlite is always newer than repo.txz,
* 1 minute should be enough.
*/
t += 60;
}
}
rc = pkg_fetch_file_to_fd(url, fd, t);
close(fd);
if (rc != EPKG_OK) {
goto cleanup;
}
if (eaccess(repofile, W_OK) == -1) {
pkg_emit_error("Insufficient privilege to update %s\n",
repofile);
rc = EPKG_ENOACCESS;
goto cleanup;
}
a = archive_read_new();
archive_read_support_compression_all(a);
archive_read_support_format_tar(a);
archive_read_open_filename(a, tmp, 4096);
while (archive_read_next_header(a, &ae) == ARCHIVE_OK) {
if (strcmp(archive_entry_pathname(ae), "repo.sqlite") == 0) {
snprintf(repofile_unchecked, sizeof(repofile_unchecked),
"%s.unchecked", repofile);
archive_entry_set_pathname(ae, repofile_unchecked);
/*
* The repo should be owned by root and not writable
*/
archive_entry_set_uid(ae, 0);
archive_entry_set_gid(ae, 0);
archive_entry_set_perm(ae, 0644);
archive_read_extract(a, ae, EXTRACT_ARCHIVE_FLAGS);
}
if (strcmp(archive_entry_pathname(ae), "signature") == 0) {
siglen = archive_entry_size(ae);
sig = malloc(siglen);
archive_read_data(a, sig, siglen);
}
}
if (pkg_config_string(PKG_CONFIG_REPOKEY, &repokey) != EPKG_OK) {
free(sig);
return (EPKG_FATAL);
}
if (repokey != NULL) {
if (sig != NULL) {
ret = rsa_verify(repofile_unchecked, repokey,
sig, siglen - 1);
if (ret != EPKG_OK) {
pkg_emit_error("Invalid signature, "
"removing repository.\n");
unlink(repofile_unchecked);
free(sig);
rc = EPKG_FATAL;
goto cleanup;
}
free(sig);
} else {
pkg_emit_error("No signature found in the repository. "
"Can not validate against %s key.", repokey);
rc = EPKG_FATAL;
unlink(repofile_unchecked);
goto cleanup;
}
}
/* check is the repository is for valid architecture */
sqlite3_initialize();
if (sqlite3_open(repofile_unchecked, &sqlite) != SQLITE_OK) {
unlink(repofile_unchecked);
pkg_emit_error("Corrupted repository");
rc = EPKG_FATAL;
goto cleanup;
}
pkg_config_string(PKG_CONFIG_ABI, &myarch);
archreq = sqlite3_mprintf("select count(arch) from packages "
"where arch not GLOB '%q'", myarch);
if (get_pragma(sqlite, archreq, &res) != EPKG_OK) {
sqlite3_free(archreq);
pkg_emit_error("Unable to query repository");
rc = EPKG_FATAL;
sqlite3_close(sqlite);
goto cleanup;
}
if (res > 0) {
pkg_emit_error("At least one of the packages provided by"
"the repository is not compatible with your abi: %s",
myarch);
rc = EPKG_FATAL;
sqlite3_close(sqlite);
goto cleanup;
}
sqlite3_close(sqlite);
sqlite3_shutdown();
if (rename(repofile_unchecked, repofile) != 0) {
pkg_emit_errno("rename", "");
rc = EPKG_FATAL;
goto cleanup;
}
if ((rc = remote_add_indexes(name)) != EPKG_OK)
goto cleanup;
rc = EPKG_OK;
cleanup:
if (a != NULL)
archive_read_finish(a);
(void)unlink(tmp);
return (rc);
}
int
pkg_create_repo(char *path, bool force,
void (progress)(struct pkg *pkg, void *data), void *data)
{
FTS *fts = NULL;
struct thd_data thd_data;
int num_workers;
size_t len;
pthread_t *tids = NULL;
struct pkg_dep *dep = NULL;
struct pkg_category *category = NULL;
struct pkg_license *license = NULL;
struct pkg_option *option = NULL;
struct pkg_shlib *shlib = NULL;
sqlite3 *sqlite = NULL;
int64_t package_id;
char *errmsg = NULL;
int retcode = EPKG_OK;
int ret;
char *repopath[2];
char repodb[MAXPATHLEN + 1];
char repopack[MAXPATHLEN + 1];
struct archive *a = NULL;
struct archive_entry *ae = NULL;
if (!is_dir(path)) {
pkg_emit_error("%s is not a directory", path);
return (EPKG_FATAL);
}
repopath[0] = path;
repopath[1] = NULL;
len = sizeof(num_workers);
if (sysctlbyname("hw.ncpu", &num_workers, &len, NULL, 0) == -1)
num_workers = 6;
if ((fts = fts_open(repopath, FTS_PHYSICAL|FTS_NOCHDIR, NULL)) == NULL) {
pkg_emit_errno("fts_open", path);
retcode = EPKG_FATAL;
goto cleanup;
}
snprintf(repodb, sizeof(repodb), "%s/repo.sqlite", path);
snprintf(repopack, sizeof(repopack), "%s/repo.txz", path);
if (access(repopack, F_OK) == 0) {
a = archive_read_new();
archive_read_support_compression_all(a);
archive_read_support_format_tar(a);
ret = archive_read_open_filename(a, repopack, 4096);
if (ret != ARCHIVE_OK) {
/* if we can't unpack it it won't be useful for us */
unlink(repopack);
} else {
while (archive_read_next_header(a, &ae) == ARCHIVE_OK) {
if (!strcmp(archive_entry_pathname(ae),
"repo.sqlite")) {
archive_entry_set_pathname(ae, repodb);
archive_read_extract(a, ae,
EXTRACT_ARCHIVE_FLAGS);
break;
}
}
}
if (a != NULL)
archive_read_finish(a);
}
if ((retcode = initialize_repo(repodb, force, &sqlite)) != EPKG_OK)
goto cleanup;
if ((retcode = initialize_prepared_statements(sqlite)) != EPKG_OK)
goto cleanup;
thd_data.root_path = path;
thd_data.max_results = num_workers;
thd_data.num_results = 0;
thd_data.stop = false;
thd_data.fts = fts;
pthread_mutex_init(&thd_data.fts_m, NULL);
STAILQ_INIT(&thd_data.results);
thd_data.thd_finished = 0;
pthread_mutex_init(&thd_data.results_m, NULL);
pthread_cond_init(&thd_data.has_result, NULL);
pthread_cond_init(&thd_data.has_room, NULL);
/* Launch workers */
tids = calloc(num_workers, sizeof(pthread_t));
for (int i = 0; i < num_workers; i++) {
pthread_create(&tids[i], NULL, (void *)&read_pkg_file, &thd_data);
}
for (;;) {
struct pkg_result *r;
const char *name, *version, *origin, *comment, *desc;
const char *arch, *maintainer, *www, *prefix;
int64_t flatsize;
lic_t licenselogic;
pthread_mutex_lock(&thd_data.results_m);
while ((r = STAILQ_FIRST(&thd_data.results)) == NULL) {
if (thd_data.thd_finished == num_workers) {
break;
}
pthread_cond_wait(&thd_data.has_result, &thd_data.results_m);
}
if (r != NULL) {
STAILQ_REMOVE_HEAD(&thd_data.results, next);
thd_data.num_results--;
pthread_cond_signal(&thd_data.has_room);
}
pthread_mutex_unlock(&thd_data.results_m);
if (r == NULL) {
break;
}
if (r->retcode != EPKG_OK) {
continue;
}
/* do not add if package if already in repodb
(possibly at a different pkg_path) */
if (run_prepared_statement(EXISTS, r->cksum) != SQLITE_ROW) {
ERROR_SQLITE(sqlite);
goto cleanup;
}
if (sqlite3_column_int(STMT(EXISTS), 0) > 0) {
continue;
}
if (progress != NULL)
progress(r->pkg, data);
pkg_get(r->pkg, PKG_ORIGIN, &origin, PKG_NAME, &name,
PKG_VERSION, &version, PKG_COMMENT, &comment,
PKG_DESC, &desc, PKG_ARCH, &arch,
PKG_MAINTAINER, &maintainer, PKG_WWW, &www,
PKG_PREFIX, &prefix, PKG_FLATSIZE, &flatsize,
PKG_LICENSE_LOGIC, &licenselogic);
try_again:
if ((ret = run_prepared_statement(PKG, origin, name, version,
comment, desc, arch, maintainer, www, prefix,
r->size, flatsize, (int64_t)licenselogic, r->cksum,
r->path)) != SQLITE_DONE) {
if (ret == SQLITE_CONSTRAINT) {
switch(maybe_delete_conflicting(origin,
version, r->path)) {
case EPKG_FATAL: /* sqlite error */
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
break;
case EPKG_END: /* repo already has newer */
continue;
break;
default: /* conflict cleared, try again */
goto try_again;
break;
}
} else {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
}
package_id = sqlite3_last_insert_rowid(sqlite);
dep = NULL;
while (pkg_deps(r->pkg, &dep) == EPKG_OK) {
if (run_prepared_statement(DEPS,
pkg_dep_origin(dep),
pkg_dep_name(dep),
pkg_dep_version(dep),
package_id) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
}
category = NULL;
while (pkg_categories(r->pkg, &category) == EPKG_OK) {
const char *cat_name = pkg_category_name(category);
ret = run_prepared_statement(CAT1, cat_name);
if (ret == SQLITE_DONE)
ret = run_prepared_statement(CAT2, package_id,
cat_name);
if (ret != SQLITE_DONE)
{
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
}
license = NULL;
while (pkg_licenses(r->pkg, &license) == EPKG_OK) {
const char *lic_name = pkg_license_name(license);
ret = run_prepared_statement(LIC1, lic_name);
if (ret == SQLITE_DONE)
ret = run_prepared_statement(LIC2, package_id,
lic_name);
if (ret != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
}
option = NULL;
while (pkg_options(r->pkg, &option) == EPKG_OK) {
if (run_prepared_statement(OPTS,
pkg_option_opt(option),
pkg_option_value(option),
package_id) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
}
shlib = NULL;
while (pkg_shlibs(r->pkg, &shlib) == EPKG_OK) {
const char *shlib_name = pkg_shlib_name(shlib);
ret = run_prepared_statement(SHLIB1, shlib_name);
if (ret == SQLITE_DONE)
ret = run_prepared_statement(SHLIB2, package_id,
shlib_name);
if (ret != SQLITE_DONE)
{
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
}
pkg_free(r->pkg);
free(r);
}
if (pkgdb_transaction_commit(sqlite, NULL) != SQLITE_OK)
retcode = EPKG_FATAL;
cleanup:
if (tids != NULL) {
// Cancel running threads
if (retcode != EPKG_OK) {
pthread_mutex_lock(&thd_data.fts_m);
thd_data.stop = true;
pthread_mutex_unlock(&thd_data.fts_m);
}
// Join on threads to release thread IDs
for (int i = 0; i < num_workers; i++) {
pthread_join(tids[i], NULL);
}
free(tids);
}
if (fts != NULL)
fts_close(fts);
finalize_prepared_statements();
if (sqlite != NULL)
sqlite3_close(sqlite);
if (errmsg != NULL)
sqlite3_free(errmsg);
sqlite3_shutdown();
return (retcode);
}
static int
initialize_repo(const char *repodb, bool force, sqlite3 **sqlite)
{
bool incremental = false;
bool db_not_open;
int reposcver;
int retcode = EPKG_OK;
const char initsql[] = ""
"CREATE TABLE packages ("
"id INTEGER PRIMARY KEY,"
"origin TEXT UNIQUE,"
"name TEXT NOT NULL,"
"version TEXT NOT NULL,"
"comment TEXT NOT NULL,"
"desc TEXT NOT NULL,"
"osversion TEXT,"
"arch TEXT NOT NULL,"
"maintainer TEXT NOT NULL,"
"www TEXT,"
"prefix TEXT NOT NULL,"
"pkgsize INTEGER NOT NULL,"
"flatsize INTEGER NOT NULL,"
"licenselogic INTEGER NOT NULL,"
"cksum TEXT NOT NULL,"
/* relative path to the package in the repository */
"path TEXT NOT NULL,"
"pkg_format_version INTEGER"
");"
"CREATE TABLE deps ("
"origin TEXT,"
"name TEXT,"
"version TEXT,"
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"UNIQUE(package_id, origin)"
");"
"CREATE TABLE categories ("
"id INTEGER PRIMARY KEY, "
"name TEXT NOT NULL UNIQUE "
");"
"CREATE TABLE pkg_categories ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"category_id INTEGER REFERENCES categories(id)"
" ON DELETE RESTRICT ON UPDATE RESTRICT,"
"UNIQUE(package_id, category_id)"
");"
"CREATE TABLE licenses ("
"id INTEGER PRIMARY KEY,"
"name TEXT NOT NULL UNIQUE"
");"
"CREATE TABLE pkg_licenses ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"license_id INTEGER REFERENCES licenses(id)"
" ON DELETE RESTRICT ON UPDATE RESTRICT,"
"UNIQUE(package_id, license_id)"
");"
"CREATE TABLE options ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"option TEXT,"
"value TEXT,"
"UNIQUE (package_id, option)"
");"
"CREATE TABLE shlibs ("
"id INTEGER PRIMARY KEY,"
"name TEXT NOT NULL UNIQUE "
");"
"CREATE TABLE pkg_shlibs ("
"package_id INTEGER REFERENCES packages(id)"
" ON DELETE CASCADE ON UPDATE CASCADE,"
"shlib_id INTEGER REFERENCES shlibs(id)"
" ON DELETE RESTRICT ON UPDATE RESTRICT,"
"UNIQUE(package_id, shlib_id)"
");"
"PRAGMA user_version=%d;"
;
if (access(repodb, F_OK) == 0)
incremental = true;
sqlite3_initialize();
db_not_open = true;
while (db_not_open) {
if (sqlite3_open(repodb, sqlite) != SQLITE_OK) {
sqlite3_shutdown();
return (EPKG_FATAL);
}
db_not_open = false;
/* If the schema is too old, or we're forcing a full
update, then we cannot do an incremental update.
Delete the existing repo, and promote this to a
full update */
if (!incremental)
continue;
retcode = get_repo_user_version(*sqlite, "main", &reposcver);
if (retcode != EPKG_OK)
return (EPKG_FATAL);
if (force || reposcver != REPO_SCHEMA_VERSION) {
if (reposcver != REPO_SCHEMA_VERSION)
pkg_emit_error("updating repo schema version "
"from %d to %d", reposcver,
REPO_SCHEMA_VERSION);
sqlite3_close(*sqlite);
unlink(repodb);
incremental = false;
db_not_open = true;
}
}
sqlite3_create_function(*sqlite, "file_exists", 2, SQLITE_ANY, NULL,
file_exists, NULL, NULL);
retcode = sql_exec(*sqlite, "PRAGMA synchronous=off");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(*sqlite, "PRAGMA journal_mode=memory");
if (retcode != EPKG_OK)
return (retcode);
retcode = sql_exec(*sqlite, "PRAGMA foreign_keys=on");
if (retcode != EPKG_OK)
return (retcode);
if (!incremental) {
retcode = sql_exec(*sqlite, initsql, REPO_SCHEMA_VERSION);
if (retcode != EPKG_OK)
return (retcode);
}
retcode = pkgdb_transaction_begin(*sqlite, NULL);
if (retcode != EPKG_OK)
return (retcode);
/* remove anything that is no longer in the repository. */
if (incremental) {
const char *obsolete[] = {
"packages WHERE NOT FILE_EXISTS(path, cksum)",
"categories WHERE id NOT IN "
"(SELECT category_id FROM pkg_categories)",
"licenses WHERE id NOT IN "
"(SELECT license_id FROM pkg_licenses)",
"shlibs WHERE id NOT IN "
"(SELECT shlib_id FROM pkg_shlibs)"
};
size_t num_objs = sizeof(obsolete) / sizeof(*obsolete);
for (size_t obj = 0; obj < num_objs; obj++)
sql_exec(*sqlite, "DELETE FROM %s;", obsolete[obj]);
}
return (EPKG_OK);
}
MainWindow::~MainWindow()
{
sqlite3_shutdown();
}
int
pkg_create_repo(char *path, void (progress)(struct pkg *pkg, void *data), void *data)
{
FTS *fts = NULL;
FTSENT *ent = NULL;
struct stat st;
struct pkg *pkg = NULL;
struct pkg_dep *dep = NULL;
struct pkg_category *category = NULL;
struct pkg_license *license = NULL;
struct pkg_option *option = NULL;
struct sbuf *manifest = sbuf_new_auto();
char *ext = NULL;
sqlite3 *sqlite = NULL;
sqlite3_stmt *stmt_deps = NULL;
sqlite3_stmt *stmt_pkg = NULL;
sqlite3_stmt *stmt_lic1 = NULL;
sqlite3_stmt *stmt_lic2 = NULL;
sqlite3_stmt *stmt_cat1 = NULL;
sqlite3_stmt *stmt_cat2 = NULL;
sqlite3_stmt *stmt_opts = NULL;
int64_t package_id;
char *errmsg = NULL;
int retcode = EPKG_OK;
char *pkg_path;
char cksum[SHA256_DIGEST_LENGTH * 2 +1];
char *repopath[2];
char repodb[MAXPATHLEN + 1];
const char initsql[] = ""
"CREATE TABLE packages ("
"id INTEGER PRIMARY KEY,"
"origin TEXT UNIQUE,"
"name TEXT NOT NULL,"
"version TEXT NOT NULL,"
"comment TEXT NOT NULL,"
"desc TEXT NOT NULL,"
"arch TEXT NOT NULL,"
"osversion TEXT NOT NULL,"
"maintainer TEXT NOT NULL,"
"www TEXT,"
"prefix TEXT NOT NULL,"
"pkgsize INTEGER NOT NULL,"
"flatsize INTEGER NOT NULL,"
"licenselogic INTEGER NOT NULL,"
"cksum TEXT NOT NULL,"
"path TEXT NOT NULL," /* relative path to the package in the repository */
"pkg_format_version INTEGER"
");"
"CREATE TABLE deps ("
"origin TEXT,"
"name TEXT,"
"version TEXT,"
"package_id INTEGER REFERENCES packages(id),"
"UNIQUE(package_id, origin)"
");"
"CREATE TABLE categories ("
"id INTEGER PRIMARY KEY, "
"name TEXT NOT NULL UNIQUE "
");"
"CREATE TABLE pkg_categories ("
"package_id INTEGER REFERENCES packages(id), "
"category_id INTEGER REFERENCES categories(id), "
"UNIQUE(package_id, category_id)"
");"
"CREATE TABLE licenses ("
"id INTEGER PRIMARY KEY,"
"name TEXT NOT NULL UNIQUE"
");"
"CREATE TABLE pkg_licenses ("
"package_id INTEGER REFERENCES packages(id), "
"license_id INTEGER REFERENCES licenses(id), "
"UNIQUE(package_id, license_id)"
");"
"CREATE TABLE options ("
"package_id INTEGER REFERENCES packages(id), "
"option TEXT,"
"value TEXT,"
"UNIQUE (package_id, option)"
");"
"PRAGMA user_version=2;"
;
const char pkgsql[] = ""
"INSERT INTO packages ("
"origin, name, version, comment, desc, arch, osversion, "
"maintainer, www, prefix, pkgsize, flatsize, licenselogic, cksum, path"
")"
"VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15);";
const char depssql[] = ""
"INSERT INTO deps (origin, name, version, package_id) "
"VALUES (?1, ?2, ?3, ?4);";
const char licsql[] = "INSERT OR IGNORE INTO licenses(name) VALUES(?1);";
const char addlicsql[] = "INSERT OR ROLLBACK INTO pkg_licenses(package_id, license_id) "
"VALUES (?1, (SELECT id FROM licenses WHERE name = ?2));";
const char catsql[] = "INSERT OR IGNORE INTO categories(name) VALUES(?1);";
const char addcatsql[] = "INSERT OR ROLLBACK INTO pkg_categories(package_id, category_id) "
"VALUES (?1, (SELECT id FROM categories WHERE name = ?2));";
const char addoption[] = "INSERT OR ROLLBACK INTO options (option, value, package_id) "
"VALUES (?1, ?2, ?3);";
if (!is_dir(path)) {
pkg_emit_error("%s is not a directory", path);
return EPKG_FATAL;
}
repopath[0] = path;
repopath[1] = NULL;
snprintf(repodb, sizeof(repodb), "%s/repo.sqlite", path);
if (stat(repodb, &st) != -1)
if (unlink(repodb) != 0) {
pkg_emit_errno("unlink", path);
return EPKG_FATAL;
}
sqlite3_initialize();
if (sqlite3_open(repodb, &sqlite) != SQLITE_OK) {
sqlite3_shutdown();
return (EPKG_FATAL);
}
if ((retcode = sql_exec(sqlite, initsql)) != EPKG_OK)
goto cleanup;
if ((retcode = sql_exec(sqlite, "BEGIN TRANSACTION;")) != EPKG_OK)
goto cleanup;
if (sqlite3_prepare_v2(sqlite, pkgsql, -1, &stmt_pkg, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_prepare_v2(sqlite, depssql, -1, &stmt_deps, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_prepare_v2(sqlite, licsql, -1, &stmt_lic1, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_prepare_v2(sqlite, addlicsql, -1, &stmt_lic2, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_prepare_v2(sqlite, addoption, -1, &stmt_opts, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if ((fts = fts_open(repopath, FTS_PHYSICAL, NULL)) == NULL) {
pkg_emit_errno("fts_open", path);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_prepare_v2(sqlite, catsql, -1, &stmt_cat1, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_prepare_v2(sqlite, addcatsql, -1, &stmt_cat2, NULL) != SQLITE_OK) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
while ((ent = fts_read(fts)) != NULL) {
cksum[0] = '\0';
/* skip everything that is not a file */
if (ent->fts_info != FTS_F)
continue;
ext = strrchr(ent->fts_name, '.');
if (ext == NULL)
continue;
if (strcmp(ext, ".tgz") != 0 &&
strcmp(ext, ".tbz") != 0 &&
strcmp(ext, ".txz") != 0 &&
strcmp(ext, ".tar") != 0)
continue;
pkg_path = ent->fts_path;
pkg_path += strlen(path);
while (pkg_path[0] == '/' )
pkg_path++;
if (pkg_open(&pkg, ent->fts_accpath, manifest) != EPKG_OK) {
retcode = EPKG_WARN;
continue;
}
if (progress != NULL)
progress(pkg, data);
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_ARCH), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 7, pkg_get(pkg, PKG_OSVERSION), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 8, pkg_get(pkg, PKG_MAINTAINER), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 9, pkg_get(pkg, PKG_WWW), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 10, pkg_get(pkg, PKG_PREFIX), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_pkg, 11, ent->fts_statp->st_size);
sqlite3_bind_int64(stmt_pkg, 12, pkg_flatsize(pkg));
sha256_file(ent->fts_accpath, cksum);
sqlite3_bind_int64(stmt_pkg, 13, pkg_licenselogic(pkg));
sqlite3_bind_text(stmt_pkg, 14, cksum, -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_pkg, 15, pkg_path, -1, SQLITE_STATIC);
if (sqlite3_step(stmt_pkg) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
sqlite3_reset(stmt_pkg);
package_id = sqlite3_last_insert_rowid(sqlite);
dep = NULL;
while (pkg_deps(pkg, &dep) == EPKG_OK) {
sqlite3_bind_text(stmt_deps, 1, pkg_dep_origin(dep), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_deps, 2, pkg_dep_name(dep), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_deps, 3, pkg_dep_version(dep), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_deps, 4, package_id);
if (sqlite3_step(stmt_deps) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
sqlite3_reset(stmt_deps);
}
category = NULL;
while (pkg_categories(pkg, &category) == EPKG_OK) {
sqlite3_bind_text(stmt_cat1, 1, pkg_category_name(category), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_cat2, 1, package_id);
sqlite3_bind_text(stmt_cat2, 2, pkg_category_name(category), -1, SQLITE_STATIC);
if (sqlite3_step(stmt_cat1) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_step(stmt_cat2) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
sqlite3_reset(stmt_cat1);
sqlite3_reset(stmt_cat2);
}
license = NULL;
while (pkg_licenses(pkg, &license) == EPKG_OK) {
sqlite3_bind_text(stmt_lic1, 1, pkg_license_name(license), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_lic2, 1, package_id);
sqlite3_bind_text(stmt_lic2, 2, pkg_license_name(license), -1, SQLITE_STATIC);
if (sqlite3_step(stmt_lic1) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
if (sqlite3_step(stmt_lic2) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
sqlite3_reset(stmt_lic1);
sqlite3_reset(stmt_lic2);
}
option = NULL;
while (pkg_options(pkg, &option) == EPKG_OK) {
sqlite3_bind_text(stmt_opts, 1, pkg_option_opt(option), -1, SQLITE_STATIC);
sqlite3_bind_text(stmt_opts, 2, pkg_option_value(option), -1, SQLITE_STATIC);
sqlite3_bind_int64(stmt_opts, 3, package_id);
if (sqlite3_step(stmt_opts) != SQLITE_DONE) {
ERROR_SQLITE(sqlite);
retcode = EPKG_FATAL;
goto cleanup;
}
sqlite3_reset(stmt_opts);
}
}
if (sqlite3_exec(sqlite, "COMMIT;", NULL, NULL, &errmsg) != SQLITE_OK) {
pkg_emit_error("sqlite: %s", errmsg);
retcode = EPKG_FATAL;
}
cleanup:
if (fts != NULL)
fts_close(fts);
if (pkg != NULL)
pkg_free(pkg);
if (stmt_pkg != NULL)
sqlite3_finalize(stmt_pkg);
if (stmt_deps != NULL)
sqlite3_finalize(stmt_deps);
if (stmt_cat1 != NULL)
sqlite3_finalize(stmt_cat1);
if (stmt_cat2 != NULL)
sqlite3_finalize(stmt_cat2);
if (stmt_lic1 != NULL)
sqlite3_finalize(stmt_lic1);
if (stmt_lic2 != NULL)
sqlite3_finalize(stmt_lic2);
if (stmt_opts != NULL)
sqlite3_finalize(stmt_opts);
if (sqlite != NULL)
sqlite3_close(sqlite);
if (errmsg != NULL)
sqlite3_free(errmsg);
sbuf_delete(manifest);
sqlite3_shutdown();
return (retcode);
}