Damnit, shut off trusted own key import again. Fixed.
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;";
98 static const char *sql_get_identity_without_trust_check =
99 "select identity.main_key_id, username, lang,"
100 " identity.flags, is_own"
102 " join person on id = identity.user_id"
103 " where (case when (address = ?1) then (1)"
104 " when (lower(address) = lower(?1)) then (1)"
105 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
108 " and identity.user_id = ?2;";
110 static const char *sql_get_identities_by_address =
111 "select user_id, identity.main_key_id, username, lang,"
112 " identity.flags, is_own"
114 " join person on id = identity.user_id"
115 " where (case when (address = ?1) then (1)"
116 " when (lower(address) = lower(?1)) then (1)"
117 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
121 static const char *sql_replace_identities_fpr =
123 " set main_key_id = ?1 "
124 " where main_key_id = ?2 ;";
126 static const char *sql_remove_fpr_as_default =
127 "update person set main_key_id = NULL where main_key_id = ?1 ;"
128 "update identity set main_key_id = NULL where main_key_id = ?1 ;";
130 // Set person, but if already exist, only update.
131 // if main_key_id already set, don't touch.
132 static const char *sql_set_person =
133 "insert into person (id, username, lang, main_key_id, device_group)"
134 " values (?1, ?2, ?3,"
135 // " (select coalesce( "
136 // " (select main_key_id from person where id = ?1), "
137 // " upper(replace(?4,' ','')))),"
139 " (select device_group from person where id = ?1)) ;";
141 static const char *sql_update_person =
143 " set username = ?2, "
146 " (select coalesce( "
147 " (select main_key_id from person where id = ?1), "
148 " upper(replace(?4,' ','')))),"
150 " (select device_group from person where id = ?1)"
153 static const char *sql_set_as_pep_user =
154 "update person set is_pep_user = 1 "
157 static const char *sql_is_pep_user =
158 "select is_pep_user from person "
161 static const char* sql_exists_person =
162 "select count(*) from person "
165 static const char *sql_set_device_group =
166 "update person set device_group = ?1 "
169 // This will cascade to identity and trust
170 static const char* sql_replace_userid =
171 "update person set id = ?1 "
174 static const char *sql_replace_main_user_fpr =
176 " set main_key_id = ?1 "
179 static const char *sql_get_main_user_fpr =
180 "select main_key_id from person"
183 static const char *sql_refresh_userid_default_key =
185 " set main_key_id = "
186 " (select identity.main_key_id from identity "
187 " join trust on trust.user_id = identity.user_id "
188 " and trust.pgp_keypair_fpr = identity.main_key_id "
189 " join person on identity.user_id = identity.user_id "
190 " where identity.user_id = ?1 "
191 " order by trust.comm_type desc "
195 static const char *sql_get_device_group =
196 "select device_group from person "
199 static const char *sql_set_pgp_keypair =
200 "insert or ignore into pgp_keypair (fpr) "
201 "values (upper(replace(?1,' ',''))) ;";
203 static const char* sql_exists_identity_entry =
204 "select count(*) from identity "
205 " where (case when (address = ?1) then (1)"
206 " when (lower(address) = lower(?1)) then (1)"
207 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
210 " and user_id = ?2;";
212 static const char *sql_set_identity_entry =
213 "insert into identity ("
214 " address, main_key_id, "
215 " user_id, flags, is_own"
218 " upper(replace(?2,' ','')),"
224 static const char* sql_update_identity_entry =
226 " set main_key_id = upper(replace(?2,' ','')), "
229 " where (case when (address = ?1) then (1)"
230 " when (lower(address) = lower(?1)) then (1)"
231 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1) "
234 " and user_id = ?3 ;";
238 // " (select flags from identity"
239 // " where address = ?1 and"
243 /* set_identity ignores previous flags, and doesn't filter machine flags */
245 static const char *sql_set_identity_flags =
246 "update identity set flags = "
247 " ((?1 & 255) | (select flags from identity"
248 " where (case when (address = ?2) then (1)"
249 " when (lower(address) = lower(?2)) then (1)"
250 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
253 " and user_id = ?3)) "
254 " where (case when (address = ?2) then (1)"
255 " when (lower(address) = lower(?2)) then (1)"
256 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
259 " and user_id = ?3 ;";
261 static const char *sql_unset_identity_flags =
262 "update identity set flags = "
263 " ( ~(?1 & 255) & (select flags from identity"
264 " where (case when (address = ?2) then (1)"
265 " when (lower(address) = lower(?2)) then (1)"
266 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
269 " and user_id = ?3)) "
270 " where (case when (address = ?2) then (1)"
271 " when (lower(address) = lower(?2)) then (1)"
272 " when (replace(lower(address),'.','') = replace(lower(?2),'.','')) then (1)"
275 " and user_id = ?3 ;";
277 static const char *sql_set_trust =
278 "insert into trust (user_id, pgp_keypair_fpr, comm_type) "
279 "values (?1, upper(replace(?2,' ','')), ?3) ;";
281 static const char *sql_update_trust =
282 "update trust set comm_type = ?3 "
283 " where user_id = ?1 and pgp_keypair_fpr = upper(replace(?2,' ',''));";
285 static const char* sql_exists_trust_entry =
286 "select count(*) from trust "
287 " where user_id = ?1 and pgp_keypair_fpr = upper(replace(?2,' ',''));";
289 static const char *sql_update_trust_for_fpr =
291 "set comm_type = ?1 "
292 "where pgp_keypair_fpr = upper(replace(?2,' ','')) ;";
294 static const char *sql_get_trust =
295 "select comm_type from trust where user_id = ?1 "
296 "and pgp_keypair_fpr = upper(replace(?2,' ','')) ;";
298 static const char *sql_least_trust =
299 "select min(comm_type) from trust where"
300 " pgp_keypair_fpr = upper(replace(?1,' ',''))"
301 " and comm_type != 0;"; // ignores PEP_ct_unknown
302 // returns PEP_ct_unknown only when no known trust is recorded
304 static const char *sql_mark_as_compromized =
305 "update trust not indexed set comm_type = 15"
306 " where pgp_keypair_fpr = upper(replace(?1,' ','')) ;";
308 static const char *sql_crashdump =
309 "select timestamp, title, entity, description, comment"
310 " from log order by timestamp desc limit ?1 ;";
312 static const char *sql_languagelist =
313 "select i18n_language.lang, name, phrase"
314 " from i18n_language join i18n_token using (lang) where i18n_token.id = 1000;" ;
316 static const char *sql_i18n_token =
317 "select phrase from i18n_token where lang = lower(?1) and id = ?2 ;";
320 static const char *sql_blacklist_add =
321 "insert or ignore into blacklist_keys (fpr) values (upper(replace(?1,' ',''))) ;"
322 "delete from identity where main_key_id = upper(replace(?1,' ','')) ;"
323 "delete from pgp_keypair where fpr = upper(replace(?1,' ','')) ;";
325 static const char *sql_blacklist_delete =
326 "delete from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
328 static const char *sql_blacklist_is_listed =
329 "select count(*) from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
331 static const char *sql_blacklist_retrieve =
332 "select * from blacklist_keys ;";
336 // We only care if it's 0 or non-zero
337 static const char *sql_own_key_is_listed =
338 "select count(*) from ("
339 " select pgp_keypair_fpr from trust"
340 " join identity on trust.user_id = identity.user_id"
341 " where pgp_keypair_fpr = upper(replace(?1,' ',''))"
342 " and identity.is_own = 1"
345 static const char *sql_own_identities_retrieve =
346 "select address, fpr, username, identity.user_id, "
347 " lang, identity.flags | pgp_keypair.flags"
349 " join person on id = identity.user_id"
350 " join pgp_keypair on fpr = identity.main_key_id"
351 " join trust on id = trust.user_id"
352 " and pgp_keypair_fpr = identity.main_key_id"
353 " where identity.is_own = 1"
354 " and (identity.flags & ?1) = 0;";
356 static const char *sql_own_keys_retrieve =
357 "select pgp_keypair_fpr from trust"
358 " join identity on trust.user_id = identity.user_id"
359 " where identity.is_own = 1";
361 static const char* sql_get_user_default_key =
362 "select main_key_id from person"
365 static const char* sql_get_default_own_userid =
366 "select id from person"
367 " join identity on id = identity.user_id"
368 " where identity.is_own = 1";
371 static const char *sql_sequence_value1 =
372 "insert or replace into sequences (name, value, own) "
374 " (select coalesce((select value + 1 from sequences "
375 " where name = ?1), 1 )), "
376 " (select coalesce((select own or ?2 from sequences "
377 " where name = ?1), ?2))) ; ";
379 static const char *sql_sequence_value2 =
380 "select value, own from sequences where name = ?1 ;";
382 static const char *sql_sequence_value3 =
383 "insert or replace into sequences (name, value, own) "
386 " (select coalesce((select own or ?3 from sequences "
387 " where name = ?1), ?3))) ; ";
389 // Revocation tracking
390 static const char *sql_set_revoked =
391 "insert or replace into revoked_keys ("
392 " revoked_fpr, replacement_fpr, revocation_date) "
393 "values (upper(replace(?1,' ','')),"
394 " upper(replace(?2,' ','')),"
397 static const char *sql_get_revoked =
398 "select revoked_fpr, revocation_date from revoked_keys"
399 " where replacement_fpr = upper(replace(?1,' ','')) ;";
401 static const char *sql_get_userid_alias_default =
402 "select default_id from alternate_user_id "
403 " where alternate_id = ?1 ; ";
405 // Revocation tracking
406 static const char *sql_add_mistrusted_key =
407 "insert or replace into mistrusted_keys (fpr) "
408 " values (upper(replace(?1,' ',''))) ;";
410 static const char *sql_delete_mistrusted_key =
411 "delete from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
413 static const char *sql_is_mistrusted_key =
414 "select count(*) from mistrusted_keys where fpr = upper(replace(?1,' ','')) ;";
416 static const char *sql_add_userid_alias =
417 "insert or replace into alternate_user_id (alternate_id, default_id) "
420 static int user_version(void *_version, int count, char **text, char **name)
424 assert(text && text[0]);
425 if (!(_version && count == 1 && text && text[0]))
428 int *version = (int *) _version;
429 *version = atoi(text[0]);
433 static int table_contains_column(PEP_SESSION session, const char* table_name,
434 const char* col_name) {
437 if (!session || !table_name || !col_name)
440 // Table names can't be SQL parameters, so we do it this way.
442 // these two must be the same number.
444 const size_t max_q_len = 500;
446 size_t t_size, c_size, q_size;
448 const char* q1 = "SELECT "; // 7
449 const char* q2 = " from "; // 6
450 const char* q3 = ";"; // 1
453 t_size = strlen(table_name);
454 c_size = strlen(col_name);
456 size_t query_len = q_size + c_size + t_size + 1;
458 if (query_len > max_q_len)
461 strlcpy(sql_buf, q1, max_q_len);
462 strlcat(sql_buf, col_name, max_q_len);
463 strlcat(sql_buf, q2, max_q_len);
464 strlcat(sql_buf, table_name, max_q_len);
465 strlcat(sql_buf, q3, max_q_len);
469 sqlite3_prepare_v2(session->db, sql_buf, -1, &stmt, NULL);
473 int rc = sqlite3_step(stmt);
474 if (rc == SQLITE_DONE || rc == SQLITE_OK || rc == SQLITE_ROW) {
478 sqlite3_finalize(stmt);
483 void errorLogCallback(void *pArg, int iErrCode, const char *zMsg){
484 fprintf(stderr, "(%d) %s\n", iErrCode, zMsg);
487 DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
489 PEP_STATUS status = PEP_STATUS_OK;
492 bool in_first = false;
493 bool very_first = false;
495 assert(sqlite3_threadsafe());
496 if (!sqlite3_threadsafe())
497 return PEP_INIT_SQLITE3_WITHOUT_MUTEX;
499 // a little race condition - but still a race condition
500 // mitigated by calling caveat (see documentation)
502 // this increment is made atomic IN THE ADAPTERS by
503 // guarding the call to init with the appropriate mutex.
504 int _count = ++init_count;
508 // Race condition mitigated by calling caveat starts here :
509 // If another call to init() preempts right now, then preemptive call
510 // will have in_first false, will not create SQL tables, and following
511 // calls relying on those tables will fail.
513 // Therefore, as above, adapters MUST guard init() with a mutex.
515 // Therefore, first session
516 // is to be created and last session to be deleted alone, and not
517 // concurently to other sessions creation or deletion.
518 // We expect adapters to enforce this either by implicitely creating a
519 // client session, or by using synchronization primitive to protect
520 // creation/deletion of first/last session from the app.
524 return PEP_ILLEGAL_VALUE;
528 pEpSession *_session = calloc(1, sizeof(pEpSession));
530 if (_session == NULL)
533 _session->version = PEP_ENGINE_VERSION;
535 #ifdef DEBUG_ERRORSTACK
536 _session->errorstack = new_stringlist("init()");
540 if (LOCAL_DB == NULL) {
541 status = PEP_INIT_CANNOT_OPEN_DB;
545 #if _PEP_SQLITE_DEBUG
546 sqlite3_config(SQLITE_CONFIG_LOG, errorLogCallback, NULL);
549 int_result = sqlite3_open_v2(
552 SQLITE_OPEN_READWRITE
554 | SQLITE_OPEN_FULLMUTEX
555 | SQLITE_OPEN_PRIVATECACHE,
559 if (int_result != SQLITE_OK) {
560 status = PEP_INIT_CANNOT_OPEN_DB;
564 int_result = sqlite3_exec(
566 "PRAGMA locking_mode=NORMAL;\n"
567 "PRAGMA journal_mode=WAL;\n",
574 sqlite3_busy_timeout(_session->db, BUSY_WAIT_TIME);
576 #if _PEP_SQLITE_DEBUG
577 sqlite3_trace_v2(_session->db,
578 SQLITE_TRACE_STMT | SQLITE_TRACE_ROW | SQLITE_TRACE_CLOSE,
584 if (SYSTEM_DB == NULL) {
585 status = PEP_INIT_CANNOT_OPEN_SYSTEM_DB;
589 int_result = sqlite3_open_v2(
590 SYSTEM_DB, &_session->system_db,
592 | SQLITE_OPEN_FULLMUTEX
593 | SQLITE_OPEN_SHAREDCACHE,
597 if (int_result != SQLITE_OK) {
598 status = PEP_INIT_CANNOT_OPEN_SYSTEM_DB;
602 sqlite3_busy_timeout(_session->system_db, 1000);
604 // increment this when patching DDL
605 #define _DDL_USER_VERSION "7"
609 int_result = sqlite3_exec(
611 "create table if not exists version_info (\n"
612 " id integer primary key,\n"
613 " timestamp integer default (datetime('now')),\n"
621 int_result = sqlite3_exec(
623 "PRAGMA application_id = 0x23423423;\n"
624 "create table if not exists log (\n"
625 " timestamp integer default (datetime('now')),\n"
626 " title text not null,\n"
627 " description text,\n"
628 " entity text not null,\n"
631 "create index if not exists log_timestamp on log (\n"
634 "create table if not exists pgp_keypair (\n"
635 " fpr text primary key,\n"
636 " created integer,\n"
637 " expires integer,\n"
639 " flags integer default 0\n"
641 "create index if not exists pgp_keypair_expires on pgp_keypair (\n"
644 "create table if not exists person (\n"
645 " id text primary key,\n"
646 " username text not null,\n"
647 " main_key_id text\n"
648 " references pgp_keypair (fpr)\n"
649 " on delete set null,\n"
652 " device_group text,\n"
653 " is_pep_user integer default 0\n"
655 "create table if not exists identity (\n"
658 " references person (id)\n"
659 " on delete cascade on update cascade,\n"
660 " main_key_id text\n"
661 " references pgp_keypair (fpr)\n"
662 " on delete set null,\n"
664 " flags integer default 0,\n"
665 " is_own integer default 0,\n"
666 " primary key (address, user_id)\n"
668 "create table if not exists trust (\n"
669 " user_id text not null\n"
670 " references person (id)\n"
671 " on delete cascade on update cascade,\n"
672 " pgp_keypair_fpr text not null\n"
673 " references pgp_keypair (fpr)\n"
674 " on delete cascade,\n"
675 " comm_type integer not null,\n"
677 " primary key (user_id, pgp_keypair_fpr)\n"
680 "create table if not exists blacklist_keys (\n"
681 " fpr text primary key\n"
684 "create table if not exists sequences(\n"
685 " name text primary key,\n"
686 " value integer default 0,\n"
687 " own integer default 0\n"
689 "create table if not exists revoked_keys (\n"
690 " revoked_fpr text primary key,\n"
691 " replacement_fpr text not null\n"
692 " references pgp_keypair (fpr)\n"
693 " on delete cascade,\n"
694 " revocation_date integer\n"
697 "create table if not exists alternate_user_id (\n"
698 " default_id text references person (id)\n"
699 " on delete cascade on update cascade,\n"
700 " alternate_id text primary key\n"
703 "create table if not exists mistrusted_keys (\n"
704 " fpr text primary key\n"
711 assert(int_result == SQLITE_OK);
714 int_result = sqlite3_exec(
716 "pragma user_version;",
722 assert(int_result == SQLITE_OK);
724 void (*xFunc_lower)(sqlite3_context*,int,sqlite3_value**) = &_sql_lower;
726 int_result = sqlite3_create_function_v2(
730 SQLITE_UTF8 | SQLITE_DETERMINISTIC,
736 assert(int_result == SQLITE_OK);
738 int_result = sqlite3_exec(
740 "pragma foreign_keys=ON;\n",
746 assert(int_result == SQLITE_OK);
749 // Sometimes the user_version wasn't set correctly. Check to see if this
750 // is really necessary...
752 bool version_changed = true;
754 if (table_contains_column(_session, "person", "is_pep_user") > 0) {
757 else if (table_contains_column(_session, "identity", "is_own") > 0) {
760 else if (table_contains_column(_session, "sequences", "own") > 0) {
763 else if (table_contains_column(_session, "pgp_keypair", "flags") > 0) {
767 version_changed = false;
770 if (version_changed) {
771 // set it in the DB, finally. Yeesh.
772 char verbuf[21]; // enough digits for a max-sized 64 bit int, cmon.
773 sprintf(verbuf,"%d",version);
775 size_t query_size = strlen(verbuf) + 25;
776 char* query = calloc(query_size, 1);
778 strlcpy(query, "pragma user_version = ", query_size);
779 strlcat(query, verbuf, query_size);
780 strlcat(query, ";", query_size);
782 int_result = sqlite3_exec(
795 // Version has been already set
797 // Early mistake : version 0 shouldn't have existed.
798 // Numbering should have started at 1 to detect newly created DB.
799 // Version 0 DBs are not anymore compatible.
801 // // Was version 0 compat code.
802 // if (version < 1) {
803 // int_result = sqlite3_exec(
805 // "alter table identity\n"
806 // " add column flags integer default 0;\n",
811 // assert(int_result == SQLITE_OK);
815 int_result = sqlite3_exec(
817 "alter table pgp_keypair\n"
818 " add column flags integer default 0;\n"
819 "alter table person\n"
820 " add column device_group text;\n",
825 assert(int_result == SQLITE_OK);
829 int_result = sqlite3_exec(
831 "alter table sequences\n"
832 " add column own integer default 0;\n",
837 assert(int_result == SQLITE_OK);
841 int_result = sqlite3_exec(
843 "delete from pgp_keypair where fpr = '';",
848 assert(int_result == SQLITE_OK);
849 int_result = sqlite3_exec(
851 "delete from trust where pgp_keypair_fpr = '';",
856 assert(int_result == SQLITE_OK);
860 int_result = sqlite3_exec(
862 "alter table identity\n"
863 " add column is_own integer default 0;\n",
868 assert(int_result == SQLITE_OK);
869 int_result = sqlite3_exec(
873 " where (user_id = '" PEP_OWN_USERID "');\n",
878 assert(int_result == SQLITE_OK);
880 // Turns out that just adding "on update cascade" in
881 // sqlite is a PITA. We need to be able to cascade
882 // person->id replacements (for temp ids like "TOFU_")
884 int_result = sqlite3_exec(
886 "PRAGMA foreign_keys=off;\n"
887 "BEGIN TRANSACTION;\n"
888 "ALTER TABLE identity RENAME TO _identity_old;\n"
889 "create table identity (\n"
892 " references person (id)\n"
893 " on delete cascade on update cascade,\n"
894 " main_key_id text\n"
895 " references pgp_keypair (fpr)\n"
896 " on delete set null,\n"
898 " flags integer default 0,\n"
899 " is_own integer default 0,\n"
900 " primary key (address, user_id)\n"
902 "INSERT INTO identity SELECT * FROM _identity_old;\n"
903 "DROP TABLE _identity_old;\n"
904 "ALTER TABLE trust RENAME TO _trust_old;\n"
905 "create table trust (\n"
906 " user_id text not null\n"
907 " references person (id)\n"
908 " on delete cascade on update cascade,\n"
909 " pgp_keypair_fpr text not null\n"
910 " references pgp_keypair (fpr)\n"
911 " on delete cascade,\n"
912 " comm_type integer not null,\n"
914 " primary key (user_id, pgp_keypair_fpr)\n"
916 "INSERT INTO trust SELECT * FROM _trust_old;\n"
917 "DROP TABLE _trust_old;\n"
920 "PRAGMA foreign_keys=on;\n"
921 "create table if not exists alternate_user_id (\n"
922 " default_id text references person (id)\n"
923 " on delete cascade on update cascade,\n"
924 " alternate_id text primary key\n"
931 assert(int_result == SQLITE_OK);
934 int_result = sqlite3_exec(
936 "alter table person\n"
937 " add column is_pep_user integer default 0;\n",
942 assert(int_result == SQLITE_OK);
943 int_result = sqlite3_exec(
946 " set is_pep_user = 1\n"
948 " (select distinct id from person "
949 " join trust on id = user_id "
950 " where (case when (comm_type = 127) then (id) "
951 " when (comm_type = 255) then (id) "
958 assert(int_result == SQLITE_OK);
960 int_result = sqlite3_exec(
962 "create table if not exists mistrusted_keys (\n"
963 " fpr text primary key\n"
969 assert(int_result == SQLITE_OK);
973 // Version from DB was 0, it means this is initial setup.
974 // DB has just been created, and all tables are empty.
978 if (version < atoi(_DDL_USER_VERSION)) {
979 int_result = sqlite3_exec(
981 "pragma user_version = "_DDL_USER_VERSION";\n"
982 "insert or replace into version_info (id, version)"
983 "values (1, '" PEP_ENGINE_VERSION "');",
988 assert(int_result == SQLITE_OK);
991 // We need to init a few globals for message id that we'd rather not
992 // calculate more than once.
996 int_result = sqlite3_prepare_v2(_session->db, sql_log,
997 (int)strlen(sql_log), &_session->log, NULL);
998 assert(int_result == SQLITE_OK);
1000 int_result = sqlite3_prepare_v2(_session->system_db, sql_trustword,
1001 (int)strlen(sql_trustword), &_session->trustword, NULL);
1002 assert(int_result == SQLITE_OK);
1004 int_result = sqlite3_prepare_v2(_session->db, sql_get_identity,
1005 (int)strlen(sql_get_identity), &_session->get_identity, NULL);
1006 assert(int_result == SQLITE_OK);
1008 int_result = sqlite3_prepare_v2(_session->db, sql_get_identity_without_trust_check,
1009 (int)strlen(sql_get_identity_without_trust_check),
1010 &_session->get_identity_without_trust_check, NULL);
1011 assert(int_result == SQLITE_OK);
1013 int_result = sqlite3_prepare_v2(_session->db, sql_get_identities_by_address,
1014 (int)strlen(sql_get_identities_by_address),
1015 &_session->get_identities_by_address, NULL);
1016 assert(int_result == SQLITE_OK);
1018 int_result = sqlite3_prepare_v2(_session->db, sql_get_user_default_key,
1019 (int)strlen(sql_get_user_default_key), &_session->get_user_default_key, NULL);
1020 assert(int_result == SQLITE_OK);
1022 int_result = sqlite3_prepare_v2(_session->db, sql_get_default_own_userid,
1023 (int)strlen(sql_get_default_own_userid), &_session->get_default_own_userid, NULL);
1024 assert(int_result == SQLITE_OK);
1026 int_result = sqlite3_prepare_v2(_session->db, sql_get_userid_alias_default,
1027 (int)strlen(sql_get_userid_alias_default), &_session->get_userid_alias_default, NULL);
1028 assert(int_result == SQLITE_OK);
1030 int_result = sqlite3_prepare_v2(_session->db, sql_add_userid_alias,
1031 (int)strlen(sql_add_userid_alias), &_session->add_userid_alias, NULL);
1032 assert(int_result == SQLITE_OK);
1034 int_result = sqlite3_prepare_v2(_session->db, sql_replace_userid,
1035 (int)strlen(sql_replace_userid), &_session->replace_userid, NULL);
1036 assert(int_result == SQLITE_OK);
1038 int_result = sqlite3_prepare_v2(_session->db, sql_replace_main_user_fpr,
1039 (int)strlen(sql_replace_main_user_fpr), &_session->replace_main_user_fpr, NULL);
1040 assert(int_result == SQLITE_OK);
1042 int_result = sqlite3_prepare_v2(_session->db, sql_get_main_user_fpr,
1043 (int)strlen(sql_get_main_user_fpr), &_session->get_main_user_fpr, NULL);
1044 assert(int_result == SQLITE_OK);
1046 int_result = sqlite3_prepare_v2(_session->db, sql_refresh_userid_default_key,
1047 (int)strlen(sql_refresh_userid_default_key), &_session->refresh_userid_default_key, NULL);
1048 assert(int_result == SQLITE_OK);
1050 int_result = sqlite3_prepare_v2(_session->db, sql_replace_identities_fpr,
1051 (int)strlen(sql_replace_identities_fpr),
1052 &_session->replace_identities_fpr, NULL);
1053 assert(int_result == SQLITE_OK);
1055 int_result = sqlite3_prepare_v2(_session->db, sql_remove_fpr_as_default,
1056 (int)strlen(sql_remove_fpr_as_default),
1057 &_session->remove_fpr_as_default, NULL);
1058 assert(int_result == SQLITE_OK);
1060 int_result = sqlite3_prepare_v2(_session->db, sql_set_person,
1061 (int)strlen(sql_set_person), &_session->set_person, NULL);
1062 assert(int_result == SQLITE_OK);
1064 int_result = sqlite3_prepare_v2(_session->db, sql_update_person,
1065 (int)strlen(sql_update_person), &_session->update_person, NULL);
1066 assert(int_result == SQLITE_OK);
1068 int_result = sqlite3_prepare_v2(_session->db, sql_exists_person,
1069 (int)strlen(sql_exists_person), &_session->exists_person, NULL);
1070 assert(int_result == SQLITE_OK);
1072 int_result = sqlite3_prepare_v2(_session->db, sql_set_as_pep_user,
1073 (int)strlen(sql_set_as_pep_user), &_session->set_as_pep_user, NULL);
1074 assert(int_result == SQLITE_OK);
1076 int_result = sqlite3_prepare_v2(_session->db, sql_is_pep_user,
1077 (int)strlen(sql_is_pep_user), &_session->is_pep_user, NULL);
1078 assert(int_result == SQLITE_OK);
1080 int_result = sqlite3_prepare_v2(_session->db, sql_set_device_group,
1081 (int)strlen(sql_set_device_group), &_session->set_device_group, NULL);
1082 assert(int_result == SQLITE_OK);
1084 int_result = sqlite3_prepare_v2(_session->db, sql_get_device_group,
1085 (int)strlen(sql_get_device_group), &_session->get_device_group, NULL);
1086 assert(int_result == SQLITE_OK);
1088 int_result = sqlite3_prepare_v2(_session->db, sql_set_pgp_keypair,
1089 (int)strlen(sql_set_pgp_keypair), &_session->set_pgp_keypair,
1091 assert(int_result == SQLITE_OK);
1093 int_result = sqlite3_prepare_v2(_session->db, sql_set_identity_entry,
1094 (int)strlen(sql_set_identity_entry), &_session->set_identity_entry, NULL);
1095 assert(int_result == SQLITE_OK);
1097 int_result = sqlite3_prepare_v2(_session->db, sql_update_identity_entry,
1098 (int)strlen(sql_update_identity_entry), &_session->update_identity_entry, NULL);
1099 assert(int_result == SQLITE_OK);
1101 int_result = sqlite3_prepare_v2(_session->db, sql_exists_identity_entry,
1102 (int)strlen(sql_exists_identity_entry), &_session->exists_identity_entry, NULL);
1103 assert(int_result == SQLITE_OK);
1105 int_result = sqlite3_prepare_v2(_session->db, sql_set_identity_flags,
1106 (int)strlen(sql_set_identity_flags), &_session->set_identity_flags,
1108 assert(int_result == SQLITE_OK);
1110 int_result = sqlite3_prepare_v2(_session->db, sql_unset_identity_flags,
1111 (int)strlen(sql_unset_identity_flags), &_session->unset_identity_flags,
1113 assert(int_result == SQLITE_OK);
1115 int_result = sqlite3_prepare_v2(_session->db, sql_set_trust,
1116 (int)strlen(sql_set_trust), &_session->set_trust, NULL);
1117 assert(int_result == SQLITE_OK);
1119 int_result = sqlite3_prepare_v2(_session->db, sql_update_trust,
1120 (int)strlen(sql_update_trust), &_session->update_trust, NULL);
1121 assert(int_result == SQLITE_OK);
1123 int_result = sqlite3_prepare_v2(_session->db, sql_exists_trust_entry,
1124 (int)strlen(sql_exists_trust_entry), &_session->exists_trust_entry, NULL);
1125 assert(int_result == SQLITE_OK);
1127 int_result = sqlite3_prepare_v2(_session->db, sql_update_trust_for_fpr,
1128 (int)strlen(sql_update_trust_for_fpr), &_session->update_trust_for_fpr, NULL);
1129 assert(int_result == SQLITE_OK);
1131 int_result = sqlite3_prepare_v2(_session->db, sql_get_trust,
1132 (int)strlen(sql_get_trust), &_session->get_trust, NULL);
1133 assert(int_result == SQLITE_OK);
1135 int_result = sqlite3_prepare_v2(_session->db, sql_least_trust,
1136 (int)strlen(sql_least_trust), &_session->least_trust, NULL);
1137 assert(int_result == SQLITE_OK);
1139 int_result = sqlite3_prepare_v2(_session->db, sql_mark_as_compromized,
1140 (int)strlen(sql_mark_as_compromized), &_session->mark_compromized,
1142 assert(int_result == SQLITE_OK);
1144 int_result = sqlite3_prepare_v2(_session->db, sql_crashdump,
1145 (int)strlen(sql_crashdump), &_session->crashdump, NULL);
1146 assert(int_result == SQLITE_OK);
1148 int_result = sqlite3_prepare_v2(_session->system_db, sql_languagelist,
1149 (int)strlen(sql_languagelist), &_session->languagelist, NULL);
1150 assert(int_result == SQLITE_OK);
1152 int_result = sqlite3_prepare_v2(_session->system_db, sql_i18n_token,
1153 (int)strlen(sql_i18n_token), &_session->i18n_token, NULL);
1154 assert(int_result == SQLITE_OK);
1158 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_add,
1159 (int)strlen(sql_blacklist_add), &_session->blacklist_add, NULL);
1160 assert(int_result == SQLITE_OK);
1162 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_delete,
1163 (int)strlen(sql_blacklist_delete), &_session->blacklist_delete,
1165 assert(int_result == SQLITE_OK);
1167 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_is_listed,
1168 (int)strlen(sql_blacklist_is_listed),
1169 &_session->blacklist_is_listed, NULL);
1170 assert(int_result == SQLITE_OK);
1172 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_retrieve,
1173 (int)strlen(sql_blacklist_retrieve), &_session->blacklist_retrieve,
1175 assert(int_result == SQLITE_OK);
1179 int_result = sqlite3_prepare_v2(_session->db, sql_own_key_is_listed,
1180 (int)strlen(sql_own_key_is_listed), &_session->own_key_is_listed,
1182 assert(int_result == SQLITE_OK);
1184 int_result = sqlite3_prepare_v2(_session->db, sql_own_identities_retrieve,
1185 (int)strlen(sql_own_identities_retrieve),
1186 &_session->own_identities_retrieve, NULL);
1187 assert(int_result == SQLITE_OK);
1189 int_result = sqlite3_prepare_v2(_session->db, sql_own_keys_retrieve,
1190 (int)strlen(sql_own_keys_retrieve),
1191 &_session->own_keys_retrieve, NULL);
1192 assert(int_result == SQLITE_OK);
1194 // int_result = sqlite3_prepare_v2(_session->db, sql_set_own_key,
1195 // (int)strlen(sql_set_own_key),
1196 // &_session->set_own_key, NULL);
1197 // assert(int_result == SQLITE_OK);
1201 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value1,
1202 (int)strlen(sql_sequence_value1), &_session->sequence_value1,
1204 assert(int_result == SQLITE_OK);
1206 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value2,
1207 (int)strlen(sql_sequence_value2), &_session->sequence_value2,
1209 assert(int_result == SQLITE_OK);
1211 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value3,
1212 (int)strlen(sql_sequence_value3), &_session->sequence_value3,
1214 assert(int_result == SQLITE_OK);
1216 // Revocation tracking
1218 int_result = sqlite3_prepare_v2(_session->db, sql_set_revoked,
1219 (int)strlen(sql_set_revoked), &_session->set_revoked, NULL);
1220 assert(int_result == SQLITE_OK);
1222 int_result = sqlite3_prepare_v2(_session->db, sql_get_revoked,
1223 (int)strlen(sql_get_revoked), &_session->get_revoked, NULL);
1224 assert(int_result == SQLITE_OK);
1226 int_result = sqlite3_prepare_v2(_session->db, sql_add_mistrusted_key,
1227 (int)strlen(sql_add_mistrusted_key), &_session->add_mistrusted_key, NULL);
1228 assert(int_result == SQLITE_OK);
1230 int_result = sqlite3_prepare_v2(_session->db, sql_delete_mistrusted_key,
1231 (int)strlen(sql_delete_mistrusted_key), &_session->delete_mistrusted_key, NULL);
1232 assert(int_result == SQLITE_OK);
1234 int_result = sqlite3_prepare_v2(_session->db, sql_is_mistrusted_key,
1235 (int)strlen(sql_is_mistrusted_key), &_session->is_mistrusted_key, NULL);
1236 assert(int_result == SQLITE_OK);
1238 status = init_cryptotech(_session, in_first);
1239 if (status != PEP_STATUS_OK)
1242 status = init_transport_system(_session, in_first);
1243 if (status != PEP_STATUS_OK)
1246 status = log_event(_session, "init", "pEp " PEP_ENGINE_VERSION, NULL, NULL);
1247 if (status != PEP_STATUS_OK)
1254 // On first run, all private keys already present in PGP keyring
1255 // are taken as own in order to seamlessly integrate with
1256 // pre-existing GPG setup.
1258 // Note: earlier fears about danger because of DB reinitialisation should
1259 // be a non-issue here, as we ONLY take the ultimately trusted keys now.
1260 // Thus, unless the user has assigned ultimate trust through PGP, there is
1261 // no chance of automatically imported pEp keys from a previous run making
1262 // their way into PEP trusted status without explicit action (Bare imported
1263 // private keys have an 'unknown' trust designation in PGP).
1265 // We don't really worry about the status here.
1266 status = import_trusted_own_keys(_session);
1269 // sync_session set to own session by default
1270 // sync_session is then never null on a valid session
1271 _session->sync_session = _session;
1273 *session = _session;
1275 // Note: Following statement is NOT for any cryptographic/secure functionality; it is
1276 // ONLY used for some randomness in generated outer message ID, which are
1277 // required by the RFC to be globally unique!
1280 return PEP_STATUS_OK;
1283 status = PEP_OUT_OF_MEMORY;
1290 DYNAMIC_API void release(PEP_SESSION session)
1292 bool out_last = false;
1293 int _count = --init_count;
1295 assert(_count >= -1);
1298 if (!((_count >= -1) && session))
1301 // a small race condition but still a race condition
1302 // mitigated by calling caveat (see documentation)
1303 // (release() is to be guarded by a mutex by the caller)
1311 sqlite3_finalize(session->log);
1312 if (session->trustword)
1313 sqlite3_finalize(session->trustword);
1314 if (session->get_identity)
1315 sqlite3_finalize(session->get_identity);
1316 if (session->get_identity_without_trust_check)
1317 sqlite3_finalize(session->get_identity_without_trust_check);
1318 if (session->get_identities_by_address)
1319 sqlite3_finalize(session->get_identities_by_address);
1320 if (session->get_user_default_key)
1321 sqlite3_finalize(session->get_user_default_key);
1322 if (session->get_default_own_userid)
1323 sqlite3_finalize(session->get_default_own_userid);
1324 if (session->get_userid_alias_default)
1325 sqlite3_finalize(session->get_userid_alias_default);
1326 if (session->add_userid_alias)
1327 sqlite3_finalize(session->add_userid_alias);
1328 if (session->replace_identities_fpr)
1329 sqlite3_finalize(session->replace_identities_fpr);
1330 if (session->remove_fpr_as_default)
1331 sqlite3_finalize(session->remove_fpr_as_default);
1332 if (session->set_person)
1333 sqlite3_finalize(session->set_person);
1334 if (session->set_as_pep_user)
1335 sqlite3_finalize(session->set_as_pep_user);
1336 if (session->is_pep_user)
1337 sqlite3_finalize(session->is_pep_user);
1338 if (session->exists_person)
1339 sqlite3_finalize(session->exists_person);
1340 if (session->set_device_group)
1341 sqlite3_finalize(session->set_device_group);
1342 if (session->get_device_group)
1343 sqlite3_finalize(session->get_device_group);
1344 if (session->set_pgp_keypair)
1345 sqlite3_finalize(session->set_pgp_keypair);
1346 if (session->exists_identity_entry)
1347 sqlite3_finalize(session->exists_identity_entry);
1348 if (session->set_identity_entry)
1349 sqlite3_finalize(session->set_identity_entry);
1350 if (session->update_identity_entry)
1351 sqlite3_finalize(session->update_identity_entry);
1352 if (session->set_identity_flags)
1353 sqlite3_finalize(session->set_identity_flags);
1354 if (session->unset_identity_flags)
1355 sqlite3_finalize(session->unset_identity_flags);
1356 if (session->exists_trust_entry)
1357 sqlite3_finalize(session->exists_trust_entry);
1358 if (session->set_trust)
1359 sqlite3_finalize(session->set_trust);
1360 if (session->update_trust)
1361 sqlite3_finalize(session->update_trust);
1362 if (session->update_trust_for_fpr)
1363 sqlite3_finalize(session->update_trust_for_fpr);
1364 if (session->get_trust)
1365 sqlite3_finalize(session->get_trust);
1366 if (session->least_trust)
1367 sqlite3_finalize(session->least_trust);
1368 if (session->mark_compromized)
1369 sqlite3_finalize(session->mark_compromized);
1370 if (session->crashdump)
1371 sqlite3_finalize(session->crashdump);
1372 if (session->languagelist)
1373 sqlite3_finalize(session->languagelist);
1374 if (session->i18n_token)
1375 sqlite3_finalize(session->i18n_token);
1376 if (session->replace_userid)
1377 sqlite3_finalize(session->replace_userid);
1378 if (session->replace_main_user_fpr)
1379 sqlite3_finalize(session->replace_main_user_fpr);
1380 if (session->get_main_user_fpr)
1381 sqlite3_finalize(session->get_main_user_fpr);
1382 if (session->refresh_userid_default_key)
1383 sqlite3_finalize(session->refresh_userid_default_key);
1384 if (session->blacklist_add)
1385 sqlite3_finalize(session->blacklist_add);
1386 if (session->blacklist_delete)
1387 sqlite3_finalize(session->blacklist_delete);
1388 if (session->blacklist_is_listed)
1389 sqlite3_finalize(session->blacklist_is_listed);
1390 if (session->blacklist_retrieve)
1391 sqlite3_finalize(session->blacklist_retrieve);
1392 if (session->own_key_is_listed)
1393 sqlite3_finalize(session->own_key_is_listed);
1394 if (session->own_identities_retrieve)
1395 sqlite3_finalize(session->own_identities_retrieve);
1396 if (session->own_keys_retrieve)
1397 sqlite3_finalize(session->own_keys_retrieve);
1398 // if (session->set_own_key)
1399 // sqlite3_finalize(session->set_own_key);
1400 if (session->sequence_value1)
1401 sqlite3_finalize(session->sequence_value1);
1402 if (session->sequence_value2)
1403 sqlite3_finalize(session->sequence_value2);
1404 if (session->sequence_value3)
1405 sqlite3_finalize(session->sequence_value3);
1406 if (session->set_revoked)
1407 sqlite3_finalize(session->set_revoked);
1408 if (session->get_revoked)
1409 sqlite3_finalize(session->get_revoked);
1411 if (session->add_mistrusted_key)
1412 sqlite3_finalize(session->add_mistrusted_key);
1413 if (session->delete_mistrusted_key)
1414 sqlite3_finalize(session->delete_mistrusted_key);
1415 if (session->is_mistrusted_key)
1416 sqlite3_finalize(session->is_mistrusted_key);
1419 sqlite3_close_v2(session->db);
1420 if (session->system_db)
1421 sqlite3_close_v2(session->system_db);
1424 release_transport_system(session, out_last);
1425 release_cryptotech(session, out_last);
1427 #ifdef DEBUG_ERRORSTACK
1428 free_stringlist(session->errorstack);
1434 DYNAMIC_API void config_passive_mode(PEP_SESSION session, bool enable)
1437 session->passive_mode = enable;
1440 DYNAMIC_API void config_unencrypted_subject(PEP_SESSION session, bool enable)
1443 session->unencrypted_subject = enable;
1446 DYNAMIC_API void config_keep_sync_msg(PEP_SESSION session, bool enable)
1449 session->keep_sync_msg = enable;
1452 DYNAMIC_API void config_service_log(PEP_SESSION session, bool enable)
1455 session->service_log = enable;
1458 DYNAMIC_API PEP_STATUS log_event(
1459 PEP_SESSION session,
1462 const char *description,
1466 PEP_STATUS status = PEP_STATUS_OK;
1473 if (!(session && title && entity))
1474 return PEP_ILLEGAL_VALUE;
1476 sqlite3_reset(session->log);
1477 sqlite3_bind_text(session->log, 1, title, -1, SQLITE_STATIC);
1478 sqlite3_bind_text(session->log, 2, entity, -1, SQLITE_STATIC);
1480 sqlite3_bind_text(session->log, 3, description, -1, SQLITE_STATIC);
1482 sqlite3_bind_null(session->log, 3);
1484 sqlite3_bind_text(session->log, 4, comment, -1, SQLITE_STATIC);
1486 sqlite3_bind_null(session->log, 4);
1487 result = sqlite3_step(session->log);
1488 sqlite3_reset(session->log);
1490 return PEP_STATUS_OK; // We ignore errors for this function.
1493 DYNAMIC_API PEP_STATUS log_service(
1494 PEP_SESSION session,
1497 const char *description,
1503 return PEP_ILLEGAL_VALUE;
1505 if (session->service_log)
1506 return log_event(session, title, entity, description, comment);
1508 return PEP_STATUS_OK;
1511 DYNAMIC_API PEP_STATUS trustword(
1512 PEP_SESSION session, uint16_t value, const char *lang,
1513 char **word, size_t *wsize
1516 PEP_STATUS status = PEP_STATUS_OK;
1522 if (!(session && word && wsize))
1523 return PEP_ILLEGAL_VALUE;
1531 assert((lang[0] >= 'A' && lang[0] <= 'Z')
1532 || (lang[0] >= 'a' && lang[0] <= 'z'));
1533 assert((lang[1] >= 'A' && lang[1] <= 'Z')
1534 || (lang[1] >= 'a' && lang[1] <= 'z'));
1535 assert(lang[2] == 0);
1537 sqlite3_reset(session->trustword);
1538 sqlite3_bind_text(session->trustword, 1, lang, -1, SQLITE_STATIC);
1539 sqlite3_bind_int(session->trustword, 2, value);
1541 const int result = sqlite3_step(session->trustword);
1542 if (result == SQLITE_ROW) {
1543 *word = strdup((const char *) sqlite3_column_text(session->trustword,
1546 *wsize = sqlite3_column_bytes(session->trustword, 1);
1548 status = PEP_OUT_OF_MEMORY;
1550 status = PEP_TRUSTWORD_NOT_FOUND;
1552 sqlite3_reset(session->trustword);
1556 DYNAMIC_API PEP_STATUS trustwords(
1557 PEP_SESSION session, const char *fingerprint, const char *lang,
1558 char **words, size_t *wsize, int max_words
1561 const char *source = fingerprint;
1564 assert(fingerprint);
1567 assert(max_words >= 0);
1569 if (!(session && fingerprint && words && wsize && max_words >= 0))
1570 return PEP_ILLEGAL_VALUE;
1575 char *buffer = calloc(1, MAX_TRUSTWORDS_SPACE);
1578 return PEP_OUT_OF_MEMORY;
1579 char *dest = buffer;
1581 const size_t fsize = strlen(fingerprint);
1583 if (!lang || !lang[0])
1586 assert((lang[0] >= 'A' && lang[0] <= 'Z')
1587 || (lang[0] >= 'a' && lang[0] <= 'z'));
1588 assert((lang[1] >= 'A' && lang[1] <= 'Z')
1589 || (lang[1] >= 'a' && lang[1] <= 'z'));
1590 assert(lang[2] == 0);
1593 while (source < fingerprint + fsize) {
1600 for (value=0, j=0; j < 4 && source < fingerprint + fsize; ) {
1601 if (*source >= 'a' && *source <= 'f')
1602 value += (*source - 'a' + 10) << (3 - j++) * 4;
1603 else if (*source >= 'A' && *source <= 'F')
1604 value += (*source - 'A' + 10) << (3 - j++) * 4;
1605 else if (*source >= '0' && *source <= '9')
1606 value += (*source - '0') << (3 - j++) * 4;
1611 _status = trustword(session, value, lang, &word, &_wsize);
1612 if (_status == PEP_OUT_OF_MEMORY) {
1614 return PEP_OUT_OF_MEMORY;
1618 return PEP_TRUSTWORD_NOT_FOUND;
1621 if (dest + _wsize < buffer + MAX_TRUSTWORDS_SPACE - 1) {
1622 strncpy(dest, word, _wsize);
1628 break; // buffer full
1631 if (source < fingerprint + fsize
1632 && dest + _wsize < buffer + MAX_TRUSTWORDS_SPACE - 1)
1636 if (max_words && n_words >= max_words)
1641 *wsize = dest - buffer;
1642 return PEP_STATUS_OK;
1645 pEp_identity *new_identity(
1646 const char *address, const char *fpr, const char *user_id,
1647 const char *username
1650 pEp_identity *result = calloc(1, sizeof(pEp_identity));
1654 result->address = strdup(address);
1655 assert(result->address);
1656 if (result->address == NULL) {
1662 result->fpr = strdup(fpr);
1663 assert(result->fpr);
1664 if (result->fpr == NULL) {
1665 free_identity(result);
1670 result->user_id = strdup(user_id);
1671 assert(result->user_id);
1672 if (result->user_id == NULL) {
1673 free_identity(result);
1678 result->username = strdup(username);
1679 assert(result->username);
1680 if (result->username == NULL) {
1681 free_identity(result);
1689 pEp_identity *identity_dup(const pEp_identity *src)
1693 pEp_identity *dup = new_identity(src->address, src->fpr, src->user_id,
1699 dup->comm_type = src->comm_type;
1700 dup->lang[0] = src->lang[0];
1701 dup->lang[1] = src->lang[1];
1703 dup->flags = src->flags;
1709 void free_identity(pEp_identity *identity)
1712 free(identity->address);
1713 free(identity->fpr);
1714 free(identity->user_id);
1715 free(identity->username);
1720 DYNAMIC_API PEP_STATUS get_default_own_userid(
1721 PEP_SESSION session,
1728 if (!session || !userid)
1729 return PEP_ILLEGAL_VALUE;
1731 PEP_STATUS status = PEP_STATUS_OK;
1732 char* retval = NULL;
1734 sqlite3_reset(session->get_default_own_userid);
1736 const int result = sqlite3_step(session->get_default_own_userid);
1741 id = (const char *) sqlite3_column_text(session->get_default_own_userid, 0);
1743 // Shouldn't happen.
1744 status = PEP_UNKNOWN_ERROR;
1747 retval = strdup(id);
1749 status = PEP_OUT_OF_MEMORY;
1753 // Technically true, given how we find it, but FIXME we need a more descriptive error
1754 status = PEP_CANNOT_FIND_IDENTITY;
1760 sqlite3_reset(session->get_default_own_userid);
1765 DYNAMIC_API PEP_STATUS get_userid_alias_default(
1766 PEP_SESSION session,
1767 const char* alias_id,
1768 char** default_id) {
1772 assert(alias_id[0]);
1775 if (!(session && alias_id && alias_id[0] && default_id))
1776 return PEP_ILLEGAL_VALUE;
1778 PEP_STATUS status = PEP_STATUS_OK;
1779 char* retval = NULL;
1781 sqlite3_reset(session->get_userid_alias_default);
1782 sqlite3_bind_text(session->get_userid_alias_default, 1, alias_id, -1, SQLITE_STATIC);
1786 const int result = sqlite3_step(session->get_userid_alias_default);
1789 tempid = (const char *) sqlite3_column_text(session->get_userid_alias_default, 0);
1791 retval = strdup(tempid);
1794 return PEP_OUT_OF_MEMORY;
1797 *default_id = retval;
1800 status = PEP_CANNOT_FIND_ALIAS;
1804 sqlite3_reset(session->get_userid_alias_default);
1808 DYNAMIC_API PEP_STATUS set_userid_alias (
1809 PEP_SESSION session,
1810 const char* default_id,
1811 const char* alias_id) {
1819 if (!(session && default_id && alias_id &&
1820 default_id[0] != '\0' && alias_id[0] != '\0'))
1821 return PEP_ILLEGAL_VALUE;
1823 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
1825 sqlite3_reset(session->add_userid_alias);
1826 sqlite3_bind_text(session->add_userid_alias, 1, default_id, -1,
1828 sqlite3_bind_text(session->add_userid_alias, 2, alias_id, -1,
1831 result = sqlite3_step(session->add_userid_alias);
1833 sqlite3_reset(session->add_userid_alias);
1834 if (result != SQLITE_DONE) {
1835 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
1836 return PEP_CANNOT_SET_ALIAS;
1838 sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
1841 return PEP_STATUS_OK;
1844 DYNAMIC_API PEP_STATUS get_identity(
1845 PEP_SESSION session,
1846 const char *address,
1847 const char *user_id,
1848 pEp_identity **identity
1851 PEP_STATUS status = PEP_STATUS_OK;
1852 static pEp_identity *_identity;
1859 if (!(session && address && address[0] && identity))
1860 return PEP_ILLEGAL_VALUE;
1864 sqlite3_reset(session->get_identity);
1865 sqlite3_bind_text(session->get_identity, 1, address, -1, SQLITE_STATIC);
1866 sqlite3_bind_text(session->get_identity, 2, user_id, -1, SQLITE_STATIC);
1868 const int result = sqlite3_step(session->get_identity);
1871 _identity = new_identity(
1873 (const char *) sqlite3_column_text(session->get_identity, 0),
1875 (const char *) sqlite3_column_text(session->get_identity, 1)
1878 if (_identity == NULL)
1879 return PEP_OUT_OF_MEMORY;
1881 _identity->comm_type = (PEP_comm_type)
1882 sqlite3_column_int(session->get_identity, 2);
1883 const char* const _lang = (const char *)
1884 sqlite3_column_text(session->get_identity, 3);
1885 if (_lang && _lang[0]) {
1886 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1887 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1888 assert(_lang[2] == 0);
1889 _identity->lang[0] = _lang[0];
1890 _identity->lang[1] = _lang[1];
1891 _identity->lang[2] = 0;
1893 _identity->flags = (unsigned int)
1894 sqlite3_column_int(session->get_identity, 4);
1895 _identity->me = (unsigned int)
1896 sqlite3_column_int(session->get_identity, 5);
1898 *identity = _identity;
1901 status = PEP_CANNOT_FIND_IDENTITY;
1905 sqlite3_reset(session->get_identity);
1909 PEP_STATUS get_identity_without_trust_check(
1910 PEP_SESSION session,
1911 const char *address,
1912 const char *user_id,
1913 pEp_identity **identity
1916 PEP_STATUS status = PEP_STATUS_OK;
1917 static pEp_identity *_identity;
1924 if (!(session && address && address[0] && identity))
1925 return PEP_ILLEGAL_VALUE;
1929 sqlite3_reset(session->get_identity_without_trust_check);
1930 sqlite3_bind_text(session->get_identity_without_trust_check, 1, address, -1, SQLITE_STATIC);
1931 sqlite3_bind_text(session->get_identity_without_trust_check, 2, user_id, -1, SQLITE_STATIC);
1933 const int result = sqlite3_step(session->get_identity_without_trust_check);
1936 _identity = new_identity(
1938 (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 0),
1940 (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 1)
1943 if (_identity == NULL)
1944 return PEP_OUT_OF_MEMORY;
1946 _identity->comm_type = PEP_ct_unknown;
1947 const char* const _lang = (const char *)
1948 sqlite3_column_text(session->get_identity_without_trust_check, 2);
1949 if (_lang && _lang[0]) {
1950 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1951 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1952 assert(_lang[2] == 0);
1953 _identity->lang[0] = _lang[0];
1954 _identity->lang[1] = _lang[1];
1955 _identity->lang[2] = 0;
1957 _identity->flags = (unsigned int)
1958 sqlite3_column_int(session->get_identity_without_trust_check, 3);
1959 _identity->me = (unsigned int)
1960 sqlite3_column_int(session->get_identity_without_trust_check, 4);
1962 *identity = _identity;
1965 status = PEP_CANNOT_FIND_IDENTITY;
1969 sqlite3_reset(session->get_identity_without_trust_check);
1973 PEP_STATUS get_identities_by_address(
1974 PEP_SESSION session,
1975 const char *address,
1976 identity_list** id_list
1979 pEp_identity* ident;
1986 if (!(session && address && address[0] && id_list))
1987 return PEP_ILLEGAL_VALUE;
1990 identity_list* ident_list = NULL;
1992 sqlite3_reset(session->get_identities_by_address);
1993 sqlite3_bind_text(session->get_identities_by_address, 1, address, -1, SQLITE_STATIC);
1996 while ((result = sqlite3_step(session->get_identities_by_address)) == SQLITE_ROW) {
1997 //"select user_id, main_key_id, username, comm_type, lang,"
1998 //" identity.flags, is_own"
1999 ident = new_identity(
2001 (const char *) sqlite3_column_text(session->get_identities_by_address, 1),
2002 (const char *) sqlite3_column_text(session->get_identities_by_address, 0),
2003 (const char *) sqlite3_column_text(session->get_identities_by_address, 2)
2007 return PEP_OUT_OF_MEMORY;
2009 ident->comm_type = PEP_ct_unknown;
2011 const char* const _lang = (const char *)
2012 sqlite3_column_text(session->get_identities_by_address, 3);
2013 if (_lang && _lang[0]) {
2014 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
2015 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
2016 assert(_lang[2] == 0);
2017 ident->lang[0] = _lang[0];
2018 ident->lang[1] = _lang[1];
2021 ident->flags = (unsigned int)
2022 sqlite3_column_int(session->get_identities_by_address, 4);
2023 ident->me = (unsigned int)
2024 sqlite3_column_int(session->get_identities_by_address, 5);
2027 identity_list_add(ident_list, ident);
2029 ident_list = new_identity_list(ident);
2032 sqlite3_reset(session->get_identities_by_address);
2034 *id_list = ident_list;
2037 return PEP_CANNOT_FIND_IDENTITY;
2039 return PEP_STATUS_OK;
2042 PEP_STATUS exists_identity_entry(PEP_SESSION session, pEp_identity* identity,
2046 assert(!EMPTYSTR(identity->user_id));
2047 assert(!EMPTYSTR(identity->address));
2048 if (!session || !exists || EMPTYSTR(identity->user_id) || EMPTYSTR(identity->address))
2049 return PEP_ILLEGAL_VALUE;
2053 sqlite3_reset(session->exists_identity_entry);
2054 sqlite3_bind_text(session->exists_identity_entry, 1, identity->address, -1,
2056 sqlite3_bind_text(session->exists_identity_entry, 2, identity->user_id, -1,
2059 int result = sqlite3_step(session->exists_identity_entry);
2062 // yeah yeah, I know, we could be lazy here, but it looks bad.
2063 *exists = (sqlite3_column_int(session->exists_identity_entry, 0) != 0);
2067 return PEP_UNKNOWN_ERROR;
2070 return PEP_STATUS_OK;
2073 PEP_STATUS exists_trust_entry(PEP_SESSION session, pEp_identity* identity,
2077 assert(!EMPTYSTR(identity->user_id));
2078 assert(!EMPTYSTR(identity->fpr));
2079 if (!session || !exists || EMPTYSTR(identity->user_id) || EMPTYSTR(identity->fpr))
2080 return PEP_ILLEGAL_VALUE;
2084 sqlite3_reset(session->exists_trust_entry);
2085 sqlite3_bind_text(session->exists_trust_entry, 1, identity->user_id, -1,
2087 sqlite3_bind_text(session->exists_trust_entry, 2, identity->fpr, -1,
2090 int result = sqlite3_step(session->exists_trust_entry);
2093 // yeah yeah, I know, we could be lazy here, but it looks bad.
2094 *exists = (sqlite3_column_int(session->exists_trust_entry, 0) != 0);
2098 return PEP_UNKNOWN_ERROR;
2101 return PEP_STATUS_OK;
2104 // FIXME: We can rollback in set_identity on the return status,
2105 // so we should probably do that.
2106 PEP_STATUS set_pgp_keypair(PEP_SESSION session, const char* fpr) {
2107 if (!session || EMPTYSTR(fpr))
2108 return PEP_ILLEGAL_VALUE;
2112 sqlite3_reset(session->set_pgp_keypair);
2113 sqlite3_bind_text(session->set_pgp_keypair, 1, fpr, -1,
2115 result = sqlite3_step(session->set_pgp_keypair);
2116 sqlite3_reset(session->set_pgp_keypair);
2117 if (result != SQLITE_DONE) {
2118 return PEP_CANNOT_SET_PGP_KEYPAIR;
2121 return PEP_STATUS_OK;
2124 static PEP_STATUS _set_or_update_trust(PEP_SESSION session,
2125 pEp_identity* identity,
2126 sqlite3_stmt* set_or_update) {
2130 assert(identity->user_id);
2131 assert(identity->fpr);
2133 if (!session || !identity || EMPTYSTR(identity->user_id) || EMPTYSTR(identity->fpr))
2134 return PEP_ILLEGAL_VALUE;
2138 sqlite3_reset(set_or_update);
2139 sqlite3_bind_text(set_or_update, 1, identity->user_id, -1,
2141 sqlite3_bind_text(set_or_update, 2, identity->fpr, -1,
2143 sqlite3_bind_int(set_or_update, 3, identity->comm_type);
2144 result = sqlite3_step(set_or_update);
2145 assert(result == SQLITE_DONE);
2146 sqlite3_reset(set_or_update);
2147 if (result != SQLITE_DONE)
2148 return PEP_CANNOT_SET_TRUST;
2150 return PEP_STATUS_OK;
2153 static PEP_STATUS _set_or_update_identity_entry(PEP_SESSION session,
2154 pEp_identity* identity,
2155 sqlite3_stmt* set_or_update) {
2158 assert(set_or_update);
2160 if (!session || !identity || !identity->user_id || !identity->address)
2161 return PEP_ILLEGAL_VALUE;
2163 sqlite3_reset(set_or_update);
2164 sqlite3_bind_text(set_or_update, 1, identity->address, -1,
2166 sqlite3_bind_text(set_or_update, 2, identity->fpr, -1,
2168 sqlite3_bind_text(set_or_update, 3, identity->user_id, -1,
2170 sqlite3_bind_int(set_or_update, 4, identity->flags);
2171 sqlite3_bind_int(set_or_update, 5, identity->me);
2172 int result = sqlite3_step(set_or_update);
2173 sqlite3_reset(set_or_update);
2174 if (result != SQLITE_DONE)
2175 return PEP_CANNOT_SET_IDENTITY;
2177 return PEP_STATUS_OK;
2180 static PEP_STATUS _set_or_update_person(PEP_SESSION session,
2181 pEp_identity* identity,
2182 sqlite3_stmt* set_or_update) {
2185 assert(set_or_update);
2187 if (!session || !identity || !identity->user_id || !identity->username)
2188 return PEP_ILLEGAL_VALUE;
2190 sqlite3_reset(set_or_update);
2191 sqlite3_bind_text(set_or_update, 1, identity->user_id, -1,
2193 sqlite3_bind_text(set_or_update, 2, identity->username, -1,
2195 if (identity->lang[0])
2196 sqlite3_bind_text(set_or_update, 3, identity->lang, 2,
2199 sqlite3_bind_null(set_or_update, 3);
2200 sqlite3_bind_text(set_or_update, 4, identity->fpr, -1,
2202 int result = sqlite3_step(set_or_update);
2203 sqlite3_reset(set_or_update);
2205 if (result != SQLITE_DONE)
2206 return PEP_CANNOT_SET_PERSON;
2208 return PEP_STATUS_OK;
2211 PEP_STATUS set_or_update_with_identity(PEP_SESSION session,
2212 pEp_identity* identity,
2213 PEP_STATUS (* set_function)(PEP_SESSION, pEp_identity*, sqlite3_stmt*),
2214 PEP_STATUS (* exists_function)(PEP_SESSION, pEp_identity*, bool*),
2215 sqlite3_stmt* update_query,
2216 sqlite3_stmt* set_query,
2217 bool guard_transaction) {
2219 if (guard_transaction) {
2220 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
2222 bool exists = false;
2223 PEP_STATUS status = exists_function(session, identity, &exists);
2225 if (status == PEP_STATUS_OK) {
2227 status = set_function(session, identity, update_query);
2230 status = set_function(session, identity, set_query);
2233 if (guard_transaction) {
2234 if (status != PEP_STATUS_OK)
2235 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2237 sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
2242 PEP_STATUS _set_trust_internal(PEP_SESSION session, pEp_identity* identity,
2243 bool guard_transaction) {
2244 PEP_STATUS status = set_or_update_with_identity(session, identity,
2245 _set_or_update_trust,
2247 session->update_trust,
2250 if (status == PEP_STATUS_OK) {
2251 if ((identity->comm_type | PEP_ct_confirmed) == PEP_ct_pEp)
2252 status = set_as_pep_user(session, identity);
2257 PEP_STATUS set_trust(PEP_SESSION session, pEp_identity* identity) {
2258 return _set_trust_internal(session, identity, true);
2261 PEP_STATUS set_person(PEP_SESSION session, pEp_identity* identity,
2262 bool guard_transaction) {
2263 return set_or_update_with_identity(session, identity,
2264 _set_or_update_person,
2266 session->update_person,
2267 session->set_person,
2271 PEP_STATUS set_identity_entry(PEP_SESSION session, pEp_identity* identity,
2272 bool guard_transaction) {
2273 return set_or_update_with_identity(session, identity,
2274 _set_or_update_identity_entry,
2275 exists_identity_entry,
2276 session->update_identity_entry,
2277 session->set_identity_entry,
2281 DYNAMIC_API PEP_STATUS set_identity(
2282 PEP_SESSION session, const pEp_identity *identity
2289 assert(identity->address);
2290 assert(identity->user_id);
2291 assert(identity->username);
2293 if (!(session && identity && identity->address &&
2294 identity->user_id && identity->username))
2295 return PEP_ILLEGAL_VALUE;
2297 PEP_STATUS status = PEP_STATUS_OK;
2301 bool has_fpr = (!EMPTYSTR(identity->fpr));
2304 // blacklist check - FIXME: ENGINE-294 will remove
2305 status = blacklist_is_listed(session, identity->fpr, &listed);
2306 assert(status == PEP_STATUS_OK);
2307 if (status != PEP_STATUS_OK)
2311 return PEP_KEY_BLACKLISTED;
2314 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
2316 if (identity->lang[0]) {
2317 assert(identity->lang[0] >= 'a' && identity->lang[0] <= 'z');
2318 assert(identity->lang[1] >= 'a' && identity->lang[1] <= 'z');
2319 assert(identity->lang[2] == 0);
2323 sqlite3_reset(session->set_pgp_keypair);
2324 sqlite3_bind_text(session->set_pgp_keypair, 1, identity->fpr, -1,
2326 result = sqlite3_step(session->set_pgp_keypair);
2327 sqlite3_reset(session->set_pgp_keypair);
2328 if (result != SQLITE_DONE) {
2329 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2330 return PEP_CANNOT_SET_PGP_KEYPAIR;
2334 // We do this because there are checks in set_person for
2335 // aliases, which modify the identity object on return.
2336 pEp_identity* ident_copy = identity_dup(identity);
2338 return PEP_OUT_OF_MEMORY;
2340 status = set_person(session, ident_copy, false);
2341 if (status != PEP_STATUS_OK) {
2342 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2346 status = set_identity_entry(session, ident_copy, false);
2347 if (status != PEP_STATUS_OK) {
2348 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2353 status = _set_trust_internal(session, ident_copy, false);
2354 if (status != PEP_STATUS_OK) {
2355 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
2360 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
2361 if (result == SQLITE_OK)
2362 status = PEP_STATUS_OK;
2364 status = PEP_COMMIT_FAILED;
2367 free_identity(ident_copy);
2371 // This ONLY sets the user flag, and creates a shell identity if necessary.
2372 PEP_STATUS set_as_pep_user(PEP_SESSION session, pEp_identity* user) {
2376 assert(!EMPTYSTR(user->user_id));
2378 if (!session || !user || EMPTYSTR(user->user_id))
2379 return PEP_ILLEGAL_VALUE;
2381 PEP_STATUS status = PEP_STATUS_OK;
2383 bool person_exists = false;
2385 status = exists_person(session, user, &person_exists);
2387 if (status != PEP_STATUS_OK)
2390 if (!person_exists) {
2392 return PEP_ILLEGAL_VALUE;
2394 // create shell identity
2395 pEp_identity* tmp_id = new_identity(user->address, NULL, user->user_id, user->username);
2396 status = set_identity(session, tmp_id); // this creates the person
2397 free_identity(tmp_id);
2398 if (status != PEP_STATUS_OK)
2402 // Ok, let's set it.
2403 sqlite3_reset(session->set_as_pep_user);
2404 sqlite3_bind_text(session->set_as_pep_user, 1, user->user_id, -1,
2406 int result = sqlite3_step(session->set_as_pep_user);
2407 sqlite3_reset(session->set_as_pep_user);
2409 if (result != SQLITE_DONE)
2410 return PEP_CANNOT_SET_PERSON;
2412 return PEP_STATUS_OK;
2415 PEP_STATUS exists_person(PEP_SESSION session, pEp_identity* identity,
2418 // const char* user_id,
2419 // char** default_id, bool* exists) {
2423 assert(!EMPTYSTR(identity->user_id));
2425 if (!session || !exists || !identity || EMPTYSTR(identity->user_id))
2426 return PEP_ILLEGAL_VALUE;
2430 const char* user_id = identity->user_id;
2431 char* alias_default = NULL;
2433 PEP_STATUS status = get_userid_alias_default(session, user_id, &alias_default);
2435 if (status == PEP_CANNOT_FIND_ALIAS || EMPTYSTR(alias_default)) {
2436 sqlite3_reset(session->exists_person);
2437 sqlite3_bind_text(session->exists_person, 1, user_id, -1,
2439 int result = sqlite3_step(session->exists_person);
2442 // yeah yeah, I know, we could be lazy here, but it looks bad.
2443 *exists = (sqlite3_column_int(session->exists_person, 0) != 0);
2444 status = PEP_STATUS_OK;
2448 return PEP_UNKNOWN_ERROR;
2451 else if (status == PEP_STATUS_OK) {
2452 *exists = true; // thank you, delete on cascade!
2453 // FIXME: Should we correct the userid default here? I think we should.
2454 free(identity->user_id);
2455 identity->user_id = alias_default; // ownership transfer
2458 free(alias_default);
2463 DYNAMIC_API PEP_STATUS is_pep_user(PEP_SESSION session, pEp_identity *identity, bool* is_pep)
2468 assert(!EMPTYSTR(identity->user_id));
2470 if (!session || !is_pep || !identity || EMPTYSTR(identity->user_id))
2471 return PEP_ILLEGAL_VALUE;
2475 const char* user_id = identity->user_id;
2477 if (!session || EMPTYSTR(user_id))
2478 return PEP_ILLEGAL_VALUE;
2480 char* alias_default = NULL;
2482 PEP_STATUS status = get_userid_alias_default(session, user_id, &alias_default);
2484 if (status == PEP_CANNOT_FIND_ALIAS || EMPTYSTR(alias_default)) {
2485 free(alias_default);
2486 alias_default = strdup(user_id);
2489 sqlite3_reset(session->is_pep_user);
2490 sqlite3_bind_text(session->is_pep_user, 1, user_id, -1,
2492 int result = sqlite3_step(session->is_pep_user);
2495 // yeah yeah, I know, we could be lazy here, but it looks bad.
2496 *is_pep = (sqlite3_column_int(session->is_pep_user, 0) != 0);
2500 free(alias_default);
2501 return PEP_CANNOT_FIND_PERSON;
2504 return PEP_STATUS_OK;
2508 PEP_STATUS remove_fpr_as_default(PEP_SESSION session,
2513 if (!session || !fpr)
2514 return PEP_ILLEGAL_VALUE;
2516 sqlite3_reset(session->remove_fpr_as_default);
2517 sqlite3_bind_text(session->remove_fpr_as_default, 1, fpr, -1,
2520 int result = sqlite3_step(session->remove_fpr_as_default);
2521 sqlite3_reset(session->remove_fpr_as_default);
2523 if (result != SQLITE_DONE)
2524 return PEP_CANNOT_SET_IDENTITY; // misleading - could also be person
2526 return PEP_STATUS_OK;
2530 PEP_STATUS replace_identities_fpr(PEP_SESSION session,
2531 const char* old_fpr,
2532 const char* new_fpr)
2537 if (!old_fpr || !new_fpr)
2538 return PEP_ILLEGAL_VALUE;
2540 sqlite3_reset(session->replace_identities_fpr);
2541 sqlite3_bind_text(session->replace_identities_fpr, 1, new_fpr, -1,
2543 sqlite3_bind_text(session->replace_identities_fpr, 2, old_fpr, -1,
2546 int result = sqlite3_step(session->replace_identities_fpr);
2547 sqlite3_reset(session->replace_identities_fpr);
2549 if (result != SQLITE_DONE)
2550 return PEP_CANNOT_SET_IDENTITY;
2552 return PEP_STATUS_OK;
2555 PEP_STATUS update_trust_for_fpr(PEP_SESSION session,
2557 PEP_comm_type comm_type)
2560 return PEP_ILLEGAL_VALUE;
2562 sqlite3_reset(session->update_trust_for_fpr);
2563 sqlite3_bind_int(session->update_trust_for_fpr, 1, comm_type);
2564 sqlite3_bind_text(session->update_trust_for_fpr, 2, fpr, -1,
2566 int result = sqlite3_step(session->update_trust_for_fpr);
2567 sqlite3_reset(session->update_trust_for_fpr);
2568 if (result != SQLITE_DONE) {
2569 return PEP_CANNOT_SET_TRUST;
2572 return PEP_STATUS_OK;
2575 DYNAMIC_API PEP_STATUS set_device_group(
2576 PEP_SESSION session,
2577 const char *group_name
2584 if (!(session && group_name))
2585 return PEP_ILLEGAL_VALUE;
2587 // 1. Get own user_id
2588 char* user_id = NULL;
2589 PEP_STATUS status = get_default_own_userid(session, &user_id);
2591 // No user_id is returned in this case, no need to free;
2592 if (status != PEP_STATUS_OK)
2595 // 2. Set device group
2596 sqlite3_reset(session->set_device_group);
2598 sqlite3_bind_text(session->set_device_group, 1, group_name, -1,
2601 sqlite3_bind_null(session->set_device_group, 1);
2604 sqlite3_bind_text(session->set_device_group, 2, user_id, -1,
2607 result = sqlite3_step(session->set_device_group);
2608 sqlite3_reset(session->set_device_group);
2612 if (result != SQLITE_DONE)
2613 return PEP_CANNOT_SET_PERSON;
2615 return PEP_STATUS_OK;
2618 DYNAMIC_API PEP_STATUS get_device_group(PEP_SESSION session, char **group_name)
2620 PEP_STATUS status = PEP_STATUS_OK;
2626 if (!(session && group_name))
2627 return PEP_ILLEGAL_VALUE;
2629 // 1. Get own user_id
2630 char* user_id = NULL;
2631 status = get_default_own_userid(session, &user_id);
2633 // No user_id is returned in this case, no need to free;
2634 if (status != PEP_STATUS_OK)
2637 // 2. get device group
2638 sqlite3_reset(session->get_device_group);
2639 sqlite3_bind_text(session->get_device_group, 1, user_id, -1,
2642 result = sqlite3_step(session->get_device_group);
2645 const char *_group_name = (const char *)sqlite3_column_text(session->get_device_group, 0);
2647 *group_name = strdup(_group_name);
2648 if(*group_name == NULL)
2649 status = PEP_OUT_OF_MEMORY;
2655 status = PEP_RECORD_NOT_FOUND;
2659 sqlite3_reset(session->get_device_group);
2663 DYNAMIC_API PEP_STATUS set_identity_flags(
2664 PEP_SESSION session,
2665 pEp_identity *identity,
2673 assert(identity->address);
2674 assert(identity->user_id);
2676 if (!(session && identity && identity->address && identity->user_id))
2677 return PEP_ILLEGAL_VALUE;
2679 sqlite3_reset(session->set_identity_flags);
2680 sqlite3_bind_int(session->set_identity_flags, 1, flags);
2681 sqlite3_bind_text(session->set_identity_flags, 2, identity->address, -1,
2683 sqlite3_bind_text(session->set_identity_flags, 3, identity->user_id, -1,
2686 result = sqlite3_step(session->set_identity_flags);
2688 sqlite3_reset(session->set_identity_flags);
2689 if (result != SQLITE_DONE)
2690 return PEP_CANNOT_SET_IDENTITY;
2692 identity->flags |= flags;
2693 return PEP_STATUS_OK;
2696 DYNAMIC_API PEP_STATUS unset_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->unset_identity_flags);
2713 sqlite3_bind_int(session->unset_identity_flags, 1, flags);
2714 sqlite3_bind_text(session->unset_identity_flags, 2, identity->address, -1,
2716 sqlite3_bind_text(session->unset_identity_flags, 3, identity->user_id, -1,
2718 result = sqlite3_step(session->unset_identity_flags);
2719 sqlite3_reset(session->unset_identity_flags);
2720 if (result != SQLITE_DONE)
2721 return PEP_CANNOT_SET_IDENTITY;
2722 identity->flags &= ~flags;
2724 return PEP_STATUS_OK;
2728 PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
2729 const char* new_uid) {
2734 if (!session || !old_uid || !new_uid)
2735 return PEP_ILLEGAL_VALUE;
2740 sqlite3_reset(session->replace_userid);
2741 sqlite3_bind_text(session->replace_userid, 1, new_uid, -1,
2743 sqlite3_bind_text(session->replace_userid, 2, old_uid, -1,
2745 result = sqlite3_step(session->replace_userid);
2746 sqlite3_reset(session->replace_userid);
2747 if (result != SQLITE_DONE)
2748 return PEP_CANNOT_SET_PERSON; // May need clearer retval
2750 return PEP_STATUS_OK;
2753 PEP_STATUS refresh_userid_default_key(PEP_SESSION session, const char* user_id) {
2757 if (!session || !user_id)
2758 return PEP_ILLEGAL_VALUE;
2762 sqlite3_reset(session->refresh_userid_default_key);
2763 sqlite3_bind_text(session->refresh_userid_default_key, 1, user_id, -1,
2765 result = sqlite3_step(session->refresh_userid_default_key);
2766 sqlite3_reset(session->refresh_userid_default_key);
2767 if (result != SQLITE_DONE)
2768 return PEP_CANNOT_SET_PERSON;
2770 return PEP_STATUS_OK;
2773 PEP_STATUS replace_main_user_fpr(PEP_SESSION session, const char* user_id,
2774 const char* new_fpr) {
2779 if (!session || !user_id || !new_fpr)
2780 return PEP_ILLEGAL_VALUE;
2784 sqlite3_reset(session->replace_main_user_fpr);
2785 sqlite3_bind_text(session->replace_main_user_fpr, 1, new_fpr, -1,
2787 sqlite3_bind_text(session->replace_main_user_fpr, 2, user_id, -1,
2789 result = sqlite3_step(session->replace_main_user_fpr);
2790 sqlite3_reset(session->replace_main_user_fpr);
2791 if (result != SQLITE_DONE)
2792 return PEP_CANNOT_SET_PERSON;
2794 return PEP_STATUS_OK;
2797 PEP_STATUS get_main_user_fpr(PEP_SESSION session,
2798 const char* user_id,
2801 PEP_STATUS status = PEP_STATUS_OK;
2808 if (!(session && user_id && user_id[0] && main_fpr))
2809 return PEP_ILLEGAL_VALUE;
2813 sqlite3_reset(session->get_main_user_fpr);
2814 sqlite3_bind_text(session->get_main_user_fpr, 1, user_id, -1,
2816 result = sqlite3_step(session->get_main_user_fpr);
2820 (const char *) sqlite3_column_text(session->get_main_user_fpr, 0);
2822 *main_fpr = strdup(_fpr);
2824 status = PEP_OUT_OF_MEMORY;
2828 status = PEP_CANNOT_FIND_PERSON;
2831 sqlite3_reset(session->get_main_user_fpr);
2836 DYNAMIC_API PEP_STATUS mark_as_compromized(
2837 PEP_SESSION session,
2844 assert(fpr && fpr[0]);
2846 if (!(session && fpr && fpr[0]))
2847 return PEP_ILLEGAL_VALUE;
2849 sqlite3_reset(session->mark_compromized);
2850 sqlite3_bind_text(session->mark_compromized, 1, fpr, -1,
2852 result = sqlite3_step(session->mark_compromized);
2853 sqlite3_reset(session->mark_compromized);
2855 if (result != SQLITE_DONE)
2856 return PEP_CANNOT_SET_TRUST;
2858 return PEP_STATUS_OK;
2861 void pEp_free(void *p)
2867 DYNAMIC_API PEP_STATUS get_trust(PEP_SESSION session, pEp_identity *identity)
2869 PEP_STATUS status = PEP_STATUS_OK;
2872 // We need to be able to test that we break correctly without shutting
2873 // asserts off everywhere.
2875 // assert(identity);
2876 // assert(identity->user_id);
2877 // assert(identity->user_id[0]);
2878 // assert(identity->fpr);
2879 // assert(identity->fpr[0]);
2881 if (!(session && identity && identity->user_id && identity->user_id[0] &&
2882 identity->fpr && identity->fpr[0]))
2883 return PEP_ILLEGAL_VALUE;
2885 identity->comm_type = PEP_ct_unknown;
2887 sqlite3_reset(session->get_trust);
2888 sqlite3_bind_text(session->get_trust, 1, identity->user_id, -1,
2890 sqlite3_bind_text(session->get_trust, 2, identity->fpr, -1, SQLITE_STATIC);
2892 result = sqlite3_step(session->get_trust);
2895 int comm_type = (PEP_comm_type) sqlite3_column_int(session->get_trust,
2897 identity->comm_type = comm_type;
2902 status = PEP_CANNOT_FIND_IDENTITY;
2905 sqlite3_reset(session->get_trust);
2909 DYNAMIC_API PEP_STATUS least_trust(
2910 PEP_SESSION session,
2912 PEP_comm_type *comm_type
2915 PEP_STATUS status = PEP_STATUS_OK;
2922 if (!(session && fpr && comm_type))
2923 return PEP_ILLEGAL_VALUE;
2925 *comm_type = PEP_ct_unknown;
2927 sqlite3_reset(session->least_trust);
2928 sqlite3_bind_text(session->least_trust, 1, fpr, -1, SQLITE_STATIC);
2930 result = sqlite3_step(session->least_trust);
2933 int _comm_type = sqlite3_column_int(session->least_trust, 0);
2934 *comm_type = (PEP_comm_type) _comm_type;
2938 // never reached because of sql min()
2939 status = PEP_CANNOT_FIND_IDENTITY;
2942 sqlite3_reset(session->least_trust);
2946 DYNAMIC_API PEP_STATUS decrypt_and_verify(
2947 PEP_SESSION session, const char *ctext, size_t csize,
2948 const char *dsigtext, size_t dsigsize,
2949 char **ptext, size_t *psize, stringlist_t **keylist
2959 if (!(session && ctext && csize && ptext && psize && keylist))
2960 return PEP_ILLEGAL_VALUE;
2962 return session->cryptotech[PEP_crypt_OpenPGP].decrypt_and_verify(
2963 session, ctext, csize, dsigtext, dsigsize, ptext, psize, keylist);
2966 DYNAMIC_API PEP_STATUS encrypt_and_sign(
2967 PEP_SESSION session, const stringlist_t *keylist, const char *ptext,
2968 size_t psize, char **ctext, size_t *csize
2978 if (!(session && keylist && ptext && psize && ctext && csize))
2979 return PEP_ILLEGAL_VALUE;
2981 return session->cryptotech[PEP_crypt_OpenPGP].encrypt_and_sign(session,
2982 keylist, ptext, psize, ctext, csize);
2985 PEP_STATUS encrypt_only(
2986 PEP_SESSION session, const stringlist_t *keylist, const char *ptext,
2987 size_t psize, char **ctext, size_t *csize
2997 if (!(session && keylist && ptext && psize && ctext && csize))
2998 return PEP_ILLEGAL_VALUE;
3000 return session->cryptotech[PEP_crypt_OpenPGP].encrypt_only(session,
3001 keylist, ptext, psize, ctext, csize);
3005 DYNAMIC_API PEP_STATUS verify_text(
3006 PEP_SESSION session, const char *text, size_t size,
3007 const char *signature, size_t sig_size, stringlist_t **keylist
3017 if (!(session && text && size && signature && sig_size && keylist))
3018 return PEP_ILLEGAL_VALUE;
3020 return session->cryptotech[PEP_crypt_OpenPGP].verify_text(session, text,
3021 size, signature, sig_size, keylist);
3024 DYNAMIC_API PEP_STATUS delete_keypair(PEP_SESSION session, const char *fpr)
3029 if (!(session && fpr))
3030 return PEP_ILLEGAL_VALUE;
3032 return session->cryptotech[PEP_crypt_OpenPGP].delete_keypair(session, fpr);
3035 DYNAMIC_API PEP_STATUS export_key(
3036 PEP_SESSION session, const char *fpr, char **key_data, size_t *size
3044 if (!(session && fpr && key_data && size))
3045 return PEP_ILLEGAL_VALUE;
3047 return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
3048 key_data, size, false);
3051 DYNAMIC_API PEP_STATUS export_secrect_key(
3052 PEP_SESSION session, const char *fpr, char **key_data, size_t *size
3060 if (!(session && fpr && key_data && size))
3061 return PEP_ILLEGAL_VALUE;
3063 // don't accept key IDs but full fingerprints only
3064 if (strlen(fpr) < 16)
3065 return PEP_ILLEGAL_VALUE;
3067 return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
3068 key_data, size, true);
3071 DYNAMIC_API PEP_STATUS find_keys(
3072 PEP_SESSION session, const char *pattern, stringlist_t **keylist
3079 if (!(session && pattern && keylist))
3080 return PEP_ILLEGAL_VALUE;
3082 return session->cryptotech[PEP_crypt_OpenPGP].find_keys(session, pattern,
3087 DYNAMIC_API PEP_STATUS generate_keypair(
3088 PEP_SESSION session, pEp_identity *identity
3093 assert(identity->address);
3094 assert(identity->fpr == NULL || identity->fpr[0] == 0);
3095 assert(identity->username);
3097 if (!(session && identity && identity->address &&
3098 (identity->fpr == NULL || identity->fpr[0] == 0) &&
3099 identity->username))
3100 return PEP_ILLEGAL_VALUE;
3103 session->cryptotech[PEP_crypt_OpenPGP].generate_keypair(session,
3105 if (status != PEP_STATUS_OK)
3109 status = set_pgp_keypair(session, identity->fpr);
3111 // add to known keypair DB, as this might not end up being a default
3115 DYNAMIC_API PEP_STATUS get_key_rating(
3116 PEP_SESSION session,
3118 PEP_comm_type *comm_type
3125 if (!(session && fpr && comm_type))
3126 return PEP_ILLEGAL_VALUE;
3128 return session->cryptotech[PEP_crypt_OpenPGP].get_key_rating(session, fpr,
3132 DYNAMIC_API PEP_STATUS import_key(
3133 PEP_SESSION session,
3134 const char *key_data,
3136 identity_list **private_keys
3142 if (!(session && key_data))
3143 return PEP_ILLEGAL_VALUE;
3145 return session->cryptotech[PEP_crypt_OpenPGP].import_key(session, key_data,
3146 size, private_keys);
3149 DYNAMIC_API PEP_STATUS recv_key(PEP_SESSION session, const char *pattern)
3154 if (!(session && pattern))
3155 return PEP_ILLEGAL_VALUE;
3157 return session->cryptotech[PEP_crypt_OpenPGP].recv_key(session, pattern);
3160 DYNAMIC_API PEP_STATUS send_key(PEP_SESSION session, const char *pattern)
3165 if (!(session && pattern))
3166 return PEP_ILLEGAL_VALUE;
3168 return session->cryptotech[PEP_crypt_OpenPGP].send_key(session, pattern);
3171 DYNAMIC_API PEP_STATUS renew_key(
3172 PEP_SESSION session,
3180 if (!(session && fpr))
3181 return PEP_ILLEGAL_VALUE;
3183 return session->cryptotech[PEP_crypt_OpenPGP].renew_key(session, fpr, ts);
3186 DYNAMIC_API PEP_STATUS revoke_key(
3187 PEP_SESSION session,
3195 if (!(session && fpr))
3196 return PEP_ILLEGAL_VALUE;
3198 return session->cryptotech[PEP_crypt_OpenPGP].revoke_key(session, fpr,
3202 DYNAMIC_API PEP_STATUS key_expired(
3203 PEP_SESSION session,
3213 if (!(session && fpr && expired))
3214 return PEP_ILLEGAL_VALUE;
3216 return session->cryptotech[PEP_crypt_OpenPGP].key_expired(session, fpr,
3220 DYNAMIC_API PEP_STATUS key_revoked(
3221 PEP_SESSION session,
3230 if (!(session && fpr && revoked))
3231 return PEP_ILLEGAL_VALUE;
3233 return session->cryptotech[PEP_crypt_OpenPGP].key_revoked(session, fpr,
3237 static void _clean_log_value(char *text)
3240 for (char *c = text; *c; c++) {
3241 if (*c < 32 && *c != '\n')
3249 static char *_concat_string(char *str1, const char *str2, char delim)
3251 str2 = str2 ? str2 : "";
3252 size_t len1 = str1 ? strlen(str1) : 0;
3253 size_t len2 = strlen(str2);
3254 size_t len = len1 + len2 + 3;
3255 char * result = realloc(str1, len + 1);
3259 strcpy(result + len1 + 1, str2);
3260 result[len - 2] = '"';
3261 result[len - 1] = delim;
3271 DYNAMIC_API PEP_STATUS get_crashdump_log(
3272 PEP_SESSION session,
3277 PEP_STATUS status = PEP_STATUS_OK;
3278 char *_logdata= NULL;
3281 assert(maxlines >= 0 && maxlines <= CRASHDUMP_MAX_LINES);
3284 if (!(session && logdata && maxlines >= 0 && maxlines <=
3285 CRASHDUMP_MAX_LINES))
3286 return PEP_ILLEGAL_VALUE;
3290 int limit = maxlines ? maxlines : CRASHDUMP_DEFAULT_LINES;
3291 const char *timestamp = NULL;
3292 const char *title = NULL;
3293 const char *entity = NULL;
3294 const char *desc = NULL;
3295 const char *comment = NULL;
3297 sqlite3_reset(session->crashdump);
3298 sqlite3_bind_int(session->crashdump, 1, limit);
3303 result = sqlite3_step(session->crashdump);
3306 timestamp = (const char *) sqlite3_column_text(session->crashdump,
3308 title = (const char *) sqlite3_column_text(session->crashdump,
3310 entity = (const char *) sqlite3_column_text(session->crashdump,
3312 desc = (const char *) sqlite3_column_text(session->crashdump,
3314 comment = (const char *) sqlite3_column_text(session->crashdump,
3317 _logdata = _concat_string(_logdata, timestamp, ',');
3318 if (_logdata == NULL)
3321 _logdata = _concat_string(_logdata, title, ',');
3322 if (_logdata == NULL)
3325 _logdata = _concat_string(_logdata, entity, ',');
3326 if (_logdata == NULL)
3329 _logdata = _concat_string(_logdata, desc, ',');
3330 if (_logdata == NULL)
3333 _logdata = _concat_string(_logdata, comment, '\n');
3334 if (_logdata == NULL)
3337 _clean_log_value(_logdata);
3344 status = PEP_UNKNOWN_ERROR;
3345 result = SQLITE_DONE;
3347 } while (result != SQLITE_DONE);
3349 sqlite3_reset(session->crashdump);
3350 if (status == PEP_STATUS_OK)
3351 *logdata = _logdata;
3356 status = PEP_OUT_OF_MEMORY;
3362 DYNAMIC_API PEP_STATUS get_languagelist(
3363 PEP_SESSION session,
3367 PEP_STATUS status = PEP_STATUS_OK;
3368 char *_languages= NULL;
3373 if (!(session && languages))
3374 return PEP_ILLEGAL_VALUE;
3378 const char *lang = NULL;
3379 const char *name = NULL;
3380 const char *phrase = NULL;
3382 sqlite3_reset(session->languagelist);
3387 result = sqlite3_step(session->languagelist);
3390 lang = (const char *) sqlite3_column_text(session->languagelist,
3392 name = (const char *) sqlite3_column_text(session->languagelist,
3394 phrase = (const char *) sqlite3_column_text(session->languagelist,
3397 _languages = _concat_string(_languages, lang, ',');
3398 if (_languages == NULL)
3401 _languages = _concat_string(_languages, name, ',');
3402 if (_languages == NULL)
3405 _languages = _concat_string(_languages, phrase, '\n');
3406 if (_languages == NULL)
3415 status = PEP_UNKNOWN_ERROR;
3416 result = SQLITE_DONE;
3418 } while (result != SQLITE_DONE);
3420 sqlite3_reset(session->languagelist);
3421 if (status == PEP_STATUS_OK)
3422 *languages = _languages;
3427 status = PEP_OUT_OF_MEMORY;
3433 DYNAMIC_API PEP_STATUS get_phrase(
3434 PEP_SESSION session,
3440 PEP_STATUS status = PEP_STATUS_OK;
3442 assert(session && lang && lang[0] && lang[1] && lang[2] == 0 && phrase);
3443 if (!(session && lang && lang[0] && lang[1] && lang[2] == 0 && phrase))
3444 return PEP_ILLEGAL_VALUE;
3448 sqlite3_reset(session->i18n_token);
3449 sqlite3_bind_text(session->i18n_token, 1, lang, -1, SQLITE_STATIC);
3450 sqlite3_bind_int(session->i18n_token, 2, phrase_id);
3452 const char *_phrase = NULL;
3455 result = sqlite3_step(session->i18n_token);
3458 _phrase = (const char *) sqlite3_column_text(session->i18n_token, 0);
3462 status = PEP_PHRASE_NOT_FOUND;
3466 status = PEP_UNKNOWN_ERROR;
3469 if (status == PEP_STATUS_OK) {
3470 *phrase = strdup(_phrase);
3471 if (*phrase == NULL)
3475 sqlite3_reset(session->i18n_token);
3479 status = PEP_OUT_OF_MEMORY;
3485 static PEP_STATUS _get_sequence_value(PEP_SESSION session, const char *name,
3488 assert(session && name && value);
3489 if (!(session && name && value))
3490 return PEP_ILLEGAL_VALUE;
3492 PEP_STATUS status = PEP_STATUS_OK;
3494 sqlite3_reset(session->sequence_value2);
3495 sqlite3_bind_text(session->sequence_value2, 1, name, -1,
3497 int result = sqlite3_step(session->sequence_value2);
3500 int32_t _value = (int32_t)
3501 sqlite3_column_int(session->sequence_value2, 0);
3503 sqlite3_column_int(session->sequence_value2, 1);
3506 status = PEP_OWN_SEQUENCE;
3510 status = PEP_RECORD_NOT_FOUND;
3513 status = PEP_UNKNOWN_ERROR;
3515 sqlite3_reset(session->sequence_value2);
3520 static PEP_STATUS _increment_sequence_value(PEP_SESSION session,
3521 const char *name, int own)
3523 assert(session && name);
3524 if (!(session && name))
3525 return PEP_ILLEGAL_VALUE;
3527 sqlite3_reset(session->sequence_value1);
3528 sqlite3_bind_text(session->sequence_value1, 1, name, -1, SQLITE_STATIC);
3529 sqlite3_bind_int(session->sequence_value1, 2, own);
3530 int result = sqlite3_step(session->sequence_value1);
3531 assert(result == SQLITE_DONE);
3532 sqlite3_reset(session->sequence_value1);
3533 if (result == SQLITE_DONE)
3534 return PEP_STATUS_OK;
3536 return PEP_CANNOT_INCREASE_SEQUENCE;
3539 static PEP_STATUS _set_sequence_value(PEP_SESSION session,
3540 const char *name, int32_t value, int own)
3542 assert(session && name && value > 0);
3543 if (!(session && name && value > 0))
3544 return PEP_ILLEGAL_VALUE;
3546 sqlite3_reset(session->sequence_value3);
3547 sqlite3_bind_text(session->sequence_value3, 1, name, -1, SQLITE_STATIC);
3548 sqlite3_bind_int(session->sequence_value3, 2, value);
3549 sqlite3_bind_int(session->sequence_value3, 3, own);
3550 int result = sqlite3_step(session->sequence_value3);
3551 assert(result == SQLITE_DONE);
3552 sqlite3_reset(session->sequence_value3);
3553 if (result == SQLITE_DONE)
3554 return PEP_STATUS_OK;
3556 return PEP_CANNOT_SET_SEQUENCE_VALUE;
3559 DYNAMIC_API PEP_STATUS sequence_value(
3560 PEP_SESSION session,
3565 PEP_STATUS status = PEP_STATUS_OK;
3569 assert(name && value && *value >= 0);
3571 if (!(session && name && value && *value >= 0))
3572 return PEP_ILLEGAL_VALUE;
3577 uuid_generate_random(uuid);
3578 uuid_unparse_upper(uuid, name);
3582 if (name == session->sync_session->sync_uuid ||
3583 strcmp(name, session->sync_session->sync_uuid) == 0)
3588 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
3589 int32_t old_value = 0;
3590 status = _get_sequence_value(session, name, &old_value);
3591 if (status != PEP_STATUS_OK && status != PEP_RECORD_NOT_FOUND)
3593 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3597 if (old_value >= *value) {
3598 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3599 return PEP_SEQUENCE_VIOLATED;
3602 status = _set_sequence_value(session, name, *value, own);
3603 if (status == PEP_STATUS_OK) {
3604 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
3605 if (result == SQLITE_OK)
3606 return PEP_STATUS_OK;
3608 return PEP_COMMIT_FAILED;
3610 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3616 assert(*value == 0);
3617 sqlite3_exec(session->db, "BEGIN TRANSACTION ;", NULL, NULL, NULL);
3618 status = _increment_sequence_value(session, name, own);
3619 if (status == PEP_STATUS_OK) {
3620 status = _get_sequence_value(session, name, value);
3622 if (status == PEP_STATUS_OK || status == PEP_OWN_SEQUENCE) {
3623 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
3624 if (result == SQLITE_OK){
3625 assert(*value < INT32_MAX);
3626 if (*value == INT32_MAX){
3627 return PEP_CANNOT_INCREASE_SEQUENCE;
3631 return PEP_COMMIT_FAILED;
3634 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3640 DYNAMIC_API PEP_STATUS set_revoked(
3641 PEP_SESSION session,
3642 const char *revoked_fpr,
3643 const char *replacement_fpr,
3644 const uint64_t revocation_date
3647 PEP_STATUS status = PEP_STATUS_OK;
3650 revoked_fpr && revoked_fpr[0] &&
3651 replacement_fpr && replacement_fpr[0]
3655 revoked_fpr && revoked_fpr[0] &&
3656 replacement_fpr && replacement_fpr[0]
3658 return PEP_ILLEGAL_VALUE;
3660 sqlite3_reset(session->set_revoked);
3661 sqlite3_bind_text(session->set_revoked, 1, revoked_fpr, -1, SQLITE_STATIC);
3662 sqlite3_bind_text(session->set_revoked, 2, replacement_fpr, -1,
3664 sqlite3_bind_int64(session->set_revoked, 3, revocation_date);
3668 result = sqlite3_step(session->set_revoked);
3671 status = PEP_STATUS_OK;
3675 status = PEP_UNKNOWN_ERROR;
3678 sqlite3_reset(session->set_revoked);
3682 DYNAMIC_API PEP_STATUS get_revoked(
3683 PEP_SESSION session,
3686 uint64_t *revocation_date
3689 PEP_STATUS status = PEP_STATUS_OK;
3700 return PEP_ILLEGAL_VALUE;
3702 *revoked_fpr = NULL;
3703 *revocation_date = 0;
3705 sqlite3_reset(session->get_revoked);
3706 sqlite3_bind_text(session->get_revoked, 1, fpr, -1, SQLITE_STATIC);
3710 result = sqlite3_step(session->get_revoked);
3713 *revoked_fpr = strdup((const char *)
3714 sqlite3_column_text(session->get_revoked, 0));
3716 *revocation_date = sqlite3_column_int64(session->get_revoked,
3719 status = PEP_OUT_OF_MEMORY;
3724 status = PEP_CANNOT_FIND_IDENTITY;
3727 sqlite3_reset(session->get_revoked);
3732 PEP_STATUS key_created(
3733 PEP_SESSION session,
3738 assert(session && fpr && created);
3739 if (!(session && fpr && created))
3740 return PEP_ILLEGAL_VALUE;
3742 return session->cryptotech[PEP_crypt_OpenPGP].key_created(session, fpr,
3746 PEP_STATUS find_private_keys(PEP_SESSION session, const char* pattern,
3747 stringlist_t **keylist) {
3748 assert(session && keylist);
3749 if (!(session && keylist))
3750 return PEP_ILLEGAL_VALUE;
3752 return session->cryptotech[PEP_crypt_OpenPGP].find_private_keys(session, pattern,
3756 PEP_STATUS import_trusted_own_keys(PEP_SESSION session) {
3759 return PEP_ILLEGAL_VALUE;
3761 return session->cryptotech[PEP_crypt_OpenPGP].import_trusted_own_keys(session);
3764 DYNAMIC_API const char* get_engine_version() {
3765 return PEP_ENGINE_VERSION;
3769 DYNAMIC_API PEP_STATUS reset_peptest_hack(PEP_SESSION session)
3774 return PEP_ILLEGAL_VALUE;
3776 int int_result = sqlite3_exec(
3778 "delete from identity where address like '%@peptest.ch' ;",
3783 assert(int_result == SQLITE_OK);
3785 if (int_result != SQLITE_OK)
3786 return PEP_UNKNOWN_ERROR;
3788 return PEP_STATUS_OK;
3791 #ifdef DEBUG_ERRORSTACK
3792 PEP_STATUS session_add_error(PEP_SESSION session, const char* file, unsigned line, PEP_STATUS status)
3797 snprintf(logline,47, "%.24s:%u status=%u (0x%x)", file, line, status, status);
3799 snprintf(logline,47, "%.24s:%u status=%i.", file, line, status);
3801 stringlist_add(session->errorstack, logline); // logline is copied! :-)
3805 DYNAMIC_API const stringlist_t* get_errorstack(PEP_SESSION session)
3807 return session->errorstack;
3810 DYNAMIC_API void clear_errorstack(PEP_SESSION session)
3812 const int old_len = stringlist_length(session->errorstack);
3814 free_stringlist(session->errorstack);
3815 snprintf(buf, 47, "(%i elements cleared)", old_len);
3816 session->errorstack = new_stringlist(buf);
3821 static stringlist_t* dummy_errorstack = NULL;
3823 DYNAMIC_API const stringlist_t* get_errorstack(PEP_SESSION session)
3825 if(dummy_errorstack == NULL)
3827 dummy_errorstack = new_stringlist("( Please recompile pEpEngine with -DDEBUG_ERRORSTACK )");
3830 return dummy_errorstack;
3833 DYNAMIC_API void clear_errorstack(PEP_SESSION session)
3835 // nothing to do here