ENGINE-382: changed alter table with non-constant default for timestamp to copy-insert-drop for version 8
1 // This file is under GNU General Public License 3.0
4 #include "pEp_internal.h"
5 #include "dynamic_api.h"
6 #include "cryptotech.h"
13 #define _PEP_SQLITE_DEBUG 0
18 static volatile int init_count = -1;
20 // sql overloaded functions - modified from sqlite3.c
21 static void _sql_lower(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
25 z2 = (char*)sqlite3_value_text(argv[0]);
26 n = sqlite3_value_bytes(argv[0]);
27 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
28 assert( z2==(char*)sqlite3_value_text(argv[0]) );
30 z1 = (char*)sqlite3_malloc(n+1);
34 char c_mod = c | 0x20;
35 if (c_mod < 0x61 || c_mod > 0x7a)
40 sqlite3_result_text(ctx, z1, n, sqlite3_free);
46 int sql_trace_callback (unsigned trace_constant,
50 switch (trace_constant) {
51 case SQLITE_TRACE_STMT:
52 fprintf(stderr, "SQL_DEBUG: STMT - ");
53 const char* X_str = (const char*) X;
54 if (!EMPTYSTR(X_str) && X_str[0] == '-' && X_str[1] == '-')
55 fprintf(stderr, "%s\n", X_str);
57 fprintf(stderr, "%s\n", sqlite3_expanded_sql((sqlite3_stmt*)P));
59 case SQLITE_TRACE_ROW:
60 fprintf(stderr, "SQL_DEBUG: ROW - ");
61 fprintf(stderr, "%s\n", sqlite3_expanded_sql((sqlite3_stmt*)P));
63 case SQLITE_TRACE_CLOSE:
64 fprintf(stderr, "SQL_DEBUG: CLOSE - ");
73 // sql manipulation statements
74 static const char *sql_log =
75 "insert into log (title, entity, description, comment)"
76 "values (?1, ?2, ?3, ?4);";
78 static const char *sql_trustword =
79 "select id, word from wordlist where lang = lower(?1) "
82 static const char *sql_get_identity =
83 "select fpr, username, comm_type, lang,"
84 " identity.flags | pgp_keypair.flags,"
87 " join person on id = identity.user_id"
88 " join pgp_keypair on fpr = identity.main_key_id"
89 " join trust on id = trust.user_id"
90 " and pgp_keypair_fpr = identity.main_key_id"
91 " where (case when (address = ?1) then (1)"
92 " when (lower(address) = lower(?1)) then (1)"
93 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
96 " and identity.user_id = ?2"
97 " order by is_own desc, "
100 static const char *sql_get_identity_without_trust_check =
101 "select identity.main_key_id, username, lang,"
102 " identity.flags, is_own"
104 " join person on id = identity.user_id"
105 " where (case when (address = ?1) then (1)"
106 " when (lower(address) = lower(?1)) then (1)"
107 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
110 " and identity.user_id = ?2 "
111 " order by is_own desc, "
114 static const char *sql_get_identities_by_address =
115 "select user_id, identity.main_key_id, username, lang,"
116 " identity.flags, is_own"
118 " join person on id = identity.user_id"
119 " where (case when (address = ?1) then (1)"
120 " when (lower(address) = lower(?1)) then (1)"
121 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
124 " order by is_own desc, "
127 static const char *sql_replace_identities_fpr =
129 " set main_key_id = ?1 "
130 " where main_key_id = ?2 ;";
132 static const char *sql_remove_fpr_as_default =
133 "update person set main_key_id = NULL where main_key_id = ?1 ;"
134 "update identity set main_key_id = NULL where main_key_id = ?1 ;";
136 // Set person, but if already exist, only update.
137 // if main_key_id already set, don't touch.
138 static const char *sql_set_person =
139 "insert into person (id, username, lang, main_key_id, device_group)"
140 " values (?1, ?2, ?3, ?4, "
141 " (select device_group from person where id = ?1)) ;";
143 static const char *sql_update_person =
145 " set username = ?2, "
148 " (select coalesce( "
149 " (select main_key_id from person where id = ?1), "
150 " upper(replace(?4,' ','')))),"
152 " (select device_group from person where id = ?1)"
155 static const char *sql_set_as_pep_user =
156 "update person set is_pep_user = 1 "
159 static const char *sql_is_pep_user =
160 "select is_pep_user from person "
163 static const char* sql_exists_person =
164 "select count(*) from person "
167 static const char *sql_set_device_group =
168 "update person set device_group = ?1 "
171 // This will cascade to identity and trust
172 static const char* sql_replace_userid =
173 "update person set id = ?1 "
176 static const char *sql_replace_main_user_fpr =
178 " set main_key_id = ?1 "
181 static const char *sql_get_main_user_fpr =
182 "select main_key_id from person"
185 static const char *sql_refresh_userid_default_key =
187 " set main_key_id = "
188 " (select identity.main_key_id from identity "
189 " join trust on trust.user_id = identity.user_id "
190 " and trust.pgp_keypair_fpr = identity.main_key_id "
191 " join person on identity.user_id = identity.user_id "
192 " where identity.user_id = ?1 "
193 " order by trust.comm_type desc "
197 static const char *sql_get_device_group =
198 "select device_group from person "
201 static const char *sql_set_pgp_keypair =
202 "insert or ignore into pgp_keypair (fpr) "
203 "values (upper(replace(?1,' ',''))) ;";
205 static const char* sql_exists_identity_entry =
206 "select count(*) from identity "
207 " where (case when (address = ?1) then (1)"
208 " when (lower(address) = lower(?1)) then (1)"
209 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
212 " and user_id = ?2;";
214 static const char *sql_set_identity_entry =
215 "insert into identity ("
216 " address, main_key_id, "
217 " user_id, flags, is_own"
220 " upper(replace(?2,' ','')),"
226 static const char* sql_update_identity_entry =
228 " set main_key_id = upper(replace(?2,' ','')), "
231 " where (case when (address = ?1) then (1)"
232 " when (lower(address) = lower(?1)) then (1)"
233 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1) "
236 " and user_id = ?3 ;";
240 // " (select flags from identity"
241 // " where address = ?1 and"
245 /* set_identity ignores previous flags, and doesn't filter machine flags */
247 static const char *sql_set_identity_flags =
248 "update identity set flags = "
249 " ((?1 & 255) | (select flags from identity"
250 " where (case when (address = ?2) then (1)"
251 " when (lower(address) = lower(?2)) then (1)"
252 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
255 " and user_id = ?3)) "
256 " where (case when (address = ?2) then (1)"
257 " when (lower(address) = lower(?2)) then (1)"
258 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
261 " and user_id = ?3 ;";
263 static const char *sql_unset_identity_flags =
264 "update identity set flags = "
265 " ( ~(?1 & 255) & (select flags from identity"
266 " where (case when (address = ?2) then (1)"
267 " when (lower(address) = lower(?2)) then (1)"
268 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
271 " and user_id = ?3)) "
272 " where (case when (address = ?2) then (1)"
273 " when (lower(address) = lower(?2)) then (1)"
274 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
277 " and user_id = ?3 ;";
279 static const char *sql_set_trust =
280 "insert into trust (user_id, pgp_keypair_fpr, comm_type) "
281 "values (?1, upper(replace(?2,' ','')), ?3) ;";
283 static const char *sql_update_trust =
284 "update trust set comm_type = ?3 "
285 " where user_id = ?1 and pgp_keypair_fpr = upper(replace(?2,' ',''));";
287 static const char* sql_exists_trust_entry =
288 "select count(*) from trust "
289 " where user_id = ?1 and pgp_keypair_fpr = upper(replace(?2,' ',''));";
291 static const char *sql_update_trust_for_fpr =
293 "set comm_type = ?1 "
294 "where pgp_keypair_fpr = upper(replace(?2,' ','')) ;";
296 static const char *sql_get_trust =
297 "select comm_type from trust where user_id = ?1 "
298 "and pgp_keypair_fpr = upper(replace(?2,' ','')) ;";
300 static const char *sql_least_trust =
301 "select min(comm_type) from trust where"
302 " pgp_keypair_fpr = upper(replace(?1,' ',''))"
303 " and comm_type != 0;"; // ignores PEP_ct_unknown
304 // returns PEP_ct_unknown only when no known trust is recorded
306 static const char *sql_mark_as_compromized =
307 "update trust not indexed set comm_type = 15"
308 " where pgp_keypair_fpr = upper(replace(?1,' ','')) ;";
310 static const char *sql_crashdump =
311 "select timestamp, title, entity, description, comment"
312 " from log order by timestamp desc limit ?1 ;";
314 static const char *sql_languagelist =
315 "select i18n_language.lang, name, phrase"
316 " from i18n_language join i18n_token using (lang) where i18n_token.id = 1000;" ;
318 static const char *sql_i18n_token =
319 "select phrase from i18n_token where lang = lower(?1) and id = ?2 ;";
322 static const char *sql_blacklist_add =
323 "insert or ignore into blacklist_keys (fpr) values (upper(replace(?1,' ',''))) ;"
324 "delete from identity where main_key_id = upper(replace(?1,' ','')) ;"
325 "delete from pgp_keypair where fpr = upper(replace(?1,' ','')) ;";
327 static const char *sql_blacklist_delete =
328 "delete from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
330 static const char *sql_blacklist_is_listed =
331 "select count(*) from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
333 static const char *sql_blacklist_retrieve =
334 "select * from blacklist_keys ;";
338 // We only care if it's 0 or non-zero
339 static const char *sql_own_key_is_listed =
340 "select count(*) from ("
341 " select pgp_keypair_fpr from trust"
342 " join identity on trust.user_id = identity.user_id"
343 " where pgp_keypair_fpr = upper(replace(?1,' ',''))"
344 " and identity.is_own = 1"
347 static const char *sql_own_identities_retrieve =
348 "select address, fpr, username, identity.user_id, "
349 " lang, identity.flags | pgp_keypair.flags"
351 " join person on id = identity.user_id"
352 " join pgp_keypair on fpr = identity.main_key_id"
353 " join trust on id = trust.user_id"
354 " and pgp_keypair_fpr = identity.main_key_id"
355 " where identity.is_own = 1"
356 " and (identity.flags & ?1) = 0;";
358 static const char *sql_own_keys_retrieve =
359 "select pgp_keypair_fpr from trust"
360 " join identity on trust.user_id = identity.user_id"
361 " where identity.is_own = 1";
363 static const char* sql_get_user_default_key =
364 "select main_key_id from person"
367 static const char* sql_get_default_own_userid =
368 "select id from person"
369 " join identity on id = identity.user_id"
370 " where identity.is_own = 1";
373 static const char *sql_sequence_value1 =
374 "insert or replace into sequences (name, value, own) "
376 " (select coalesce((select value + 1 from sequences "
377 " where name = ?1), 1 )), "
378 " (select coalesce((select own or ?2 from sequences "
379 " where name = ?1), ?2))) ; ";
381 static const char *sql_sequence_value2 =
382 "select value, own from sequences where name = ?1 ;";
384 static const char *sql_sequence_value3 =
385 "insert or replace into sequences (name, value, own) "
388 " (select coalesce((select own or ?3 from sequences "
389 " where name = ?1), ?3))) ; ";
391 // Revocation tracking
392 static const char *sql_set_revoked =
393 "insert or replace into revoked_keys ("
394 " revoked_fpr, replacement_fpr, revocation_date) "
395 "values (upper(replace(?1,' ','')),"
396 " upper(replace(?2,' ','')),"
399 static const char *sql_get_revoked =
400 "select revoked_fpr, revocation_date from revoked_keys"
401 " where replacement_fpr = upper(replace(?1,' ','')) ;";
403 static const char *sql_get_userid_alias_default =
404 "select default_id from alternate_user_id "
405 " where alternate_id = ?1 ; ";
407 // Revocation tracking
408 static const char *sql_add_mistrusted_key =
409 "insert or replace into mistrusted_keys (fpr) "
410 " values (upper(replace(?1,' ',''))) ;";
412 static const char *sql_delete_mistrusted_key =
413 "delete from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
415 static const char *sql_is_mistrusted_key =
416 "select count(*) from mistrusted_keys where fpr = upper(replace(?1,' ','')) ;";
418 static const char *sql_add_userid_alias =
419 "insert or replace into alternate_user_id (alternate_id, default_id) "
422 static int user_version(void *_version, int count, char **text, char **name)
426 assert(text && text[0]);
427 if (!(_version && count == 1 && text && text[0]))
430 int *version = (int *) _version;
431 *version = atoi(text[0]);
435 static int table_contains_column(PEP_SESSION session, const char* table_name,
436 const char* col_name) {
439 if (!session || !table_name || !col_name)
442 // Table names can't be SQL parameters, so we do it this way.
444 // these two must be the same number.
446 const size_t max_q_len = 500;
448 size_t t_size, c_size, q_size;
450 const char* q1 = "SELECT "; // 7
451 const char* q2 = " from "; // 6
452 const char* q3 = ";"; // 1
455 t_size = strlen(table_name);
456 c_size = strlen(col_name);
458 size_t query_len = q_size + c_size + t_size + 1;
460 if (query_len > max_q_len)
463 strlcpy(sql_buf, q1, max_q_len);
464 strlcat(sql_buf, col_name, max_q_len);
465 strlcat(sql_buf, q2, max_q_len);
466 strlcat(sql_buf, table_name, max_q_len);
467 strlcat(sql_buf, q3, max_q_len);
471 sqlite3_prepare_v2(session->db, sql_buf, -1, &stmt, NULL);
475 int rc = sqlite3_step(stmt);
476 if (rc == SQLITE_DONE || rc == SQLITE_OK || rc == SQLITE_ROW) {
480 sqlite3_finalize(stmt);
485 void errorLogCallback(void *pArg, int iErrCode, const char *zMsg){
486 fprintf(stderr, "(%d) %s\n", iErrCode, zMsg);
489 DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
491 PEP_STATUS status = PEP_STATUS_OK;
494 bool in_first = false;
495 bool very_first = false;
497 assert(sqlite3_threadsafe());
498 if (!sqlite3_threadsafe())
499 return PEP_INIT_SQLITE3_WITHOUT_MUTEX;
501 // a little race condition - but still a race condition
502 // mitigated by calling caveat (see documentation)
504 // this increment is made atomic IN THE ADAPTERS by
505 // guarding the call to init with the appropriate mutex.
506 int _count = ++init_count;
510 // Race condition mitigated by calling caveat starts here :
511 // If another call to init() preempts right now, then preemptive call
512 // will have in_first false, will not create SQL tables, and following
513 // calls relying on those tables will fail.
515 // Therefore, as above, adapters MUST guard init() with a mutex.
517 // Therefore, first session
518 // is to be created and last session to be deleted alone, and not
519 // concurently to other sessions creation or deletion.
520 // We expect adapters to enforce this either by implicitely creating a
521 // client session, or by using synchronization primitive to protect
522 // creation/deletion of first/last session from the app.
526 return PEP_ILLEGAL_VALUE;
530 pEpSession *_session = calloc(1, sizeof(pEpSession));
532 if (_session == NULL)
535 _session->version = PEP_ENGINE_VERSION;
537 #ifdef DEBUG_ERRORSTACK
538 _session->errorstack = new_stringlist("init()");
542 if (LOCAL_DB == NULL) {
543 status = PEP_INIT_CANNOT_OPEN_DB;
547 #if _PEP_SQLITE_DEBUG
548 sqlite3_config(SQLITE_CONFIG_LOG, errorLogCallback, NULL);
551 int_result = sqlite3_open_v2(
554 SQLITE_OPEN_READWRITE
556 | SQLITE_OPEN_FULLMUTEX
557 | SQLITE_OPEN_PRIVATECACHE,
561 if (int_result != SQLITE_OK) {
562 status = PEP_INIT_CANNOT_OPEN_DB;
566 int_result = sqlite3_exec(
568 "PRAGMA locking_mode=NORMAL;\n"
569 "PRAGMA journal_mode=WAL;\n",
576 sqlite3_busy_timeout(_session->db, BUSY_WAIT_TIME);
578 #if _PEP_SQLITE_DEBUG
579 sqlite3_trace_v2(_session->db,
580 SQLITE_TRACE_STMT | SQLITE_TRACE_ROW | SQLITE_TRACE_CLOSE,
586 if (SYSTEM_DB == NULL) {
587 status = PEP_INIT_CANNOT_OPEN_SYSTEM_DB;
591 int_result = sqlite3_open_v2(
592 SYSTEM_DB, &_session->system_db,
594 | SQLITE_OPEN_FULLMUTEX
595 | SQLITE_OPEN_SHAREDCACHE,
599 if (int_result != SQLITE_OK) {
600 status = PEP_INIT_CANNOT_OPEN_SYSTEM_DB;
604 sqlite3_busy_timeout(_session->system_db, 1000);
606 // increment this when patching DDL
607 #define _DDL_USER_VERSION "8"
611 int_result = sqlite3_exec(
613 "create table if not exists version_info (\n"
614 " id integer primary key,\n"
615 " timestamp integer default (datetime('now')),\n"
623 int_result = sqlite3_exec(
625 "PRAGMA application_id = 0x23423423;\n"
626 "create table if not exists log (\n"
627 " timestamp integer default (datetime('now')),\n"
628 " title text not null,\n"
629 " description text,\n"
630 " entity text not null,\n"
633 "create index if not exists log_timestamp on log (\n"
636 "create table if not exists pgp_keypair (\n"
637 " fpr text primary key,\n"
638 " created integer,\n"
639 " expires integer,\n"
641 " flags integer default 0\n"
643 "create index if not exists pgp_keypair_expires on pgp_keypair (\n"
646 "create table if not exists person (\n"
647 " id text primary key,\n"
648 " username text not null,\n"
649 " main_key_id text\n"
650 " references pgp_keypair (fpr)\n"
651 " on delete set null,\n"
654 " device_group text,\n"
655 " is_pep_user integer default 0\n"
657 "create table if not exists identity (\n"
660 " references person (id)\n"
661 " on delete cascade on update cascade,\n"
662 " main_key_id text\n"
663 " references pgp_keypair (fpr)\n"
664 " on delete set null,\n"
666 " flags integer default 0,\n"
667 " is_own integer default 0,\n"
668 " timestamp integer default (datetime('now')),\n"
669 " primary key (address, user_id)\n"
671 "create table if not exists trust (\n"
672 " user_id text not null\n"
673 " references person (id)\n"
674 " on delete cascade on update cascade,\n"
675 " pgp_keypair_fpr text not null\n"
676 " references pgp_keypair (fpr)\n"
677 " on delete cascade,\n"
678 " comm_type integer not null,\n"
680 " primary key (user_id, pgp_keypair_fpr)\n"
683 "create table if not exists blacklist_keys (\n"
684 " fpr text primary key\n"
687 "create table if not exists sequences(\n"
688 " name text primary key,\n"
689 " value integer default 0,\n"
690 " own integer default 0\n"
692 "create table if not exists revoked_keys (\n"
693 " revoked_fpr text primary key,\n"
694 " replacement_fpr text not null\n"
695 " references pgp_keypair (fpr)\n"
696 " on delete cascade,\n"
697 " revocation_date integer\n"
700 "create table if not exists alternate_user_id (\n"
701 " default_id text references person (id)\n"
702 " on delete cascade on update cascade,\n"
703 " alternate_id text primary key\n"
706 "create table if not exists mistrusted_keys (\n"
707 " fpr text primary key\n"
714 assert(int_result == SQLITE_OK);
717 int_result = sqlite3_exec(
719 "pragma user_version;",
725 assert(int_result == SQLITE_OK);
727 void (*xFunc_lower)(sqlite3_context*,int,sqlite3_value**) = &_sql_lower;
729 int_result = sqlite3_create_function_v2(
733 SQLITE_UTF8 | SQLITE_DETERMINISTIC,
739 assert(int_result == SQLITE_OK);
741 int_result = sqlite3_exec(
743 "pragma foreign_keys=ON;\n",
749 assert(int_result == SQLITE_OK);
752 // Sometimes the user_version wasn't set correctly. Check to see if this
753 // is really necessary...
755 bool version_changed = true;
756 if (table_contains_column(_session, "identity", "timestamp") > 0) {
759 if (table_contains_column(_session, "person", "is_pep_user") > 0) {
762 else if (table_contains_column(_session, "identity", "is_own") > 0) {
765 else if (table_contains_column(_session, "sequences", "own") > 0) {
768 else if (table_contains_column(_session, "pgp_keypair", "flags") > 0) {
772 version_changed = false;
775 if (version_changed) {
776 // set it in the DB, finally. Yeesh.
777 char verbuf[21]; // enough digits for a max-sized 64 bit int, cmon.
778 sprintf(verbuf,"%d",version);
780 size_t query_size = strlen(verbuf) + 25;
781 char* query = calloc(query_size, 1);
783 strlcpy(query, "pragma user_version = ", query_size);
784 strlcat(query, verbuf, query_size);
785 strlcat(query, ";", query_size);
787 int_result = sqlite3_exec(
800 // Version has been already set
802 // Early mistake : version 0 shouldn't have existed.
803 // Numbering should have started at 1 to detect newly created DB.
804 // Version 0 DBs are not anymore compatible.
806 // // Was version 0 compat code.
807 // if (version < 1) {
808 // int_result = sqlite3_exec(
810 // "alter table identity\n"
811 // " add column flags integer default 0;\n",
816 // assert(int_result == SQLITE_OK);
820 int_result = sqlite3_exec(
822 "alter table pgp_keypair\n"
823 " add column flags integer default 0;\n"
824 "alter table person\n"
825 " add column device_group text;\n",
830 assert(int_result == SQLITE_OK);
834 int_result = sqlite3_exec(
836 "alter table sequences\n"
837 " add column own integer default 0;\n",
842 assert(int_result == SQLITE_OK);
846 int_result = sqlite3_exec(
848 "delete from pgp_keypair where fpr = '';",
853 assert(int_result == SQLITE_OK);
854 int_result = sqlite3_exec(
856 "delete from trust where pgp_keypair_fpr = '';",
861 assert(int_result == SQLITE_OK);
865 int_result = sqlite3_exec(
867 "alter table identity\n"
868 " add column is_own integer default 0;\n",
873 assert(int_result == SQLITE_OK);
874 int_result = sqlite3_exec(
878 " where (user_id = '" PEP_OWN_USERID "');\n",
883 assert(int_result == SQLITE_OK);
885 // Turns out that just adding "on update cascade" in
886 // sqlite is a PITA. We need to be able to cascade
887 // person->id replacements (for temp ids like "TOFU_")
889 int_result = sqlite3_exec(
891 "PRAGMA foreign_keys=off;\n"
892 "BEGIN TRANSACTION;\n"
893 "ALTER TABLE identity RENAME TO _identity_old;\n"
894 "create table identity (\n"
897 " references person (id)\n"
898 " on delete cascade on update cascade,\n"
899 " main_key_id text\n"
900 " references pgp_keypair (fpr)\n"
901 " on delete set null,\n"
903 " flags integer default 0,\n"
904 " is_own integer default 0,\n"
905 " primary key (address, user_id)\n"
907 "INSERT INTO identity SELECT * FROM _identity_old;\n"
908 "DROP TABLE _identity_old;\n"
909 "ALTER TABLE trust RENAME TO _trust_old;\n"
910 "create table trust (\n"
911 " user_id text not null\n"
912 " references person (id)\n"
913 " on delete cascade on update cascade,\n"
914 " pgp_keypair_fpr text not null\n"
915 " references pgp_keypair (fpr)\n"
916 " on delete cascade,\n"
917 " comm_type integer not null,\n"
919 " primary key (user_id, pgp_keypair_fpr)\n"
921 "INSERT INTO trust SELECT * FROM _trust_old;\n"
922 "DROP TABLE _trust_old;\n"
925 "PRAGMA foreign_keys=on;\n"
926 "create table if not exists alternate_user_id (\n"
927 " default_id text references person (id)\n"
928 " on delete cascade on update cascade,\n"
929 " alternate_id text primary key\n"
936 assert(int_result == SQLITE_OK);
939 int_result = sqlite3_exec(
941 "alter table person\n"
942 " add column is_pep_user integer default 0;\n",
947 assert(int_result == SQLITE_OK);
948 int_result = sqlite3_exec(
951 " set is_pep_user = 1\n"
953 " (select distinct id from person "
954 " join trust on id = user_id "
955 " where (case when (comm_type = 127) then (id) "
956 " when (comm_type = 255) then (id) "
963 assert(int_result == SQLITE_OK);
965 int_result = sqlite3_exec(
967 "create table if not exists mistrusted_keys (\n"
968 " fpr text primary key\n"
974 assert(int_result == SQLITE_OK);
977 int_result = sqlite3_exec(
979 "PRAGMA foreign_keys=off;\n"
980 "BEGIN TRANSACTION;\n"
981 "ALTER TABLE identity RENAME TO _identity_old;\n"
982 "create table identity (\n"
985 " references person (id)\n"
986 " on delete cascade on update cascade,\n"
987 " main_key_id text\n"
988 " references pgp_keypair (fpr)\n"
989 " on delete set null,\n"
991 " flags integer default 0,\n"
992 " is_own integer default 0,\n"
993 " timestamp integer default (datetime('now')),\n"
994 " primary key (address, user_id)\n"
996 "INSERT INTO identity SELECT * FROM _identity_old;\n"
997 "DROP TABLE _identity_old;\n"
1000 "PRAGMA foreign_keys=on;\n"
1006 assert(int_result == SQLITE_OK);
1010 // Version from DB was 0, it means this is initial setup.
1011 // DB has just been created, and all tables are empty.
1015 if (version < atoi(_DDL_USER_VERSION)) {
1016 int_result = sqlite3_exec(
1018 "pragma user_version = "_DDL_USER_VERSION";\n"
1019 "insert or replace into version_info (id, version)"
1020 "values (1, '" PEP_ENGINE_VERSION "');",
1025 assert(int_result == SQLITE_OK);
1028 // We need to init a few globals for message id that we'd rather not
1029 // calculate more than once.
1033 int_result = sqlite3_prepare_v2(_session->db, sql_log,
1034 (int)strlen(sql_log), &_session->log, NULL);
1035 assert(int_result == SQLITE_OK);
1037 int_result = sqlite3_prepare_v2(_session->system_db, sql_trustword,
1038 (int)strlen(sql_trustword), &_session->trustword, NULL);
1039 assert(int_result == SQLITE_OK);
1041 int_result = sqlite3_prepare_v2(_session->db, sql_get_identity,
1042 (int)strlen(sql_get_identity), &_session->get_identity, NULL);
1043 assert(int_result == SQLITE_OK);
1045 int_result = sqlite3_prepare_v2(_session->db, sql_get_identity_without_trust_check,
1046 (int)strlen(sql_get_identity_without_trust_check),
1047 &_session->get_identity_without_trust_check, NULL);
1048 assert(int_result == SQLITE_OK);
1050 int_result = sqlite3_prepare_v2(_session->db, sql_get_identities_by_address,
1051 (int)strlen(sql_get_identities_by_address),
1052 &_session->get_identities_by_address, NULL);
1053 assert(int_result == SQLITE_OK);
1055 int_result = sqlite3_prepare_v2(_session->db, sql_get_user_default_key,
1056 (int)strlen(sql_get_user_default_key), &_session->get_user_default_key, NULL);
1057 assert(int_result == SQLITE_OK);
1059 int_result = sqlite3_prepare_v2(_session->db, sql_get_default_own_userid,
1060 (int)strlen(sql_get_default_own_userid), &_session->get_default_own_userid, NULL);
1061 assert(int_result == SQLITE_OK);
1063 int_result = sqlite3_prepare_v2(_session->db, sql_get_userid_alias_default,
1064 (int)strlen(sql_get_userid_alias_default), &_session->get_userid_alias_default, NULL);
1065 assert(int_result == SQLITE_OK);
1067 int_result = sqlite3_prepare_v2(_session->db, sql_add_userid_alias,
1068 (int)strlen(sql_add_userid_alias), &_session->add_userid_alias, NULL);
1069 assert(int_result == SQLITE_OK);
1071 int_result = sqlite3_prepare_v2(_session->db, sql_replace_userid,
1072 (int)strlen(sql_replace_userid), &_session->replace_userid, NULL);
1073 assert(int_result == SQLITE_OK);
1075 int_result = sqlite3_prepare_v2(_session->db, sql_replace_main_user_fpr,
1076 (int)strlen(sql_replace_main_user_fpr), &_session->replace_main_user_fpr, NULL);
1077 assert(int_result == SQLITE_OK);
1079 int_result = sqlite3_prepare_v2(_session->db, sql_get_main_user_fpr,
1080 (int)strlen(sql_get_main_user_fpr), &_session->get_main_user_fpr, NULL);
1081 assert(int_result == SQLITE_OK);
1083 int_result = sqlite3_prepare_v2(_session->db, sql_refresh_userid_default_key,
1084 (int)strlen(sql_refresh_userid_default_key), &_session->refresh_userid_default_key, NULL);
1085 assert(int_result == SQLITE_OK);
1087 int_result = sqlite3_prepare_v2(_session->db, sql_replace_identities_fpr,
1088 (int)strlen(sql_replace_identities_fpr),
1089 &_session->replace_identities_fpr, NULL);
1090 assert(int_result == SQLITE_OK);
1092 int_result = sqlite3_prepare_v2(_session->db, sql_remove_fpr_as_default,
1093 (int)strlen(sql_remove_fpr_as_default),
1094 &_session->remove_fpr_as_default, NULL);
1095 assert(int_result == SQLITE_OK);
1097 int_result = sqlite3_prepare_v2(_session->db, sql_set_person,
1098 (int)strlen(sql_set_person), &_session->set_person, NULL);
1099 assert(int_result == SQLITE_OK);
1101 int_result = sqlite3_prepare_v2(_session->db, sql_update_person,
1102 (int)strlen(sql_update_person), &_session->update_person, NULL);
1103 assert(int_result == SQLITE_OK);
1105 int_result = sqlite3_prepare_v2(_session->db, sql_exists_person,
1106 (int)strlen(sql_exists_person), &_session->exists_person, NULL);
1107 assert(int_result == SQLITE_OK);
1109 int_result = sqlite3_prepare_v2(_session->db, sql_set_as_pep_user,
1110 (int)strlen(sql_set_as_pep_user), &_session->set_as_pep_user, NULL);
1111 assert(int_result == SQLITE_OK);
1113 int_result = sqlite3_prepare_v2(_session->db, sql_is_pep_user,
1114 (int)strlen(sql_is_pep_user), &_session->is_pep_user, NULL);
1115 assert(int_result == SQLITE_OK);
1117 int_result = sqlite3_prepare_v2(_session->db, sql_set_device_group,
1118 (int)strlen(sql_set_device_group), &_session->set_device_group, NULL);
1119 assert(int_result == SQLITE_OK);
1121 int_result = sqlite3_prepare_v2(_session->db, sql_get_device_group,
1122 (int)strlen(sql_get_device_group), &_session->get_device_group, NULL);
1123 assert(int_result == SQLITE_OK);
1125 int_result = sqlite3_prepare_v2(_session->db, sql_set_pgp_keypair,
1126 (int)strlen(sql_set_pgp_keypair), &_session->set_pgp_keypair,
1128 assert(int_result == SQLITE_OK);
1130 int_result = sqlite3_prepare_v2(_session->db, sql_set_identity_entry,
1131 (int)strlen(sql_set_identity_entry), &_session->set_identity_entry, NULL);
1132 assert(int_result == SQLITE_OK);
1134 int_result = sqlite3_prepare_v2(_session->db, sql_update_identity_entry,
1135 (int)strlen(sql_update_identity_entry), &_session->update_identity_entry, NULL);
1136 assert(int_result == SQLITE_OK);
1138 int_result = sqlite3_prepare_v2(_session->db, sql_exists_identity_entry,
1139 (int)strlen(sql_exists_identity_entry), &_session->exists_identity_entry, NULL);
1140 assert(int_result == SQLITE_OK);
1142 int_result = sqlite3_prepare_v2(_session->db, sql_set_identity_flags,
1143 (int)strlen(sql_set_identity_flags), &_session->set_identity_flags,
1145 assert(int_result == SQLITE_OK);
1147 int_result = sqlite3_prepare_v2(_session->db, sql_unset_identity_flags,
1148 (int)strlen(sql_unset_identity_flags), &_session->unset_identity_flags,
1150 assert(int_result == SQLITE_OK);
1152 int_result = sqlite3_prepare_v2(_session->db, sql_set_trust,
1153 (int)strlen(sql_set_trust), &_session->set_trust, NULL);
1154 assert(int_result == SQLITE_OK);
1156 int_result = sqlite3_prepare_v2(_session->db, sql_update_trust,
1157 (int)strlen(sql_update_trust), &_session->update_trust, NULL);
1158 assert(int_result == SQLITE_OK);
1160 int_result = sqlite3_prepare_v2(_session->db, sql_exists_trust_entry,
1161 (int)strlen(sql_exists_trust_entry), &_session->exists_trust_entry, NULL);
1162 assert(int_result == SQLITE_OK);
1164 int_result = sqlite3_prepare_v2(_session->db, sql_update_trust_for_fpr,
1165 (int)strlen(sql_update_trust_for_fpr), &_session->update_trust_for_fpr, NULL);
1166 assert(int_result == SQLITE_OK);
1168 int_result = sqlite3_prepare_v2(_session->db, sql_get_trust,
1169 (int)strlen(sql_get_trust), &_session->get_trust, NULL);
1170 assert(int_result == SQLITE_OK);
1172 int_result = sqlite3_prepare_v2(_session->db, sql_least_trust,
1173 (int)strlen(sql_least_trust), &_session->least_trust, NULL);
1174 assert(int_result == SQLITE_OK);
1176 int_result = sqlite3_prepare_v2(_session->db, sql_mark_as_compromized,
1177 (int)strlen(sql_mark_as_compromized), &_session->mark_compromized,
1179 assert(int_result == SQLITE_OK);
1181 int_result = sqlite3_prepare_v2(_session->db, sql_crashdump,
1182 (int)strlen(sql_crashdump), &_session->crashdump, NULL);
1183 assert(int_result == SQLITE_OK);
1185 int_result = sqlite3_prepare_v2(_session->system_db, sql_languagelist,
1186 (int)strlen(sql_languagelist), &_session->languagelist, NULL);
1187 assert(int_result == SQLITE_OK);
1189 int_result = sqlite3_prepare_v2(_session->system_db, sql_i18n_token,
1190 (int)strlen(sql_i18n_token), &_session->i18n_token, NULL);
1191 assert(int_result == SQLITE_OK);
1195 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_add,
1196 (int)strlen(sql_blacklist_add), &_session->blacklist_add, NULL);
1197 assert(int_result == SQLITE_OK);
1199 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_delete,
1200 (int)strlen(sql_blacklist_delete), &_session->blacklist_delete,
1202 assert(int_result == SQLITE_OK);
1204 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_is_listed,
1205 (int)strlen(sql_blacklist_is_listed),
1206 &_session->blacklist_is_listed, NULL);
1207 assert(int_result == SQLITE_OK);
1209 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_retrieve,
1210 (int)strlen(sql_blacklist_retrieve), &_session->blacklist_retrieve,
1212 assert(int_result == SQLITE_OK);
1216 int_result = sqlite3_prepare_v2(_session->db, sql_own_key_is_listed,
1217 (int)strlen(sql_own_key_is_listed), &_session->own_key_is_listed,
1219 assert(int_result == SQLITE_OK);
1221 int_result = sqlite3_prepare_v2(_session->db, sql_own_identities_retrieve,
1222 (int)strlen(sql_own_identities_retrieve),
1223 &_session->own_identities_retrieve, NULL);
1224 assert(int_result == SQLITE_OK);
1226 int_result = sqlite3_prepare_v2(_session->db, sql_own_keys_retrieve,
1227 (int)strlen(sql_own_keys_retrieve),
1228 &_session->own_keys_retrieve, NULL);
1229 assert(int_result == SQLITE_OK);
1231 // int_result = sqlite3_prepare_v2(_session->db, sql_set_own_key,
1232 // (int)strlen(sql_set_own_key),
1233 // &_session->set_own_key, NULL);
1234 // assert(int_result == SQLITE_OK);
1238 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value1,
1239 (int)strlen(sql_sequence_value1), &_session->sequence_value1,
1241 assert(int_result == SQLITE_OK);
1243 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value2,
1244 (int)strlen(sql_sequence_value2), &_session->sequence_value2,
1246 assert(int_result == SQLITE_OK);
1248 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value3,
1249 (int)strlen(sql_sequence_value3), &_session->sequence_value3,
1251 assert(int_result == SQLITE_OK);
1253 // Revocation tracking
1255 int_result = sqlite3_prepare_v2(_session->db, sql_set_revoked,
1256 (int)strlen(sql_set_revoked), &_session->set_revoked, NULL);
1257 assert(int_result == SQLITE_OK);
1259 int_result = sqlite3_prepare_v2(_session->db, sql_get_revoked,
1260 (int)strlen(sql_get_revoked), &_session->get_revoked, NULL);
1261 assert(int_result == SQLITE_OK);
1263 int_result = sqlite3_prepare_v2(_session->db, sql_add_mistrusted_key,
1264 (int)strlen(sql_add_mistrusted_key), &_session->add_mistrusted_key, NULL);
1265 assert(int_result == SQLITE_OK);
1267 int_result = sqlite3_prepare_v2(_session->db, sql_delete_mistrusted_key,
1268 (int)strlen(sql_delete_mistrusted_key), &_session->delete_mistrusted_key, NULL);
1269 assert(int_result == SQLITE_OK);
1271 int_result = sqlite3_prepare_v2(_session->db, sql_is_mistrusted_key,
1272 (int)strlen(sql_is_mistrusted_key), &_session->is_mistrusted_key, NULL);
1273 assert(int_result == SQLITE_OK);
1275 status = init_cryptotech(_session, in_first);
1276 if (status != PEP_STATUS_OK)
1279 status = init_transport_system(_session, in_first);
1280 if (status != PEP_STATUS_OK)
1283 status = log_event(_session, "init", "pEp " PEP_ENGINE_VERSION, NULL, NULL);
1284 if (status != PEP_STATUS_OK)
1291 // On first run, all private keys already present in PGP keyring
1292 // are taken as own in order to seamlessly integrate with
1293 // pre-existing GPG setup.
1295 // Note: earlier fears about danger because of DB reinitialisation should
1296 // be a non-issue here, as we ONLY take the ultimately trusted keys now.
1297 // Thus, unless the user has assigned ultimate trust through PGP, there is
1298 // no chance of automatically imported pEp keys from a previous run making
1299 // their way into PEP trusted status without explicit action (Bare imported
1300 // private keys have an 'unknown' trust designation in PGP).
1302 // We don't really worry about the status here.
1303 status = import_trusted_own_keys(_session);
1306 // sync_session set to own session by default
1307 // sync_session is then never null on a valid session
1308 _session->sync_session = _session;
1310 *session = _session;
1312 // Note: Following statement is NOT for any cryptographic/secure functionality; it is
1313 // ONLY used for some randomness in generated outer message ID, which are
1314 // required by the RFC to be globally unique!
1317 return PEP_STATUS_OK;
1320 status = PEP_OUT_OF_MEMORY;
1327 DYNAMIC_API void release(PEP_SESSION session)
1329 bool out_last = false;
1330 int _count = --init_count;
1332 assert(_count >= -1);
1335 if (!((_count >= -1) && session))
1338 // a small race condition but still a race condition
1339 // mitigated by calling caveat (see documentation)
1340 // (release() is to be guarded by a mutex by the caller)
1348 sqlite3_finalize(session->log);
1349 if (session->trustword)
1350 sqlite3_finalize(session->trustword);
1351 if (session->get_identity)
1352 sqlite3_finalize(session->get_identity);
1353 if (session->get_identity_without_trust_check)
1354 sqlite3_finalize(session->get_identity_without_trust_check);
1355 if (session->get_identities_by_address)
1356 sqlite3_finalize(session->get_identities_by_address);
1357 if (session->get_user_default_key)
1358 sqlite3_finalize(session->get_user_default_key);
1359 if (session->get_default_own_userid)
1360 sqlite3_finalize(session->get_default_own_userid);
1361 if (session->get_userid_alias_default)
1362 sqlite3_finalize(session->get_userid_alias_default);
1363 if (session->add_userid_alias)
1364 sqlite3_finalize(session->add_userid_alias);
1365 if (session->replace_identities_fpr)
1366 sqlite3_finalize(session->replace_identities_fpr);
1367 if (session->remove_fpr_as_default)
1368 sqlite3_finalize(session->remove_fpr_as_default);
1369 if (session->set_person)
1370 sqlite3_finalize(session->set_person);
1371 if (session->set_as_pep_user)
1372 sqlite3_finalize(session->set_as_pep_user);
1373 if (session->is_pep_user)
1374 sqlite3_finalize(session->is_pep_user);
1375 if (session->exists_person)
1376 sqlite3_finalize(session->exists_person);
1377 if (session->set_device_group)
1378 sqlite3_finalize(session->set_device_group);
1379 if (session->get_device_group)
1380 sqlite3_finalize(session->get_device_group);
1381 if (session->set_pgp_keypair)
1382 sqlite3_finalize(session->set_pgp_keypair);
1383 if (session->exists_identity_entry)
1384 sqlite3_finalize(session->exists_identity_entry);
1385 if (session->set_identity_entry)
1386 sqlite3_finalize(session->set_identity_entry);
1387 if (session->update_identity_entry)
1388 sqlite3_finalize(session->update_identity_entry);
1389 if (session->set_identity_flags)
1390 sqlite3_finalize(session->set_identity_flags);
1391 if (session->unset_identity_flags)
1392 sqlite3_finalize(session->unset_identity_flags);
1393 if (session->exists_trust_entry)
1394 sqlite3_finalize(session->exists_trust_entry);
1395 if (session->set_trust)
1396 sqlite3_finalize(session->set_trust);
1397 if (session->update_trust)
1398 sqlite3_finalize(session->update_trust);
1399 if (session->update_trust_for_fpr)
1400 sqlite3_finalize(session->update_trust_for_fpr);
1401 if (session->get_trust)
1402 sqlite3_finalize(session->get_trust);
1403 if (session->least_trust)
1404 sqlite3_finalize(session->least_trust);
1405 if (session->mark_compromized)
1406 sqlite3_finalize(session->mark_compromized);
1407 if (session->crashdump)
1408 sqlite3_finalize(session->crashdump);
1409 if (session->languagelist)
1410 sqlite3_finalize(session->languagelist);
1411 if (session->i18n_token)
1412 sqlite3_finalize(session->i18n_token);
1413 if (session->replace_userid)
1414 sqlite3_finalize(session->replace_userid);
1415 if (session->replace_main_user_fpr)
1416 sqlite3_finalize(session->replace_main_user_fpr);
1417 if (session->get_main_user_fpr)
1418 sqlite3_finalize(session->get_main_user_fpr);
1419 if (session->refresh_userid_default_key)
1420 sqlite3_finalize(session->refresh_userid_default_key);
1421 if (session->blacklist_add)
1422 sqlite3_finalize(session->blacklist_add);
1423 if (session->blacklist_delete)
1424 sqlite3_finalize(session->blacklist_delete);
1425 if (session->blacklist_is_listed)
1426 sqlite3_finalize(session->blacklist_is_listed);
1427 if (session->blacklist_retrieve)
1428 sqlite3_finalize(session->blacklist_retrieve);
1429 if (session->own_key_is_listed)
1430 sqlite3_finalize(session->own_key_is_listed);
1431 if (session->own_identities_retrieve)
1432 sqlite3_finalize(session->own_identities_retrieve);
1433 if (session->own_keys_retrieve)
1434 sqlite3_finalize(session->own_keys_retrieve);
1435 // if (session->set_own_key)
1436 // sqlite3_finalize(session->set_own_key);
1437 if (session->sequence_value1)
1438 sqlite3_finalize(session->sequence_value1);
1439 if (session->sequence_value2)
1440 sqlite3_finalize(session->sequence_value2);
1441 if (session->sequence_value3)
1442 sqlite3_finalize(session->sequence_value3);
1443 if (session->set_revoked)
1444 sqlite3_finalize(session->set_revoked);
1445 if (session->get_revoked)
1446 sqlite3_finalize(session->get_revoked);
1448 if (session->add_mistrusted_key)
1449 sqlite3_finalize(session->add_mistrusted_key);
1450 if (session->delete_mistrusted_key)
1451 sqlite3_finalize(session->delete_mistrusted_key);
1452 if (session->is_mistrusted_key)
1453 sqlite3_finalize(session->is_mistrusted_key);
1456 sqlite3_close_v2(session->db);
1457 if (session->system_db)
1458 sqlite3_close_v2(session->system_db);
1461 release_transport_system(session, out_last);
1462 release_cryptotech(session, out_last);
1464 #ifdef DEBUG_ERRORSTACK
1465 free_stringlist(session->errorstack);
1471 DYNAMIC_API void config_passive_mode(PEP_SESSION session, bool enable)
1474 session->passive_mode = enable;
1477 DYNAMIC_API void config_unencrypted_subject(PEP_SESSION session, bool enable)
1480 session->unencrypted_subject = enable;
1483 DYNAMIC_API void config_keep_sync_msg(PEP_SESSION session, bool enable)
1486 session->keep_sync_msg = enable;
1489 DYNAMIC_API void config_service_log(PEP_SESSION session, bool enable)
1492 session->service_log = enable;
1495 DYNAMIC_API PEP_STATUS log_event(
1496 PEP_SESSION session,
1499 const char *description,
1503 // PEP_STATUS status = PEP_STATUS_OK;
1510 if (!(session && title && entity))
1511 return PEP_ILLEGAL_VALUE;
1513 sqlite3_reset(session->log);
1514 sqlite3_bind_text(session->log, 1, title, -1, SQLITE_STATIC);
1515 sqlite3_bind_text(session->log, 2, entity, -1, SQLITE_STATIC);
1517 sqlite3_bind_text(session->log, 3, description, -1, SQLITE_STATIC);
1519 sqlite3_bind_null(session->log, 3);
1521 sqlite3_bind_text(session->log, 4, comment, -1, SQLITE_STATIC);
1523 sqlite3_bind_null(session->log, 4);
1524 result = sqlite3_step(session->log);
1525 sqlite3_reset(session->log);
1527 return PEP_STATUS_OK; // We ignore errors for this function.
1530 DYNAMIC_API PEP_STATUS log_service(
1531 PEP_SESSION session,
1534 const char *description,
1540 return PEP_ILLEGAL_VALUE;
1542 if (session->service_log)
1543 return log_event(session, title, entity, description, comment);
1545 return PEP_STATUS_OK;
1548 DYNAMIC_API PEP_STATUS trustword(
1549 PEP_SESSION session, uint16_t value, const char *lang,
1550 char **word, size_t *wsize
1553 PEP_STATUS status = PEP_STATUS_OK;
1559 if (!(session && word && wsize))
1560 return PEP_ILLEGAL_VALUE;
1568 assert((lang[0] >= 'A' && lang[0] <= 'Z')
1569 || (lang[0] >= 'a' && lang[0] <= 'z'));
1570 assert((lang[1] >= 'A' && lang[1] <= 'Z')
1571 || (lang[1] >= 'a' && lang[1] <= 'z'));
1572 assert(lang[2] == 0);
1574 sqlite3_reset(session->trustword);
1575 sqlite3_bind_text(session->trustword, 1, lang, -1, SQLITE_STATIC);
1576 sqlite3_bind_int(session->trustword, 2, value);
1578 const int result = sqlite3_step(session->trustword);
1579 if (result == SQLITE_ROW) {
1580 *word = strdup((const char *) sqlite3_column_text(session->trustword,
1583 *wsize = sqlite3_column_bytes(session->trustword, 1);
1585 status = PEP_OUT_OF_MEMORY;
1587 status = PEP_TRUSTWORD_NOT_FOUND;
1589 sqlite3_reset(session->trustword);
1593 DYNAMIC_API PEP_STATUS trustwords(
1594 PEP_SESSION session, const char *fingerprint, const char *lang,
1595 char **words, size_t *wsize, int max_words
1598 const char *source = fingerprint;
1601 assert(fingerprint);
1604 assert(max_words >= 0);
1606 if (!(session && fingerprint && words && wsize && max_words >= 0))
1607 return PEP_ILLEGAL_VALUE;
1612 char *buffer = calloc(1, MAX_TRUSTWORDS_SPACE);
1615 return PEP_OUT_OF_MEMORY;
1616 char *dest = buffer;
1618 const size_t fsize = strlen(fingerprint);
1620 if (!lang || !lang[0])
1623 assert((lang[0] >= 'A' && lang[0] <= 'Z')
1624 || (lang[0] >= 'a' && lang[0] <= 'z'));
1625 assert((lang[1] >= 'A' && lang[1] <= 'Z')
1626 || (lang[1] >= 'a' && lang[1] <= 'z'));
1627 assert(lang[2] == 0);
1630 while (source < fingerprint + fsize) {
1637 for (value=0, j=0; j < 4 && source < fingerprint + fsize; ) {
1638 if (*source >= 'a' && *source <= 'f')
1639 value += (*source - 'a' + 10) << (3 - j++) * 4;
1640 else if (*source >= 'A' && *source <= 'F')
1641 value += (*source - 'A' + 10) << (3 - j++) * 4;
1642 else if (*source >= '0' && *source <= '9')
1643 value += (*source - '0') << (3 - j++) * 4;
1648 _status = trustword(session, value, lang, &word, &_wsize);
1649 if (_status == PEP_OUT_OF_MEMORY) {
1651 return PEP_OUT_OF_MEMORY;
1655 return PEP_TRUSTWORD_NOT_FOUND;
1658 if (dest + _wsize < buffer + MAX_TRUSTWORDS_SPACE - 1) {
1659 strncpy(dest, word, _wsize);
1665 break; // buffer full
1668 if (source < fingerprint + fsize
1669 && dest + _wsize < buffer + MAX_TRUSTWORDS_SPACE - 1)
1673 if (max_words && n_words >= max_words)
1678 *wsize = dest - buffer;
1679 return PEP_STATUS_OK;
1682 pEp_identity *new_identity(
1683 const char *address, const char *fpr, const char *user_id,
1684 const char *username
1687 pEp_identity *result = calloc(1, sizeof(pEp_identity));
1691 result->address = strdup(address);
1692 assert(result->address);
1693 if (result->address == NULL) {
1699 result->fpr = strdup(fpr);
1700 assert(result->fpr);
1701 if (result->fpr == NULL) {
1702 free_identity(result);
1707 result->user_id = strdup(user_id);
1708 assert(result->user_id);
1709 if (result->user_id == NULL) {
1710 free_identity(result);
1715 result->username = strdup(username);
1716 assert(result->username);
1717 if (result->username == NULL) {
1718 free_identity(result);
1726 pEp_identity *identity_dup(const pEp_identity *src)
1730 pEp_identity *dup = new_identity(src->address, src->fpr, src->user_id,
1736 dup->comm_type = src->comm_type;
1737 dup->lang[0] = src->lang[0];
1738 dup->lang[1] = src->lang[1];
1740 dup->flags = src->flags;
1746 void free_identity(pEp_identity *identity)
1749 free(identity->address);
1750 free(identity->fpr);
1751 free(identity->user_id);
1752 free(identity->username);
1757 DYNAMIC_API PEP_STATUS get_default_own_userid(
1758 PEP_SESSION session,
1765 if (!session || !userid)
1766 return PEP_ILLEGAL_VALUE;
1768 PEP_STATUS status = PEP_STATUS_OK;
1769 char* retval = NULL;
1771 sqlite3_reset(session->get_default_own_userid);
1773 const int result = sqlite3_step(session->get_default_own_userid);
1778 id = (const char *) sqlite3_column_text(session->get_default_own_userid, 0);
1780 // Shouldn't happen.
1781 status = PEP_UNKNOWN_ERROR;
1784 retval = strdup(id);
1786 status = PEP_OUT_OF_MEMORY;
1790 // Technically true, given how we find it, but FIXME we need a more descriptive error
1791 status = PEP_CANNOT_FIND_IDENTITY;
1797 sqlite3_reset(session->get_default_own_userid);
1802 DYNAMIC_API PEP_STATUS get_userid_alias_default(
1803 PEP_SESSION session,
1804 const char* alias_id,
1805 char** default_id) {
1809 assert(alias_id[0]);
1812 if (!(session && alias_id && alias_id[0] && default_id))
1813 return PEP_ILLEGAL_VALUE;
1815 PEP_STATUS status = PEP_STATUS_OK;
1816 char* retval = NULL;
1818 sqlite3_reset(session->get_userid_alias_default);
1819 sqlite3_bind_text(session->get_userid_alias_default, 1, alias_id, -1, SQLITE_STATIC);
1823 const int result = sqlite3_step(session->get_userid_alias_default);
1826 tempid = (const char *) sqlite3_column_text(session->get_userid_alias_default, 0);
1828 retval = strdup(tempid);
1831 return PEP_OUT_OF_MEMORY;
1834 *default_id = retval;
1837 status = PEP_CANNOT_FIND_ALIAS;
1841 sqlite3_reset(session->get_userid_alias_default);
1845 DYNAMIC_API PEP_STATUS set_userid_alias (
1846 PEP_SESSION session,
1847 const char* default_id,
1848 const char* alias_id) {
1856 if (!(session && default_id && alias_id &&
1857 default_id[0] != '\0' && alias_id[0] != '\0'))
1858 return PEP_ILLEGAL_VALUE;
1860 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
1862 sqlite3_reset(session->add_userid_alias);
1863 sqlite3_bind_text(session->add_userid_alias, 1, default_id, -1,
1865 sqlite3_bind_text(session->add_userid_alias, 2, alias_id, -1,
1868 result = sqlite3_step(session->add_userid_alias);
1870 sqlite3_reset(session->add_userid_alias);
1871 if (result != SQLITE_DONE) {
1872 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
1873 return PEP_CANNOT_SET_ALIAS;
1875 sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
1878 return PEP_STATUS_OK;
1881 DYNAMIC_API PEP_STATUS get_identity(
1882 PEP_SESSION session,
1883 const char *address,
1884 const char *user_id,
1885 pEp_identity **identity
1888 PEP_STATUS status = PEP_STATUS_OK;
1889 static pEp_identity *_identity;
1896 if (!(session && address && address[0] && identity))
1897 return PEP_ILLEGAL_VALUE;
1901 sqlite3_reset(session->get_identity);
1902 sqlite3_bind_text(session->get_identity, 1, address, -1, SQLITE_STATIC);
1903 sqlite3_bind_text(session->get_identity, 2, user_id, -1, SQLITE_STATIC);
1905 const int result = sqlite3_step(session->get_identity);
1908 _identity = new_identity(
1910 (const char *) sqlite3_column_text(session->get_identity, 0),
1912 (const char *) sqlite3_column_text(session->get_identity, 1)
1915 if (_identity == NULL)
1916 return PEP_OUT_OF_MEMORY;
1918 _identity->comm_type = (PEP_comm_type)
1919 sqlite3_column_int(session->get_identity, 2);
1920 const char* const _lang = (const char *)
1921 sqlite3_column_text(session->get_identity, 3);
1922 if (_lang && _lang[0]) {
1923 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1924 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1925 assert(_lang[2] == 0);
1926 _identity->lang[0] = _lang[0];
1927 _identity->lang[1] = _lang[1];
1928 _identity->lang[2] = 0;
1930 _identity->flags = (unsigned int)
1931 sqlite3_column_int(session->get_identity, 4);
1932 _identity->me = (unsigned int)
1933 sqlite3_column_int(session->get_identity, 5);
1935 *identity = _identity;
1938 status = PEP_CANNOT_FIND_IDENTITY;
1942 sqlite3_reset(session->get_identity);
1946 PEP_STATUS get_identity_without_trust_check(
1947 PEP_SESSION session,
1948 const char *address,
1949 const char *user_id,
1950 pEp_identity **identity
1953 PEP_STATUS status = PEP_STATUS_OK;
1954 static pEp_identity *_identity;
1961 if (!(session && address && address[0] && identity))
1962 return PEP_ILLEGAL_VALUE;
1966 sqlite3_reset(session->get_identity_without_trust_check);
1967 sqlite3_bind_text(session->get_identity_without_trust_check, 1, address, -1, SQLITE_STATIC);
1968 sqlite3_bind_text(session->get_identity_without_trust_check, 2, user_id, -1, SQLITE_STATIC);
1970 const int result = sqlite3_step(session->get_identity_without_trust_check);
1973 _identity = new_identity(
1975 (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 0),
1977 (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 1)
1980 if (_identity == NULL)
1981 return PEP_OUT_OF_MEMORY;
1983 _identity->comm_type = PEP_ct_unknown;
1984 const char* const _lang = (const char *)
1985 sqlite3_column_text(session->get_identity_without_trust_check, 2);
1986 if (_lang && _lang[0]) {
1987 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1988 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1989 assert(_lang[2] == 0);
1990 _identity->lang[0] = _lang[0];
1991 _identity->lang[1] = _lang[1];
1992 _identity->lang[2] = 0;
1994 _identity->flags = (unsigned int)
1995 sqlite3_column_int(session->get_identity_without_trust_check, 3);
1996 _identity->me = (unsigned int)
1997 sqlite3_column_int(session->get_identity_without_trust_check, 4);
1999 *identity = _identity;
2002 status = PEP_CANNOT_FIND_IDENTITY;
2006 sqlite3_reset(session->get_identity_without_trust_check);
2010 PEP_STATUS get_identities_by_address(
2011 PEP_SESSION session,
2012 const char *address,
2013 identity_list** id_list
2016 pEp_identity* ident;
2023 if (!(session && address && address[0] && id_list))
2024 return PEP_ILLEGAL_VALUE;
2027 identity_list* ident_list = NULL;
2029 sqlite3_reset(session->get_identities_by_address);
2030 sqlite3_bind_text(session->get_identities_by_address, 1, address, -1, SQLITE_STATIC);
2033 while ((result = sqlite3_step(session->get_identities_by_address)) == SQLITE_ROW) {
2034 //"select user_id, main_key_id, username, comm_type, lang,"
2035 //" identity.flags, is_own"
2036 ident = new_identity(
2038 (const char *) sqlite3_column_text(session->get_identities_by_address, 1),
2039 (const char *) sqlite3_column_text(session->get_identities_by_address, 0),
2040 (const char *) sqlite3_column_text(session->get_identities_by_address, 2)
2044 return PEP_OUT_OF_MEMORY;
2046 ident->comm_type = PEP_ct_unknown;
2048 const char* const _lang = (const char *)
2049 sqlite3_column_text(session->get_identities_by_address, 3);
2050 if (_lang && _lang[0]) {
2051 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
2052 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
2053 assert(_lang[2] == 0);
2054 ident->lang[0] = _lang[0];
2055 ident->lang[1] = _lang[1];
2058 ident->flags = (unsigned int)
2059 sqlite3_column_int(session->get_identities_by_address, 4);
2060 ident->me = (unsigned int)
2061 sqlite3_column_int(session->get_identities_by_address, 5);
2064 identity_list_add(ident_list, ident);
2066 ident_list = new_identity_list(ident);
2069 sqlite3_reset(session->get_identities_by_address);
2071 *id_list = ident_list;
2074 return PEP_CANNOT_FIND_IDENTITY;
2076 return PEP_STATUS_OK;
2079 PEP_STATUS exists_identity_entry(PEP_SESSION session, pEp_identity* identity,
2083 assert(!EMPTYSTR(identity->user_id));
2084 assert(!EMPTYSTR(identity->address));
2085 if (!session || !exists || EMPTYSTR(identity->user_id) || EMPTYSTR(identity->address))
2086 return PEP_ILLEGAL_VALUE;
2090 sqlite3_reset(session->exists_identity_entry);
2091 sqlite3_bind_text(session->exists_identity_entry, 1, identity->address, -1,
2093 sqlite3_bind_text(session->exists_identity_entry, 2, identity->user_id, -1,
2096 int result = sqlite3_step(session->exists_identity_entry);
2099 // yeah yeah, I know, we could be lazy here, but it looks bad.
2100 *exists = (sqlite3_column_int(session->exists_identity_entry, 0) != 0);
2104 return PEP_UNKNOWN_ERROR;
2107 return PEP_STATUS_OK;
2110 PEP_STATUS exists_trust_entry(PEP_SESSION session, pEp_identity* identity,
2114 assert(!EMPTYSTR(identity->user_id));
2115 assert(!EMPTYSTR(identity->fpr));
2116 if (!session || !exists || EMPTYSTR(identity->user_id) || EMPTYSTR(identity->fpr))
2117 return PEP_ILLEGAL_VALUE;
2121 sqlite3_reset(session->exists_trust_entry);
2122 sqlite3_bind_text(session->exists_trust_entry, 1, identity->user_id, -1,
2124 sqlite3_bind_text(session->exists_trust_entry, 2, identity->fpr, -1,
2127 int result = sqlite3_step(session->exists_trust_entry);
2130 // yeah yeah, I know, we could be lazy here, but it looks bad.
2131 *exists = (sqlite3_column_int(session->exists_trust_entry, 0) != 0);
2135 return PEP_UNKNOWN_ERROR;
2138 return PEP_STATUS_OK;
2141 // FIXME: We can rollback in set_identity on the return status,
2142 // so we should probably do that.
2143 PEP_STATUS set_pgp_keypair(PEP_SESSION session, const char* fpr) {
2144 if (!session || EMPTYSTR(fpr))
2145 return PEP_ILLEGAL_VALUE;
2149 sqlite3_reset(session->set_pgp_keypair);
2150 sqlite3_bind_text(session->set_pgp_keypair, 1, fpr, -1,
2152 result = sqlite3_step(session->set_pgp_keypair);
2153 sqlite3_reset(session->set_pgp_keypair);
2154 if (result != SQLITE_DONE) {
2155 return PEP_CANNOT_SET_PGP_KEYPAIR;
2158 return PEP_STATUS_OK;
2161 static PEP_STATUS _set_or_update_trust(PEP_SESSION session,
2162 pEp_identity* identity,
2163 sqlite3_stmt* set_or_update) {
2167 assert(identity->user_id);
2168 assert(identity->fpr);
2170 if (!session || !identity || EMPTYSTR(identity->user_id) || EMPTYSTR(identity->fpr))
2171 return PEP_ILLEGAL_VALUE;
2175 sqlite3_reset(set_or_update);
2176 sqlite3_bind_text(set_or_update, 1, identity->user_id, -1,
2178 sqlite3_bind_text(set_or_update, 2, identity->fpr, -1,
2180 sqlite3_bind_int(set_or_update, 3, identity->comm_type);
2181 result = sqlite3_step(set_or_update);
2182 assert(result == SQLITE_DONE);
2183 sqlite3_reset(set_or_update);
2184 if (result != SQLITE_DONE)
2185 return PEP_CANNOT_SET_TRUST;
2187 return PEP_STATUS_OK;
2190 static PEP_STATUS _set_or_update_identity_entry(PEP_SESSION session,
2191 pEp_identity* identity,
2192 sqlite3_stmt* set_or_update) {
2195 assert(set_or_update);
2197 if (!session || !identity || !identity->user_id || !identity->address)
2198 return PEP_ILLEGAL_VALUE;
2200 sqlite3_reset(set_or_update);
2201 sqlite3_bind_text(set_or_update, 1, identity->address, -1,
2203 sqlite3_bind_text(set_or_update, 2, identity->fpr, -1,
2205 sqlite3_bind_text(set_or_update, 3, identity->user_id, -1,
2207 sqlite3_bind_int(set_or_update, 4, identity->flags);
2208 sqlite3_bind_int(set_or_update, 5, identity->me);
2209 int result = sqlite3_step(set_or_update);
2210 sqlite3_reset(set_or_update);
2211 if (result != SQLITE_DONE)
2212 return PEP_CANNOT_SET_IDENTITY;
2214 return PEP_STATUS_OK;
2217 static PEP_STATUS _set_or_update_person(PEP_SESSION session,
2218 pEp_identity* identity,
2219 sqlite3_stmt* set_or_update) {
2222 assert(set_or_update);
2224 if (!session || !identity || !identity->user_id || !identity->username)
2225 return PEP_ILLEGAL_VALUE;
2227 sqlite3_reset(set_or_update);
2228 sqlite3_bind_text(set_or_update, 1, identity->user_id, -1,
2230 sqlite3_bind_text(set_or_update, 2, identity->username, -1,
2232 if (identity->lang[0])
2233 sqlite3_bind_text(set_or_update, 3, identity->lang, 2,
2236 sqlite3_bind_null(set_or_update, 3);
2237 sqlite3_bind_text(set_or_update, 4, identity->fpr, -1,
2239 int result = sqlite3_step(set_or_update);
2240 sqlite3_reset(set_or_update);
2242 if (result != SQLITE_DONE)
2243 return PEP_CANNOT_SET_PERSON;
2245 return PEP_STATUS_OK;
2248 PEP_STATUS set_or_update_with_identity(PEP_SESSION session,
2249 pEp_identity* identity,
2250 PEP_STATUS (* set_function)(PEP_SESSION, pEp_identity*, sqlite3_stmt*),
2251 PEP_STATUS (* exists_function)(PEP_SESSION, pEp_identity*, bool*),
2252 sqlite3_stmt* update_query,
2253 sqlite3_stmt* set_query,
2254 bool guard_transaction) {
2256 if (guard_transaction) {
2257 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
2259 bool exists = false;
2260 PEP_STATUS status = exists_function(session, identity, &exists);
2262 if (status == PEP_STATUS_OK) {
2264 status = set_function(session, identity, update_query);
2267 status = set_function(session, identity, set_query);
2270 if (guard_transaction) {
2271 if (status != PEP_STATUS_OK)
2272 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2274 sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
2279 PEP_STATUS _set_trust_internal(PEP_SESSION session, pEp_identity* identity,
2280 bool guard_transaction) {
2281 return set_or_update_with_identity(session, identity,
2282 _set_or_update_trust,
2284 session->update_trust,
2289 // This is the TOP-LEVEL function. If you're calling from set_identity,
2290 // you can't use this one.
2291 PEP_STATUS set_trust(PEP_SESSION session, pEp_identity* identity) {
2292 PEP_STATUS status = PEP_STATUS_OK;
2294 status = _set_trust_internal(session, identity, true);
2295 if (status == PEP_STATUS_OK) {
2296 if ((identity->comm_type | PEP_ct_confirmed) == PEP_ct_pEp)
2297 status = set_as_pep_user(session, identity);
2302 PEP_STATUS set_person(PEP_SESSION session, pEp_identity* identity,
2303 bool guard_transaction) {
2304 return set_or_update_with_identity(session, identity,
2305 _set_or_update_person,
2307 session->update_person,
2308 session->set_person,
2312 PEP_STATUS set_identity_entry(PEP_SESSION session, pEp_identity* identity,
2313 bool guard_transaction) {
2314 return set_or_update_with_identity(session, identity,
2315 _set_or_update_identity_entry,
2316 exists_identity_entry,
2317 session->update_identity_entry,
2318 session->set_identity_entry,
2322 // This will NOT call set_as_pep_user; you have to do that separately.
2323 DYNAMIC_API PEP_STATUS set_identity(
2324 PEP_SESSION session, const pEp_identity *identity
2331 assert(identity->address);
2332 assert(identity->user_id);
2333 assert(identity->username);
2335 if (!(session && identity && identity->address &&
2336 identity->user_id && identity->username))
2337 return PEP_ILLEGAL_VALUE;
2339 PEP_STATUS status = PEP_STATUS_OK;
2343 bool has_fpr = (!EMPTYSTR(identity->fpr));
2346 // blacklist check - FIXME: ENGINE-294 will remove
2347 status = blacklist_is_listed(session, identity->fpr, &listed);
2348 assert(status == PEP_STATUS_OK);
2349 if (status != PEP_STATUS_OK)
2353 return PEP_KEY_BLACKLISTED;
2356 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
2358 if (identity->lang[0]) {
2359 assert(identity->lang[0] >= 'a' && identity->lang[0] <= 'z');
2360 assert(identity->lang[1] >= 'a' && identity->lang[1] <= 'z');
2361 assert(identity->lang[2] == 0);
2365 sqlite3_reset(session->set_pgp_keypair);
2366 sqlite3_bind_text(session->set_pgp_keypair, 1, identity->fpr, -1,
2368 result = sqlite3_step(session->set_pgp_keypair);
2369 sqlite3_reset(session->set_pgp_keypair);
2370 if (result != SQLITE_DONE) {
2371 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2372 return PEP_CANNOT_SET_PGP_KEYPAIR;
2376 // We do this because there are checks in set_person for
2377 // aliases, which modify the identity object on return.
2378 pEp_identity* ident_copy = identity_dup(identity);
2380 return PEP_OUT_OF_MEMORY;
2382 status = set_person(session, ident_copy, false);
2383 if (status != PEP_STATUS_OK) {
2384 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2388 status = set_identity_entry(session, ident_copy, false);
2389 if (status != PEP_STATUS_OK) {
2390 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2395 status = _set_trust_internal(session, ident_copy, false);
2396 if (status != PEP_STATUS_OK) {
2397 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2402 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
2403 if (result == SQLITE_OK)
2404 status = PEP_STATUS_OK;
2406 status = PEP_COMMIT_FAILED;
2409 free_identity(ident_copy);
2413 // This ONLY sets the user flag. Must be called outside of a transaction.
2414 PEP_STATUS set_as_pep_user(PEP_SESSION session, pEp_identity* user) {
2418 assert(!EMPTYSTR(user->user_id));
2420 if (!session || !user || EMPTYSTR(user->user_id))
2421 return PEP_ILLEGAL_VALUE;
2423 PEP_STATUS status = PEP_STATUS_OK;
2425 bool person_exists = false;
2427 status = exists_person(session, user, &person_exists);
2429 if (status != PEP_STATUS_OK)
2433 status = set_person(session, user, true);
2435 // Ok, let's set it.
2436 sqlite3_reset(session->set_as_pep_user);
2437 sqlite3_bind_text(session->set_as_pep_user, 1, user->user_id, -1,
2439 int result = sqlite3_step(session->set_as_pep_user);
2440 sqlite3_reset(session->set_as_pep_user);
2442 if (result != SQLITE_DONE)
2443 return PEP_CANNOT_SET_PERSON;
2445 return PEP_STATUS_OK;
2448 PEP_STATUS exists_person(PEP_SESSION session, pEp_identity* identity,
2451 // const char* user_id,
2452 // char** default_id, bool* exists) {
2456 assert(!EMPTYSTR(identity->user_id));
2458 if (!session || !exists || !identity || EMPTYSTR(identity->user_id))
2459 return PEP_ILLEGAL_VALUE;
2463 const char* user_id = identity->user_id;
2464 char* alias_default = NULL;
2466 PEP_STATUS status = get_userid_alias_default(session, user_id, &alias_default);
2468 if (status == PEP_CANNOT_FIND_ALIAS || EMPTYSTR(alias_default)) {
2469 sqlite3_reset(session->exists_person);
2470 sqlite3_bind_text(session->exists_person, 1, user_id, -1,
2472 int result = sqlite3_step(session->exists_person);
2475 // yeah yeah, I know, we could be lazy here, but it looks bad.
2476 *exists = (sqlite3_column_int(session->exists_person, 0) != 0);
2477 status = PEP_STATUS_OK;
2481 return PEP_UNKNOWN_ERROR;
2484 else if (status == PEP_STATUS_OK) {
2485 *exists = true; // thank you, delete on cascade!
2486 // FIXME: Should we correct the userid default here? I think we should.
2487 free(identity->user_id);
2488 identity->user_id = alias_default; // ownership transfer
2491 free(alias_default);
2496 DYNAMIC_API PEP_STATUS is_pep_user(PEP_SESSION session, pEp_identity *identity, bool* is_pep)
2501 assert(!EMPTYSTR(identity->user_id));
2503 if (!session || !is_pep || !identity || EMPTYSTR(identity->user_id))
2504 return PEP_ILLEGAL_VALUE;
2508 const char* user_id = identity->user_id;
2510 if (!session || EMPTYSTR(user_id))
2511 return PEP_ILLEGAL_VALUE;
2513 char* alias_default = NULL;
2515 PEP_STATUS status = get_userid_alias_default(session, user_id, &alias_default);
2517 if (status == PEP_CANNOT_FIND_ALIAS || EMPTYSTR(alias_default)) {
2518 free(alias_default);
2519 alias_default = strdup(user_id);
2522 sqlite3_reset(session->is_pep_user);
2523 sqlite3_bind_text(session->is_pep_user, 1, user_id, -1,
2525 int result = sqlite3_step(session->is_pep_user);
2528 // yeah yeah, I know, we could be lazy here, but it looks bad.
2529 *is_pep = (sqlite3_column_int(session->is_pep_user, 0) != 0);
2533 free(alias_default);
2534 return PEP_CANNOT_FIND_PERSON;
2537 return PEP_STATUS_OK;
2541 PEP_STATUS remove_fpr_as_default(PEP_SESSION session,
2546 if (!session || !fpr)
2547 return PEP_ILLEGAL_VALUE;
2549 sqlite3_reset(session->remove_fpr_as_default);
2550 sqlite3_bind_text(session->remove_fpr_as_default, 1, fpr, -1,
2553 int result = sqlite3_step(session->remove_fpr_as_default);
2554 sqlite3_reset(session->remove_fpr_as_default);
2556 if (result != SQLITE_DONE)
2557 return PEP_CANNOT_SET_IDENTITY; // misleading - could also be person
2559 return PEP_STATUS_OK;
2563 PEP_STATUS replace_identities_fpr(PEP_SESSION session,
2564 const char* old_fpr,
2565 const char* new_fpr)
2570 if (!old_fpr || !new_fpr)
2571 return PEP_ILLEGAL_VALUE;
2573 sqlite3_reset(session->replace_identities_fpr);
2574 sqlite3_bind_text(session->replace_identities_fpr, 1, new_fpr, -1,
2576 sqlite3_bind_text(session->replace_identities_fpr, 2, old_fpr, -1,
2579 int result = sqlite3_step(session->replace_identities_fpr);
2580 sqlite3_reset(session->replace_identities_fpr);
2582 if (result != SQLITE_DONE)
2583 return PEP_CANNOT_SET_IDENTITY;
2585 return PEP_STATUS_OK;
2588 PEP_STATUS update_trust_for_fpr(PEP_SESSION session,
2590 PEP_comm_type comm_type)
2593 return PEP_ILLEGAL_VALUE;
2595 sqlite3_reset(session->update_trust_for_fpr);
2596 sqlite3_bind_int(session->update_trust_for_fpr, 1, comm_type);
2597 sqlite3_bind_text(session->update_trust_for_fpr, 2, fpr, -1,
2599 int result = sqlite3_step(session->update_trust_for_fpr);
2600 sqlite3_reset(session->update_trust_for_fpr);
2601 if (result != SQLITE_DONE) {
2602 return PEP_CANNOT_SET_TRUST;
2605 return PEP_STATUS_OK;
2608 DYNAMIC_API PEP_STATUS set_device_group(
2609 PEP_SESSION session,
2610 const char *group_name
2617 if (!(session && group_name))
2618 return PEP_ILLEGAL_VALUE;
2620 // 1. Get own user_id
2621 char* user_id = NULL;
2622 PEP_STATUS status = get_default_own_userid(session, &user_id);
2624 // No user_id is returned in this case, no need to free;
2625 if (status != PEP_STATUS_OK)
2628 // 2. Set device group
2629 sqlite3_reset(session->set_device_group);
2631 sqlite3_bind_text(session->set_device_group, 1, group_name, -1,
2634 sqlite3_bind_null(session->set_device_group, 1);
2637 sqlite3_bind_text(session->set_device_group, 2, user_id, -1,
2640 result = sqlite3_step(session->set_device_group);
2641 sqlite3_reset(session->set_device_group);
2645 if (result != SQLITE_DONE)
2646 return PEP_CANNOT_SET_PERSON;
2648 return PEP_STATUS_OK;
2651 DYNAMIC_API PEP_STATUS get_device_group(PEP_SESSION session, char **group_name)
2653 PEP_STATUS status = PEP_STATUS_OK;
2659 if (!(session && group_name))
2660 return PEP_ILLEGAL_VALUE;
2662 // 1. Get own user_id
2663 char* user_id = NULL;
2664 status = get_default_own_userid(session, &user_id);
2666 // No user_id is returned in this case, no need to free;
2667 if (status != PEP_STATUS_OK)
2670 // 2. get device group
2671 sqlite3_reset(session->get_device_group);
2672 sqlite3_bind_text(session->get_device_group, 1, user_id, -1,
2675 result = sqlite3_step(session->get_device_group);
2678 const char *_group_name = (const char *)sqlite3_column_text(session->get_device_group, 0);
2680 *group_name = strdup(_group_name);
2681 if(*group_name == NULL)
2682 status = PEP_OUT_OF_MEMORY;
2688 status = PEP_RECORD_NOT_FOUND;
2692 sqlite3_reset(session->get_device_group);
2696 DYNAMIC_API PEP_STATUS set_identity_flags(
2697 PEP_SESSION session,
2698 pEp_identity *identity,
2706 assert(identity->address);
2707 assert(identity->user_id);
2709 if (!(session && identity && identity->address && identity->user_id))
2710 return PEP_ILLEGAL_VALUE;
2712 sqlite3_reset(session->set_identity_flags);
2713 sqlite3_bind_int(session->set_identity_flags, 1, flags);
2714 sqlite3_bind_text(session->set_identity_flags, 2, identity->address, -1,
2716 sqlite3_bind_text(session->set_identity_flags, 3, identity->user_id, -1,
2719 result = sqlite3_step(session->set_identity_flags);
2721 sqlite3_reset(session->set_identity_flags);
2722 if (result != SQLITE_DONE)
2723 return PEP_CANNOT_SET_IDENTITY;
2725 identity->flags |= flags;
2726 return PEP_STATUS_OK;
2729 DYNAMIC_API PEP_STATUS unset_identity_flags(
2730 PEP_SESSION session,
2731 pEp_identity *identity,
2739 assert(identity->address);
2740 assert(identity->user_id);
2742 if (!(session && identity && identity->address && identity->user_id))
2743 return PEP_ILLEGAL_VALUE;
2745 sqlite3_reset(session->unset_identity_flags);
2746 sqlite3_bind_int(session->unset_identity_flags, 1, flags);
2747 sqlite3_bind_text(session->unset_identity_flags, 2, identity->address, -1,
2749 sqlite3_bind_text(session->unset_identity_flags, 3, identity->user_id, -1,
2751 result = sqlite3_step(session->unset_identity_flags);
2752 sqlite3_reset(session->unset_identity_flags);
2753 if (result != SQLITE_DONE)
2754 return PEP_CANNOT_SET_IDENTITY;
2755 identity->flags &= ~flags;
2757 return PEP_STATUS_OK;
2761 PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
2762 const char* new_uid) {
2767 if (!session || !old_uid || !new_uid)
2768 return PEP_ILLEGAL_VALUE;
2773 sqlite3_reset(session->replace_userid);
2774 sqlite3_bind_text(session->replace_userid, 1, new_uid, -1,
2776 sqlite3_bind_text(session->replace_userid, 2, old_uid, -1,
2778 result = sqlite3_step(session->replace_userid);
2779 sqlite3_reset(session->replace_userid);
2780 if (result != SQLITE_DONE)
2781 return PEP_CANNOT_SET_PERSON; // May need clearer retval
2783 return PEP_STATUS_OK;
2786 PEP_STATUS refresh_userid_default_key(PEP_SESSION session, const char* user_id) {
2790 if (!session || !user_id)
2791 return PEP_ILLEGAL_VALUE;
2795 sqlite3_reset(session->refresh_userid_default_key);
2796 sqlite3_bind_text(session->refresh_userid_default_key, 1, user_id, -1,
2798 result = sqlite3_step(session->refresh_userid_default_key);
2799 sqlite3_reset(session->refresh_userid_default_key);
2800 if (result != SQLITE_DONE)
2801 return PEP_CANNOT_SET_PERSON;
2803 return PEP_STATUS_OK;
2806 PEP_STATUS replace_main_user_fpr(PEP_SESSION session, const char* user_id,
2807 const char* new_fpr) {
2812 if (!session || !user_id || !new_fpr)
2813 return PEP_ILLEGAL_VALUE;
2817 sqlite3_reset(session->replace_main_user_fpr);
2818 sqlite3_bind_text(session->replace_main_user_fpr, 1, new_fpr, -1,
2820 sqlite3_bind_text(session->replace_main_user_fpr, 2, user_id, -1,
2822 result = sqlite3_step(session->replace_main_user_fpr);
2823 sqlite3_reset(session->replace_main_user_fpr);
2824 if (result != SQLITE_DONE)
2825 return PEP_CANNOT_SET_PERSON;
2827 return PEP_STATUS_OK;
2830 PEP_STATUS get_main_user_fpr(PEP_SESSION session,
2831 const char* user_id,
2834 PEP_STATUS status = PEP_STATUS_OK;
2841 if (!(session && user_id && user_id[0] && main_fpr))
2842 return PEP_ILLEGAL_VALUE;
2846 sqlite3_reset(session->get_main_user_fpr);
2847 sqlite3_bind_text(session->get_main_user_fpr, 1, user_id, -1,
2849 result = sqlite3_step(session->get_main_user_fpr);
2853 (const char *) sqlite3_column_text(session->get_main_user_fpr, 0);
2855 *main_fpr = strdup(_fpr);
2857 status = PEP_OUT_OF_MEMORY;
2861 status = PEP_CANNOT_FIND_PERSON;
2864 sqlite3_reset(session->get_main_user_fpr);
2869 DYNAMIC_API PEP_STATUS mark_as_compromized(
2870 PEP_SESSION session,
2877 assert(fpr && fpr[0]);
2879 if (!(session && fpr && fpr[0]))
2880 return PEP_ILLEGAL_VALUE;
2882 sqlite3_reset(session->mark_compromized);
2883 sqlite3_bind_text(session->mark_compromized, 1, fpr, -1,
2885 result = sqlite3_step(session->mark_compromized);
2886 sqlite3_reset(session->mark_compromized);
2888 if (result != SQLITE_DONE)
2889 return PEP_CANNOT_SET_TRUST;
2891 return PEP_STATUS_OK;
2894 void pEp_free(void *p)
2900 DYNAMIC_API PEP_STATUS get_trust(PEP_SESSION session, pEp_identity *identity)
2902 PEP_STATUS status = PEP_STATUS_OK;
2905 // We need to be able to test that we break correctly without shutting
2906 // asserts off everywhere.
2908 // assert(identity);
2909 // assert(identity->user_id);
2910 // assert(identity->user_id[0]);
2911 // assert(identity->fpr);
2912 // assert(identity->fpr[0]);
2914 if (!(session && identity && identity->user_id && identity->user_id[0] &&
2915 identity->fpr && identity->fpr[0]))
2916 return PEP_ILLEGAL_VALUE;
2918 identity->comm_type = PEP_ct_unknown;
2920 sqlite3_reset(session->get_trust);
2921 sqlite3_bind_text(session->get_trust, 1, identity->user_id, -1,
2923 sqlite3_bind_text(session->get_trust, 2, identity->fpr, -1, SQLITE_STATIC);
2925 result = sqlite3_step(session->get_trust);
2928 int comm_type = (PEP_comm_type) sqlite3_column_int(session->get_trust,
2930 identity->comm_type = comm_type;
2935 status = PEP_CANNOT_FIND_IDENTITY;
2938 sqlite3_reset(session->get_trust);
2942 DYNAMIC_API PEP_STATUS least_trust(
2943 PEP_SESSION session,
2945 PEP_comm_type *comm_type
2948 PEP_STATUS status = PEP_STATUS_OK;
2955 if (!(session && fpr && comm_type))
2956 return PEP_ILLEGAL_VALUE;
2958 *comm_type = PEP_ct_unknown;
2960 sqlite3_reset(session->least_trust);
2961 sqlite3_bind_text(session->least_trust, 1, fpr, -1, SQLITE_STATIC);
2963 result = sqlite3_step(session->least_trust);
2966 int _comm_type = sqlite3_column_int(session->least_trust, 0);
2967 *comm_type = (PEP_comm_type) _comm_type;
2971 // never reached because of sql min()
2972 status = PEP_CANNOT_FIND_IDENTITY;
2975 sqlite3_reset(session->least_trust);
2979 DYNAMIC_API PEP_STATUS decrypt_and_verify(
2980 PEP_SESSION session, const char *ctext, size_t csize,
2981 const char *dsigtext, size_t dsigsize,
2982 char **ptext, size_t *psize, stringlist_t **keylist
2992 if (!(session && ctext && csize && ptext && psize && keylist))
2993 return PEP_ILLEGAL_VALUE;
2995 return session->cryptotech[PEP_crypt_OpenPGP].decrypt_and_verify(
2996 session, ctext, csize, dsigtext, dsigsize, ptext, psize, keylist);
2999 DYNAMIC_API PEP_STATUS encrypt_and_sign(
3000 PEP_SESSION session, const stringlist_t *keylist, const char *ptext,
3001 size_t psize, char **ctext, size_t *csize
3011 if (!(session && keylist && ptext && psize && ctext && csize))
3012 return PEP_ILLEGAL_VALUE;
3014 return session->cryptotech[PEP_crypt_OpenPGP].encrypt_and_sign(session,
3015 keylist, ptext, psize, ctext, csize);
3018 PEP_STATUS encrypt_only(
3019 PEP_SESSION session, const stringlist_t *keylist, const char *ptext,
3020 size_t psize, char **ctext, size_t *csize
3030 if (!(session && keylist && ptext && psize && ctext && csize))
3031 return PEP_ILLEGAL_VALUE;
3033 return session->cryptotech[PEP_crypt_OpenPGP].encrypt_only(session,
3034 keylist, ptext, psize, ctext, csize);
3038 DYNAMIC_API PEP_STATUS verify_text(
3039 PEP_SESSION session, const char *text, size_t size,
3040 const char *signature, size_t sig_size, stringlist_t **keylist
3050 if (!(session && text && size && signature && sig_size && keylist))
3051 return PEP_ILLEGAL_VALUE;
3053 return session->cryptotech[PEP_crypt_OpenPGP].verify_text(session, text,
3054 size, signature, sig_size, keylist);
3057 DYNAMIC_API PEP_STATUS delete_keypair(PEP_SESSION session, const char *fpr)
3062 if (!(session && fpr))
3063 return PEP_ILLEGAL_VALUE;
3065 return session->cryptotech[PEP_crypt_OpenPGP].delete_keypair(session, fpr);
3068 DYNAMIC_API PEP_STATUS export_key(
3069 PEP_SESSION session, const char *fpr, char **key_data, size_t *size
3077 if (!(session && fpr && key_data && size))
3078 return PEP_ILLEGAL_VALUE;
3080 return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
3081 key_data, size, false);
3084 DYNAMIC_API PEP_STATUS export_secrect_key(
3085 PEP_SESSION session, const char *fpr, char **key_data, size_t *size
3093 if (!(session && fpr && key_data && size))
3094 return PEP_ILLEGAL_VALUE;
3096 // don't accept key IDs but full fingerprints only
3097 if (strlen(fpr) < 16)
3098 return PEP_ILLEGAL_VALUE;
3100 return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
3101 key_data, size, true);
3104 DYNAMIC_API PEP_STATUS find_keys(
3105 PEP_SESSION session, const char *pattern, stringlist_t **keylist
3112 if (!(session && pattern && keylist))
3113 return PEP_ILLEGAL_VALUE;
3115 return session->cryptotech[PEP_crypt_OpenPGP].find_keys(session, pattern,
3120 DYNAMIC_API PEP_STATUS generate_keypair(
3121 PEP_SESSION session, pEp_identity *identity
3126 assert(identity->address);
3127 assert(identity->fpr == NULL || identity->fpr[0] == 0);
3128 assert(identity->username);
3130 if (!(session && identity && identity->address &&
3131 (identity->fpr == NULL || identity->fpr[0] == 0) &&
3132 identity->username))
3133 return PEP_ILLEGAL_VALUE;
3136 session->cryptotech[PEP_crypt_OpenPGP].generate_keypair(session,
3138 if (status != PEP_STATUS_OK)
3142 status = set_pgp_keypair(session, identity->fpr);
3144 // add to known keypair DB, as this might not end up being a default
3148 DYNAMIC_API PEP_STATUS get_key_rating(
3149 PEP_SESSION session,
3151 PEP_comm_type *comm_type
3158 if (!(session && fpr && comm_type))
3159 return PEP_ILLEGAL_VALUE;
3161 return session->cryptotech[PEP_crypt_OpenPGP].get_key_rating(session, fpr,
3165 DYNAMIC_API PEP_STATUS import_key(
3166 PEP_SESSION session,
3167 const char *key_data,
3169 identity_list **private_keys
3175 if (!(session && key_data))
3176 return PEP_ILLEGAL_VALUE;
3178 return session->cryptotech[PEP_crypt_OpenPGP].import_key(session, key_data,
3179 size, private_keys);
3182 DYNAMIC_API PEP_STATUS recv_key(PEP_SESSION session, const char *pattern)
3187 if (!(session && pattern))
3188 return PEP_ILLEGAL_VALUE;
3190 return session->cryptotech[PEP_crypt_OpenPGP].recv_key(session, pattern);
3193 DYNAMIC_API PEP_STATUS send_key(PEP_SESSION session, const char *pattern)
3198 if (!(session && pattern))
3199 return PEP_ILLEGAL_VALUE;
3201 return session->cryptotech[PEP_crypt_OpenPGP].send_key(session, pattern);
3204 DYNAMIC_API PEP_STATUS renew_key(
3205 PEP_SESSION session,
3213 if (!(session && fpr))
3214 return PEP_ILLEGAL_VALUE;
3216 return session->cryptotech[PEP_crypt_OpenPGP].renew_key(session, fpr, ts);
3219 DYNAMIC_API PEP_STATUS revoke_key(
3220 PEP_SESSION session,
3228 if (!(session && fpr))
3229 return PEP_ILLEGAL_VALUE;
3231 return session->cryptotech[PEP_crypt_OpenPGP].revoke_key(session, fpr,
3235 DYNAMIC_API PEP_STATUS key_expired(
3236 PEP_SESSION session,
3246 if (!(session && fpr && expired))
3247 return PEP_ILLEGAL_VALUE;
3249 return session->cryptotech[PEP_crypt_OpenPGP].key_expired(session, fpr,
3253 DYNAMIC_API PEP_STATUS key_revoked(
3254 PEP_SESSION session,
3263 if (!(session && fpr && revoked))
3264 return PEP_ILLEGAL_VALUE;
3266 return session->cryptotech[PEP_crypt_OpenPGP].key_revoked(session, fpr,
3270 static void _clean_log_value(char *text)
3273 for (char *c = text; *c; c++) {
3274 if (*c < 32 && *c != '\n')
3282 static char *_concat_string(char *str1, const char *str2, char delim)
3284 str2 = str2 ? str2 : "";
3285 size_t len1 = str1 ? strlen(str1) : 0;
3286 size_t len2 = strlen(str2);
3287 size_t len = len1 + len2 + 3;
3288 char * result = realloc(str1, len + 1);
3292 strcpy(result + len1 + 1, str2);
3293 result[len - 2] = '"';
3294 result[len - 1] = delim;
3304 DYNAMIC_API PEP_STATUS get_crashdump_log(
3305 PEP_SESSION session,
3310 PEP_STATUS status = PEP_STATUS_OK;
3311 char *_logdata= NULL;
3314 assert(maxlines >= 0 && maxlines <= CRASHDUMP_MAX_LINES);
3317 if (!(session && logdata && maxlines >= 0 && maxlines <=
3318 CRASHDUMP_MAX_LINES))
3319 return PEP_ILLEGAL_VALUE;
3323 int limit = maxlines ? maxlines : CRASHDUMP_DEFAULT_LINES;
3324 const char *timestamp = NULL;
3325 const char *title = NULL;
3326 const char *entity = NULL;
3327 const char *desc = NULL;
3328 const char *comment = NULL;
3330 sqlite3_reset(session->crashdump);
3331 sqlite3_bind_int(session->crashdump, 1, limit);
3336 result = sqlite3_step(session->crashdump);
3339 timestamp = (const char *) sqlite3_column_text(session->crashdump,
3341 title = (const char *) sqlite3_column_text(session->crashdump,
3343 entity = (const char *) sqlite3_column_text(session->crashdump,
3345 desc = (const char *) sqlite3_column_text(session->crashdump,
3347 comment = (const char *) sqlite3_column_text(session->crashdump,
3350 _logdata = _concat_string(_logdata, timestamp, ',');
3351 if (_logdata == NULL)
3354 _logdata = _concat_string(_logdata, title, ',');
3355 if (_logdata == NULL)
3358 _logdata = _concat_string(_logdata, entity, ',');
3359 if (_logdata == NULL)
3362 _logdata = _concat_string(_logdata, desc, ',');
3363 if (_logdata == NULL)
3366 _logdata = _concat_string(_logdata, comment, '\n');
3367 if (_logdata == NULL)
3370 _clean_log_value(_logdata);
3377 status = PEP_UNKNOWN_ERROR;
3378 result = SQLITE_DONE;
3380 } while (result != SQLITE_DONE);
3382 sqlite3_reset(session->crashdump);
3383 if (status == PEP_STATUS_OK)
3384 *logdata = _logdata;
3389 status = PEP_OUT_OF_MEMORY;
3395 DYNAMIC_API PEP_STATUS get_languagelist(
3396 PEP_SESSION session,
3400 PEP_STATUS status = PEP_STATUS_OK;
3401 char *_languages= NULL;
3406 if (!(session && languages))
3407 return PEP_ILLEGAL_VALUE;
3411 const char *lang = NULL;
3412 const char *name = NULL;
3413 const char *phrase = NULL;
3415 sqlite3_reset(session->languagelist);
3420 result = sqlite3_step(session->languagelist);
3423 lang = (const char *) sqlite3_column_text(session->languagelist,
3425 name = (const char *) sqlite3_column_text(session->languagelist,
3427 phrase = (const char *) sqlite3_column_text(session->languagelist,
3430 _languages = _concat_string(_languages, lang, ',');
3431 if (_languages == NULL)
3434 _languages = _concat_string(_languages, name, ',');
3435 if (_languages == NULL)
3438 _languages = _concat_string(_languages, phrase, '\n');
3439 if (_languages == NULL)
3448 status = PEP_UNKNOWN_ERROR;
3449 result = SQLITE_DONE;
3451 } while (result != SQLITE_DONE);
3453 sqlite3_reset(session->languagelist);
3454 if (status == PEP_STATUS_OK)
3455 *languages = _languages;
3460 status = PEP_OUT_OF_MEMORY;
3466 DYNAMIC_API PEP_STATUS get_phrase(
3467 PEP_SESSION session,
3473 PEP_STATUS status = PEP_STATUS_OK;
3475 assert(session && lang && lang[0] && lang[1] && lang[2] == 0 && phrase);
3476 if (!(session && lang && lang[0] && lang[1] && lang[2] == 0 && phrase))
3477 return PEP_ILLEGAL_VALUE;
3481 sqlite3_reset(session->i18n_token);
3482 sqlite3_bind_text(session->i18n_token, 1, lang, -1, SQLITE_STATIC);
3483 sqlite3_bind_int(session->i18n_token, 2, phrase_id);
3485 const char *_phrase = NULL;
3488 result = sqlite3_step(session->i18n_token);
3491 _phrase = (const char *) sqlite3_column_text(session->i18n_token, 0);
3495 status = PEP_PHRASE_NOT_FOUND;
3499 status = PEP_UNKNOWN_ERROR;
3502 if (status == PEP_STATUS_OK) {
3503 *phrase = strdup(_phrase);
3504 if (*phrase == NULL)
3508 sqlite3_reset(session->i18n_token);
3512 status = PEP_OUT_OF_MEMORY;
3518 static PEP_STATUS _get_sequence_value(PEP_SESSION session, const char *name,
3521 assert(session && name && value);
3522 if (!(session && name && value))
3523 return PEP_ILLEGAL_VALUE;
3525 PEP_STATUS status = PEP_STATUS_OK;
3527 sqlite3_reset(session->sequence_value2);
3528 sqlite3_bind_text(session->sequence_value2, 1, name, -1,
3530 int result = sqlite3_step(session->sequence_value2);
3533 int32_t _value = (int32_t)
3534 sqlite3_column_int(session->sequence_value2, 0);
3536 sqlite3_column_int(session->sequence_value2, 1);
3539 status = PEP_OWN_SEQUENCE;
3543 status = PEP_RECORD_NOT_FOUND;
3546 status = PEP_UNKNOWN_ERROR;
3548 sqlite3_reset(session->sequence_value2);
3553 static PEP_STATUS _increment_sequence_value(PEP_SESSION session,
3554 const char *name, int own)
3556 assert(session && name);
3557 if (!(session && name))
3558 return PEP_ILLEGAL_VALUE;
3560 sqlite3_reset(session->sequence_value1);
3561 sqlite3_bind_text(session->sequence_value1, 1, name, -1, SQLITE_STATIC);
3562 sqlite3_bind_int(session->sequence_value1, 2, own);
3563 int result = sqlite3_step(session->sequence_value1);
3564 assert(result == SQLITE_DONE);
3565 sqlite3_reset(session->sequence_value1);
3566 if (result == SQLITE_DONE)
3567 return PEP_STATUS_OK;
3569 return PEP_CANNOT_INCREASE_SEQUENCE;
3572 static PEP_STATUS _set_sequence_value(PEP_SESSION session,
3573 const char *name, int32_t value, int own)
3575 assert(session && name && value > 0);
3576 if (!(session && name && value > 0))
3577 return PEP_ILLEGAL_VALUE;
3579 sqlite3_reset(session->sequence_value3);
3580 sqlite3_bind_text(session->sequence_value3, 1, name, -1, SQLITE_STATIC);
3581 sqlite3_bind_int(session->sequence_value3, 2, value);
3582 sqlite3_bind_int(session->sequence_value3, 3, own);
3583 int result = sqlite3_step(session->sequence_value3);
3584 assert(result == SQLITE_DONE);
3585 sqlite3_reset(session->sequence_value3);
3586 if (result == SQLITE_DONE)
3587 return PEP_STATUS_OK;
3589 return PEP_CANNOT_SET_SEQUENCE_VALUE;
3592 DYNAMIC_API PEP_STATUS sequence_value(
3593 PEP_SESSION session,
3598 PEP_STATUS status = PEP_STATUS_OK;
3602 assert(name && value && *value >= 0);
3604 if (!(session && name && value && *value >= 0))
3605 return PEP_ILLEGAL_VALUE;
3610 uuid_generate_random(uuid);
3611 uuid_unparse_upper(uuid, name);
3615 if (name == session->sync_session->sync_uuid ||
3616 strcmp(name, session->sync_session->sync_uuid) == 0)
3621 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
3622 int32_t old_value = 0;
3623 status = _get_sequence_value(session, name, &old_value);
3624 if (status != PEP_STATUS_OK && status != PEP_RECORD_NOT_FOUND)
3626 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3630 if (old_value >= *value) {
3631 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3632 return PEP_SEQUENCE_VIOLATED;
3635 status = _set_sequence_value(session, name, *value, own);
3636 if (status == PEP_STATUS_OK) {
3637 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
3638 if (result == SQLITE_OK)
3639 return PEP_STATUS_OK;
3641 return PEP_COMMIT_FAILED;
3643 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3649 assert(*value == 0);
3650 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
3651 status = _increment_sequence_value(session, name, own);
3652 if (status == PEP_STATUS_OK) {
3653 status = _get_sequence_value(session, name, value);
3655 if (status == PEP_STATUS_OK || status == PEP_OWN_SEQUENCE) {
3656 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
3657 if (result == SQLITE_OK){
3658 assert(*value < INT32_MAX);
3659 if (*value == INT32_MAX){
3660 return PEP_CANNOT_INCREASE_SEQUENCE;
3664 return PEP_COMMIT_FAILED;
3667 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3673 DYNAMIC_API PEP_STATUS set_revoked(
3674 PEP_SESSION session,
3675 const char *revoked_fpr,
3676 const char *replacement_fpr,
3677 const uint64_t revocation_date
3680 PEP_STATUS status = PEP_STATUS_OK;
3683 revoked_fpr && revoked_fpr[0] &&
3684 replacement_fpr && replacement_fpr[0]
3688 revoked_fpr && revoked_fpr[0] &&
3689 replacement_fpr && replacement_fpr[0]
3691 return PEP_ILLEGAL_VALUE;
3693 sqlite3_reset(session->set_revoked);
3694 sqlite3_bind_text(session->set_revoked, 1, revoked_fpr, -1, SQLITE_STATIC);
3695 sqlite3_bind_text(session->set_revoked, 2, replacement_fpr, -1,
3697 sqlite3_bind_int64(session->set_revoked, 3, revocation_date);
3701 result = sqlite3_step(session->set_revoked);
3704 status = PEP_STATUS_OK;
3708 status = PEP_UNKNOWN_ERROR;
3711 sqlite3_reset(session->set_revoked);
3715 DYNAMIC_API PEP_STATUS get_revoked(
3716 PEP_SESSION session,
3719 uint64_t *revocation_date
3722 PEP_STATUS status = PEP_STATUS_OK;
3733 return PEP_ILLEGAL_VALUE;
3735 *revoked_fpr = NULL;
3736 *revocation_date = 0;
3738 sqlite3_reset(session->get_revoked);
3739 sqlite3_bind_text(session->get_revoked, 1, fpr, -1, SQLITE_STATIC);
3743 result = sqlite3_step(session->get_revoked);
3746 *revoked_fpr = strdup((const char *)
3747 sqlite3_column_text(session->get_revoked, 0));
3749 *revocation_date = sqlite3_column_int64(session->get_revoked,
3752 status = PEP_OUT_OF_MEMORY;
3757 status = PEP_CANNOT_FIND_IDENTITY;
3760 sqlite3_reset(session->get_revoked);
3765 PEP_STATUS key_created(
3766 PEP_SESSION session,
3771 assert(session && fpr && created);
3772 if (!(session && fpr && created))
3773 return PEP_ILLEGAL_VALUE;
3775 return session->cryptotech[PEP_crypt_OpenPGP].key_created(session, fpr,
3779 PEP_STATUS find_private_keys(PEP_SESSION session, const char* pattern,
3780 stringlist_t **keylist) {
3781 assert(session && keylist);
3782 if (!(session && keylist))
3783 return PEP_ILLEGAL_VALUE;
3785 return session->cryptotech[PEP_crypt_OpenPGP].find_private_keys(session, pattern,
3789 PEP_STATUS import_trusted_own_keys(PEP_SESSION session) {
3792 return PEP_ILLEGAL_VALUE;
3794 return session->cryptotech[PEP_crypt_OpenPGP].import_trusted_own_keys(session);
3797 DYNAMIC_API const char* get_engine_version() {
3798 return PEP_ENGINE_VERSION;
3802 DYNAMIC_API PEP_STATUS reset_peptest_hack(PEP_SESSION session)
3807 return PEP_ILLEGAL_VALUE;
3809 int int_result = sqlite3_exec(
3811 "delete from identity where address like '%@peptest.ch' ;",
3816 assert(int_result == SQLITE_OK);
3818 if (int_result != SQLITE_OK)
3819 return PEP_UNKNOWN_ERROR;
3821 return PEP_STATUS_OK;
3824 #ifdef DEBUG_ERRORSTACK
3825 PEP_STATUS session_add_error(PEP_SESSION session, const char* file, unsigned line, PEP_STATUS status)
3830 snprintf(logline,47, "%.24s:%u status=%u (0x%x)", file, line, status, status);
3832 snprintf(logline,47, "%.24s:%u status=%i.", file, line, status);
3834 stringlist_add(session->errorstack, logline); // logline is copied! :-)
3838 DYNAMIC_API const stringlist_t* get_errorstack(PEP_SESSION session)
3840 return session->errorstack;
3843 DYNAMIC_API void clear_errorstack(PEP_SESSION session)
3845 const int old_len = stringlist_length(session->errorstack);
3847 free_stringlist(session->errorstack);
3848 snprintf(buf, 47, "(%i elements cleared)", old_len);
3849 session->errorstack = new_stringlist(buf);
3854 static stringlist_t* dummy_errorstack = NULL;
3856 DYNAMIC_API const stringlist_t* get_errorstack(PEP_SESSION session)
3858 if(dummy_errorstack == NULL)
3860 dummy_errorstack = new_stringlist("( Please recompile pEpEngine with -DDEBUG_ERRORSTACK )");
3863 return dummy_errorstack;
3866 DYNAMIC_API void clear_errorstack(PEP_SESSION session)
3868 // nothing to do here