#include "pEp_internal.h" #include "engine_sql.h" // sql overloaded functions - modified from sqlite3.c /** * @internal * * * * @brief TODO * * @param[in] *ctx sqlite3_context * @param[in] argc int * @param[in] **argv sqlite3_value * */ static void _sql_lower(sqlite3_context* ctx, int argc, sqlite3_value** argv) { const char *z2; int n; z2 = (char*)sqlite3_value_text(argv[0]); n = sqlite3_value_bytes(argv[0]); /* Verify that the call to _bytes() does not invalidate the _text() pointer */ assert( z2==(char*)sqlite3_value_text(argv[0]) ); if( z2 ){ char *z1 = (char*)sqlite3_malloc(n+1); if( z1 ){ for(int i=0; i 0x7a) c_mod = c; z1[i] = c_mod; } z1[n] = '\0'; sqlite3_result_text(ctx, z1, n, sqlite3_free); } } } #ifdef _PEP_SQLITE_DEBUG /** * @internal * * * * @brief TODO * * @param[in] trace_constant unsigned * @param[in] *context_ptr void * @param[in] *P void * @param[in] *X void * */ int sql_trace_callback (unsigned trace_constant, void* context_ptr, void* P, void* X) { switch (trace_constant) { case SQLITE_TRACE_STMT: fprintf(stderr, "SQL_DEBUG: STMT - "); const char* X_str = (const char*) X; if (!EMPTYSTR(X_str) && X_str[0] == '-' && X_str[1] == '-') fprintf(stderr, "%s\n", X_str); else fprintf(stderr, "%s\n", sqlite3_expanded_sql((sqlite3_stmt*)P)); break; case SQLITE_TRACE_ROW: fprintf(stderr, "SQL_DEBUG: ROW - "); fprintf(stderr, "%s\n", sqlite3_expanded_sql((sqlite3_stmt*)P)); break; case SQLITE_TRACE_CLOSE: fprintf(stderr, "SQL_DEBUG: CLOSE - "); break; default: break; } return 0; } #endif /** * @internal * * * * @brief TODO * * @param[in] *pArg void * @param[in] iErrCode int * @param[in] *zMsg constchar * */ void errorLogCallback(void *pArg, int iErrCode, const char *zMsg){ fprintf(stderr, "(%d) %s\n", iErrCode, zMsg); } // TODO: refactor and generalise these two functions if possible. /** * @internal * * * * @brief TODO * * @param[in] session PEP_SESSION * @param[in] *table_name constchar * */ static int db_contains_table(PEP_SESSION session, const char* table_name) { if (!session || !table_name) return -1; // Table names can't be SQL parameters, so we do it this way. // these two must be the same number. char sql_buf[500]; const size_t max_q_len = 500; size_t t_size, q_size; const char* q1 = "SELECT name FROM sqlite_master WHERE type='table' AND name='{"; // 61 const char* q2 = "}';"; // 3 q_size = 64; t_size = strlen(table_name); size_t query_len = q_size + t_size + 1; if (query_len > max_q_len) return -1; strlcpy(sql_buf, q1, max_q_len); strlcat(sql_buf, table_name, max_q_len); strlcat(sql_buf, q2, max_q_len); sqlite3_stmt *stmt; sqlite3_prepare_v2(session->db, sql_buf, -1, &stmt, NULL); int retval = 0; int rc = sqlite3_step(stmt); if (rc == SQLITE_DONE || rc == SQLITE_OK || rc == SQLITE_ROW) { retval = 1; } sqlite3_finalize(stmt); return retval; } /** * @internal * * * * @brief TODO * * @param[in] session PEP_SESSION * @param[in] *table_name constchar * @param[in] *col_name constchar * */ static int table_contains_column(PEP_SESSION session, const char* table_name, const char* col_name) { if (!session || !table_name || !col_name) return -1; // Table names can't be SQL parameters, so we do it this way. // these two must be the same number. char sql_buf[500]; const size_t max_q_len = 500; size_t t_size, c_size, q_size; const char* q1 = "SELECT "; // 7 const char* q2 = " from "; // 6 const char* q3 = ";"; // 1 q_size = 14; t_size = strlen(table_name); c_size = strlen(col_name); size_t query_len = q_size + c_size + t_size + 1; if (query_len > max_q_len) return -1; strlcpy(sql_buf, q1, max_q_len); strlcat(sql_buf, col_name, max_q_len); strlcat(sql_buf, q2, max_q_len); strlcat(sql_buf, table_name, max_q_len); strlcat(sql_buf, q3, max_q_len); sqlite3_stmt *stmt; sqlite3_prepare_v2(session->db, sql_buf, -1, &stmt, NULL); int retval = 0; int rc = sqlite3_step(stmt); if (rc == SQLITE_DONE || rc == SQLITE_OK || rc == SQLITE_ROW) { retval = 1; } sqlite3_finalize(stmt); return retval; } /** * @internal * * * * @brief TODO * * @param[in] session PEP_SESSION * */ #define _PEP_MAX_AFFECTED 5 PEP_STATUS repair_altered_tables(PEP_SESSION session) { PEP_STATUS status = PEP_STATUS_OK; char* table_names[_PEP_MAX_AFFECTED] = {0}; const char* sql_query = "select tbl_name from sqlite_master WHERE sql LIKE '%REFERENCES%' AND sql LIKE '%_old%';"; sqlite3_stmt *stmt; sqlite3_prepare_v2(session->db, sql_query, -1, &stmt, NULL); int i = 0; int int_result = 0; while ((int_result = sqlite3_step(stmt)) == SQLITE_ROW && i < _PEP_MAX_AFFECTED) { table_names[i++] = strdup((const char*)(sqlite3_column_text(stmt, 0))); } sqlite3_finalize(stmt); if ((int_result != SQLITE_DONE && int_result != SQLITE_OK) || i > (_PEP_MAX_AFFECTED + 1)) { status = PEP_UNKNOWN_DB_ERROR; goto pEp_free; } for (i = 0; i < _PEP_MAX_AFFECTED; i++) { const char* table_name = table_names[i]; if (!table_name) break; if (strcmp(table_name, "identity") == 0) { int_result = sqlite3_exec(session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _identity_new (\n" " address text,\n" " user_id text\n" " references person (id)\n" " on delete cascade on update cascade,\n" " main_key_id text\n" " references pgp_keypair (fpr)\n" " on delete set null,\n" " comment text,\n" " flags integer default 0,\n" " is_own integer default 0,\n" " timestamp integer default (datetime('now')),\n" " primary key (address, user_id)\n" ");\n" "INSERT INTO _identity_new SELECT * from identity;\n" "DROP TABLE identity;\n" "ALTER TABLE _identity_new RENAME TO identity;\n" "COMMIT;\n" "PRAGMA foreign_keys=on;" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } else if (strcmp(table_name, "trust") == 0) { int_result = sqlite3_exec(session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _trust_new (\n" " user_id text not null\n" " references person (id)\n" " on delete cascade on update cascade,\n" " pgp_keypair_fpr text not null\n" " references pgp_keypair (fpr)\n" " on delete cascade,\n" " comm_type integer not null,\n" " comment text,\n" " primary key (user_id, pgp_keypair_fpr)\n" ");\n" "INSERT INTO _trust_new SELECT * from trust;\n" "DROP TABLE trust;\n" "ALTER TABLE _trust_new RENAME TO trust;\n" "COMMIT;\n" "PRAGMA foreign_keys=on;" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } else if (strcmp(table_name, "alternate_user_id") == 0) { int_result = sqlite3_exec(session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _alternate_user_id_new (\n" " default_id text references person (id)\n" " on delete cascade on update cascade,\n" " alternate_id text primary key\n" ");\n" "INSERT INTO _alternate_user_id_new SELECT * from alternate_user_id;\n" "DROP TABLE alternate_user_id;\n" "ALTER TABLE _alternate_user_id_new RENAME TO alternate_user_id;\n" "COMMIT;\n" "PRAGMA foreign_keys=on;" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } else if (strcmp(table_name, "revocation_contact_list") == 0) { int_result = sqlite3_exec(session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _revocation_contact_list_new (\n" " fpr text not null references pgp_keypair (fpr)\n" " on delete cascade,\n" " contact_id text not null references person (id)\n" " on delete cascade on update cascade,\n" " timestamp integer default (datetime('now')),\n" " PRIMARY KEY(fpr, contact_id)\n" ");\n" "INSERT INTO _revocation_contact_list_new SELECT * from revocation_contact_list;\n" "DROP TABLE revocation_contact_list;\n" "ALTER TABLE _revocation_contact_list_new RENAME TO revocation_contact_list;\n" "COMMIT;\n" "PRAGMA foreign_keys=on;" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } else if (strcmp(table_name, "social_graph")) { int_result = sqlite3_exec(session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _social_new (\n" " own_userid text,\n" " own_address text,\n" " contact_userid text,\n" " CONSTRAINT fk_own_identity\n" " FOREIGN KEY(own_address, own_userid)\n" " REFERENCES identity(address, user_id)\n" " ON DELETE CASCADE ON UPDATE CASCADE\n" ");\n" "INSERT INTO _social_graph_new SELECT * from social_graph;\n" "DROP TABLE social_graph;\n" "ALTER TABLE _social_graph_new RENAME TO social_graph;\n" "COMMIT;\n" "PRAGMA foreign_keys=on;" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } } int_result = sqlite3_exec( session->db, "PRAGMA foreign_key_check;\n" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; pEp_free: for (i = 0; i < _PEP_MAX_AFFECTED; i++) { free(table_names[i]); } return status; } /** * @internal * * * * @brief TODO * * @param[in] session PEP_SESSION * */ static PEP_STATUS upgrade_revoc_contact_to_13(PEP_SESSION session) { // I HATE SQLITE. PEP_STATUS status = PEP_STATUS_OK; int int_result = 0; // Ok, first we ADD the column so we can USE it. // We will end up propagating the "error" this first time // (one-to-one revoke-replace relationships), but since key reset // hasn't been used in production, this is not a customer-facing // issue. // Note: the check upfront is to deal with partially-upgraded DB issues if (!table_contains_column(session, "revocation_contact_list", "own_address")) { int_result = sqlite3_exec( session->db, "alter table revocation_contact_list\n" " add column own_address text;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } // the best we can do here is search per address, since these // are no longer associated with an identity. For now, if we find // something we can't add an address to, we'll delete the record. // this should not, in the current environment, ever happen, but // since we need to make the address part of the primary key, it's // the right thing to do. sqlite does support null fields in a primary // key for a weird version compatibility reason, but that doesn't // mean we should use it, and we should be *safe*, not relying // on an implementation-specific quirk which might be sanely removed // in a future sqlite version. identity_list* id_list = NULL; sqlite3_stmt* tmp_own_id_retrieve = NULL; sqlite3_prepare_v2(session->db, sql_own_identities_retrieve, -1, &tmp_own_id_retrieve, NULL); // Kludgey - put the stmt in temporarily, and then remove again, so less code dup. // FIXME LATER: refactor if possible, but... chicken and egg, and thiis case rarely happens. session->own_identities_retrieve = tmp_own_id_retrieve; status = own_identities_retrieve(session, &id_list); sqlite3_finalize(tmp_own_id_retrieve); session->own_identities_retrieve = NULL; if (!status || !id_list) return PEP_STATUS_OK; // it's empty AFAIK (FIXME) identity_list* curr_own = id_list; sqlite3_stmt* update_revoked_w_addr_stmt = NULL; const char* sql_query = "update revocation_contact_list set own_address = ?1 where fpr = ?2;"; sqlite3_prepare_v2(session->db, sql_query, -1, &update_revoked_w_addr_stmt, NULL); // Ok, go through and find any keys associated with this address for ( ; curr_own && curr_own->ident; curr_own = curr_own->next) { if (EMPTYSTR(curr_own->ident->address)) // shouldn't happen continue; stringlist_t* keylist = NULL; status = find_keys(session, curr_own->ident->address, &keylist); stringlist_t* curr_key = keylist; for ( ; curr_key && curr_key->value; curr_key = curr_key->next) { if (EMPTYSTR(curr_key->value)) continue; // We just do this lazily - if this isn't a revoked key, it // won't do anything. sqlite3_bind_text(update_revoked_w_addr_stmt, 1, curr_own->ident->address, -1, SQLITE_STATIC); sqlite3_bind_text(update_revoked_w_addr_stmt, 2, curr_key->value, -1, SQLITE_STATIC); int_result = sqlite3_step(update_revoked_w_addr_stmt); assert(int_result == SQLITE_DONE); sqlite3_reset(update_revoked_w_addr_stmt); if (int_result != SQLITE_DONE) return PEP_UNKNOWN_DB_ERROR; } } sqlite3_finalize(update_revoked_w_addr_stmt); int_result = sqlite3_exec( session->db, "delete from revocation_contact_list where own_address is NULL;\n" "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table if not exists _revocation_contact_list_new (\n" " fpr text not null references pgp_keypair (fpr)\n" " on delete cascade,\n" " own_address text,\n" " contact_id text not null references person (id)\n" " on delete cascade on update cascade,\n" " timestamp integer default (datetime('now')),\n" " PRIMARY KEY(fpr, own_address, contact_id)\n" ");\n" "INSERT INTO _revocation_contact_list_new (fpr, " " own_address, " " contact_id) " " SELECT revocation_contact_list.fpr, " " revocation_contact_list.own_address, " " revocation_contact_list.contact_id " " FROM revocation_contact_list " " WHERE 1;\n" "DROP TABLE revocation_contact_list;\n" "ALTER TABLE _revocation_contact_list_new RENAME TO revocation_contact_list;\n" "COMMIT;\n" "\n" "PRAGMA foreign_keys=on;\n" , NULL, NULL, NULL ); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return status; } /** * @internal * * * * @brief TODO * * @param[in] *_version void * @param[in] count int * @param[in] **text char * @param[in] **name char * */ static int user_version(void *_version, int count, char **text, char **name) { if (!(_version && count == 1 && text && text[0])) return -1; int *version = (int *) _version; *version = atoi(text[0]); return 0; } PEP_STATUS init_databases(PEP_SESSION session) { assert(LOCAL_DB); if (LOCAL_DB == NULL) return PEP_INIT_CANNOT_OPEN_DB; #ifdef _PEP_SQLITE_DEBUG sqlite3_config(SQLITE_CONFIG_LOG, errorLogCallback, NULL); #endif int int_result = sqlite3_open_v2( LOCAL_DB, &session->db, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_PRIVATECACHE, NULL ); if (int_result != SQLITE_OK) return PEP_INIT_CANNOT_OPEN_DB; int_result = sqlite3_exec( session->db, "PRAGMA locking_mode=NORMAL;\n" "PRAGMA journal_mode=WAL;\n", NULL, NULL, NULL ); sqlite3_busy_timeout(session->db, BUSY_WAIT_TIME); #ifdef _PEP_SQLITE_DEBUG sqlite3_trace_v2(session->db, SQLITE_TRACE_STMT | SQLITE_TRACE_ROW | SQLITE_TRACE_CLOSE, sql_trace_callback, NULL); #endif assert(SYSTEM_DB); if (SYSTEM_DB == NULL) return PEP_INIT_CANNOT_OPEN_SYSTEM_DB; int_result = sqlite3_open_v2( SYSTEM_DB, &session->system_db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL ); if (int_result != SQLITE_OK) return PEP_INIT_CANNOT_OPEN_SYSTEM_DB; sqlite3_busy_timeout(session->system_db, 1000); return PEP_STATUS_OK; } static PEP_STATUS _create_initial_tables(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "create table if not exists version_info (\n" " id integer primary key,\n" " timestamp integer default (datetime('now')),\n" " version text,\n" " comment text\n" ");\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // This string is now too large for the C standard, so we're going to break it up some. // I presume we use the enormous string for performance purposes... terrible for debugging purposes, but OK. int_result = sqlite3_exec( session->db, "PRAGMA application_id = 0x23423423;\n" "create table if not exists log (\n" " timestamp integer default (datetime('now')),\n" " title text not null,\n" " description text,\n" " entity text not null,\n" " comment text\n" ");\n" "create index if not exists log_timestamp on log (\n" " timestamp\n" ");\n" , NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _create_core_tables(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "create table if not exists pgp_keypair (\n" " fpr text primary key,\n" " created integer,\n" " expires integer,\n" " comment text,\n" " flags integer default 0\n" ");\n" "create index if not exists pgp_keypair_expires on pgp_keypair (\n" " expires\n" ");\n" "create table if not exists person (\n" " id text primary key,\n" " username text not null,\n" " main_key_id text\n" " references pgp_keypair (fpr)\n" " on delete set null,\n" " lang text,\n" " comment text,\n" // " device_group text,\n" " is_pEp_user integer default 0\n" ");\n" "create table if not exists identity (\n" " address text,\n" " user_id text\n" " references person (id)\n" " on delete cascade on update cascade,\n" " main_key_id text\n" " references pgp_keypair (fpr)\n" " on delete set null,\n" " username text,\n" " comment text,\n" " flags integer default 0,\n" " is_own integer default 0,\n" " pEp_version_major integer default 0,\n" " pEp_version_minor integer default 0,\n" " enc_format integer default 0,\n" " timestamp integer default (datetime('now')),\n" " primary key (address, user_id)\n" ");\n" "create index if not exists identity_userid_addr on identity(address, user_id);\n" "create table if not exists trust (\n" " user_id text not null\n" " references person (id)\n" " on delete cascade on update cascade,\n" " pgp_keypair_fpr text not null\n" " references pgp_keypair (fpr)\n" " on delete cascade,\n" " comm_type integer not null,\n" " comment text,\n" " sticky integer default 0,\n" " primary key (user_id, pgp_keypair_fpr)\n" ");\n" , NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _create_group_tables(PEP_SESSION session) { if (!session) return PEP_ILLEGAL_VALUE; int int_result = sqlite3_exec( session->db, // group information "create table if not exists groups (\n" " group_id text,\n" " group_address text,\n" " manager_userid text,\n" " manager_address text,\n" " active integer default 0,\n" " constraint groups_pk\n" " primary key (group_address, group_id),\n" " constraint group_identity_fk\n" " foreign key (group_address, group_id) references identity\n" " on update cascade on delete cascade,\n" " constraint manager_identity_fk\n" " foreign key (manager_address, manager_userid) references identity\n" " on update cascade on delete cascade\n" ");\n" "create table if not exists own_memberships (\n" " group_id text,\n" " group_address text,\n" " own_id text,\n" " own_address text,\n" " have_joined int default 0,\n" " constraint own_memberships_pk\n" " primary key (group_address, group_id),\n" " constraint own_memberships_own_id_fk\n" " foreign key (own_address, own_id) references identity\n" " on update cascade on delete cascade,\n" " constraint own_memberships_group_fk\n" " foreign key (group_address, group_id) references groups\n" " on update cascade on delete cascade\n" ");\n" "create table if not exists own_groups_members (\n" " group_id text,\n" " group_address text,\n" " member_id text,\n" " member_address text,\n" " active_member int default 0,\n" " constraint own_groups_members_pk\n" " primary key (group_address, group_id, member_address, member_id),\n" " constraint group_ident_fk\n" " foreign key (group_address, group_id) references groups\n" " on update cascade on delete cascade,\n" " constraint member_ident_fk\n" " foreign key (member_address, member_id) references identity\n" " on update cascade on delete cascade\n" ");\n" , NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _create_supplementary_key_tables(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "create table if not exists revoked_keys (\n" " revoked_fpr text primary key,\n" " replacement_fpr text not null\n" " references pgp_keypair (fpr)\n" " on delete cascade,\n" " revocation_date integer\n" ");\n" // mistrusted keys "create table if not exists mistrusted_keys (\n" " fpr text primary key\n" ");\n" // social graph for key resets "create table if not exists social_graph (\n" " own_userid text,\n" " own_address text,\n" " contact_userid text,\n" " CONSTRAINT fk_own_identity\n" " FOREIGN KEY(own_address, own_userid)\n" " REFERENCES identity(address, user_id)\n" " ON DELETE CASCADE ON UPDATE CASCADE\n" ");\n" // list of user_ids sent revocation "create table if not exists revocation_contact_list (\n" " fpr text not null references pgp_keypair (fpr)\n" " on delete cascade,\n" " own_address text,\n" " contact_id text not null references person (id)\n" " on delete cascade on update cascade,\n" " timestamp integer default (datetime('now')),\n" " PRIMARY KEY(fpr, own_address, contact_id)\n" ");\n" , NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _create_misc_admin_tables(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, // sequences "create table if not exists sequences(\n" " name text primary key,\n" " value integer default 0\n" ");\n" // user id aliases "create table if not exists alternate_user_id (\n" " default_id text references person (id)\n" " on delete cascade on update cascade,\n" " alternate_id text primary key\n" ");\n" , NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } // The create tables string is now too large for the C standard, so we're going to break it up some. // I presume we use the enormous string for performance purposes... terrible for debugging purposes, but OK. PEP_STATUS create_tables(PEP_SESSION session) { if (!session) return PEP_ILLEGAL_VALUE; PEP_STATUS status = PEP_STATUS_OK; status = _create_initial_tables(session); if (status != PEP_STATUS_OK) return status; status = _create_core_tables(session); if (status != PEP_STATUS_OK) return status; status = _create_group_tables(session); if (status != PEP_STATUS_OK) return status; status = _create_supplementary_key_tables(session); if (status != PEP_STATUS_OK) return status; status = _create_misc_admin_tables(session); return status; } PEP_STATUS get_db_user_version(PEP_SESSION session, int* version) { int int_result = sqlite3_exec( session->db, "pragma user_version;", user_version, version, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } // Only called if input version is 1 static PEP_STATUS _verify_version(PEP_SESSION session, int* version) { // Sometimes the user_version wasn't set correctly. bool version_changed = true; int int_result; if (table_contains_column(session, "identity", "username")) { *version = 17; } else if (table_contains_column(session, "trust", "sticky")) { *version = 16; } else if (table_contains_column(session, "groups", "group_identity")) { *version = 15; } else if (table_contains_column(session, "identity", "enc_format")) { *version = 14; } else if (table_contains_column(session, "revocation_contact_list", "own_address")) { *version = 13; } else if (table_contains_column(session, "identity", "pEp_version_major")) { *version = 12; } else if (db_contains_table(session, "social_graph") > 0) { if (!table_contains_column(session, "person", "device_group")) *version = 10; else *version = 9; } else if (table_contains_column(session, "identity", "timestamp") > 0) { *version = 8; } else if (table_contains_column(session, "person", "is_pEp_user") > 0) { *version = 7; } else if (table_contains_column(session, "identity", "is_own") > 0) { *version = 6; } else if (table_contains_column(session, "pgp_keypair", "flags") > 0) { *version = 2; } else { version_changed = false; } if (version_changed) { // set it in the DB, finally. Yeesh. char verbuf[21]; // enough digits for a max-sized 64 bit int, cmon. sprintf(verbuf, "%d", *version); size_t query_size = strlen(verbuf) + 25; char *query = calloc(query_size, 1); strlcpy(query, "pragma user_version = ", query_size); strlcat(query, verbuf, query_size); strlcat(query, ";", query_size); int_result = sqlite3_exec( session->db, query, user_version, &*version, NULL ); free(query); } // FIXME: status return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_2(PEP_SESSION session) { // N.B. addition of device_group column removed in DDL v10 int int_result = sqlite3_exec( session->db, "alter table pgp_keypair\n" " add column flags integer default 0;\n", // "alter table person\n" // " add column device_group text;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_5(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "delete from pgp_keypair where fpr = '';", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "delete from trust where pgp_keypair_fpr = '';", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_6(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "alter table identity\n" " add column is_own integer default 0;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "update identity\n" " set is_own = 1\n" " where (user_id = '" PEP_OWN_USERID "');\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // Turns out that just adding "on update cascade" in // sqlite is a PITA. We need to be able to cascade // person->id replacements (for temp ids like "TOFU_") // so here we go... int_result = sqlite3_exec( session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _identity_new (\n" " address text,\n" " user_id text\n" " references person (id)\n" " on delete cascade on update cascade,\n" " main_key_id text\n" " references pgp_keypair (fpr)\n" " on delete set null,\n" " comment text,\n" " flags integer default 0,\n" " is_own integer default 0,\n" " primary key (address, user_id)\n" ");\n" "INSERT INTO _identity_new SELECT * FROM identity;\n" "DROP TABLE identity;\n" "ALTER TABLE _identity_new RENAME TO identity;\n" "COMMIT;\n" "\n" "BEGIN TRANSACTION;\n" "create table _trust_new (\n" " user_id text not null\n" " references person (id)\n" " on delete cascade on update cascade,\n" " pgp_keypair_fpr text not null\n" " references pgp_keypair (fpr)\n" " on delete cascade,\n" " comm_type integer not null,\n" " comment text,\n" " primary key (user_id, pgp_keypair_fpr)\n" ");\n" "INSERT INTO _trust_new SELECT * FROM trust;\n" "DROP TABLE trust;\n" "ALTER TABLE _trust_new RENAME TO trust;\n" "COMMIT;\n" "\n" "PRAGMA foreign_keys=on;\n" "create table if not exists alternate_user_id (\n" " default_id text references person (id)\n" " on delete cascade on update cascade,\n" " alternate_id text primary key\n" ");\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "PRAGMA foreign_key_check;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // FIXME: foreign key check here assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_7(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "alter table person\n" " add column is_pEp_user integer default 0;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "update person\n" " set is_pEp_user = 1\n" " where id = " " (select distinct id from person " " join trust on id = user_id " " where (case when (comm_type = 127) then (id) " " when (comm_type = 255) then (id) " " else 0" " end) = id );\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "create table if not exists mistrusted_keys (\n" " fpr text primary key\n" ");\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_8(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _identity_new (\n" " address text,\n" " user_id text\n" " references person (id)\n" " on delete cascade on update cascade,\n" " main_key_id text\n" " references pgp_keypair (fpr)\n" " on delete set null,\n" " comment text,\n" " flags integer default 0,\n" " is_own integer default 0,\n" " timestamp integer default (datetime('now')),\n" " primary key (address, user_id)\n" ");\n" "INSERT INTO _identity_new (address, user_id, main_key_id, " " comment, flags, is_own) " " SELECT identity.address, identity.user_id, " " identity.main_key_id, identity.comment, " " identity.flags, identity.is_own " " FROM identity " " WHERE 1;\n" "DROP TABLE identity;\n" "ALTER TABLE _identity_new RENAME TO identity;\n" "COMMIT;\n" "\n" "PRAGMA foreign_keys=on;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "PRAGMA foreign_key_check;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); // FIXME: foreign key check if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_9(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "create table if not exists social_graph (\n" " own_userid text,\n" " own_address text,\n" " contact_userid text,\n" " CONSTRAINT fk_own_identity\n" " FOREIGN KEY(own_address, own_userid)\n" " REFERENCES identity(address, user_id)\n" " ON DELETE CASCADE ON UPDATE CASCADE\n" ");\n" "create table if not exists revocation_contact_list (\n" " fpr text not null references pgp_keypair (fpr)\n" " on delete cascade,\n" " contact_id text not null references person (id)\n" " on delete cascade on update cascade,\n" " timestamp integer default (datetime('now')),\n" " PRIMARY KEY(fpr, contact_id)\n" ");\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_10(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "PRAGMA foreign_keys=off;\n" "BEGIN TRANSACTION;\n" "create table _person_new (\n" " id text primary key,\n" " username text not null,\n" " main_key_id text\n" " references pgp_keypair (fpr)\n" " on delete set null,\n" " lang text,\n" " comment text,\n" " is_pEp_user integer default 0\n" ");\n" "INSERT INTO _person_new (id, username, main_key_id, " " lang, comment, is_pEp_user) " " SELECT person.id, person.username, " " person.main_key_id, person.lang, " " person.comment, person.is_pEp_user " " FROM person " " WHERE 1;\n" "DROP TABLE person;\n" "ALTER TABLE _person_new RENAME TO person;\n" "COMMIT;\n" "\n" "PRAGMA foreign_keys=on;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "PRAGMA foreign_key_check;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _force_upgrade_own_latest_message_version(PEP_SESSION session) { // N.B. WE DEFINE PEP_VERSION - IF WE'RE AT 9-DIGIT MAJOR OR MINOR VERSIONS, ER, BAD. char major_buf[10]; char minor_buf[10]; // Guess we were abusing sscanf here, so we'll do it this way: const char *cptr = PEP_VERSION; size_t major_len = 0; size_t minor_len = 0; char *bufptr = major_buf; while (*cptr != '.' && *cptr != '\0') { *bufptr++ = *cptr++; major_len++; } *bufptr = '\0'; bufptr = minor_buf; if (*cptr == '.') { cptr++; while (*cptr != '\0') { *bufptr++ = *cptr++; minor_len++; } } else { *bufptr++ = '0'; } *bufptr = '\0'; const char *version_upgrade_startstr = "update identity\n" " set pEp_version_major = "; const char *version_upgrade_midstr = ",\n" " pEp_version_minor = "; const char *version_upgrade_endstr = "\n" " where identity.is_own = 1;\n"; // FIXME: Group idents? size_t new_stringlen = strlen(version_upgrade_startstr) + major_len + strlen(version_upgrade_midstr) + minor_len + strlen(version_upgrade_endstr); char *version_upgrade_stmt = calloc(new_stringlen + 1, 1); snprintf(version_upgrade_stmt, new_stringlen + 1, "%s%s%s%s%s", version_upgrade_startstr, major_buf, version_upgrade_midstr, minor_buf, version_upgrade_endstr); int int_result = sqlite3_exec( session->db, version_upgrade_stmt, NULL, NULL, NULL ); free(version_upgrade_stmt); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_12(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "create index if not exists identity_userid_addr on identity(address, user_id);\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "alter table identity\n" " add column pEp_version_major integer default 0;\n" "alter table identity\n" " add column pEp_version_minor integer default 0;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "update identity\n" " set pEp_version_major = 2,\n" " pEp_version_minor = 1\n" " where exists (select * from person\n" " where identity.user_id = person.id\n" " and identity.is_own = 0\n" " and person.is_pEp_user = 1);\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; // Superceded by the -to-version-18 upgrade. // return _force_upgrade_own_latest_message_version(session); } static PEP_STATUS _upgrade_DB_to_ver_14(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "alter table identity\n" " add column enc_format integer default 0;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_15(PEP_SESSION session) { return _create_group_tables(session); } static PEP_STATUS _upgrade_DB_to_ver_16(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "alter table trust\n" " add column sticky integer default 0;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } static PEP_STATUS _upgrade_DB_to_ver_17(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "alter table identity\n" " add column username;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return PEP_STATUS_OK; } // Version 2.0 and earlier will now no longer be supported with other // pEp users. static PEP_STATUS _upgrade_DB_to_ver_18(PEP_SESSION session) { int int_result = sqlite3_exec( session->db, "update identity\n" " set pEp_version_major = 2,\n" " pEp_version_minor = 1\n" " where exists (select * from person\n" " where identity.user_id = person.id\n" " and identity.pEp_version_major = 2\n" " and identity.pEp_version_minor = 0\n" " and person.is_pEp_user = 1);\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; return _force_upgrade_own_latest_message_version(session); } // Honestly, the upgrades should be redone in a transaction IMHO. static PEP_STATUS _check_and_execute_upgrades(PEP_SESSION session, int version) { PEP_STATUS status = PEP_STATUS_OK; switch(version) { case 1: status = _upgrade_DB_to_ver_2(session); if (status != PEP_STATUS_OK) return status; case 2: case 3: case 4: status = _upgrade_DB_to_ver_5(session); if (status != PEP_STATUS_OK) return status; case 5: status = _upgrade_DB_to_ver_6(session); if (status != PEP_STATUS_OK) return status; case 6: status = _upgrade_DB_to_ver_7(session); if (status != PEP_STATUS_OK) return status; case 7: status = _upgrade_DB_to_ver_8(session); if (status != PEP_STATUS_OK) return status; case 8: status = _upgrade_DB_to_ver_9(session); if (status != PEP_STATUS_OK) return status; case 9: if (version > 1) { status = _upgrade_DB_to_ver_10(session); if (status != PEP_STATUS_OK) return status; } case 10: status = repair_altered_tables(session); assert(status == PEP_STATUS_OK); if (status != PEP_STATUS_OK) return status; case 11: status = _upgrade_DB_to_ver_12(session); if (status != PEP_STATUS_OK) return status; case 12: status = upgrade_revoc_contact_to_13(session); assert(status == PEP_STATUS_OK); if (status != PEP_STATUS_OK) return status; case 13: status = _upgrade_DB_to_ver_14(session); if (status != PEP_STATUS_OK) return status; case 14: status = _upgrade_DB_to_ver_15(session); if (status != PEP_STATUS_OK) return status; case 15: status = _upgrade_DB_to_ver_16(session); if (status != PEP_STATUS_OK) return status; case 16: status = _upgrade_DB_to_ver_17(session); if (status != PEP_STATUS_OK) return status; case 17: status = _upgrade_DB_to_ver_18(session); if (status != PEP_STATUS_OK) return status; case 18: break; default: return PEP_ILLEGAL_VALUE; } return PEP_STATUS_OK; } PEP_STATUS pEp_sql_init(PEP_SESSION session) { bool very_first = false; PEP_STATUS status = create_tables(session); if (status != PEP_STATUS_OK) return status; int version = 0; status = get_db_user_version(session, &version); if (status != PEP_STATUS_OK) return status; void (*xFunc_lower)(sqlite3_context *, int, sqlite3_value **) = &_sql_lower; int int_result = sqlite3_create_function_v2( session->db, "lower", 1, SQLITE_UTF8 | SQLITE_DETERMINISTIC, NULL, xFunc_lower, NULL, NULL, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_exec( session->db, "pragma foreign_keys=ON;\n", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; if (version > atoi(_DDL_USER_VERSION)) { // This is *explicitly* not allowed. return PEP_INIT_DB_DOWNGRADE_VIOLATION; } if (version == 1) { // Sometimes the user_version wasn't set correctly. status = _verify_version(session, &version); if (status != PEP_STATUS_OK) return PEP_ILLEGAL_VALUE; } if (version != 0) { // Version has been already set // Early mistake : version 0 shouldn't have existed. // Numbering should have started at 1 to detect newly created DB. // Version 0 DBs are not anymore compatible. status = _check_and_execute_upgrades(session, version); if (status != PEP_STATUS_OK) return PEP_ILLEGAL_VALUE; } else { // Version from DB was 0, it means this is initial setup. // DB has just been created, and all tables are empty. very_first = true; } if (version < atoi(_DDL_USER_VERSION)) { int_result = sqlite3_exec( session->db, "pragma user_version = "_DDL_USER_VERSION";\n" "insert or replace into version_info (id, version)" "values (1, '" PEP_ENGINE_VERSION "');", NULL, NULL, NULL ); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; } return PEP_STATUS_OK; } // This whole mess really does need to be generated somewhere. PEP_STATUS pEp_prepare_sql_stmts(PEP_SESSION session) { int int_result = sqlite3_prepare_v2(session->system_db, sql_trustword, (int)strlen(sql_trustword), &session->trustword, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_identity, (int)strlen(sql_get_identity), &session->get_identity, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_identity_without_trust_check, (int)strlen(sql_get_identity_without_trust_check), &session->get_identity_without_trust_check, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_identities_by_address, (int)strlen(sql_get_identities_by_address), &session->get_identities_by_address, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_identities_by_userid, (int)strlen(sql_get_identities_by_userid), &session->get_identities_by_userid, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_identities_by_main_key_id, (int)strlen(sql_get_identities_by_main_key_id), &session->get_identities_by_main_key_id, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_default_identity_fpr, (int)strlen(sql_set_default_identity_fpr), &session->set_default_identity_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_default_identity_fpr, (int)strlen(sql_get_default_identity_fpr), &session->get_default_identity_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_user_default_key, (int)strlen(sql_get_user_default_key), &session->get_user_default_key, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_all_keys_for_user, (int)strlen(sql_get_all_keys_for_user), &session->get_all_keys_for_user, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_default_own_userid, (int)strlen(sql_get_default_own_userid), &session->get_default_own_userid, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_userid_alias_default, (int)strlen(sql_get_userid_alias_default), &session->get_userid_alias_default, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_add_userid_alias, (int)strlen(sql_add_userid_alias), &session->add_userid_alias, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_replace_userid, (int)strlen(sql_replace_userid), &session->replace_userid, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_delete_key, (int)strlen(sql_delete_key), &session->delete_key, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_replace_main_user_fpr, (int)strlen(sql_replace_main_user_fpr), &session->replace_main_user_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_replace_main_user_fpr_if_equal, (int)strlen(sql_replace_main_user_fpr_if_equal), &session->replace_main_user_fpr_if_equal, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_main_user_fpr, (int)strlen(sql_get_main_user_fpr), &session->get_main_user_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_refresh_userid_default_key, (int)strlen(sql_refresh_userid_default_key), &session->refresh_userid_default_key, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_replace_identities_fpr, (int)strlen(sql_replace_identities_fpr), &session->replace_identities_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_remove_fpr_as_identity_default, (int)strlen(sql_remove_fpr_as_identity_default), &session->remove_fpr_as_identity_default, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_remove_fpr_as_user_default, (int)strlen(sql_remove_fpr_as_user_default), &session->remove_fpr_as_user_default, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_person, (int)strlen(sql_set_person), &session->set_person, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_update_person, (int)strlen(sql_update_person), &session->update_person, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_delete_person, (int)strlen(sql_delete_person), &session->delete_person, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_exists_person, (int)strlen(sql_exists_person), &session->exists_person, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_as_pEp_user, (int)strlen(sql_set_as_pEp_user), &session->set_as_pEp_user, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_pEp_user, (int)strlen(sql_is_pEp_user), &session->is_pEp_user, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_add_into_social_graph, (int)strlen(sql_add_into_social_graph), &session->add_into_social_graph, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_own_address_binding_from_contact, (int)strlen(sql_get_own_address_binding_from_contact), &session->get_own_address_binding_from_contact, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_revoke_contact_as_notified, (int)strlen(sql_set_revoke_contact_as_notified), &session->set_revoke_contact_as_notified, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_contacted_ids_from_revoke_fpr, (int)strlen(sql_get_contacted_ids_from_revoke_fpr), &session->get_contacted_ids_from_revoke_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_was_id_for_revoke_contacted, (int)strlen(sql_was_id_for_revoke_contacted), &session->was_id_for_revoke_contacted, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_has_id_contacted_address, (int)strlen(sql_has_id_contacted_address), &session->has_id_contacted_address, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_last_contacted, (int)strlen(sql_get_last_contacted), &session->get_last_contacted, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_pgp_keypair, (int)strlen(sql_set_pgp_keypair), &session->set_pgp_keypair, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_pgp_keypair_flags, (int)strlen(sql_set_pgp_keypair_flags), &session->set_pgp_keypair_flags, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_unset_pgp_keypair_flags, (int)strlen(sql_unset_pgp_keypair_flags), &session->unset_pgp_keypair_flags, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_identity_entry, (int)strlen(sql_set_identity_entry), &session->set_identity_entry, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_update_identity_entry, (int)strlen(sql_update_identity_entry), &session->update_identity_entry, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_exists_identity_entry, (int)strlen(sql_exists_identity_entry), &session->exists_identity_entry, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_force_set_identity_username, (int)strlen(sql_force_set_identity_username), &session->force_set_identity_username, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_identity_flags, (int)strlen(sql_set_identity_flags), &session->set_identity_flags, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_unset_identity_flags, (int)strlen(sql_unset_identity_flags), &session->unset_identity_flags, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_ident_enc_format, (int)strlen(sql_set_ident_enc_format), &session->set_ident_enc_format, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_pEp_version, (int)strlen(sql_set_pEp_version), &session->set_pEp_version, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_upgrade_pEp_version_by_user_id, (int)strlen(sql_upgrade_pEp_version_by_user_id), &session->upgrade_pEp_version_by_user_id, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_clear_trust_info, (int)strlen(sql_clear_trust_info), &session->clear_trust_info, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_trust, (int)strlen(sql_set_trust), &session->set_trust, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_update_trust, (int)strlen(sql_update_trust), &session->update_trust, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_update_trust_to_pEp, (int)strlen(sql_update_trust_to_pEp), &session->update_trust_to_pEp, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_exists_trust_entry, (int)strlen(sql_exists_trust_entry), &session->exists_trust_entry, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_update_trust_for_fpr, (int)strlen(sql_update_trust_for_fpr), &session->update_trust_for_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_trust, (int)strlen(sql_get_trust), &session->get_trust, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_trust_by_userid, (int)strlen(sql_get_trust_by_userid), &session->get_trust_by_userid, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_least_trust, (int)strlen(sql_least_trust), &session->least_trust, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_update_key_sticky_bit_for_user, (int)strlen(sql_update_key_sticky_bit_for_user), &session->update_key_sticky_bit_for_user, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_key_sticky_for_user, (int)strlen(sql_is_key_sticky_for_user), &session->is_key_sticky_for_user, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_mark_as_compromised, (int)strlen(sql_mark_as_compromised), &session->mark_compromised, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_crashdump, (int)strlen(sql_crashdump), &session->crashdump, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->system_db, sql_languagelist, (int)strlen(sql_languagelist), &session->languagelist, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->system_db, sql_i18n_token, (int)strlen(sql_i18n_token), &session->i18n_token, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // Own keys int_result = sqlite3_prepare_v2(session->db, sql_own_key_is_listed, (int)strlen(sql_own_key_is_listed), &session->own_key_is_listed, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_own_address, (int)strlen(sql_is_own_address), &session->is_own_address, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_own_identities_retrieve, (int)strlen(sql_own_identities_retrieve), &session->own_identities_retrieve, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_own_keys_retrieve, (int)strlen(sql_own_keys_retrieve), &session->own_keys_retrieve, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // int_result = sqlite3_prepare_v2(session->db, sql_set_own_key, // (int)strlen(sql_set_own_key), // &session->set_own_key, NULL); // assert(int_result == SQLITE_OK); // Sequence int_result = sqlite3_prepare_v2(session->db, sql_sequence_value1, (int)strlen(sql_sequence_value1), &session->sequence_value1, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_sequence_value2, (int)strlen(sql_sequence_value2), &session->sequence_value2, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // Revocation tracking int_result = sqlite3_prepare_v2(session->db, sql_set_revoked, (int)strlen(sql_set_revoked), &session->set_revoked, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_revoked, (int)strlen(sql_get_revoked), &session->get_revoked, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_replacement_fpr, (int)strlen(sql_get_replacement_fpr), &session->get_replacement_fpr, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_add_mistrusted_key, (int)strlen(sql_add_mistrusted_key), &session->add_mistrusted_key, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_delete_mistrusted_key, (int)strlen(sql_delete_mistrusted_key), &session->delete_mistrusted_key, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_mistrusted_key, (int)strlen(sql_is_mistrusted_key), &session->is_mistrusted_key, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; /* Groups */ int_result = sqlite3_prepare_v2(session->db, sql_create_group, (int)strlen(sql_create_group), &session->create_group, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_enable_group, (int)strlen(sql_enable_group), &session->enable_group, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_disable_group, (int)strlen(sql_disable_group), &session->disable_group, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_exists_group_entry, (int)strlen(sql_exists_group_entry), &session->exists_group_entry, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_group_add_member, (int)strlen(sql_group_add_member), &session->group_add_member, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_group_delete_member, (int)strlen(sql_group_delete_member), &session->group_delete_member, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_set_group_member_status, (int)strlen(sql_set_group_member_status), &session->set_group_member_status, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_group_join, (int)strlen(sql_group_join), &session->group_join, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_leave_group, (int)strlen(sql_leave_group), &session->leave_group, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_all_members, (int)strlen(sql_get_all_members), &session->get_all_members, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_active_members, (int)strlen(sql_get_active_members), &session->get_active_members, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_all_groups, (int)strlen(sql_get_all_groups), &session->get_all_groups, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_active_groups, (int)strlen(sql_get_active_groups), &session->get_active_groups, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_add_own_membership_entry, (int)strlen(sql_add_own_membership_entry), &session->add_own_membership_entry, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_own_membership_status, (int)strlen(sql_get_own_membership_status), &session->get_own_membership_status, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_retrieve_own_membership_info_for_group_and_ident, (int)strlen(sql_retrieve_own_membership_info_for_group_and_ident), &session->retrieve_own_membership_info_for_group_and_ident, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_retrieve_own_membership_info_for_group, (int)strlen(sql_retrieve_own_membership_info_for_group), &session->retrieve_own_membership_info_for_group, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_get_group_manager, (int)strlen(sql_get_group_manager), &session->get_group_manager, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_invited_group_member, (int)strlen(sql_is_invited_group_member), &session->is_invited_group_member, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_active_group_member, (int)strlen(sql_is_active_group_member), &session->is_active_group_member, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_is_group_active, (int)strlen(sql_is_group_active), &session->is_group_active, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; // int_result = sqlite3_prepare_v2(session->db, sql_group_invite_exists, // (int)strlen(sql_group_invite_exists), &session->group_invite_exists, NULL); // assert(int_result == SQLITE_OK); // // if (int_result != SQLITE_OK) // return PEP_UNKNOWN_DB_ERROR; int_result = sqlite3_prepare_v2(session->db, sql_log, (int)strlen(sql_log), &session->log, NULL); assert(int_result == SQLITE_OK); if (int_result != SQLITE_OK) return PEP_UNKNOWN_DB_ERROR; /* End groups */ return PEP_STATUS_OK; } PEP_STATUS pEp_finalize_sql_stmts(PEP_SESSION session) { sqlite3_finalize(session->log); sqlite3_finalize(session->trustword); sqlite3_finalize(session->get_identity); sqlite3_finalize(session->get_identity_without_trust_check); sqlite3_finalize(session->get_identities_by_address); sqlite3_finalize(session->get_identities_by_userid); sqlite3_finalize(session->get_identities_by_main_key_id); sqlite3_finalize(session->get_user_default_key); sqlite3_finalize(session->get_all_keys_for_user); sqlite3_finalize(session->get_default_own_userid); sqlite3_finalize(session->get_userid_alias_default); sqlite3_finalize(session->add_userid_alias); sqlite3_finalize(session->replace_identities_fpr); sqlite3_finalize(session->get_default_identity_fpr); sqlite3_finalize(session->remove_fpr_as_identity_default); sqlite3_finalize(session->remove_fpr_as_user_default); sqlite3_finalize(session->set_person); sqlite3_finalize(session->delete_person); sqlite3_finalize(session->update_person); sqlite3_finalize(session->set_as_pEp_user); sqlite3_finalize(session->upgrade_pEp_version_by_user_id); sqlite3_finalize(session->is_pEp_user); sqlite3_finalize(session->exists_person); sqlite3_finalize(session->add_into_social_graph); sqlite3_finalize(session->get_own_address_binding_from_contact); sqlite3_finalize(session->set_revoke_contact_as_notified); sqlite3_finalize(session->get_contacted_ids_from_revoke_fpr); sqlite3_finalize(session->was_id_for_revoke_contacted); sqlite3_finalize(session->has_id_contacted_address); sqlite3_finalize(session->get_last_contacted); sqlite3_finalize(session->set_pgp_keypair); sqlite3_finalize(session->exists_identity_entry); sqlite3_finalize(session->set_identity_entry); sqlite3_finalize(session->update_identity_entry); sqlite3_finalize(session->force_set_identity_username); sqlite3_finalize(session->set_identity_flags); sqlite3_finalize(session->unset_identity_flags); sqlite3_finalize(session->set_ident_enc_format); sqlite3_finalize(session->set_pEp_version); sqlite3_finalize(session->exists_trust_entry); sqlite3_finalize(session->clear_trust_info); sqlite3_finalize(session->set_trust); sqlite3_finalize(session->update_trust); sqlite3_finalize(session->update_trust_to_pEp); sqlite3_finalize(session->update_trust_for_fpr); sqlite3_finalize(session->get_trust); sqlite3_finalize(session->get_trust_by_userid); sqlite3_finalize(session->least_trust); sqlite3_finalize(session->update_key_sticky_bit_for_user); sqlite3_finalize(session->is_key_sticky_for_user); sqlite3_finalize(session->mark_compromised); sqlite3_finalize(session->crashdump); sqlite3_finalize(session->languagelist); sqlite3_finalize(session->i18n_token); sqlite3_finalize(session->replace_userid); sqlite3_finalize(session->delete_key); sqlite3_finalize(session->replace_main_user_fpr); sqlite3_finalize(session->replace_main_user_fpr_if_equal); sqlite3_finalize(session->get_main_user_fpr); sqlite3_finalize(session->refresh_userid_default_key); sqlite3_finalize(session->own_key_is_listed); sqlite3_finalize(session->is_own_address); sqlite3_finalize(session->own_identities_retrieve); sqlite3_finalize(session->own_keys_retrieve); // sqlite3_finalize(session->set_own_key); sqlite3_finalize(session->sequence_value1); sqlite3_finalize(session->sequence_value2); sqlite3_finalize(session->set_revoked); sqlite3_finalize(session->get_revoked); sqlite3_finalize(session->get_replacement_fpr); sqlite3_finalize(session->add_mistrusted_key); sqlite3_finalize(session->delete_mistrusted_key); sqlite3_finalize(session->is_mistrusted_key); sqlite3_finalize(session->create_group); sqlite3_finalize(session->enable_group); sqlite3_finalize(session->disable_group); sqlite3_finalize(session->exists_group_entry); sqlite3_finalize(session->group_add_member); sqlite3_finalize(session->group_delete_member); sqlite3_finalize(session->set_group_member_status); sqlite3_finalize(session->group_join); sqlite3_finalize(session->leave_group); sqlite3_finalize(session->get_all_members); sqlite3_finalize(session->get_active_members); sqlite3_finalize(session->get_active_groups); sqlite3_finalize(session->get_all_groups); sqlite3_finalize(session->add_own_membership_entry); sqlite3_finalize(session->get_own_membership_status); sqlite3_finalize(session->retrieve_own_membership_info_for_group_and_ident); sqlite3_finalize(session->retrieve_own_membership_info_for_group); sqlite3_finalize(session->get_group_manager); sqlite3_finalize(session->is_invited_group_member); sqlite3_finalize(session->is_active_group_member); sqlite3_finalize(session->is_group_active); sqlite3_finalize(session->set_pgp_keypair_flags); sqlite3_finalize(session->unset_pgp_keypair_flags); // retrieve_own_membership_info_for_group_and_ident // sqlite3_finalize(session->group_invite_exists); return PEP_STATUS_OK; }