Fixing bad merges still.
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 static volatile int init_count = -1;
15 // sql overloaded functions - modified from sqlite3.c
16 static void _sql_lower(sqlite3_context* ctx, int argc, sqlite3_value** argv) {
20 z2 = (char*)sqlite3_value_text(argv[0]);
21 n = sqlite3_value_bytes(argv[0]);
22 /* Verify that the call to _bytes() does not invalidate the _text() pointer */
23 assert( z2==(char*)sqlite3_value_text(argv[0]) );
25 z1 = (char*)sqlite3_malloc(n+1);
29 char c_mod = c | 0x20;
30 if (c_mod < 0x61 || c_mod > 0x7a)
35 sqlite3_result_text(ctx, z1, n, sqlite3_free);
41 // sql manipulation statements
42 static const char *sql_log =
43 "insert into log (title, entity, description, comment)"
44 "values (?1, ?2, ?3, ?4);";
46 static const char *sql_trustword =
47 "select id, word from wordlist where lang = lower(?1) "
50 static const char *sql_get_identity =
51 "select fpr, username, comm_type, lang,"
52 " identity.flags | pgp_keypair.flags,"
55 " join person on id = identity.user_id"
56 " join pgp_keypair on fpr = identity.main_key_id"
57 " join trust on id = trust.user_id"
58 " and pgp_keypair_fpr = identity.main_key_id"
59 " where (case when (address = ?1) then (1)"
60 " when (lower(address) = lower(?1)) then (1)"
61 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
64 " and identity.user_id = ?2;";
66 static const char *sql_get_identity_without_trust_check =
67 "select identity.main_key_id, username, lang,"
68 " identity.flags, is_own"
70 " join person on id = identity.user_id"
71 " where (case when (address = ?1) then (1)"
72 " when (lower(address) = lower(?1)) then (1)"
73 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
76 " and identity.user_id = ?2;";
78 static const char *sql_get_identities_by_address =
79 "select user_id, identity.main_key_id, username, lang,"
80 " identity.flags, is_own"
82 " join person on id = identity.user_id"
83 " where (case when (address = ?1) then (1)"
84 " when (lower(address) = lower(?1)) then (1)"
85 " when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
89 static const char *sql_replace_identities_fpr =
91 " set main_key_id = ?1 "
92 " where main_key_id = ?2 ;";
94 static const char *sql_remove_fpr_as_default =
95 "update person set main_key_id = NULL where main_key_id = ?1 ;"
96 "update identity set main_key_id = NULL where main_key_id = ?1 ;";
98 // Set person, but if already exist, only update.
99 // if main_key_id already set, don't touch.
100 static const char *sql_set_person =
101 "insert or replace into person (id, username, lang, main_key_id, device_group)"
102 " values (?1, ?2, ?3,"
103 " (select coalesce((select main_key_id from person "
104 " where id = ?1), upper(replace(?4,' ','')))),"
105 " (select device_group from person where id = ?1)) ;";
107 static const char *sql_set_device_group =
108 "update person set device_group = ?1 "
111 // This will cascade to identity and trust
112 static const char* sql_replace_userid =
113 "update person set id = ?1 "
116 static const char *sql_replace_main_user_fpr =
118 " set main_key_id = ?1 "
121 static const char *sql_get_main_user_fpr =
122 "select main_key_id from person"
125 static const char *sql_refresh_userid_default_key =
127 " set main_key_id = "
128 " (select identity.main_key_id from identity "
129 " join trust on trust.user_id = identity.user_id "
130 " and trust.pgp_keypair_fpr = identity.main_key_id "
131 " join person on identity.user_id = identity.user_id "
132 " where identity.user_id = ?1 "
133 " order by trust.comm_type desc "
137 static const char *sql_get_device_group =
138 "select device_group from person "
141 static const char *sql_set_pgp_keypair =
142 "insert or replace into pgp_keypair (fpr) "
143 "values (upper(replace(?1,' ',''))) ;";
145 static const char *sql_set_identity =
146 "insert or replace into identity ("
147 " address, main_key_id, "
148 " user_id, flags, is_own"
151 " upper(replace(?2,' ','')),"
155 // " (select flags from identity"
156 // " where address = ?1 and"
160 /* set_identity ignores previous flags, and doesn't filter machine flags */
165 static const char *sql_set_identity_flags =
166 "update identity set flags = "
167 " ((?1 & 255) | (select flags from identity"
168 " where address = ?2 and user_id = ?3)) "
169 "where address = ?2 and user_id = ?3 ;";
171 static const char *sql_unset_identity_flags =
172 "update identity set flags = "
173 " ( ~(?1 & 255) & (select flags from identity"
174 " where address = ?2 and user_id = ?3)) "
175 "where address = ?2 and user_id = ?3 ;";
177 static const char *sql_set_trust =
178 "insert or replace into trust (user_id, pgp_keypair_fpr, comm_type) "
179 "values (?1, upper(replace(?2,' ','')), ?3) ;";
181 static const char *sql_update_trust_for_fpr =
183 "set comm_type = ?1 "
184 "where pgp_keypair_fpr = upper(replace(?2,' ','')) ;";
186 static const char *sql_get_trust =
187 "select comm_type from trust where user_id = ?1 "
188 "and pgp_keypair_fpr = upper(replace(?2,' ','')) ;";
190 static const char *sql_least_trust =
191 "select min(comm_type) from trust where"
192 " pgp_keypair_fpr = upper(replace(?1,' ',''))"
193 " and comm_type != 0;"; // ignores PEP_ct_unknown
194 // returns PEP_ct_unknown only when no known trust is recorded
196 static const char *sql_mark_as_compromized =
197 "update trust not indexed set comm_type = 15"
198 " where pgp_keypair_fpr = upper(replace(?1,' ','')) ;";
200 static const char *sql_crashdump =
201 "select timestamp, title, entity, description, comment"
202 " from log order by timestamp desc limit ?1 ;";
204 static const char *sql_languagelist =
205 "select i18n_language.lang, name, phrase"
206 " from i18n_language join i18n_token using (lang) where i18n_token.id = 1000;" ;
208 static const char *sql_i18n_token =
209 "select phrase from i18n_token where lang = lower(?1) and id = ?2 ;";
212 static const char *sql_blacklist_add =
213 "insert or replace into blacklist_keys (fpr) values (upper(replace(?1,' ',''))) ;"
214 "delete from identity where main_key_id = upper(replace(?1,' ','')) ;"
215 "delete from pgp_keypair where fpr = upper(replace(?1,' ','')) ;";
217 static const char *sql_blacklist_delete =
218 "delete from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
220 static const char *sql_blacklist_is_listed =
221 "select count(*) from blacklist_keys where fpr = upper(replace(?1,' ','')) ;";
223 static const char *sql_blacklist_retrieve =
224 "select * from blacklist_keys ;";
228 // We only care if it's 0 or non-zero
229 static const char *sql_own_key_is_listed =
230 "select count(*) from ("
231 " select pgp_keypair_fpr from trust"
232 " join identity on trust.user_id = identity.user_id"
233 " where pgp_keypair_fpr = upper(replace(?1,' ',''))"
234 " and identity.is_own = 1"
237 static const char *sql_own_identities_retrieve =
238 "select address, fpr, username, identity.user_id, "
239 " lang, identity.flags | pgp_keypair.flags"
241 " join person on id = identity.user_id"
242 " join pgp_keypair on fpr = identity.main_key_id"
243 " join trust on id = trust.user_id"
244 " and pgp_keypair_fpr = identity.main_key_id"
245 " where identity.is_own = 1"
246 " and (identity.flags & ?1) = 0;";
248 static const char *sql_own_keys_retrieve =
249 "select pgp_keypair_fpr from trust"
250 " join identity on trust.user_id = identity.user_id"
251 " where identity.is_own = 1";
253 static const char* sql_get_user_default_key =
254 "select main_key_id from person"
257 static const char* sql_get_default_own_userid =
258 "select id from person"
259 " join identity on id = identity.user_id"
260 " where identity.is_own = 1";
263 static const char *sql_sequence_value1 =
264 "insert or replace into sequences (name, value, own) "
266 " (select coalesce((select value + 1 from sequences "
267 " where name = ?1), 1 )), "
268 " (select coalesce((select own or ?2 from sequences "
269 " where name = ?1), ?2))) ; ";
271 static const char *sql_sequence_value2 =
272 "select value, own from sequences where name = ?1 ;";
274 static const char *sql_sequence_value3 =
275 "insert or replace into sequences (name, value, own) "
278 " (select coalesce((select own or ?3 from sequences "
279 " where name = ?1), ?3))) ; ";
281 // Revocation tracking
282 static const char *sql_set_revoked =
283 "insert or replace into revoked_keys ("
284 " revoked_fpr, replacement_fpr, revocation_date) "
285 "values (upper(replace(?1,' ','')),"
286 " upper(replace(?2,' ','')),"
289 static const char *sql_get_revoked =
290 "select revoked_fpr, revocation_date from revoked_keys"
291 " where replacement_fpr = upper(replace(?1,' ','')) ;";
293 static const char *sql_get_userid_alias_default =
294 "select default_id from alternate_user_id "
295 " where alternate_id = ?1 ; ";
297 static const char *sql_add_userid_alias =
298 "insert or replace into alternate_user_id (default_id, alternate_id) "
301 static int user_version(void *_version, int count, char **text, char **name)
305 assert(text && text[0]);
306 if (!(_version && count == 1 && text && text[0]))
309 int *version = (int *) _version;
310 *version = atoi(text[0]);
314 static int table_contains_column(PEP_SESSION session, const char* table_name,
315 const char* col_name) {
318 if (!session || !table_name || !col_name)
321 // Table names can't be SQL parameters, so we do it this way.
323 // these two must be the same number.
325 const size_t max_q_len = 500;
327 size_t t_size, c_size, q_size;
329 const char* q1 = "SELECT "; // 7
330 const char* q2 = " from "; // 6
331 const char* q3 = ";"; // 1
334 t_size = strlen(table_name);
335 c_size = strlen(col_name);
337 size_t query_len = q_size + c_size + t_size + 1;
339 if (query_len > max_q_len)
342 strlcpy(sql_buf, q1, max_q_len);
343 strlcat(sql_buf, col_name, max_q_len);
344 strlcat(sql_buf, q2, max_q_len);
345 strlcat(sql_buf, table_name, max_q_len);
346 strlcat(sql_buf, q3, max_q_len);
350 sqlite3_prepare_v2(session->db, sql_buf, -1, &stmt, NULL);
354 int rc = sqlite3_step(stmt);
355 if (rc == SQLITE_DONE || rc == SQLITE_OK || rc == SQLITE_ROW) {
359 sqlite3_finalize(stmt);
364 DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
366 PEP_STATUS status = PEP_STATUS_OK;
369 bool in_first = false;
370 bool very_first = false;
372 assert(sqlite3_threadsafe());
373 if (!sqlite3_threadsafe())
374 return PEP_INIT_SQLITE3_WITHOUT_MUTEX;
376 // a little race condition - but still a race condition
377 // mitigated by calling caveat (see documentation)
379 // this increment is made atomic IN THE ADAPTERS by
380 // guarding the call to init with the appropriate mutex.
381 int _count = ++init_count;
385 // Race condition mitigated by calling caveat starts here :
386 // If another call to init() preempts right now, then preemptive call
387 // will have in_first false, will not create SQL tables, and following
388 // calls relying on those tables will fail.
390 // Therefore, as above, adapters MUST guard init() with a mutex.
392 // Therefore, first session
393 // is to be created and last session to be deleted alone, and not
394 // concurently to other sessions creation or deletion.
395 // We expect adapters to enforce this either by implicitely creating a
396 // client session, or by using synchronization primitive to protect
397 // creation/deletion of first/last session from the app.
401 return PEP_ILLEGAL_VALUE;
405 pEpSession *_session = calloc(1, sizeof(pEpSession));
407 if (_session == NULL)
410 _session->version = PEP_ENGINE_VERSION;
412 #ifdef DEBUG_ERRORSTACK
413 _session->errorstack = new_stringlist("init()");
417 if (LOCAL_DB == NULL) {
418 status = PEP_INIT_CANNOT_OPEN_DB;
422 int_result = sqlite3_open_v2(
425 SQLITE_OPEN_READWRITE
427 | SQLITE_OPEN_FULLMUTEX
428 | SQLITE_OPEN_PRIVATECACHE,
432 if (int_result != SQLITE_OK) {
433 status = PEP_INIT_CANNOT_OPEN_DB;
437 int_result = sqlite3_exec(
439 "PRAGMA locking_mode=NORMAL;\n"
440 "PRAGMA journal_mode=WAL;\n",
447 sqlite3_busy_timeout(_session->db, BUSY_WAIT_TIME);
450 if (SYSTEM_DB == NULL) {
451 status = PEP_INIT_CANNOT_OPEN_SYSTEM_DB;
455 int_result = sqlite3_open_v2(
456 SYSTEM_DB, &_session->system_db,
458 | SQLITE_OPEN_FULLMUTEX
459 | SQLITE_OPEN_SHAREDCACHE,
463 if (int_result != SQLITE_OK) {
464 status = PEP_INIT_CANNOT_OPEN_SYSTEM_DB;
468 sqlite3_busy_timeout(_session->system_db, 1000);
470 // increment this when patching DDL
471 #define _DDL_USER_VERSION "6"
475 int_result = sqlite3_exec(
477 "create table if not exists version_info (\n"
478 " id integer primary key,\n"
479 " timestamp integer default (datetime('now')),\n"
487 int_result = sqlite3_exec(
489 "PRAGMA application_id = 0x23423423;\n"
490 "create table if not exists log (\n"
491 " timestamp integer default (datetime('now')),\n"
492 " title text not null,\n"
493 " description text,\n"
494 " entity text not null,\n"
497 "create index if not exists log_timestamp on log (\n"
500 "create table if not exists pgp_keypair (\n"
501 " fpr text primary key,\n"
502 " created integer,\n"
503 " expires integer,\n"
505 " flags integer default 0\n"
507 "create index if not exists pgp_keypair_expires on pgp_keypair (\n"
510 "create table if not exists person (\n"
511 " id text primary key,\n"
512 " username text not null,\n"
513 " main_key_id text\n"
514 " references pgp_keypair (fpr)\n"
515 " on delete set null,\n"
518 " device_group text\n"
520 "create table if not exists identity (\n"
523 " references person (id)\n"
524 " on delete cascade on update cascade,\n"
525 " main_key_id text\n"
526 " references pgp_keypair (fpr)\n"
527 " on delete set null,\n"
529 " flags integer default 0,\n"
530 " is_own integer default 0,\n"
531 " primary key (address, user_id)\n"
533 "create table if not exists trust (\n"
534 " user_id text not null\n"
535 " references person (id)\n"
536 " on delete cascade on update cascade,\n"
537 " pgp_keypair_fpr text not null\n"
538 " references pgp_keypair (fpr)\n"
539 " on delete cascade,\n"
540 " comm_type integer not null,\n"
542 " primary key (user_id, pgp_keypair_fpr)\n"
545 "create table if not exists blacklist_keys (\n"
546 " fpr text primary key\n"
549 "create table if not exists sequences(\n"
550 " name text primary key,\n"
551 " value integer default 0,\n"
552 " own integer default 0\n"
554 "create table if not exists revoked_keys (\n"
555 " revoked_fpr text primary key,\n"
556 " replacement_fpr text not null\n"
557 " references pgp_keypair (fpr)\n"
558 " on delete cascade,\n"
559 " revocation_date integer\n"
562 "create table if not exists alternate_user_id (\n"
563 " default_id text references person (id)\n"
564 " on delete cascade on update cascade,\n"
565 " alternate_id text primary key\n"
572 assert(int_result == SQLITE_OK);
575 int_result = sqlite3_exec(
577 "pragma user_version;",
583 assert(int_result == SQLITE_OK);
585 void (*xFunc_lower)(sqlite3_context*,int,sqlite3_value**) = &_sql_lower;
587 int_result = sqlite3_create_function_v2(
591 SQLITE_UTF8 | SQLITE_DETERMINISTIC,
597 assert(int_result == SQLITE_OK);
599 // Sometimes the user_version wasn't set correctly. Check to see if this
600 // is really necessary...
602 bool version_changed = true;
604 if (table_contains_column(_session, "identity", "is_own") > 0) {
607 else if (table_contains_column(_session, "sequences", "own") > 0) {
610 else if (table_contains_column(_session, "pgp_keypair", "flags") > 0) {
614 version_changed = false;
617 if (version_changed) {
618 // set it in the DB, finally. Yeesh.
619 char verbuf[21]; // enough digits for a max-sized 64 bit int, cmon.
620 sprintf(verbuf,"%d",version);
622 size_t query_size = strlen(verbuf) + 25;
623 char* query = calloc(query_size, 1);
625 strlcpy(query, "pragma user_version = ", query_size);
626 strlcat(query, verbuf, query_size);
627 strlcat(query, ";", query_size);
629 int_result = sqlite3_exec(
642 // Version has been already set
644 // Early mistake : version 0 shouldn't have existed.
645 // Numbering should have started at 1 to detect newly created DB.
646 // Version 0 DBs are not anymore compatible.
648 // // Was version 0 compat code.
649 // if (version < 1) {
650 // int_result = sqlite3_exec(
652 // "alter table identity\n"
653 // " add column flags integer default 0;\n",
658 // assert(int_result == SQLITE_OK);
662 int_result = sqlite3_exec(
664 "alter table pgp_keypair\n"
665 " add column flags integer default 0;\n"
666 "alter table person\n"
667 " add column device_group text;\n",
672 assert(int_result == SQLITE_OK);
676 int_result = sqlite3_exec(
678 "alter table sequences\n"
679 " add column own integer default 0;\n",
684 assert(int_result == SQLITE_OK);
688 int_result = sqlite3_exec(
690 "delete from pgp_keypair where fpr = '';",
695 assert(int_result == SQLITE_OK);
696 int_result = sqlite3_exec(
698 "delete from trust where pgp_keypair_fpr = '';",
703 assert(int_result == SQLITE_OK);
707 int_result = sqlite3_exec(
709 "alter table identity\n"
710 " add column is_own integer default 0;\n",
715 assert(int_result == SQLITE_OK);
716 int_result = sqlite3_exec(
720 " where (user_id = '" PEP_OWN_USERID "');\n",
725 assert(int_result == SQLITE_OK);
727 // Turns out that just adding "on update cascade" in
728 // sqlite is a PITA. We need to be able to cascade
729 // person->id replacements (for temp ids like "TOFU_")
731 int_result = sqlite3_exec(
733 "PRAGMA foreign_keys=off;\n"
734 "BEGIN TRANSACTION;\n"
735 "ALTER TABLE identity RENAME TO _identity_old;\n"
736 "create table identity (\n"
739 " references person (id)\n"
740 " on delete cascade on update cascade,\n"
741 " main_key_id text\n"
742 " references pgp_keypair (fpr)\n"
743 " on delete set null,\n"
745 " flags integer default 0,\n"
746 " is_own integer default 0,\n"
747 " primary key (address, user_id)\n"
749 "INSERT INTO identity SELECT * FROM _identity_old;\n"
750 "DROP TABLE _identity_old;\n"
751 "ALTER TABLE trust RENAME TO _trust_old;\n"
752 "create table trust (\n"
753 " user_id text not null\n"
754 " references person (id)\n"
755 " on delete cascade on update cascade,\n"
756 " pgp_keypair_fpr text not null\n"
757 " references pgp_keypair (fpr)\n"
758 " on delete cascade,\n"
759 " comm_type integer not null,\n"
761 " primary key (user_id, pgp_keypair_fpr)\n"
763 "INSERT INTO trust SELECT * FROM _trust_old;\n"
764 "DROP TABLE _trust_old;\n"
767 "PRAGMA foreign_keys=on;\n"
768 "create table if not exists alternate_user_id (\n"
769 " default_id text references person (id)\n"
770 " on delete cascade on update cascade,\n"
771 " alternate_id text primary key\n"
778 assert(int_result == SQLITE_OK);
782 // Version from DB was 0, it means this is initial setup.
783 // DB has just been created, and all tables are empty.
787 if (version < atoi(_DDL_USER_VERSION)) {
788 int_result = sqlite3_exec(
790 "pragma user_version = "_DDL_USER_VERSION";\n"
791 "insert or replace into version_info (id, version)"
792 "values (1, '" PEP_ENGINE_VERSION "');",
797 assert(int_result == SQLITE_OK);
800 // We need to init a few globals for message id that we'd rather not
801 // calculate more than once.
805 int_result = sqlite3_prepare_v2(_session->db, sql_log,
806 (int)strlen(sql_log), &_session->log, NULL);
807 assert(int_result == SQLITE_OK);
809 int_result = sqlite3_prepare_v2(_session->system_db, sql_trustword,
810 (int)strlen(sql_trustword), &_session->trustword, NULL);
811 assert(int_result == SQLITE_OK);
813 int_result = sqlite3_prepare_v2(_session->db, sql_get_identity,
814 (int)strlen(sql_get_identity), &_session->get_identity, NULL);
815 assert(int_result == SQLITE_OK);
817 int_result = sqlite3_prepare_v2(_session->db, sql_get_identity_without_trust_check,
818 (int)strlen(sql_get_identity_without_trust_check),
819 &_session->get_identity_without_trust_check, NULL);
820 assert(int_result == SQLITE_OK);
822 int_result = sqlite3_prepare_v2(_session->db, sql_get_identities_by_address,
823 (int)strlen(sql_get_identities_by_address),
824 &_session->get_identities_by_address, NULL);
825 assert(int_result == SQLITE_OK);
827 int_result = sqlite3_prepare_v2(_session->db, sql_get_user_default_key,
828 (int)strlen(sql_get_user_default_key), &_session->get_user_default_key, NULL);
829 assert(int_result == SQLITE_OK);
831 int_result = sqlite3_prepare_v2(_session->db, sql_get_default_own_userid,
832 (int)strlen(sql_get_default_own_userid), &_session->get_default_own_userid, NULL);
833 assert(int_result == SQLITE_OK);
835 int_result = sqlite3_prepare_v2(_session->db, sql_get_userid_alias_default,
836 (int)strlen(sql_get_userid_alias_default), &_session->get_userid_alias_default, NULL);
837 assert(int_result == SQLITE_OK);
839 int_result = sqlite3_prepare_v2(_session->db, sql_add_userid_alias,
840 (int)strlen(sql_add_userid_alias), &_session->add_userid_alias, NULL);
841 assert(int_result == SQLITE_OK);
843 int_result = sqlite3_prepare_v2(_session->db, sql_replace_userid,
844 (int)strlen(sql_replace_userid), &_session->replace_userid, NULL);
845 assert(int_result == SQLITE_OK);
847 int_result = sqlite3_prepare_v2(_session->db, sql_replace_main_user_fpr,
848 (int)strlen(sql_replace_main_user_fpr), &_session->replace_main_user_fpr, NULL);
849 assert(int_result == SQLITE_OK);
851 int_result = sqlite3_prepare_v2(_session->db, sql_get_main_user_fpr,
852 (int)strlen(sql_get_main_user_fpr), &_session->get_main_user_fpr, NULL);
853 assert(int_result == SQLITE_OK);
855 int_result = sqlite3_prepare_v2(_session->db, sql_refresh_userid_default_key,
856 (int)strlen(sql_refresh_userid_default_key), &_session->refresh_userid_default_key, NULL);
857 assert(int_result == SQLITE_OK);
859 int_result = sqlite3_prepare_v2(_session->db, sql_replace_identities_fpr,
860 (int)strlen(sql_replace_identities_fpr),
861 &_session->replace_identities_fpr, NULL);
862 assert(int_result == SQLITE_OK);
864 int_result = sqlite3_prepare_v2(_session->db, sql_remove_fpr_as_default,
865 (int)strlen(sql_remove_fpr_as_default),
866 &_session->remove_fpr_as_default, NULL);
867 assert(int_result == SQLITE_OK);
869 int_result = sqlite3_prepare_v2(_session->db, sql_set_person,
870 (int)strlen(sql_set_person), &_session->set_person, NULL);
871 assert(int_result == SQLITE_OK);
873 int_result = sqlite3_prepare_v2(_session->db, sql_set_device_group,
874 (int)strlen(sql_set_device_group), &_session->set_device_group, NULL);
875 assert(int_result == SQLITE_OK);
877 int_result = sqlite3_prepare_v2(_session->db, sql_get_device_group,
878 (int)strlen(sql_get_device_group), &_session->get_device_group, NULL);
879 assert(int_result == SQLITE_OK);
881 int_result = sqlite3_prepare_v2(_session->db, sql_set_pgp_keypair,
882 (int)strlen(sql_set_pgp_keypair), &_session->set_pgp_keypair,
884 assert(int_result == SQLITE_OK);
886 int_result = sqlite3_prepare_v2(_session->db, sql_set_identity,
887 (int)strlen(sql_set_identity), &_session->set_identity, NULL);
888 assert(int_result == SQLITE_OK);
890 int_result = sqlite3_prepare_v2(_session->db, sql_set_identity_flags,
891 (int)strlen(sql_set_identity_flags), &_session->set_identity_flags,
893 assert(int_result == SQLITE_OK);
895 int_result = sqlite3_prepare_v2(_session->db, sql_unset_identity_flags,
896 (int)strlen(sql_unset_identity_flags), &_session->unset_identity_flags,
898 assert(int_result == SQLITE_OK);
900 int_result = sqlite3_prepare_v2(_session->db, sql_set_trust,
901 (int)strlen(sql_set_trust), &_session->set_trust, NULL);
902 assert(int_result == SQLITE_OK);
904 int_result = sqlite3_prepare_v2(_session->db, sql_update_trust_for_fpr,
905 (int)strlen(sql_update_trust_for_fpr), &_session->update_trust_for_fpr, NULL);
906 assert(int_result == SQLITE_OK);
908 int_result = sqlite3_prepare_v2(_session->db, sql_get_trust,
909 (int)strlen(sql_get_trust), &_session->get_trust, NULL);
910 assert(int_result == SQLITE_OK);
912 int_result = sqlite3_prepare_v2(_session->db, sql_least_trust,
913 (int)strlen(sql_least_trust), &_session->least_trust, NULL);
914 assert(int_result == SQLITE_OK);
916 int_result = sqlite3_prepare_v2(_session->db, sql_mark_as_compromized,
917 (int)strlen(sql_mark_as_compromized), &_session->mark_compromized,
919 assert(int_result == SQLITE_OK);
921 int_result = sqlite3_prepare_v2(_session->db, sql_crashdump,
922 (int)strlen(sql_crashdump), &_session->crashdump, NULL);
923 assert(int_result == SQLITE_OK);
925 int_result = sqlite3_prepare_v2(_session->system_db, sql_languagelist,
926 (int)strlen(sql_languagelist), &_session->languagelist, NULL);
927 assert(int_result == SQLITE_OK);
929 int_result = sqlite3_prepare_v2(_session->system_db, sql_i18n_token,
930 (int)strlen(sql_i18n_token), &_session->i18n_token, NULL);
931 assert(int_result == SQLITE_OK);
935 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_add,
936 (int)strlen(sql_blacklist_add), &_session->blacklist_add, NULL);
937 assert(int_result == SQLITE_OK);
939 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_delete,
940 (int)strlen(sql_blacklist_delete), &_session->blacklist_delete,
942 assert(int_result == SQLITE_OK);
944 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_is_listed,
945 (int)strlen(sql_blacklist_is_listed),
946 &_session->blacklist_is_listed, NULL);
947 assert(int_result == SQLITE_OK);
949 int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_retrieve,
950 (int)strlen(sql_blacklist_retrieve), &_session->blacklist_retrieve,
952 assert(int_result == SQLITE_OK);
956 int_result = sqlite3_prepare_v2(_session->db, sql_own_key_is_listed,
957 (int)strlen(sql_own_key_is_listed), &_session->own_key_is_listed,
959 assert(int_result == SQLITE_OK);
961 int_result = sqlite3_prepare_v2(_session->db, sql_own_identities_retrieve,
962 (int)strlen(sql_own_identities_retrieve),
963 &_session->own_identities_retrieve, NULL);
964 assert(int_result == SQLITE_OK);
966 int_result = sqlite3_prepare_v2(_session->db, sql_own_keys_retrieve,
967 (int)strlen(sql_own_keys_retrieve),
968 &_session->own_keys_retrieve, NULL);
969 assert(int_result == SQLITE_OK);
971 // int_result = sqlite3_prepare_v2(_session->db, sql_set_own_key,
972 // (int)strlen(sql_set_own_key),
973 // &_session->set_own_key, NULL);
974 // assert(int_result == SQLITE_OK);
978 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value1,
979 (int)strlen(sql_sequence_value1), &_session->sequence_value1,
981 assert(int_result == SQLITE_OK);
983 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value2,
984 (int)strlen(sql_sequence_value2), &_session->sequence_value2,
986 assert(int_result == SQLITE_OK);
988 int_result = sqlite3_prepare_v2(_session->db, sql_sequence_value3,
989 (int)strlen(sql_sequence_value3), &_session->sequence_value3,
991 assert(int_result == SQLITE_OK);
993 // Revocation tracking
995 int_result = sqlite3_prepare_v2(_session->db, sql_set_revoked,
996 (int)strlen(sql_set_revoked), &_session->set_revoked, NULL);
997 assert(int_result == SQLITE_OK);
999 int_result = sqlite3_prepare_v2(_session->db, sql_get_revoked,
1000 (int)strlen(sql_get_revoked), &_session->get_revoked, NULL);
1001 assert(int_result == SQLITE_OK);
1003 status = init_cryptotech(_session, in_first);
1004 if (status != PEP_STATUS_OK)
1007 status = init_transport_system(_session, in_first);
1008 if (status != PEP_STATUS_OK)
1011 status = log_event(_session, "init", "pEp " PEP_ENGINE_VERSION, NULL, NULL);
1012 if (status != PEP_STATUS_OK)
1019 // On first run, all private keys already present in PGP keyring
1020 // are taken as own in order to seamlessly integrate with
1021 // pre-existing GPG setup.
1023 // Note: earlier fears about danger because of DB reinitialisation should
1024 // be a non-issue here, as we ONLY take the ultimately trusted keys now.
1025 // Thus, unless the user has assigned ultimate trust through PGP, there is
1026 // no chance of automatically imported pEp keys from a previous run making
1027 // their way into PEP trusted status without explicit action (Bare imported
1028 // private keys have an 'unknown' trust designation in PGP).
1030 // We don't really worry about the status here.
1031 status = import_trusted_own_keys(_session);
1034 // sync_session set to own session by default
1035 // sync_session is then never null on a valid session
1036 _session->sync_session = _session;
1038 *session = _session;
1040 // Note: Following statement is NOT for any cryptographic/secure functionality; it is
1041 // ONLY used for some randomness in generated outer message ID, which are
1042 // required by the RFC to be globally unique!
1045 return PEP_STATUS_OK;
1048 status = PEP_OUT_OF_MEMORY;
1055 DYNAMIC_API void release(PEP_SESSION session)
1057 bool out_last = false;
1058 int _count = --init_count;
1060 assert(_count >= -1);
1063 if (!((_count >= -1) && session))
1066 // a small race condition but still a race condition
1067 // mitigated by calling caveat (see documentation)
1068 // (release() is to be guarded by a mutex by the caller)
1076 sqlite3_finalize(session->log);
1077 if (session->trustword)
1078 sqlite3_finalize(session->trustword);
1079 if (session->get_identity)
1080 sqlite3_finalize(session->get_identity);
1081 if (session->get_identity_without_trust_check)
1082 sqlite3_finalize(session->get_identity_without_trust_check);
1083 if (session->get_identities_by_address)
1084 sqlite3_finalize(session->get_identities_by_address);
1085 if (session->get_user_default_key)
1086 sqlite3_finalize(session->get_user_default_key);
1087 if (session->get_default_own_userid)
1088 sqlite3_finalize(session->get_default_own_userid);
1089 if (session->get_userid_alias_default)
1090 sqlite3_finalize(session->get_userid_alias_default);
1091 if (session->add_userid_alias)
1092 sqlite3_finalize(session->add_userid_alias);
1093 if (session->replace_identities_fpr)
1094 sqlite3_finalize(session->replace_identities_fpr);
1095 if (session->remove_fpr_as_default)
1096 sqlite3_finalize(session->remove_fpr_as_default);
1097 if (session->set_person)
1098 sqlite3_finalize(session->set_person);
1099 if (session->set_device_group)
1100 sqlite3_finalize(session->set_device_group);
1101 if (session->get_device_group)
1102 sqlite3_finalize(session->get_device_group);
1103 if (session->set_pgp_keypair)
1104 sqlite3_finalize(session->set_pgp_keypair);
1105 if (session->set_identity)
1106 sqlite3_finalize(session->set_identity);
1107 if (session->set_identity_flags)
1108 sqlite3_finalize(session->set_identity_flags);
1109 if (session->unset_identity_flags)
1110 sqlite3_finalize(session->unset_identity_flags);
1111 if (session->set_trust)
1112 sqlite3_finalize(session->set_trust);
1113 if (session->update_trust_for_fpr)
1114 sqlite3_finalize(session->update_trust_for_fpr);
1115 if (session->get_trust)
1116 sqlite3_finalize(session->get_trust);
1117 if (session->least_trust)
1118 sqlite3_finalize(session->least_trust);
1119 if (session->mark_compromized)
1120 sqlite3_finalize(session->mark_compromized);
1121 if (session->crashdump)
1122 sqlite3_finalize(session->crashdump);
1123 if (session->languagelist)
1124 sqlite3_finalize(session->languagelist);
1125 if (session->i18n_token)
1126 sqlite3_finalize(session->i18n_token);
1127 if (session->replace_userid)
1128 sqlite3_finalize(session->replace_userid);
1129 if (session->replace_main_user_fpr)
1130 sqlite3_finalize(session->replace_main_user_fpr);
1131 if (session->get_main_user_fpr)
1132 sqlite3_finalize(session->get_main_user_fpr);
1133 if (session->refresh_userid_default_key)
1134 sqlite3_finalize(session->refresh_userid_default_key);
1135 if (session->blacklist_add)
1136 sqlite3_finalize(session->blacklist_add);
1137 if (session->blacklist_delete)
1138 sqlite3_finalize(session->blacklist_delete);
1139 if (session->blacklist_is_listed)
1140 sqlite3_finalize(session->blacklist_is_listed);
1141 if (session->blacklist_retrieve)
1142 sqlite3_finalize(session->blacklist_retrieve);
1143 if (session->own_key_is_listed)
1144 sqlite3_finalize(session->own_key_is_listed);
1145 if (session->own_identities_retrieve)
1146 sqlite3_finalize(session->own_identities_retrieve);
1147 if (session->own_keys_retrieve)
1148 sqlite3_finalize(session->own_keys_retrieve);
1149 // if (session->set_own_key)
1150 // sqlite3_finalize(session->set_own_key);
1151 if (session->sequence_value1)
1152 sqlite3_finalize(session->sequence_value1);
1153 if (session->sequence_value2)
1154 sqlite3_finalize(session->sequence_value2);
1155 if (session->sequence_value3)
1156 sqlite3_finalize(session->sequence_value3);
1157 if (session->set_revoked)
1158 sqlite3_finalize(session->set_revoked);
1159 if (session->get_revoked)
1160 sqlite3_finalize(session->get_revoked);
1163 sqlite3_close_v2(session->db);
1164 if (session->system_db)
1165 sqlite3_close_v2(session->system_db);
1168 release_transport_system(session, out_last);
1169 release_cryptotech(session, out_last);
1171 #ifdef DEBUG_ERRORSTACK
1172 free_stringlist(session->errorstack);
1178 DYNAMIC_API void config_passive_mode(PEP_SESSION session, bool enable)
1181 session->passive_mode = enable;
1184 DYNAMIC_API void config_unencrypted_subject(PEP_SESSION session, bool enable)
1187 session->unencrypted_subject = enable;
1190 DYNAMIC_API void config_keep_sync_msg(PEP_SESSION session, bool enable)
1193 session->keep_sync_msg = enable;
1196 DYNAMIC_API void config_service_log(PEP_SESSION session, bool enable)
1199 session->service_log = enable;
1202 DYNAMIC_API PEP_STATUS log_event(
1203 PEP_SESSION session,
1206 const char *description,
1210 PEP_STATUS status = PEP_STATUS_OK;
1217 if (!(session && title && entity))
1218 return PEP_ILLEGAL_VALUE;
1220 sqlite3_reset(session->log);
1221 sqlite3_bind_text(session->log, 1, title, -1, SQLITE_STATIC);
1222 sqlite3_bind_text(session->log, 2, entity, -1, SQLITE_STATIC);
1224 sqlite3_bind_text(session->log, 3, description, -1, SQLITE_STATIC);
1226 sqlite3_bind_null(session->log, 3);
1228 sqlite3_bind_text(session->log, 4, comment, -1, SQLITE_STATIC);
1230 sqlite3_bind_null(session->log, 4);
1232 result = sqlite3_step(session->log);
1233 assert(result == SQLITE_DONE || result == SQLITE_BUSY);
1234 if (result != SQLITE_DONE && result != SQLITE_BUSY)
1235 status = PEP_UNKNOWN_ERROR;
1236 } while (result == SQLITE_BUSY);
1237 sqlite3_reset(session->log);
1239 return ADD_TO_LOG(status);
1242 DYNAMIC_API PEP_STATUS log_service(
1243 PEP_SESSION session,
1246 const char *description,
1252 return PEP_ILLEGAL_VALUE;
1254 if (session->service_log)
1255 return log_event(session, title, entity, description, comment);
1257 return PEP_STATUS_OK;
1260 DYNAMIC_API PEP_STATUS trustword(
1261 PEP_SESSION session, uint16_t value, const char *lang,
1262 char **word, size_t *wsize
1265 PEP_STATUS status = PEP_STATUS_OK;
1271 if (!(session && word && wsize))
1272 return PEP_ILLEGAL_VALUE;
1280 assert((lang[0] >= 'A' && lang[0] <= 'Z')
1281 || (lang[0] >= 'a' && lang[0] <= 'z'));
1282 assert((lang[1] >= 'A' && lang[1] <= 'Z')
1283 || (lang[1] >= 'a' && lang[1] <= 'z'));
1284 assert(lang[2] == 0);
1286 sqlite3_reset(session->trustword);
1287 sqlite3_bind_text(session->trustword, 1, lang, -1, SQLITE_STATIC);
1288 sqlite3_bind_int(session->trustword, 2, value);
1290 const int result = sqlite3_step(session->trustword);
1291 if (result == SQLITE_ROW) {
1292 *word = strdup((const char *) sqlite3_column_text(session->trustword,
1295 *wsize = sqlite3_column_bytes(session->trustword, 1);
1297 status = PEP_OUT_OF_MEMORY;
1299 status = PEP_TRUSTWORD_NOT_FOUND;
1301 sqlite3_reset(session->trustword);
1305 DYNAMIC_API PEP_STATUS trustwords(
1306 PEP_SESSION session, const char *fingerprint, const char *lang,
1307 char **words, size_t *wsize, int max_words
1310 const char *source = fingerprint;
1313 assert(fingerprint);
1316 assert(max_words >= 0);
1318 if (!(session && fingerprint && words && wsize && max_words >= 0))
1319 return PEP_ILLEGAL_VALUE;
1324 char *buffer = calloc(1, MAX_TRUSTWORDS_SPACE);
1327 return PEP_OUT_OF_MEMORY;
1328 char *dest = buffer;
1330 const size_t fsize = strlen(fingerprint);
1332 if (!lang || !lang[0])
1335 assert((lang[0] >= 'A' && lang[0] <= 'Z')
1336 || (lang[0] >= 'a' && lang[0] <= 'z'));
1337 assert((lang[1] >= 'A' && lang[1] <= 'Z')
1338 || (lang[1] >= 'a' && lang[1] <= 'z'));
1339 assert(lang[2] == 0);
1342 while (source < fingerprint + fsize) {
1349 for (value=0, j=0; j < 4 && source < fingerprint + fsize; ) {
1350 if (*source >= 'a' && *source <= 'f')
1351 value += (*source - 'a' + 10) << (3 - j++) * 4;
1352 else if (*source >= 'A' && *source <= 'F')
1353 value += (*source - 'A' + 10) << (3 - j++) * 4;
1354 else if (*source >= '0' && *source <= '9')
1355 value += (*source - '0') << (3 - j++) * 4;
1360 _status = trustword(session, value, lang, &word, &_wsize);
1361 if (_status == PEP_OUT_OF_MEMORY) {
1363 return PEP_OUT_OF_MEMORY;
1367 return PEP_TRUSTWORD_NOT_FOUND;
1370 if (dest + _wsize < buffer + MAX_TRUSTWORDS_SPACE - 1) {
1371 strncpy(dest, word, _wsize);
1377 break; // buffer full
1380 if (source < fingerprint + fsize
1381 && dest + _wsize < buffer + MAX_TRUSTWORDS_SPACE - 1)
1385 if (max_words && n_words >= max_words)
1390 *wsize = dest - buffer;
1391 return PEP_STATUS_OK;
1394 pEp_identity *new_identity(
1395 const char *address, const char *fpr, const char *user_id,
1396 const char *username
1399 pEp_identity *result = calloc(1, sizeof(pEp_identity));
1403 result->address = strdup(address);
1404 assert(result->address);
1405 if (result->address == NULL) {
1411 result->fpr = strdup(fpr);
1412 assert(result->fpr);
1413 if (result->fpr == NULL) {
1414 free_identity(result);
1419 result->user_id = strdup(user_id);
1420 assert(result->user_id);
1421 if (result->user_id == NULL) {
1422 free_identity(result);
1427 result->username = strdup(username);
1428 assert(result->username);
1429 if (result->username == NULL) {
1430 free_identity(result);
1438 pEp_identity *identity_dup(const pEp_identity *src)
1442 pEp_identity *dup = new_identity(src->address, src->fpr, src->user_id,
1448 dup->comm_type = src->comm_type;
1449 dup->lang[0] = src->lang[0];
1450 dup->lang[1] = src->lang[1];
1452 dup->flags = src->flags;
1458 void free_identity(pEp_identity *identity)
1461 free(identity->address);
1462 free(identity->fpr);
1463 free(identity->user_id);
1464 free(identity->username);
1469 DYNAMIC_API PEP_STATUS get_default_own_userid(
1470 PEP_SESSION session,
1477 if (!session || !userid)
1478 return PEP_ILLEGAL_VALUE;
1480 PEP_STATUS status = PEP_STATUS_OK;
1481 char* retval = NULL;
1483 sqlite3_reset(session->get_default_own_userid);
1485 const int result = sqlite3_step(session->get_default_own_userid);
1490 id = (const char *) sqlite3_column_text(session->get_default_own_userid, 0);
1492 // Shouldn't happen.
1493 status = PEP_UNKNOWN_ERROR;
1496 retval = strdup(id);
1498 status = PEP_OUT_OF_MEMORY;
1502 // Technically true, given how we find it, but FIXME we need a more descriptive error
1503 status = PEP_CANNOT_FIND_IDENTITY;
1509 sqlite3_reset(session->get_default_own_userid);
1514 DYNAMIC_API PEP_STATUS get_userid_alias_default(
1515 PEP_SESSION session,
1516 const char* alias_id,
1517 char** default_id) {
1521 assert(alias_id[0]);
1524 if (!(session && alias_id && alias_id[0] && default_id))
1525 return PEP_ILLEGAL_VALUE;
1527 PEP_STATUS status = PEP_STATUS_OK;
1528 char* retval = NULL;
1530 sqlite3_reset(session->get_userid_alias_default);
1531 sqlite3_bind_text(session->get_userid_alias_default, 1, alias_id, -1, SQLITE_STATIC);
1535 const int result = sqlite3_step(session->get_userid_alias_default);
1538 tempid = (const char *) sqlite3_column_text(session->get_userid_alias_default, 0);
1540 retval = strdup(tempid);
1543 return PEP_OUT_OF_MEMORY;
1546 *default_id = retval;
1549 status = PEP_CANNOT_FIND_ALIAS;
1553 sqlite3_reset(session->get_userid_alias_default);
1557 DYNAMIC_API PEP_STATUS set_userid_alias (
1558 PEP_SESSION session,
1559 const char* default_id,
1560 const char* alias_id) {
1568 if (!(session && default_id && alias_id &&
1569 default_id[0] != '\0' && alias_id[0] != '\0'))
1570 return PEP_ILLEGAL_VALUE;
1572 sqlite3_reset(session->add_userid_alias);
1573 sqlite3_bind_text(session->add_userid_alias, 1, default_id, -1,
1575 sqlite3_bind_text(session->add_userid_alias, 2, alias_id, -1,
1578 result = sqlite3_step(session->add_userid_alias);
1580 sqlite3_reset(session->add_userid_alias);
1581 if (result != SQLITE_DONE)
1582 return PEP_CANNOT_SET_ALIAS;
1584 return PEP_STATUS_OK;
1587 DYNAMIC_API PEP_STATUS get_identity(
1588 PEP_SESSION session,
1589 const char *address,
1590 const char *user_id,
1591 pEp_identity **identity
1594 PEP_STATUS status = PEP_STATUS_OK;
1595 static pEp_identity *_identity;
1602 if (!(session && address && address[0] && identity))
1603 return PEP_ILLEGAL_VALUE;
1607 sqlite3_reset(session->get_identity);
1608 sqlite3_bind_text(session->get_identity, 1, address, -1, SQLITE_STATIC);
1609 sqlite3_bind_text(session->get_identity, 2, user_id, -1, SQLITE_STATIC);
1611 const int result = sqlite3_step(session->get_identity);
1614 _identity = new_identity(
1616 (const char *) sqlite3_column_text(session->get_identity, 0),
1618 (const char *) sqlite3_column_text(session->get_identity, 1)
1621 if (_identity == NULL)
1622 return PEP_OUT_OF_MEMORY;
1624 _identity->comm_type = (PEP_comm_type)
1625 sqlite3_column_int(session->get_identity, 2);
1626 const char* const _lang = (const char *)
1627 sqlite3_column_text(session->get_identity, 3);
1628 if (_lang && _lang[0]) {
1629 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1630 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1631 assert(_lang[2] == 0);
1632 _identity->lang[0] = _lang[0];
1633 _identity->lang[1] = _lang[1];
1634 _identity->lang[2] = 0;
1636 _identity->flags = (unsigned int)
1637 sqlite3_column_int(session->get_identity, 4);
1638 _identity->me = (unsigned int)
1639 sqlite3_column_int(session->get_identity, 5);
1641 *identity = _identity;
1644 status = PEP_CANNOT_FIND_IDENTITY;
1648 sqlite3_reset(session->get_identity);
1652 PEP_STATUS get_identity_without_trust_check(
1653 PEP_SESSION session,
1654 const char *address,
1655 const char *user_id,
1656 pEp_identity **identity
1659 PEP_STATUS status = PEP_STATUS_OK;
1660 static pEp_identity *_identity;
1667 if (!(session && address && address[0] && identity))
1668 return PEP_ILLEGAL_VALUE;
1672 sqlite3_reset(session->get_identity_without_trust_check);
1673 sqlite3_bind_text(session->get_identity_without_trust_check, 1, address, -1, SQLITE_STATIC);
1674 sqlite3_bind_text(session->get_identity_without_trust_check, 2, user_id, -1, SQLITE_STATIC);
1676 const int result = sqlite3_step(session->get_identity_without_trust_check);
1679 _identity = new_identity(
1681 (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 0),
1683 (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 1)
1686 if (_identity == NULL)
1687 return PEP_OUT_OF_MEMORY;
1689 _identity->comm_type = PEP_ct_unknown;
1690 const char* const _lang = (const char *)
1691 sqlite3_column_text(session->get_identity_without_trust_check, 2);
1692 if (_lang && _lang[0]) {
1693 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1694 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1695 assert(_lang[2] == 0);
1696 _identity->lang[0] = _lang[0];
1697 _identity->lang[1] = _lang[1];
1698 _identity->lang[2] = 0;
1700 _identity->flags = (unsigned int)
1701 sqlite3_column_int(session->get_identity_without_trust_check, 3);
1702 _identity->me = (unsigned int)
1703 sqlite3_column_int(session->get_identity_without_trust_check, 4);
1705 *identity = _identity;
1708 status = PEP_CANNOT_FIND_IDENTITY;
1712 sqlite3_reset(session->get_identity_without_trust_check);
1716 PEP_STATUS get_identities_by_address(
1717 PEP_SESSION session,
1718 const char *address,
1719 identity_list** id_list
1722 pEp_identity* ident;
1729 if (!(session && address && address[0] && id_list))
1730 return PEP_ILLEGAL_VALUE;
1733 identity_list* ident_list = NULL;
1735 sqlite3_reset(session->get_identities_by_address);
1736 sqlite3_bind_text(session->get_identities_by_address, 1, address, -1, SQLITE_STATIC);
1739 while ((result = sqlite3_step(session->get_identities_by_address)) == SQLITE_ROW) {
1740 //"select user_id, main_key_id, username, comm_type, lang,"
1741 //" identity.flags, is_own"
1742 ident = new_identity(
1744 (const char *) sqlite3_column_text(session->get_identities_by_address, 1),
1745 (const char *) sqlite3_column_text(session->get_identities_by_address, 0),
1746 (const char *) sqlite3_column_text(session->get_identities_by_address, 2)
1750 return PEP_OUT_OF_MEMORY;
1752 ident->comm_type = PEP_ct_unknown;
1754 const char* const _lang = (const char *)
1755 sqlite3_column_text(session->get_identities_by_address, 3);
1756 if (_lang && _lang[0]) {
1757 assert(_lang[0] >= 'a' && _lang[0] <= 'z');
1758 assert(_lang[1] >= 'a' && _lang[1] <= 'z');
1759 assert(_lang[2] == 0);
1760 ident->lang[0] = _lang[0];
1761 ident->lang[1] = _lang[1];
1764 ident->flags = (unsigned int)
1765 sqlite3_column_int(session->get_identities_by_address, 4);
1766 ident->me = (unsigned int)
1767 sqlite3_column_int(session->get_identities_by_address, 5);
1770 identity_list_add(ident_list, ident);
1772 ident_list = new_identity_list(ident);
1775 sqlite3_reset(session->get_identities_by_address);
1777 *id_list = ident_list;
1780 return PEP_CANNOT_FIND_IDENTITY;
1782 return PEP_STATUS_OK;
1786 DYNAMIC_API PEP_STATUS set_identity(
1787 PEP_SESSION session, const pEp_identity *identity
1794 assert(identity->address);
1795 assert(identity->user_id);
1796 assert(identity->username);
1798 if (!(session && identity && identity->address &&
1799 identity->user_id && identity->username))
1800 return PEP_ILLEGAL_VALUE;
1802 PEP_STATUS status = PEP_STATUS_OK;
1806 bool has_fpr = (identity->fpr && identity->fpr[0] != '\0');
1809 // blacklist check - FIXME: ENGINE-294 will remove
1810 status = blacklist_is_listed(session, identity->fpr, &listed);
1811 assert(status == PEP_STATUS_OK);
1812 if (status != PEP_STATUS_OK)
1816 return PEP_KEY_BLACKLISTED;
1819 sqlite3_exec(session->db, "BEGIN ;", NULL, NULL, NULL);
1821 if (identity->lang[0]) {
1822 assert(identity->lang[0] >= 'a' && identity->lang[0] <= 'z');
1823 assert(identity->lang[1] >= 'a' && identity->lang[1] <= 'z');
1824 assert(identity->lang[2] == 0);
1827 sqlite3_reset(session->set_person);
1828 sqlite3_bind_text(session->set_person, 1, identity->user_id, -1,
1830 sqlite3_bind_text(session->set_person, 2, identity->username, -1,
1832 if (identity->lang[0])
1833 sqlite3_bind_text(session->set_person, 3, identity->lang, 2,
1836 sqlite3_bind_null(session->set_person, 3);
1837 sqlite3_bind_text(session->set_person, 4, identity->fpr, -1,
1839 result = sqlite3_step(session->set_person);
1840 sqlite3_reset(session->set_person);
1841 if (result != SQLITE_DONE) {
1842 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
1843 return PEP_CANNOT_SET_PERSON;
1847 sqlite3_reset(session->set_pgp_keypair);
1848 sqlite3_bind_text(session->set_pgp_keypair, 1, identity->fpr, -1,
1850 result = sqlite3_step(session->set_pgp_keypair);
1851 sqlite3_reset(session->set_pgp_keypair);
1852 if (result != SQLITE_DONE) {
1853 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
1854 return PEP_CANNOT_SET_PGP_KEYPAIR;
1858 sqlite3_reset(session->set_identity);
1859 sqlite3_bind_text(session->set_identity, 1, identity->address, -1,
1861 sqlite3_bind_text(session->set_identity, 2, identity->fpr, -1,
1863 sqlite3_bind_text(session->set_identity, 3, identity->user_id, -1,
1865 sqlite3_bind_int(session->set_identity, 4, identity->flags);
1866 sqlite3_bind_int(session->set_identity, 5, identity->me);
1867 result = sqlite3_step(session->set_identity);
1868 sqlite3_reset(session->set_identity);
1869 if (result != SQLITE_DONE) {
1870 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
1871 return PEP_CANNOT_SET_IDENTITY;
1875 sqlite3_reset(session->set_trust);
1876 sqlite3_bind_text(session->set_trust, 1, identity->user_id, -1,
1878 sqlite3_bind_text(session->set_trust, 2, identity->fpr, -1,
1880 sqlite3_bind_int(session->set_trust, 3, identity->comm_type);
1881 result = sqlite3_step(session->set_trust);
1882 sqlite3_reset(session->set_trust);
1883 if (result != SQLITE_DONE) {
1884 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
1885 return PEP_CANNOT_SET_TRUST;
1889 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
1890 if (result == SQLITE_OK)
1891 return PEP_STATUS_OK;
1893 return PEP_COMMIT_FAILED;
1896 PEP_STATUS remove_fpr_as_default(PEP_SESSION session,
1901 if (!session || !fpr)
1902 return PEP_ILLEGAL_VALUE;
1904 sqlite3_reset(session->remove_fpr_as_default);
1905 sqlite3_bind_text(session->remove_fpr_as_default, 1, fpr, -1,
1908 int result = sqlite3_step(session->remove_fpr_as_default);
1909 sqlite3_reset(session->remove_fpr_as_default);
1911 if (result != SQLITE_DONE)
1912 return PEP_CANNOT_SET_IDENTITY; // misleading - could also be person
1914 return PEP_STATUS_OK;
1918 PEP_STATUS replace_identities_fpr(PEP_SESSION session,
1919 const char* old_fpr,
1920 const char* new_fpr)
1925 if (!old_fpr || !new_fpr)
1926 return PEP_ILLEGAL_VALUE;
1928 sqlite3_reset(session->replace_identities_fpr);
1929 sqlite3_bind_text(session->replace_identities_fpr, 1, new_fpr, -1,
1931 sqlite3_bind_text(session->replace_identities_fpr, 2, old_fpr, -1,
1934 int result = sqlite3_step(session->replace_identities_fpr);
1935 sqlite3_reset(session->replace_identities_fpr);
1937 if (result != SQLITE_DONE)
1938 return PEP_CANNOT_SET_IDENTITY;
1940 return PEP_STATUS_OK;
1943 PEP_STATUS update_trust_for_fpr(PEP_SESSION session,
1945 PEP_comm_type comm_type)
1948 return PEP_ILLEGAL_VALUE;
1950 sqlite3_reset(session->update_trust_for_fpr);
1951 sqlite3_bind_int(session->update_trust_for_fpr, 1, comm_type);
1952 sqlite3_bind_text(session->update_trust_for_fpr, 2, fpr, -1,
1954 int result = sqlite3_step(session->update_trust_for_fpr);
1955 sqlite3_reset(session->update_trust_for_fpr);
1956 if (result != SQLITE_DONE) {
1957 return PEP_CANNOT_SET_TRUST;
1960 return PEP_STATUS_OK;
1963 DYNAMIC_API PEP_STATUS set_device_group(
1964 PEP_SESSION session,
1965 const char *group_name
1972 if (!(session && group_name))
1973 return PEP_ILLEGAL_VALUE;
1975 // 1. Get own user_id
1976 char* user_id = NULL;
1977 PEP_STATUS status = get_default_own_userid(session, &user_id);
1979 // No user_id is returned in this case, no need to free;
1980 if (status != PEP_STATUS_OK)
1983 // 2. Set device group
1984 sqlite3_reset(session->set_device_group);
1986 sqlite3_bind_text(session->set_device_group, 1, group_name, -1,
1989 sqlite3_bind_null(session->set_device_group, 1);
1992 sqlite3_bind_text(session->set_device_group, 2, user_id, -1,
1995 result = sqlite3_step(session->set_device_group);
1996 sqlite3_reset(session->set_device_group);
2000 if (result != SQLITE_DONE)
2001 return PEP_CANNOT_SET_PERSON;
2003 return PEP_STATUS_OK;
2006 DYNAMIC_API PEP_STATUS get_device_group(PEP_SESSION session, char **group_name)
2008 PEP_STATUS status = PEP_STATUS_OK;
2014 if (!(session && group_name))
2015 return PEP_ILLEGAL_VALUE;
2017 // 1. Get own user_id
2018 char* user_id = NULL;
2019 status = get_default_own_userid(session, &user_id);
2021 // No user_id is returned in this case, no need to free;
2022 if (status != PEP_STATUS_OK)
2025 // 2. get device group
2026 sqlite3_reset(session->get_device_group);
2027 sqlite3_bind_text(session->get_device_group, 1, user_id, -1,
2030 result = sqlite3_step(session->get_device_group);
2033 const char *_group_name = (const char *)sqlite3_column_text(session->get_device_group, 0);
2035 *group_name = strdup(_group_name);
2036 if(*group_name == NULL)
2037 status = PEP_OUT_OF_MEMORY;
2043 status = PEP_RECORD_NOT_FOUND;
2047 sqlite3_reset(session->get_device_group);
2051 DYNAMIC_API PEP_STATUS set_identity_flags(
2052 PEP_SESSION session,
2053 pEp_identity *identity,
2061 assert(identity->address);
2062 assert(identity->user_id);
2064 if (!(session && identity && identity->address && identity->user_id))
2065 return PEP_ILLEGAL_VALUE;
2067 sqlite3_reset(session->set_identity_flags);
2068 sqlite3_bind_int(session->set_identity_flags, 1, flags);
2069 sqlite3_bind_text(session->set_identity_flags, 2, identity->address, -1,
2071 sqlite3_bind_text(session->set_identity_flags, 3, identity->user_id, -1,
2074 result = sqlite3_step(session->set_identity_flags);
2076 sqlite3_reset(session->set_identity_flags);
2077 if (result != SQLITE_DONE)
2078 return PEP_CANNOT_SET_IDENTITY;
2080 identity->flags |= flags;
2081 return PEP_STATUS_OK;
2084 DYNAMIC_API PEP_STATUS unset_identity_flags(
2085 PEP_SESSION session,
2086 pEp_identity *identity,
2094 assert(identity->address);
2095 assert(identity->user_id);
2097 if (!(session && identity && identity->address && identity->user_id))
2098 return PEP_ILLEGAL_VALUE;
2100 sqlite3_reset(session->unset_identity_flags);
2101 sqlite3_bind_int(session->unset_identity_flags, 1, flags);
2102 sqlite3_bind_text(session->unset_identity_flags, 2, identity->address, -1,
2104 sqlite3_bind_text(session->unset_identity_flags, 3, identity->user_id, -1,
2106 result = sqlite3_step(session->unset_identity_flags);
2107 sqlite3_reset(session->unset_identity_flags);
2108 if (result != SQLITE_DONE)
2109 return PEP_CANNOT_SET_IDENTITY;
2110 identity->flags &= ~flags;
2112 return PEP_STATUS_OK;
2116 PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
2117 const char* new_uid) {
2122 if (!session || !old_uid || !new_uid)
2123 return PEP_ILLEGAL_VALUE;
2128 sqlite3_reset(session->replace_userid);
2129 sqlite3_bind_text(session->replace_userid, 1, new_uid, -1,
2131 sqlite3_bind_text(session->replace_userid, 2, old_uid, -1,
2133 result = sqlite3_step(session->replace_userid);
2134 sqlite3_reset(session->replace_userid);
2135 if (result != SQLITE_DONE)
2136 return PEP_CANNOT_SET_PERSON; // May need clearer retval
2138 return PEP_STATUS_OK;
2141 PEP_STATUS refresh_userid_default_key(PEP_SESSION session, const char* user_id) {
2145 if (!session || !user_id)
2146 return PEP_ILLEGAL_VALUE;
2150 sqlite3_reset(session->refresh_userid_default_key);
2151 sqlite3_bind_text(session->refresh_userid_default_key, 1, user_id, -1,
2153 result = sqlite3_step(session->refresh_userid_default_key);
2154 sqlite3_reset(session->refresh_userid_default_key);
2155 if (result != SQLITE_DONE)
2156 return PEP_CANNOT_SET_PERSON;
2158 return PEP_STATUS_OK;
2161 PEP_STATUS replace_main_user_fpr(PEP_SESSION session, const char* user_id,
2162 const char* new_fpr) {
2167 if (!session || !user_id || !new_fpr)
2168 return PEP_ILLEGAL_VALUE;
2172 sqlite3_reset(session->replace_main_user_fpr);
2173 sqlite3_bind_text(session->replace_main_user_fpr, 1, new_fpr, -1,
2175 sqlite3_bind_text(session->replace_main_user_fpr, 2, user_id, -1,
2177 result = sqlite3_step(session->replace_main_user_fpr);
2178 sqlite3_reset(session->replace_main_user_fpr);
2179 if (result != SQLITE_DONE)
2180 return PEP_CANNOT_SET_PERSON;
2182 return PEP_STATUS_OK;
2185 PEP_STATUS get_main_user_fpr(PEP_SESSION session,
2186 const char* user_id,
2189 PEP_STATUS status = PEP_STATUS_OK;
2196 if (!(session && user_id && user_id[0] && main_fpr))
2197 return PEP_ILLEGAL_VALUE;
2201 sqlite3_reset(session->get_main_user_fpr);
2202 sqlite3_bind_text(session->get_main_user_fpr, 1, user_id, -1,
2204 result = sqlite3_step(session->get_main_user_fpr);
2208 (const char *) sqlite3_column_text(session->get_main_user_fpr, 0);
2210 *main_fpr = strdup(_fpr);
2212 status = PEP_OUT_OF_MEMORY;
2216 status = PEP_CANNOT_FIND_PERSON;
2219 sqlite3_reset(session->get_main_user_fpr);
2224 DYNAMIC_API PEP_STATUS mark_as_compromized(
2225 PEP_SESSION session,
2232 assert(fpr && fpr[0]);
2234 if (!(session && fpr && fpr[0]))
2235 return PEP_ILLEGAL_VALUE;
2237 sqlite3_reset(session->mark_compromized);
2238 sqlite3_bind_text(session->mark_compromized, 1, fpr, -1,
2240 result = sqlite3_step(session->mark_compromized);
2241 sqlite3_reset(session->mark_compromized);
2243 if (result != SQLITE_DONE)
2244 return PEP_CANNOT_SET_TRUST;
2246 return PEP_STATUS_OK;
2249 void pEp_free(void *p)
2254 PEP_STATUS set_trust(PEP_SESSION session,
2255 const char* user_id,
2257 PEP_comm_type comm_type)
2263 if (!session || !user_id || user_id[0] == '\0' || !fpr || fpr[0] == '\0')
2264 return PEP_ILLEGAL_VALUE;
2268 sqlite3_reset(session->set_trust);
2269 sqlite3_bind_text(session->set_trust, 1, user_id, -1,
2271 sqlite3_bind_text(session->set_trust, 2, fpr, -1,
2273 sqlite3_bind_int(session->set_trust, 3, comm_type);
2274 result = sqlite3_step(session->set_trust);
2275 assert(result == SQLITE_DONE);
2276 sqlite3_reset(session->set_trust);
2277 if (result != SQLITE_DONE)
2278 return PEP_CANNOT_SET_TRUST;
2280 return PEP_STATUS_OK;
2284 DYNAMIC_API PEP_STATUS get_trust(PEP_SESSION session, pEp_identity *identity)
2286 PEP_STATUS status = PEP_STATUS_OK;
2289 // We need to be able to test that we break correctly without shutting
2290 // asserts off everywhere.
2292 // assert(identity);
2293 // assert(identity->user_id);
2294 // assert(identity->user_id[0]);
2295 // assert(identity->fpr);
2296 // assert(identity->fpr[0]);
2298 if (!(session && identity && identity->user_id && identity->user_id[0] &&
2299 identity->fpr && identity->fpr[0]))
2300 return PEP_ILLEGAL_VALUE;
2302 identity->comm_type = PEP_ct_unknown;
2304 sqlite3_reset(session->get_trust);
2305 sqlite3_bind_text(session->get_trust, 1, identity->user_id, -1,
2307 sqlite3_bind_text(session->get_trust, 2, identity->fpr, -1, SQLITE_STATIC);
2309 result = sqlite3_step(session->get_trust);
2312 int comm_type = (PEP_comm_type) sqlite3_column_int(session->get_trust,
2314 identity->comm_type = comm_type;
2319 status = PEP_CANNOT_FIND_IDENTITY;
2322 sqlite3_reset(session->get_trust);
2326 DYNAMIC_API PEP_STATUS least_trust(
2327 PEP_SESSION session,
2329 PEP_comm_type *comm_type
2332 PEP_STATUS status = PEP_STATUS_OK;
2339 if (!(session && fpr && comm_type))
2340 return PEP_ILLEGAL_VALUE;
2342 *comm_type = PEP_ct_unknown;
2344 sqlite3_reset(session->least_trust);
2345 sqlite3_bind_text(session->least_trust, 1, fpr, -1, SQLITE_STATIC);
2347 result = sqlite3_step(session->least_trust);
2350 int _comm_type = sqlite3_column_int(session->least_trust, 0);
2351 *comm_type = (PEP_comm_type) _comm_type;
2355 // never reached because of sql min()
2356 status = PEP_CANNOT_FIND_IDENTITY;
2359 sqlite3_reset(session->least_trust);
2363 DYNAMIC_API PEP_STATUS decrypt_and_verify(
2364 PEP_SESSION session, const char *ctext, size_t csize,
2365 const char *dsigtext, size_t dsigsize,
2366 char **ptext, size_t *psize, stringlist_t **keylist
2376 if (!(session && ctext && csize && ptext && psize && keylist))
2377 return PEP_ILLEGAL_VALUE;
2379 return session->cryptotech[PEP_crypt_OpenPGP].decrypt_and_verify(
2380 session, ctext, csize, dsigtext, dsigsize, ptext, psize, keylist);
2383 DYNAMIC_API PEP_STATUS encrypt_and_sign(
2384 PEP_SESSION session, const stringlist_t *keylist, const char *ptext,
2385 size_t psize, char **ctext, size_t *csize
2395 if (!(session && keylist && ptext && psize && ctext && csize))
2396 return PEP_ILLEGAL_VALUE;
2398 return session->cryptotech[PEP_crypt_OpenPGP].encrypt_and_sign(session,
2399 keylist, ptext, psize, ctext, csize);
2402 PEP_STATUS encrypt_only(
2403 PEP_SESSION session, const stringlist_t *keylist, const char *ptext,
2404 size_t psize, char **ctext, size_t *csize
2414 if (!(session && keylist && ptext && psize && ctext && csize))
2415 return PEP_ILLEGAL_VALUE;
2417 return session->cryptotech[PEP_crypt_OpenPGP].encrypt_only(session,
2418 keylist, ptext, psize, ctext, csize);
2422 DYNAMIC_API PEP_STATUS verify_text(
2423 PEP_SESSION session, const char *text, size_t size,
2424 const char *signature, size_t sig_size, stringlist_t **keylist
2434 if (!(session && text && size && signature && sig_size && keylist))
2435 return PEP_ILLEGAL_VALUE;
2437 return session->cryptotech[PEP_crypt_OpenPGP].verify_text(session, text,
2438 size, signature, sig_size, keylist);
2441 DYNAMIC_API PEP_STATUS delete_keypair(PEP_SESSION session, const char *fpr)
2446 if (!(session && fpr))
2447 return PEP_ILLEGAL_VALUE;
2449 return session->cryptotech[PEP_crypt_OpenPGP].delete_keypair(session, fpr);
2452 DYNAMIC_API PEP_STATUS export_key(
2453 PEP_SESSION session, const char *fpr, char **key_data, size_t *size
2461 if (!(session && fpr && key_data && size))
2462 return PEP_ILLEGAL_VALUE;
2464 return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
2465 key_data, size, false);
2468 DYNAMIC_API PEP_STATUS export_secrect_key(
2469 PEP_SESSION session, const char *fpr, char **key_data, size_t *size
2477 if (!(session && fpr && key_data && size))
2478 return PEP_ILLEGAL_VALUE;
2480 // don't accept key IDs but full fingerprints only
2481 if (strlen(fpr) < 16)
2482 return PEP_ILLEGAL_VALUE;
2484 return session->cryptotech[PEP_crypt_OpenPGP].export_key(session, fpr,
2485 key_data, size, true);
2488 DYNAMIC_API PEP_STATUS find_keys(
2489 PEP_SESSION session, const char *pattern, stringlist_t **keylist
2496 if (!(session && pattern && keylist))
2497 return PEP_ILLEGAL_VALUE;
2499 return session->cryptotech[PEP_crypt_OpenPGP].find_keys(session, pattern,
2504 DYNAMIC_API PEP_STATUS generate_keypair(
2505 PEP_SESSION session, pEp_identity *identity
2510 assert(identity->address);
2511 assert(identity->fpr == NULL || identity->fpr[0] == 0);
2512 assert(identity->username);
2514 if (!(session && identity && identity->address &&
2515 (identity->fpr == NULL || identity->fpr[0] == 0) &&
2516 identity->username))
2517 return PEP_ILLEGAL_VALUE;
2520 session->cryptotech[PEP_crypt_OpenPGP].generate_keypair(session,
2522 if (status != PEP_STATUS_OK)
2528 DYNAMIC_API PEP_STATUS get_key_rating(
2529 PEP_SESSION session,
2531 PEP_comm_type *comm_type
2538 if (!(session && fpr && comm_type))
2539 return PEP_ILLEGAL_VALUE;
2541 return session->cryptotech[PEP_crypt_OpenPGP].get_key_rating(session, fpr,
2545 DYNAMIC_API PEP_STATUS import_key(
2546 PEP_SESSION session,
2547 const char *key_data,
2549 identity_list **private_keys
2555 if (!(session && key_data))
2556 return PEP_ILLEGAL_VALUE;
2558 return session->cryptotech[PEP_crypt_OpenPGP].import_key(session, key_data,
2559 size, private_keys);
2562 DYNAMIC_API PEP_STATUS recv_key(PEP_SESSION session, const char *pattern)
2567 if (!(session && pattern))
2568 return PEP_ILLEGAL_VALUE;
2570 return session->cryptotech[PEP_crypt_OpenPGP].recv_key(session, pattern);
2573 DYNAMIC_API PEP_STATUS send_key(PEP_SESSION session, const char *pattern)
2578 if (!(session && pattern))
2579 return PEP_ILLEGAL_VALUE;
2581 return session->cryptotech[PEP_crypt_OpenPGP].send_key(session, pattern);
2584 DYNAMIC_API PEP_STATUS renew_key(
2585 PEP_SESSION session,
2593 if (!(session && fpr))
2594 return PEP_ILLEGAL_VALUE;
2596 return session->cryptotech[PEP_crypt_OpenPGP].renew_key(session, fpr, ts);
2599 DYNAMIC_API PEP_STATUS revoke_key(
2600 PEP_SESSION session,
2608 if (!(session && fpr))
2609 return PEP_ILLEGAL_VALUE;
2611 return session->cryptotech[PEP_crypt_OpenPGP].revoke_key(session, fpr,
2615 DYNAMIC_API PEP_STATUS key_expired(
2616 PEP_SESSION session,
2626 if (!(session && fpr && expired))
2627 return PEP_ILLEGAL_VALUE;
2629 return session->cryptotech[PEP_crypt_OpenPGP].key_expired(session, fpr,
2633 DYNAMIC_API PEP_STATUS key_revoked(
2634 PEP_SESSION session,
2643 if (!(session && fpr && revoked))
2644 return PEP_ILLEGAL_VALUE;
2646 return session->cryptotech[PEP_crypt_OpenPGP].key_revoked(session, fpr,
2650 static void _clean_log_value(char *text)
2653 for (char *c = text; *c; c++) {
2654 if (*c < 32 && *c != '\n')
2662 static char *_concat_string(char *str1, const char *str2, char delim)
2664 str2 = str2 ? str2 : "";
2665 size_t len1 = str1 ? strlen(str1) : 0;
2666 size_t len2 = strlen(str2);
2667 size_t len = len1 + len2 + 3;
2668 char * result = realloc(str1, len + 1);
2672 strcpy(result + len1 + 1, str2);
2673 result[len - 2] = '"';
2674 result[len - 1] = delim;
2684 DYNAMIC_API PEP_STATUS get_crashdump_log(
2685 PEP_SESSION session,
2690 PEP_STATUS status = PEP_STATUS_OK;
2691 char *_logdata= NULL;
2694 assert(maxlines >= 0 && maxlines <= CRASHDUMP_MAX_LINES);
2697 if (!(session && logdata && maxlines >= 0 && maxlines <=
2698 CRASHDUMP_MAX_LINES))
2699 return PEP_ILLEGAL_VALUE;
2703 int limit = maxlines ? maxlines : CRASHDUMP_DEFAULT_LINES;
2704 const char *timestamp = NULL;
2705 const char *title = NULL;
2706 const char *entity = NULL;
2707 const char *desc = NULL;
2708 const char *comment = NULL;
2710 sqlite3_reset(session->crashdump);
2711 sqlite3_bind_int(session->crashdump, 1, limit);
2716 result = sqlite3_step(session->crashdump);
2719 timestamp = (const char *) sqlite3_column_text(session->crashdump,
2721 title = (const char *) sqlite3_column_text(session->crashdump,
2723 entity = (const char *) sqlite3_column_text(session->crashdump,
2725 desc = (const char *) sqlite3_column_text(session->crashdump,
2727 comment = (const char *) sqlite3_column_text(session->crashdump,
2730 _logdata = _concat_string(_logdata, timestamp, ',');
2731 if (_logdata == NULL)
2734 _logdata = _concat_string(_logdata, title, ',');
2735 if (_logdata == NULL)
2738 _logdata = _concat_string(_logdata, entity, ',');
2739 if (_logdata == NULL)
2742 _logdata = _concat_string(_logdata, desc, ',');
2743 if (_logdata == NULL)
2746 _logdata = _concat_string(_logdata, comment, '\n');
2747 if (_logdata == NULL)
2750 _clean_log_value(_logdata);
2757 status = PEP_UNKNOWN_ERROR;
2758 result = SQLITE_DONE;
2760 } while (result != SQLITE_DONE);
2762 sqlite3_reset(session->crashdump);
2763 if (status == PEP_STATUS_OK)
2764 *logdata = _logdata;
2769 status = PEP_OUT_OF_MEMORY;
2772 return ADD_TO_LOG(status);
2775 DYNAMIC_API PEP_STATUS get_languagelist(
2776 PEP_SESSION session,
2780 PEP_STATUS status = PEP_STATUS_OK;
2781 char *_languages= NULL;
2786 if (!(session && languages))
2787 return PEP_ILLEGAL_VALUE;
2791 const char *lang = NULL;
2792 const char *name = NULL;
2793 const char *phrase = NULL;
2795 sqlite3_reset(session->languagelist);
2800 result = sqlite3_step(session->languagelist);
2803 lang = (const char *) sqlite3_column_text(session->languagelist,
2805 name = (const char *) sqlite3_column_text(session->languagelist,
2807 phrase = (const char *) sqlite3_column_text(session->languagelist,
2810 _languages = _concat_string(_languages, lang, ',');
2811 if (_languages == NULL)
2814 _languages = _concat_string(_languages, name, ',');
2815 if (_languages == NULL)
2818 _languages = _concat_string(_languages, phrase, '\n');
2819 if (_languages == NULL)
2828 status = PEP_UNKNOWN_ERROR;
2829 result = SQLITE_DONE;
2831 } while (result != SQLITE_DONE);
2833 sqlite3_reset(session->languagelist);
2834 if (status == PEP_STATUS_OK)
2835 *languages = _languages;
2840 status = PEP_OUT_OF_MEMORY;
2846 DYNAMIC_API PEP_STATUS get_phrase(
2847 PEP_SESSION session,
2853 PEP_STATUS status = PEP_STATUS_OK;
2855 assert(session && lang && lang[0] && lang[1] && lang[2] == 0 && phrase);
2856 if (!(session && lang && lang[0] && lang[1] && lang[2] == 0 && phrase))
2857 return PEP_ILLEGAL_VALUE;
2861 sqlite3_reset(session->i18n_token);
2862 sqlite3_bind_text(session->i18n_token, 1, lang, -1, SQLITE_STATIC);
2863 sqlite3_bind_int(session->i18n_token, 2, phrase_id);
2865 const char *_phrase = NULL;
2868 result = sqlite3_step(session->i18n_token);
2871 _phrase = (const char *) sqlite3_column_text(session->i18n_token, 0);
2875 status = PEP_PHRASE_NOT_FOUND;
2879 status = PEP_UNKNOWN_ERROR;
2882 if (status == PEP_STATUS_OK) {
2883 *phrase = strdup(_phrase);
2884 if (*phrase == NULL)
2888 sqlite3_reset(session->i18n_token);
2892 status = PEP_OUT_OF_MEMORY;
2898 static PEP_STATUS _get_sequence_value(PEP_SESSION session, const char *name,
2901 assert(session && name && value);
2902 if (!(session && name && value))
2903 return PEP_ILLEGAL_VALUE;
2905 PEP_STATUS status = PEP_STATUS_OK;
2907 sqlite3_reset(session->sequence_value2);
2908 sqlite3_bind_text(session->sequence_value2, 1, name, -1,
2910 int result = sqlite3_step(session->sequence_value2);
2913 int32_t _value = (int32_t)
2914 sqlite3_column_int(session->sequence_value2, 0);
2916 sqlite3_column_int(session->sequence_value2, 1);
2919 status = PEP_OWN_SEQUENCE;
2923 status = PEP_RECORD_NOT_FOUND;
2926 status = PEP_UNKNOWN_ERROR;
2928 sqlite3_reset(session->sequence_value2);
2933 static PEP_STATUS _increment_sequence_value(PEP_SESSION session,
2934 const char *name, int own)
2936 assert(session && name);
2937 if (!(session && name))
2938 return PEP_ILLEGAL_VALUE;
2940 sqlite3_reset(session->sequence_value1);
2941 sqlite3_bind_text(session->sequence_value1, 1, name, -1, SQLITE_STATIC);
2942 sqlite3_bind_int(session->sequence_value1, 2, own);
2943 int result = sqlite3_step(session->sequence_value1);
2944 assert(result == SQLITE_DONE);
2945 sqlite3_reset(session->sequence_value1);
2946 if (result == SQLITE_DONE)
2947 return PEP_STATUS_OK;
2949 return PEP_CANNOT_INCREASE_SEQUENCE;
2952 static PEP_STATUS _set_sequence_value(PEP_SESSION session,
2953 const char *name, int32_t value, int own)
2955 assert(session && name && value > 0);
2956 if (!(session && name && value > 0))
2957 return PEP_ILLEGAL_VALUE;
2959 sqlite3_reset(session->sequence_value3);
2960 sqlite3_bind_text(session->sequence_value3, 1, name, -1, SQLITE_STATIC);
2961 sqlite3_bind_int(session->sequence_value3, 2, value);
2962 sqlite3_bind_int(session->sequence_value3, 3, own);
2963 int result = sqlite3_step(session->sequence_value3);
2964 assert(result == SQLITE_DONE);
2965 sqlite3_reset(session->sequence_value3);
2966 if (result == SQLITE_DONE)
2967 return PEP_STATUS_OK;
2969 return PEP_CANNOT_SET_SEQUENCE_VALUE;
2972 DYNAMIC_API PEP_STATUS sequence_value(
2973 PEP_SESSION session,
2978 PEP_STATUS status = PEP_STATUS_OK;
2982 assert(name && value && *value >= 0);
2984 if (!(session && name && value && *value >= 0))
2985 return PEP_ILLEGAL_VALUE;
2990 uuid_generate_random(uuid);
2991 uuid_unparse_upper(uuid, name);
2995 if (name == session->sync_session->sync_uuid ||
2996 strcmp(name, session->sync_session->sync_uuid) == 0)
3001 sqlite3_exec(session->db, "BEGIN ;", NULL, NULL, NULL);
3002 int32_t old_value = 0;
3003 status = _get_sequence_value(session, name, &old_value);
3004 if (status != PEP_STATUS_OK && status != PEP_RECORD_NOT_FOUND)
3006 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3010 if (old_value >= *value) {
3011 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3012 return PEP_SEQUENCE_VIOLATED;
3015 status = _set_sequence_value(session, name, *value, own);
3016 if (status == PEP_STATUS_OK) {
3017 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
3018 if (result == SQLITE_OK)
3019 return PEP_STATUS_OK;
3021 return PEP_COMMIT_FAILED;
3023 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3029 assert(*value == 0);
3030 sqlite3_exec(session->db, "BEGIN ;", NULL, NULL, NULL);
3031 status = _increment_sequence_value(session, name, own);
3032 if (status == PEP_STATUS_OK) {
3033 status = _get_sequence_value(session, name, value);
3035 if (status == PEP_STATUS_OK || status == PEP_OWN_SEQUENCE) {
3036 result = sqlite3_exec(session->db, "COMMIT ;", NULL, NULL, NULL);
3037 if (result == SQLITE_OK){
3038 assert(*value < INT32_MAX);
3039 if (*value == INT32_MAX){
3040 return PEP_CANNOT_INCREASE_SEQUENCE;
3044 return PEP_COMMIT_FAILED;
3047 sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
3053 DYNAMIC_API PEP_STATUS set_revoked(
3054 PEP_SESSION session,
3055 const char *revoked_fpr,
3056 const char *replacement_fpr,
3057 const uint64_t revocation_date
3060 PEP_STATUS status = PEP_STATUS_OK;
3063 revoked_fpr && revoked_fpr[0] &&
3064 replacement_fpr && replacement_fpr[0]
3068 revoked_fpr && revoked_fpr[0] &&
3069 replacement_fpr && replacement_fpr[0]
3071 return PEP_ILLEGAL_VALUE;
3073 sqlite3_reset(session->set_revoked);
3074 sqlite3_bind_text(session->set_revoked, 1, revoked_fpr, -1, SQLITE_STATIC);
3075 sqlite3_bind_text(session->set_revoked, 2, replacement_fpr, -1,
3077 sqlite3_bind_int64(session->set_revoked, 3, revocation_date);
3081 result = sqlite3_step(session->set_revoked);
3084 status = PEP_STATUS_OK;
3088 status = PEP_UNKNOWN_ERROR;
3091 sqlite3_reset(session->set_revoked);
3095 DYNAMIC_API PEP_STATUS get_revoked(
3096 PEP_SESSION session,
3099 uint64_t *revocation_date
3102 PEP_STATUS status = PEP_STATUS_OK;
3113 return PEP_ILLEGAL_VALUE;
3115 *revoked_fpr = NULL;
3116 *revocation_date = 0;
3118 sqlite3_reset(session->get_revoked);
3119 sqlite3_bind_text(session->get_revoked, 1, fpr, -1, SQLITE_STATIC);
3123 result = sqlite3_step(session->get_revoked);
3126 *revoked_fpr = strdup((const char *)
3127 sqlite3_column_text(session->get_revoked, 0));
3129 *revocation_date = sqlite3_column_int64(session->get_revoked,
3132 status = PEP_OUT_OF_MEMORY;
3137 status = PEP_CANNOT_FIND_IDENTITY;
3140 sqlite3_reset(session->get_revoked);
3145 PEP_STATUS key_created(
3146 PEP_SESSION session,
3151 assert(session && fpr && created);
3152 if (!(session && fpr && created))
3153 return PEP_ILLEGAL_VALUE;
3155 return session->cryptotech[PEP_crypt_OpenPGP].key_created(session, fpr,
3159 PEP_STATUS find_private_keys(PEP_SESSION session, const char* pattern,
3160 stringlist_t **keylist) {
3161 assert(session && keylist);
3162 if (!(session && keylist))
3163 return PEP_ILLEGAL_VALUE;
3165 return session->cryptotech[PEP_crypt_OpenPGP].find_private_keys(session, pattern,
3169 PEP_STATUS import_trusted_own_keys(PEP_SESSION session) {
3172 return PEP_ILLEGAL_VALUE;
3174 return session->cryptotech[PEP_crypt_OpenPGP].import_trusted_own_keys(session);
3177 DYNAMIC_API const char* get_engine_version() {
3178 return PEP_ENGINE_VERSION;
3182 DYNAMIC_API PEP_STATUS reset_peptest_hack(PEP_SESSION session)
3187 return PEP_ILLEGAL_VALUE;
3189 int int_result = sqlite3_exec(
3191 "delete from identity where address like '%@peptest.ch' ;",
3196 assert(int_result == SQLITE_OK);
3198 if (int_result != SQLITE_OK)
3199 return PEP_UNKNOWN_ERROR;
3201 return PEP_STATUS_OK;
3204 #ifdef DEBUG_ERRORSTACK
3205 PEP_STATUS session_add_error(PEP_SESSION session, const char* file, unsigned line, PEP_STATUS status)
3210 snprintf(logline,47, "%.24s:%u status=%u (0x%x)", file, line, status, status);
3212 snprintf(logline,47, "%.24s:%u status=%i.", file, line, status);
3214 stringlist_add(session->errorstack, logline); // logline is copied! :-)
3218 DYNAMIC_API const stringlist_t* get_errorstack(PEP_SESSION session)
3220 return session->errorstack;
3223 DYNAMIC_API void clear_errorstack(PEP_SESSION session)
3225 const int old_len = stringlist_length(session->errorstack);
3227 free_stringlist(session->errorstack);
3228 snprintf(buf, 47, "(%i elements cleared)", old_len);
3229 session->errorstack = new_stringlist(buf);
3234 static stringlist_t* dummy_errorstack = NULL;
3236 DYNAMIC_API const stringlist_t* get_errorstack(PEP_SESSION session)
3238 if(dummy_errorstack == NULL)
3240 dummy_errorstack = new_stringlist("( Please recompile pEpEngine with -DDEBUG_ERRORSTACK )");
3243 return dummy_errorstack;
3246 DYNAMIC_API void clear_errorstack(PEP_SESSION session)
3248 // nothing to do here