aniani/profanity
1
0
Fork 0
mirror of https://github.com/profanity-im/profanity.git synced 2024-12-04 14:46:46 -05:00
Code

Merge pull request #1126 from paulfariello/feature/decrypt_all_incoming_OMEMO_msg

Browse Source 
Decrypt all incoming omemo msg
This commit is contained in:
Michael Vetter 2019-06-21 09:08:58 +02:00 committed by GitHub
commit db86286ea3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
28 changed files with 463 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.am
View File

@ -101,6 +101,7 @@ unittest_sources = \
src/event/client_events.c src/event/client_events.h \
src/ui/tray.h src/ui/tray.c \
tests/unittests/xmpp/stub_xmpp.c \
tests/unittests/xmpp/stub_message.c \
tests/unittests/ui/stub_ui.c tests/unittests/ui/stub_ui.h \
tests/unittests/log/stub_log.c \
tests/unittests/config/stub_accounts.c \

2
src/config/theme.c
View File

@ -153,6 +153,7 @@ theme_init(const char *const theme_name)
g_hash_table_insert(defaults, strdup("roster.room.trigger"), strdup("green"));
g_hash_table_insert(defaults, strdup("roster.room.mention"), strdup("green"));
g_hash_table_insert(defaults, strdup("occupants.header"), strdup("yellow"));
g_hash_table_insert(defaults, strdup("untrusted"), strdup("red"));
_load_preferences();
}
@ -854,6 +855,7 @@ theme_attrs(theme_item_t attrs)
case THEME_ROSTER_ROOM_TRIGGER: _theme_prep_fgnd("roster.room.trigger", lookup_str, &bold); break;
case THEME_ROSTER_ROOM_MENTION: _theme_prep_fgnd("roster.room.mention", lookup_str, &bold); break;
case THEME_OCCUPANTS_HEADER: _theme_prep_fgnd("occupants.header", lookup_str, &bold); break;
case THEME_UNTRUSTED: _theme_prep_fgnd("untrusted", lookup_str, &bold); break;
case THEME_WHITE: g_string_append(lookup_str, "white"); bold = FALSE; break;
case THEME_WHITE_BOLD: g_string_append(lookup_str, "white"); bold = TRUE; break;
case THEME_GREEN: g_string_append(lookup_str, "green"); bold = FALSE; break;

3
src/config/theme.h
View File

@ -117,6 +117,7 @@ typedef enum {
THEME_ROSTER_ROOM_TRIGGER,
THEME_ROSTER_ROOM_MENTION,
THEME_RECEIPT_SENT,
THEME_UNTRUSTED,
THEME_NONE,
THEME_WHITE,
THEME_WHITE_BOLD,
@ -133,7 +134,7 @@ typedef enum {
THEME_BLACK,
THEME_BLACK_BOLD,
THEME_MAGENTA,
THEME_MAGENTA_BOLD
THEME_MAGENTA_BOLD,
} theme_item_t;
void theme_init(const char *const theme_name);

38
src/event/client_events.c
View File

@ -143,14 +143,14 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (chatwin->pgp_send) {
char *id = message_send_chat_pgp(chatwin->barejid, plugin_msg, request_receipt);
chat_log_pgp_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PGP, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PGP, request_receipt);
free(id);
} else {
gboolean handled = otr_on_message_send(chatwin, plugin_msg, request_receipt);
if (!handled) {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
}
@ -170,7 +170,7 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (!handled) {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
@ -188,12 +188,12 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (chatwin->pgp_send) {
char *id = message_send_chat_pgp(chatwin->barejid, plugin_msg, request_receipt);
chat_log_pgp_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PGP, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PGP, request_receipt);
free(id);
} else {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
@ -211,12 +211,12 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (chatwin->is_omemo) {
char *id = omemo_on_message_send((ProfWin *)chatwin, plugin_msg, request_receipt, FALSE);
chat_log_omemo_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_OMEMO, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_OMEMO, request_receipt);
free(id);
} else {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
@ -234,14 +234,14 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (chatwin->is_omemo) {
char *id = omemo_on_message_send((ProfWin *)chatwin, plugin_msg, request_receipt, FALSE);
chat_log_omemo_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_OMEMO, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_OMEMO, request_receipt);
free(id);
} else {
gboolean handled = otr_on_message_send(chatwin, plugin_msg, request_receipt);
if (!handled) {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
}
@ -260,17 +260,17 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (chatwin->is_omemo) {
char *id = omemo_on_message_send((ProfWin *)chatwin, plugin_msg, request_receipt, FALSE);
chat_log_omemo_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_OMEMO, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_OMEMO, request_receipt);
free(id);
} else if (chatwin->pgp_send) {
char *id = message_send_chat_pgp(chatwin->barejid, plugin_msg, request_receipt);
chat_log_pgp_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PGP, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PGP, request_receipt);
free(id);
} else {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
@ -288,19 +288,19 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
if (chatwin->is_omemo) {
char *id = omemo_on_message_send((ProfWin *)chatwin, plugin_msg, request_receipt, FALSE);
chat_log_omemo_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_OMEMO, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_OMEMO, request_receipt);
free(id);
} else if (chatwin->pgp_send) {
char *id = message_send_chat_pgp(chatwin->barejid, plugin_msg, request_receipt);
chat_log_pgp_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PGP, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PGP, request_receipt);
free(id);
} else {
gboolean handled = otr_on_message_send(chatwin, plugin_msg, request_receipt);
if (!handled) {
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
}
}
@ -318,7 +318,7 @@ cl_ev_send_msg(ProfChatWin *chatwin, const char *const msg, const char *const oo
#ifndef HAVE_OMEMO
char *id = message_send_chat(chatwin->barejid, plugin_msg, oob_url, request_receipt);
chat_log_msg_out(chatwin->barejid, plugin_msg);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, plugin_msg, id, PROF_MSG_ENC_PLAIN, request_receipt);
free(id);
plugins_post_chat_message_send(chatwin->barejid, plugin_msg);
@ -341,12 +341,12 @@ cl_ev_send_muc_msg(ProfMucWin *mucwin, const char *const msg, const char *const
if (mucwin->is_omemo) {
char *id = omemo_on_message_send((ProfWin *)mucwin, plugin_msg, FALSE, TRUE);
groupchat_log_omemo_msg_out(mucwin->roomjid, plugin_msg);
mucwin_outgoing_msg(mucwin, plugin_msg, id, PROF_MSG_OMEMO);
mucwin_outgoing_msg(mucwin, plugin_msg, id, PROF_MSG_ENC_OMEMO);
free(id);
} else {
char *id = message_send_groupchat(mucwin->roomjid, plugin_msg, oob_url);
groupchat_log_msg_out(mucwin->roomjid, plugin_msg);
mucwin_outgoing_msg(mucwin, plugin_msg, id, PROF_MSG_PLAIN);
mucwin_outgoing_msg(mucwin, plugin_msg, id, PROF_MSG_ENC_PLAIN);
free(id);
}
@ -358,7 +358,7 @@ cl_ev_send_muc_msg(ProfMucWin *mucwin, const char *const msg, const char *const
#ifndef HAVE_OMEMO
char *id = message_send_groupchat(mucwin->roomjid, plugin_msg, oob_url);
groupchat_log_msg_out(mucwin->roomjid, plugin_msg);
mucwin_outgoing_msg(mucwin, plugin_msg, id, PROF_MSG_PLAIN);
mucwin_outgoing_msg(mucwin, plugin_msg, id, PROF_MSG_ENC_PLAIN);
free(id);
plugins_post_room_message_send(mucwin->roomjid, plugin_msg);

245
src/event/server_events.c
View File

@ -267,10 +267,9 @@ sv_ev_room_subject(const char *const room, const char *const nick, const char *c
}
void
sv_ev_room_history(const char *const room_jid, const char *const nick,
GDateTime *timestamp, const char *const message)
sv_ev_room_history(ProfMessage *message)
{
ProfMucWin *mucwin = wins_get_muc(room_jid);
ProfMucWin *mucwin = wins_get_muc(message->jid->barejid);
if (mucwin) {
// if this is the first successful connection
if (_success_connections_counter == 1) {
@ -282,34 +281,35 @@ sv_ev_room_history(const char *const room_jid, const char *const nick,
mucwin->last_msg_timestamp = g_date_time_new_now_local();
}
gboolean younger = g_date_time_compare(mucwin->last_msg_timestamp, timestamp) < 0 ? TRUE : FALSE;
gboolean younger = g_date_time_compare(mucwin->last_msg_timestamp, message->timestamp) < 0 ? TRUE : FALSE;
if (_success_connections_counter == 1 || younger ) {
mucwin_history(mucwin, nick, timestamp, message);
mucwin_history(mucwin, message->jid->resourcepart, message->timestamp, message->plain);
}
}
}
void
sv_ev_room_message(const char *const room_jid, const char *const nick, const char *const message, const char *const id, gboolean omemo)
sv_ev_room_message(ProfMessage *message)
{
ProfMucWin *mucwin = wins_get_muc(room_jid);
ProfMucWin *mucwin = wins_get_muc(message->jid->barejid);
if (!mucwin) {
return;
}
char *mynick = muc_nick(mucwin->roomjid);
if (omemo) {
groupchat_log_omemo_msg_in(room_jid, nick, message);
if (message->enc == PROF_MSG_ENC_OMEMO) {
groupchat_log_omemo_msg_in(message->jid->barejid, message->jid->resourcepart, message->plain);
} else {
groupchat_log_msg_in(room_jid, nick, message);
groupchat_log_msg_in(message->jid->barejid, message->jid->resourcepart, message->plain);
}
char *new_message = plugins_pre_room_message_display(room_jid, nick, message);
char *old_plain = message->plain;
message->plain = plugins_pre_room_message_display(message->jid->barejid, message->jid->resourcepart, message->plain);
gboolean whole_word = prefs_get_boolean(PREF_NOTIFY_MENTION_WHOLE_WORD);
gboolean case_sensitive = prefs_get_boolean(PREF_NOTIFY_MENTION_CASE_SENSITIVE);
char *message_search = case_sensitive ? strdup(new_message) : g_utf8_strdown(new_message, -1);
char *message_search = case_sensitive ? strdup(message->plain) : g_utf8_strdown(message->plain, -1);
char *mynick_search = case_sensitive ? strdup(mynick) : g_utf8_strdown(mynick, -1);
GSList *mentions = NULL;
@ -318,13 +318,9 @@ sv_ev_room_message(const char *const room_jid, const char *const nick, const cha
g_free(message_search);
g_free(mynick_search);
GList *triggers = prefs_message_get_triggers(new_message);
GList *triggers = prefs_message_get_triggers(message->plain);
if (omemo) {
mucwin_incoming_msg(mucwin, nick, new_message, id, mentions, triggers, PROF_MSG_OMEMO);
} else {
mucwin_incoming_msg(mucwin, nick, new_message, id, mentions, triggers, PROF_MSG_PLAIN);
}
mucwin_incoming_msg(mucwin, message, mentions, triggers);
g_slist_free(mentions);
@ -337,7 +333,7 @@ sv_ev_room_message(const char *const room_jid, const char *const nick, const cha
is_current = TRUE;
status_bar_active(num, WIN_MUC, mucwin->roomjid);
if ((g_strcmp0(mynick, nick) != 0) && (prefs_get_boolean(PREF_BEEP))) {
if ((g_strcmp0(mynick, message->jid->resourcepart) != 0) && (prefs_get_boolean(PREF_BEEP))) {
beep();
}
@ -345,11 +341,11 @@ sv_ev_room_message(const char *const room_jid, const char *const nick, const cha
} else {
status_bar_new(num, WIN_MUC, mucwin->roomjid);
if ((g_strcmp0(mynick, nick) != 0) && (prefs_get_boolean(PREF_FLASH))) {
if ((g_strcmp0(mynick, message->jid->resourcepart) != 0) && (prefs_get_boolean(PREF_FLASH))) {
flash();
}
cons_show_incoming_room_message(nick, mucwin->roomjid, num, mention, triggers, mucwin->unread);
cons_show_incoming_room_message(message->jid->resourcepart, mucwin->roomjid, num, mention, triggers, mucwin->unread);
mucwin->unread++;
@ -367,9 +363,9 @@ sv_ev_room_message(const char *const room_jid, const char *const nick, const cha
}
mucwin->last_msg_timestamp = g_date_time_new_now_local();
if (prefs_do_room_notify(is_current, mucwin->roomjid, mynick, nick, new_message, mention, triggers != NULL)) {
if (prefs_do_room_notify(is_current, mucwin->roomjid, mynick, message->jid->resourcepart, message->plain, mention, triggers != NULL)) {
Jid *jidp = jid_create(mucwin->roomjid);
notify_room_message(nick, jidp->localpart, num, new_message);
notify_room_message(message->jid->resourcepart, jidp->localpart, num, message->plain);
jid_destroy(jidp);
}
@ -379,43 +375,48 @@ sv_ev_room_message(const char *const room_jid, const char *const nick, const cha
rosterwin_roster();
plugins_post_room_message_display(room_jid, nick, new_message);
free(new_message);
plugins_post_room_message_display(message->jid->barejid, message->jid->resourcepart, message->plain);
free(message->plain);
message->plain = old_plain;
}
void
sv_ev_incoming_private_message(const char *const fulljid, char *message)
sv_ev_incoming_private_message(ProfMessage *message)
{
char *plugin_message = plugins_pre_priv_message_display(fulljid, message);
char *old_plain = message->plain;
message->plain = plugins_pre_priv_message_display(message->jid->fulljid, message->plain);
ProfPrivateWin *privatewin = wins_get_private(fulljid);
ProfPrivateWin *privatewin = wins_get_private(message->jid->fulljid);
if (privatewin == NULL) {
ProfWin *window = wins_new_private(fulljid);
ProfWin *window = wins_new_private(message->jid->fulljid);
privatewin = (ProfPrivateWin*)window;
}
privwin_incoming_msg(privatewin, plugin_message, NULL);
privwin_incoming_msg(privatewin, message);
plugins_post_priv_message_display(fulljid, plugin_message);
plugins_post_priv_message_display(message->jid->fulljid, message->plain);
free(plugin_message);
free(message->plain);
message->plain = old_plain;
rosterwin_roster();
}
void
sv_ev_delayed_private_message(const char *const fulljid, char *message, GDateTime *timestamp)
sv_ev_delayed_private_message(ProfMessage *message)
{
char *new_message = plugins_pre_priv_message_display(fulljid, message);
char *old_plain = message->plain;
message->plain = plugins_pre_priv_message_display(message->jid->fulljid, message->plain);
ProfPrivateWin *privatewin = wins_get_private(fulljid);
ProfPrivateWin *privatewin = wins_get_private(message->jid->fulljid);
if (privatewin == NULL) {
ProfWin *window = wins_new_private(fulljid);
ProfWin *window = wins_new_private(message->jid->fulljid);
privatewin = (ProfPrivateWin*)window;
}
privwin_incoming_msg(privatewin, new_message, timestamp);
privwin_incoming_msg(privatewin, message);
plugins_post_priv_message_display(fulljid, new_message);
plugins_post_priv_message_display(message->jid->fulljid, message->plain);
free(new_message);
free(message->plain);
message->plain = old_plain;
}
void
@ -433,12 +434,12 @@ sv_ev_outgoing_carbon(char *barejid, char *message, char *pgp_message, gboolean
if (pgp_message) {
char *decrypted = p_gpg_decrypt(pgp_message);
if (decrypted) {
chatwin_outgoing_carbon(chatwin, decrypted, PROF_MSG_PGP);
chatwin_outgoing_carbon(chatwin, decrypted, PROF_MSG_ENC_PGP);
} else {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_PLAIN);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_PLAIN);
}
} else {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_PLAIN);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_PLAIN);
}
return;
#endif
@ -447,9 +448,9 @@ sv_ev_outgoing_carbon(char *barejid, char *message, char *pgp_message, gboolean
#ifndef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (omemo) {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_OMEMO);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_OMEMO);
} else {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_PLAIN);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_PLAIN);
}
return;
#endif
@ -458,16 +459,16 @@ sv_ev_outgoing_carbon(char *barejid, char *message, char *pgp_message, gboolean
#ifdef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (omemo) {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_OMEMO);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_OMEMO);
} else if (pgp_message) {
char *decrypted = p_gpg_decrypt(pgp_message);
if (decrypted) {
chatwin_outgoing_carbon(chatwin, decrypted, PROF_MSG_PGP);
chatwin_outgoing_carbon(chatwin, decrypted, PROF_MSG_ENC_PGP);
} else {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_PLAIN);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_PLAIN);
}
} else {
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_PLAIN);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_PLAIN);
}
return;
#endif
@ -475,24 +476,27 @@ sv_ev_outgoing_carbon(char *barejid, char *message, char *pgp_message, gboolean
#ifndef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_PLAIN);
chatwin_outgoing_carbon(chatwin, message, PROF_MSG_ENC_PLAIN);
#endif
#endif
}
#ifdef HAVE_LIBGPGME
static void
_sv_ev_incoming_pgp(ProfChatWin *chatwin, gboolean new_win, char *barejid, char *resource, char *message, char *pgp_message, GDateTime *timestamp)
_sv_ev_incoming_pgp(ProfChatWin *chatwin, gboolean new_win, ProfMessage *message)
{
char *decrypted = p_gpg_decrypt(pgp_message);
if (decrypted) {
chatwin_incoming_msg(chatwin, resource, decrypted, timestamp, new_win, PROF_MSG_PGP);
chat_log_pgp_msg_in(barejid, decrypted, timestamp);
message->plain = p_gpg_decrypt(message->encrypted);
if (message->plain) {
message->enc = PROF_MSG_ENC_PGP;
chatwin_incoming_msg(chatwin, message, new_win);
chat_log_pgp_msg_in(message);
chatwin->pgp_recv = TRUE;
p_gpg_free_decrypted(decrypted);
p_gpg_free_decrypted(message->plain);
message->plain = NULL;
} else {
chatwin_incoming_msg(chatwin, resource, message, timestamp, new_win, PROF_MSG_PLAIN);
chat_log_msg_in(barejid, message, timestamp);
message->enc = PROF_MSG_ENC_PLAIN;
chatwin_incoming_msg(chatwin, message, new_win);
chat_log_msg_in(message);
chatwin->pgp_recv = FALSE;
}
}
@ -500,19 +504,23 @@ _sv_ev_incoming_pgp(ProfChatWin *chatwin, gboolean new_win, char *barejid, char
#ifdef HAVE_LIBOTR
static void
_sv_ev_incoming_otr(ProfChatWin *chatwin, gboolean new_win, char *barejid, char *resource, char *message, GDateTime *timestamp)
_sv_ev_incoming_otr(ProfChatWin *chatwin, gboolean new_win, ProfMessage *message)
{
gboolean decrypted = FALSE;
char *otr_res = otr_on_message_recv(barejid, resource, message, &decrypted);
if (otr_res) {
message->plain = otr_on_message_recv(message->jid->barejid, message->jid->resourcepart, message->body, &decrypted);
if (message->plain) {
if (decrypted) {
chatwin_incoming_msg(chatwin, resource, otr_res, timestamp, new_win, PROF_MSG_OTR);
message->enc = PROF_MSG_ENC_OTR;
chatwin->pgp_send = FALSE;
} else {
chatwin_incoming_msg(chatwin, resource, otr_res, timestamp, new_win, PROF_MSG_PLAIN);
message->enc = PROF_MSG_ENC_PLAIN;
}
chat_log_otr_msg_in(barejid, otr_res, decrypted, timestamp);
otr_free_message(otr_res);
chatwin_incoming_msg(chatwin, message, new_win);
chat_log_otr_msg_in(message);
otr_free_message(message->plain);
message->plain = NULL;
chatwin->pgp_recv = FALSE;
}
}
@ -520,35 +528,36 @@ _sv_ev_incoming_otr(ProfChatWin *chatwin, gboolean new_win, char *barejid, char
#ifdef HAVE_OMEMO
static void
_sv_ev_incoming_omemo(ProfChatWin *chatwin, gboolean new_win, char *barejid, char *resource, char *message, GDateTime *timestamp)
_sv_ev_incoming_omemo(ProfChatWin *chatwin, gboolean new_win, ProfMessage *message)
{
chatwin_incoming_msg(chatwin, resource, message, timestamp, new_win, PROF_MSG_OMEMO);
chat_log_omemo_msg_in(barejid, message, timestamp);
chatwin_incoming_msg(chatwin, message, new_win);
chat_log_omemo_msg_in(message);
chatwin->pgp_recv = FALSE;
}
#endif
static void
_sv_ev_incoming_plain(ProfChatWin *chatwin, gboolean new_win, char *barejid, char *resource, char *message, GDateTime *timestamp)
_sv_ev_incoming_plain(ProfChatWin *chatwin, gboolean new_win, ProfMessage *message)
{
chatwin_incoming_msg(chatwin, resource, message, timestamp, new_win, PROF_MSG_PLAIN);
chat_log_msg_in(barejid, message, timestamp);
message->plain = strdup(message->body);
chatwin_incoming_msg(chatwin, message, new_win);
chat_log_msg_in(message);
chatwin->pgp_recv = FALSE;
}
void
sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_message, GDateTime *timestamp, gboolean omemo)
sv_ev_incoming_message(ProfMessage *message)
{
gboolean new_win = FALSE;
ProfChatWin *chatwin = wins_get_chat(barejid);
ProfChatWin *chatwin = wins_get_chat(message->jid->barejid);
if (!chatwin) {
ProfWin *window = wins_new_chat(barejid);
ProfWin *window = wins_new_chat(message->jid->barejid);
chatwin = (ProfChatWin*)window;
new_win = TRUE;
#ifdef HAVE_OMEMO
if (omemo_automatic_start(barejid)) {
omemo_start_session(barejid);
if (omemo_automatic_start(message->jid->barejid)) {
omemo_start_session(message->jid->barejid);
chatwin->is_omemo = TRUE;
}
#endif
@ -558,14 +567,14 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifdef HAVE_LIBOTR
#ifdef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
if (pgp_message) {
if (message->encrypted) {
if (chatwin->is_otr) {
win_println((ProfWin*)chatwin, THEME_DEFAULT, '-', "PGP encrypted message received whilst in OTR session.");
} else { // PROF_ENC_NONE, PROF_ENC_PGP
_sv_ev_incoming_pgp(chatwin, new_win, barejid, resource, message, pgp_message, timestamp);
} else {
_sv_ev_incoming_pgp(chatwin, new_win, message);
}
} else {
_sv_ev_incoming_otr(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_otr(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -577,7 +586,7 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifdef HAVE_LIBOTR
#ifndef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
_sv_ev_incoming_otr(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_otr(chatwin, new_win, message);
rosterwin_roster();
return;
#endif
@ -588,10 +597,10 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifndef HAVE_LIBOTR
#ifdef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
if (pgp_message) {
_sv_ev_incoming_pgp(chatwin, new_win, barejid, resource, message, pgp_message, timestamp);
if (message->encrypted) {
_sv_ev_incoming_pgp(chatwin, new_win, message);
} else {
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_plain(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -603,16 +612,16 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifdef HAVE_LIBOTR
#ifdef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (pgp_message) {
if (message->encrypted) {
if (chatwin->is_otr) {
win_println((ProfWin*)chatwin, THEME_DEFAULT, '-', "PGP encrypted message received whilst in OTR session.");
} else { // PROF_ENC_NONE, PROF_ENC_PGP
_sv_ev_incoming_pgp(chatwin, new_win, barejid, resource, message, pgp_message, timestamp);
} else {
_sv_ev_incoming_pgp(chatwin, new_win, message);
}
} else if (omemo) {
_sv_ev_incoming_omemo(chatwin, new_win, barejid, resource, message, timestamp);
} else if (message->enc == PROF_MSG_ENC_OMEMO) {
_sv_ev_incoming_omemo(chatwin, new_win, message);
} else {
_sv_ev_incoming_otr(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_otr(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -624,10 +633,10 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifdef HAVE_LIBOTR
#ifndef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (omemo) {
_sv_ev_incoming_omemo(chatwin, new_win, barejid, resource, message, timestamp);
if (message->enc == PROF_MSG_ENC_OMEMO) {
_sv_ev_incoming_omemo(chatwin, new_win, message);
} else {
_sv_ev_incoming_otr(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_otr(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -639,12 +648,12 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifndef HAVE_LIBOTR
#ifdef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (pgp_message) {
_sv_ev_incoming_pgp(chatwin, new_win, barejid, resource, message, pgp_message, timestamp);
} else if (omemo) {
_sv_ev_incoming_omemo(chatwin, new_win, barejid, resource, message, timestamp);
if (message->encrypted) {
_sv_ev_incoming_pgp(chatwin, new_win, message);
} else if (message->enc == PROF_MSG_ENC_OMEMO) {
_sv_ev_incoming_omemo(chatwin, new_win, message);
} else {
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_plain(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -656,10 +665,10 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifndef HAVE_LIBOTR
#ifndef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (omemo) {
_sv_ev_incoming_omemo(chatwin, new_win, barejid, resource, message, timestamp);
if (message->enc == PROF_MSG_ENC_OMEMO) {
_sv_ev_incoming_omemo(chatwin, new_win, message);
} else {
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_plain(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -671,7 +680,7 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
#ifndef HAVE_LIBOTR
#ifndef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, timestamp);
_sv_ev_incoming_plain(chatwin, new_win, message);
rosterwin_roster();
return;
#endif
@ -680,18 +689,18 @@ sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_m
}
void
sv_ev_incoming_carbon(char *barejid, char *resource, char *message, char *pgp_message, gboolean omemo)
sv_ev_incoming_carbon(ProfMessage *message)
{
gboolean new_win = FALSE;
ProfChatWin *chatwin = wins_get_chat(barejid);
ProfChatWin *chatwin = wins_get_chat(message->jid->barejid);
if (!chatwin) {
ProfWin *window = wins_new_chat(barejid);
ProfWin *window = wins_new_chat(message->jid->barejid);
chatwin = (ProfChatWin*)window;
new_win = TRUE;
#ifdef HAVE_OMEMO
if (omemo_automatic_start(barejid)) {
omemo_start_session(barejid);
if (omemo_automatic_start(message->jid->barejid)) {
omemo_start_session(message->jid->barejid);
chatwin->is_omemo = TRUE;
}
#endif
@ -699,10 +708,10 @@ sv_ev_incoming_carbon(char *barejid, char *resource, char *message, char *pgp_me
#ifdef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
if (pgp_message) {
_sv_ev_incoming_pgp(chatwin, new_win, barejid, resource, message, pgp_message, NULL);
if (message->encrypted) {
_sv_ev_incoming_pgp(chatwin, new_win, message);
} else {
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, NULL);
_sv_ev_incoming_plain(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -711,12 +720,12 @@ sv_ev_incoming_carbon(char *barejid, char *resource, char *message, char *pgp_me
#ifdef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (pgp_message) {
_sv_ev_incoming_pgp(chatwin, new_win, barejid, resource, message, pgp_message, NULL);
} else if (omemo) {
_sv_ev_incoming_omemo(chatwin, new_win, barejid, resource, message, NULL);
if (message->encrypted) {
_sv_ev_incoming_pgp(chatwin, new_win, message);
} else if (message->enc == PROF_MSG_ENC_OMEMO) {
_sv_ev_incoming_omemo(chatwin, new_win, message);
} else {
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, NULL);
_sv_ev_incoming_plain(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -725,10 +734,10 @@ sv_ev_incoming_carbon(char *barejid, char *resource, char *message, char *pgp_me
#ifndef HAVE_LIBGPGME
#ifdef HAVE_OMEMO
if (omemo) {
_sv_ev_incoming_omemo(chatwin, new_win, barejid, resource, message, NULL);
if (message->enc == PROF_MSG_ENC_OMEMO) {
_sv_ev_incoming_omemo(chatwin, new_win, message);
} else {
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, NULL);
_sv_ev_incoming_plain(chatwin, new_win, message);
}
rosterwin_roster();
return;
@ -737,7 +746,7 @@ sv_ev_incoming_carbon(char *barejid, char *resource, char *message, char *pgp_me
#ifndef HAVE_LIBGPGME
#ifndef HAVE_OMEMO
_sv_ev_incoming_plain(chatwin, new_win, barejid, resource, message, NULL);
_sv_ev_incoming_plain(chatwin, new_win, message);
rosterwin_roster();
return;
#endif

17
src/event/server_events.h
View File

@ -36,6 +36,7 @@
#define EVENT_SERVER_EVENTS_H
#include "xmpp/xmpp.h"
#include "xmpp/message.h"
void sv_ev_login_account_success(char *account_name, gboolean secured);
void sv_ev_lost_connection(void);
@ -45,13 +46,11 @@ void sv_ev_room_invite(jabber_invite_t invite_type,
const char *const reason, const char *const password);
void sv_ev_room_broadcast(const char *const room_jid, const char *const message);
void sv_ev_room_subject(const char *const room, const char *const nick, const char *const subject);
void sv_ev_room_history(const char *const room_jid, const char *const nick,
GDateTime *timestamp, const char *const message, gboolean omemo);
void sv_ev_room_message(const char *const room_jid, const char *const nick,
const char *const message, const char *const id, gboolean omemo);
void sv_ev_incoming_message(char *barejid, char *resource, char *message, char *pgp_message, GDateTime *timestamp, gboolean omemo);
void sv_ev_incoming_private_message(const char *const fulljid, char *message);
void sv_ev_delayed_private_message(const char *const fulljid, char *message, GDateTime *timestamp);
void sv_ev_room_history(ProfMessage *message);
void sv_ev_room_message(ProfMessage *message);
void sv_ev_incoming_message(ProfMessage *message);
void sv_ev_incoming_private_message(ProfMessage *message);
void sv_ev_delayed_private_message(ProfMessage *message);
void sv_ev_typing(char *barejid, char *resource);
void sv_ev_paused(char *barejid, char *resource);
void sv_ev_inactive(char *barejid, char *resource);
@ -73,8 +72,8 @@ void sv_ev_room_occupent_kicked(const char *const room, const char *const nick,
void sv_ev_room_banned(const char *const room, const char *const actor, const char *const reason);
void sv_ev_room_occupent_banned(const char *const room, const char *const nick, const char *const actor,
const char *const reason);
void sv_ev_outgoing_carbon(char *barejid, char *message, char *pgp_message, gboolean omemo);
void sv_ev_incoming_carbon(char *barejid, char *resource, char *message, char *pgp_message, gboolean omemo);
void sv_ev_outgoing_carbon(ProfMessage *message);
void sv_ev_incoming_carbon(ProfMessage *message);
void sv_ev_xmpp_stanza(const char *const msg);
void sv_ev_muc_self_online(const char *const room, const char *const nick, gboolean config_required,
const char *const role, const char *const affiliation, const char *const actor, const char *const reason,

24
src/log.c
View File

@ -329,16 +329,16 @@ chat_log_omemo_msg_out(const char *const barejid, const char *const msg)
}
void
chat_log_otr_msg_in(const char *const barejid, const char *const msg, gboolean was_decrypted, GDateTime *timestamp)
chat_log_otr_msg_in(ProfMessage *message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char *jid = connection_get_fulljid();
Jid *jidp = jid_create(jid);
char *pref_otr_log = prefs_get_string(PREF_OTR_LOG);
if (!was_decrypted || (strcmp(pref_otr_log, "on") == 0)) {
_chat_log_chat(jidp->barejid, barejid, msg, PROF_IN_LOG, timestamp);
if (message->enc == PROF_MSG_ENC_PLAIN || (strcmp(pref_otr_log, "on") == 0)) {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp);
} else if (strcmp(pref_otr_log, "redact") == 0) {
_chat_log_chat(jidp->barejid, barejid, "[redacted]", PROF_IN_LOG, timestamp);
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp);
}
prefs_free_string(pref_otr_log);
jid_destroy(jidp);
@ -346,16 +346,16 @@ chat_log_otr_msg_in(const char *const barejid, const char *const msg, gboolean w
}
void
chat_log_pgp_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp)
chat_log_pgp_msg_in(ProfMessage *message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char *jid = connection_get_fulljid();
Jid *jidp = jid_create(jid);
char *pref_pgp_log = prefs_get_string(PREF_PGP_LOG);
if (strcmp(pref_pgp_log, "on") == 0) {
_chat_log_chat(jidp->barejid, barejid, msg, PROF_IN_LOG, timestamp);
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp);
} else if (strcmp(pref_pgp_log, "redact") == 0) {
_chat_log_chat(jidp->barejid, barejid, "[redacted]", PROF_IN_LOG, timestamp);
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp);
}
prefs_free_string(pref_pgp_log);
jid_destroy(jidp);
@ -363,16 +363,16 @@ chat_log_pgp_msg_in(const char *const barejid, const char *const msg, GDateTime
}
void
chat_log_omemo_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp)
chat_log_omemo_msg_in(ProfMessage *message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char *jid = connection_get_fulljid();
Jid *jidp = jid_create(jid);
char *pref_omemo_log = prefs_get_string(PREF_OMEMO_LOG);
if (strcmp(pref_omemo_log, "on") == 0) {
_chat_log_chat(jidp->barejid, barejid, msg, PROF_IN_LOG, timestamp);
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp);
} else if (strcmp(pref_omemo_log, "redact") == 0) {
_chat_log_chat(jidp->barejid, barejid, "[redacted]", PROF_IN_LOG, timestamp);
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp);
}
prefs_free_string(pref_omemo_log);
jid_destroy(jidp);
@ -380,12 +380,12 @@ chat_log_omemo_msg_in(const char *const barejid, const char *const msg, GDateTim
}
void
chat_log_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp)
chat_log_msg_in(ProfMessage *message)
{
if (prefs_get_boolean(PREF_CHLOG)) {
const char *jid = connection_get_fulljid();
Jid *jidp = jid_create(jid);
_chat_log_chat(jidp->barejid, barejid, msg, PROF_IN_LOG, timestamp);
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp);
jid_destroy(jidp);
}
}

10
src/log.h
View File

@ -37,6 +37,8 @@
#include <glib.h>
#include "xmpp/message.h"
// log levels
typedef enum {
PROF_LEVEL_DEBUG,
@ -73,10 +75,10 @@ void chat_log_otr_msg_out(const char *const barejid, const char *const msg);
void chat_log_pgp_msg_out(const char *const barejid, const char *const msg);
void chat_log_omemo_msg_out(const char *const barejid, const char *const msg);
void chat_log_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp);
void chat_log_otr_msg_in(const char *const barejid, const char *const msg, gboolean was_decrypted, GDateTime *timestamp);
void chat_log_pgp_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp);
void chat_log_omemo_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp);
void chat_log_msg_in(ProfMessage *message);
void chat_log_otr_msg_in(ProfMessage *message);
void chat_log_pgp_msg_in(ProfMessage *message);
void chat_log_omemo_msg_in(ProfMessage *message);
void chat_log_close(void);
GSList* chat_log_get_previous(const gchar *const login, const gchar *const recipient);

9
src/omemo/omemo.c
View File

@ -724,6 +724,8 @@ omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_
GList *device_ids_iter;
omemo_ctx.identity_key_store.recv = false;
GList *recipients_iter;
for (recipients_iter = recipients; recipients_iter != NULL; recipients_iter = recipients_iter->next) {
GList *recipient_device_id = NULL;
@ -830,7 +832,7 @@ out:
char *
omemo_on_message_recv(const char *const from_jid, uint32_t sid,
const unsigned char *const iv, size_t iv_len, GList *keys,
const unsigned char *const payload, size_t payload_len, gboolean muc)
const unsigned char *const payload, size_t payload_len, gboolean muc, gboolean *trusted)
{
unsigned char *plaintext = NULL;
Jid *sender = NULL;
@ -888,6 +890,8 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid,
goto out;
}
omemo_ctx.identity_key_store.recv = true;
if (key->prekey) {
log_debug("OMEMO: decrypting message with prekey");
pre_key_signal_message *message;
@ -923,6 +927,9 @@ omemo_on_message_recv(const char *const from_jid, uint32_t sid,
}
}
omemo_ctx.identity_key_store.recv = false;
*trusted = omemo_ctx.identity_key_store.trusted_msg;
session_cipher_free(cipher);
if (res != 0) {
log_error("OMEMO: cannot decrypt message key");

2
src/omemo/omemo.h
View File

@ -91,4 +91,4 @@ void omemo_start_device_session(const char *const jid, uint32_t device_id, GList
gboolean omemo_loaded(void);
char * omemo_on_message_send(ProfWin *win, const char *const message, gboolean request_receipt, gboolean muc);
char * omemo_on_message_recv(const char *const from, uint32_t sid, const unsigned char *const iv, size_t iv_len, GList *keys, const unsigned char *const payload, size_t payload_len, gboolean muc);
char * omemo_on_message_recv(const char *const from, uint32_t sid, const unsigned char *const iv, size_t iv_len, GList *keys, const unsigned char *const payload, size_t payload_len, gboolean muc, gboolean *trusted);

20
src/omemo/store.c
View File

@ -362,6 +362,11 @@ save_identity(const signal_protocol_address *address, uint8_t *key_data,
{
identity_key_store_t *identity_key_store = (identity_key_store_t *)user_data;
if (identity_key_store->recv && !identity_key_store->trusted_msg) {
/* Do not trust identity automatically */
return SG_SUCCESS;
}
signal_buffer *buffer = signal_buffer_create(key_data, key_len);
GHashTable *trusted = g_hash_table_lookup(identity_key_store->trusted, strdup(address->name));
@ -392,7 +397,12 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data,
GHashTable *trusted = g_hash_table_lookup(identity_key_store->trusted, address->name);
if (!trusted) {
return 0;
if (identity_key_store->recv) {
identity_key_store->trusted_msg = false;
return 1;
} else {
return 0;
}
}
signal_buffer *buffer = signal_buffer_create(key_data, key_len);
@ -402,7 +412,13 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data,
signal_buffer_free(buffer);
return ret;
if (identity_key_store->recv) {
identity_key_store->trusted_msg = ret;
return 1;
} else {
return ret;
}
}
int

2
src/omemo/store.h
View File

@ -48,6 +48,8 @@ typedef struct {
signal_buffer *private;
uint32_t registration_id;
GHashTable *trusted;
bool recv;
bool trusted_msg;
} identity_key_store_t;
GHashTable * session_store_new(void);

4
src/otr/otr.c
View File

@ -347,7 +347,7 @@ otr_on_message_send(ProfChatWin *chatwin, const char *const message, gboolean re
if (encrypted) {
id = message_send_chat_otr(chatwin->barejid, encrypted, request_receipt);
chat_log_otr_msg_out(chatwin->barejid, message);
chatwin_outgoing_msg(chatwin, message, id, PROF_MSG_OTR, request_receipt);
chatwin_outgoing_msg(chatwin, message, id, PROF_MSG_ENC_OTR, request_receipt);
otr_free_message(encrypted);
free(id);
return TRUE;
@ -367,7 +367,7 @@ otr_on_message_send(ProfChatWin *chatwin, const char *const message, gboolean re
if (policy == PROF_OTRPOLICY_OPPORTUNISTIC) {
char *otr_tagged_msg = otr_tag_message(message);
id = message_send_chat_otr(chatwin->barejid, otr_tagged_msg, request_receipt);
chatwin_outgoing_msg(chatwin, message, id, PROF_MSG_PLAIN, request_receipt);
chatwin_outgoing_msg(chatwin, message, id, PROF_MSG_ENC_PLAIN, request_receipt);
chat_log_msg_out(chatwin->barejid, message);
free(otr_tagged_msg);
free(id);

10
src/plugins/api.c
View File

@ -471,12 +471,18 @@ api_settings_int_set(const char *const group, const char *const key, int value)
}
void
api_incoming_message(const char *const barejid, const char *const resource, const char *const message)
api_incoming_message(const char *const barejid, const char *const resource, const char *const plain)
{
sv_ev_incoming_message((char*)barejid, (char*)resource, (char*)message, NULL, NULL, FALSE);
ProfMessage *message = message_init();
message->jid = jid_create_from_bare_and_resource(barejid, resource);
message->plain = strdup(plain);
sv_ev_incoming_message(message);
// TODO handle all states
sv_ev_activity((char*)barejid, (char*)resource, FALSE);
message_free(message);
}
void

30
src/ui/chatwin.c
View File

@ -241,23 +241,24 @@ chatwin_recipient_gone(ProfChatWin *chatwin)
}
void
chatwin_incoming_msg(ProfChatWin *chatwin, const char *const resource, const char *const message, GDateTime *timestamp, gboolean win_created, prof_enc_t enc_mode)
chatwin_incoming_msg(ProfChatWin *chatwin, ProfMessage *message, gboolean win_created)
{
assert(chatwin != NULL);
char *old_plain = message->plain;
char *plugin_message = plugins_pre_chat_message_display(chatwin->barejid, resource, message);
message->plain = plugins_pre_chat_message_display(chatwin->barejid, message->jid->resourcepart, message->plain);
ProfWin *window = (ProfWin*)chatwin;
int num = wins_get_num(window);
char *display_name = roster_get_msg_display_name(chatwin->barejid, resource);
char *display_name = roster_get_msg_display_name(chatwin->barejid, message->jid->resourcepart);
gboolean is_current = wins_is_current(window);
gboolean notify = prefs_do_chat_notify(is_current);
// currently viewing chat window with sender
if (wins_is_current(window)) {
win_print_incoming(window, timestamp, display_name, plugin_message, enc_mode);
win_print_incoming(window, display_name, message);
title_bar_set_typing(FALSE);
status_bar_active(num, WIN_CHAT, chatwin->barejid);
@ -277,14 +278,14 @@ chatwin_incoming_msg(ProfChatWin *chatwin, const char *const resource, const cha
}
// show users status first, when receiving message via delayed delivery
if (timestamp && win_created) {
if (message->timestamp && win_created) {
PContact pcontact = roster_get_contact(chatwin->barejid);
if (pcontact) {
win_show_contact(window, pcontact);
}
}
win_print_incoming(window, timestamp, display_name, plugin_message, enc_mode);
win_print_incoming(window, display_name, message);
}
if (prefs_get_boolean(PREF_BEEP)) {
@ -292,14 +293,15 @@ chatwin_incoming_msg(ProfChatWin *chatwin, const char *const resource, const cha
}
if (notify) {
notify_message(display_name, num, plugin_message);
notify_message(display_name, num, message->plain);
}
free(display_name);
plugins_post_chat_message_display(chatwin->barejid, resource, plugin_message);
plugins_post_chat_message_display(chatwin->barejid, message->jid->resourcepart, message->plain);
free(plugin_message);
free(message->plain);
message->plain = old_plain;
}
void
@ -311,11 +313,11 @@ chatwin_outgoing_msg(ProfChatWin *chatwin, const char *const message, char *id,
char enc_char = '-';
if (chatwin->outgoing_char) {
enc_char = chatwin->outgoing_char[0];
} else if (enc_mode == PROF_MSG_OTR) {
} else if (enc_mode == PROF_MSG_ENC_OTR) {
enc_char = prefs_get_otr_char();
} else if (enc_mode == PROF_MSG_PGP) {
} else if (enc_mode == PROF_MSG_ENC_PGP) {
enc_char = prefs_get_pgp_char();
} else if (enc_mode == PROF_MSG_OMEMO) {
} else if (enc_mode == PROF_MSG_ENC_OMEMO) {
enc_char = prefs_get_omemo_char();
}
@ -332,9 +334,9 @@ chatwin_outgoing_carbon(ProfChatWin *chatwin, const char *const message, prof_en
assert(chatwin != NULL);
char enc_char = '-';
if (enc_mode == PROF_MSG_PGP) {
if (enc_mode == PROF_MSG_ENC_PGP) {
enc_char = prefs_get_pgp_char();
} else if (enc_mode == PROF_MSG_OMEMO) {
} else if (enc_mode == PROF_MSG_ENC_OMEMO) {
enc_char = prefs_get_omemo_char();
}

35
src/ui/mucwin.c
View File

@ -383,7 +383,7 @@ mucwin_history(ProfMucWin *mucwin, const char *const nick, GDateTime *timestamp,
}
static void
_mucwin_print_mention(ProfWin *window, const char *const message, const char *const from, const char *const mynick, GSList *mentions, const char *const ch)
_mucwin_print_mention(ProfWin *window, const char *const message, const char *const from, const char *const mynick, GSList *mentions, const char *const ch, int flags)
{
int last_pos = 0;
int pos = 0;
@ -393,11 +393,11 @@ _mucwin_print_mention(ProfWin *window, const char *const message, const char *co
char *before_str = g_strndup(message + last_pos, pos - last_pos);
if (strncmp(before_str, "/me ", 4) == 0) {
win_print_them(window, THEME_ROOMMENTION, *ch, "");
win_print_them(window, THEME_ROOMMENTION, *ch, flags, "");
win_append_highlight(window, THEME_ROOMMENTION, "*%s ", from);
win_append_highlight(window, THEME_ROOMMENTION, "%s", before_str + 4);
} else {
win_print_them(window, THEME_ROOMMENTION, *ch, from);
win_print_them(window, THEME_ROOMMENTION, *ch, flags, from);
win_append_highlight(window, THEME_ROOMMENTION, "%s", before_str);
}
g_free(before_str);
@ -512,11 +512,11 @@ mucwin_outgoing_msg(ProfMucWin *mucwin, const char *const message, const char *c
char ch = '-';
if (mucwin->message_char) {
ch = mucwin->message_char[0];
} else if (enc_mode == PROF_MSG_OTR) {
} else if (enc_mode == PROF_MSG_ENC_OTR) {
ch = prefs_get_otr_char();
} else if (enc_mode == PROF_MSG_PGP) {
} else if (enc_mode == PROF_MSG_ENC_PGP) {
ch = prefs_get_pgp_char();
} else if (enc_mode == PROF_MSG_OMEMO) {
} else if (enc_mode == PROF_MSG_ENC_OMEMO) {
ch = prefs_get_omemo_char();
}
@ -524,36 +524,41 @@ mucwin_outgoing_msg(ProfMucWin *mucwin, const char *const message, const char *c
}
void
mucwin_incoming_msg(ProfMucWin *mucwin, const char *const nick, const char *const message, const char *const id, GSList *mentions, GList *triggers, prof_enc_t enc_mode)
mucwin_incoming_msg(ProfMucWin *mucwin, ProfMessage *message, GSList *mentions, GList *triggers)
{
assert(mucwin != NULL);
int flags = 0;
if (id && g_hash_table_remove(mucwin->sent_messages, id)) {
if (message->id && g_hash_table_remove(mucwin->sent_messages, message->id)) {
/* Ignore reflection messages */
return;
}
if (!message->trusted) {
flags |= UNTRUSTED;
}
ProfWin *window = (ProfWin*)mucwin;
char *mynick = muc_nick(mucwin->roomjid);
char ch = '-';
if (mucwin->message_char) {
ch = mucwin->message_char[0];
} else if (enc_mode == PROF_MSG_OTR) {
} else if (message->enc == PROF_MSG_ENC_OTR) {
ch = prefs_get_otr_char();
} else if (enc_mode == PROF_MSG_PGP) {
} else if (message->enc == PROF_MSG_ENC_PGP) {
ch = prefs_get_pgp_char();
} else if (enc_mode == PROF_MSG_OMEMO) {
} else if (message->enc == PROF_MSG_ENC_OMEMO) {
ch = prefs_get_omemo_char();
}
if (g_slist_length(mentions) > 0) {
_mucwin_print_mention(window, message, nick, mynick, mentions, &ch);
_mucwin_print_mention(window, message->plain, message->jid->resourcepart, mynick, mentions, &ch, flags);
} else if (triggers) {
win_print_them(window, THEME_ROOMTRIGGER, ch, nick);
_mucwin_print_triggers(window, message, triggers);
win_print_them(window, THEME_ROOMTRIGGER, ch, flags, message->jid->resourcepart);
_mucwin_print_triggers(window, message->plain, triggers);
} else {
win_println_them_message(window, ch, nick, "%s", message);
win_println_them_message(window, ch, flags, message->jid->resourcepart, "%s", message->plain);
}
}

8
src/ui/privwin.c
View File

@ -43,7 +43,7 @@
#include "ui/window_list.h"
void
privwin_incoming_msg(ProfPrivateWin *privatewin, const char *const message, GDateTime *timestamp)
privwin_incoming_msg(ProfPrivateWin *privatewin, ProfMessage *message)
{
assert(privatewin != NULL);
@ -60,7 +60,7 @@ privwin_incoming_msg(ProfPrivateWin *privatewin, const char *const message, GDat
// currently viewing chat window with sender
if (wins_is_current(window)) {
win_print_incoming(window, timestamp, jidp->resourcepart, message, PROF_MSG_PLAIN);
win_print_incoming(window, jidp->resourcepart, message);
title_bar_set_typing(FALSE);
status_bar_active(num, WIN_PRIVATE, privatewin->fulljid);
@ -68,7 +68,7 @@ privwin_incoming_msg(ProfPrivateWin *privatewin, const char *const message, GDat
} else {
status_bar_new(num, WIN_PRIVATE, privatewin->fulljid);
cons_show_incoming_private_message(jidp->resourcepart, jidp->barejid, num, privatewin->unread);
win_print_incoming(window, timestamp, jidp->resourcepart, message, PROF_MSG_PLAIN);
win_print_incoming(window, jidp->resourcepart, message);
privatewin->unread++;
@ -82,7 +82,7 @@ privwin_incoming_msg(ProfPrivateWin *privatewin, const char *const message, GDat
}
if (notify) {
notify_message(jidp->resourcepart, num, message);
notify_message(jidp->resourcepart, num, message->plain);
}
jid_destroy(jidp);

15
src/ui/ui.h
View File

@ -41,6 +41,7 @@
#include "config/account.h"
#include "command/cmd_funcs.h"
#include "ui/win_types.h"
#include "xmpp/message.h"
#include "xmpp/muc.h"
#ifdef HAVE_LIBOTR
@ -52,13 +53,8 @@
#define NO_EOL 4
#define NO_COLOUR_FROM 8
#define NO_COLOUR_DATE 16
#define UNTRUSTED 32
typedef enum {
PROF_MSG_PLAIN,
PROF_MSG_OTR,
PROF_MSG_PGP,
PROF_MSG_OMEMO
} prof_enc_t;
// core UI
void ui_init(void);
@ -124,8 +120,7 @@ gboolean ui_win_has_unsaved_form(int num);
// Chat window
ProfChatWin* chatwin_new(const char *const barejid);
void chatwin_incoming_msg(ProfChatWin *chatwin, const char *const resource, const char *const message,
GDateTime *timestamp, gboolean win_created, prof_enc_t enc_mode);
void chatwin_incoming_msg(ProfChatWin *chatwin, ProfMessage *message, gboolean win_created);
void chatwin_receipt_received(ProfChatWin *chatwin, const char *const id);
void chatwin_recipient_gone(ProfChatWin *chatwin);
void chatwin_outgoing_msg(ProfChatWin *chatwin, const char *const message, char *id, prof_enc_t enc_mode,
@ -164,7 +159,7 @@ void mucwin_occupant_role_and_affiliation_change(ProfMucWin *mucwin, const char
void mucwin_roster(ProfMucWin *mucwin, GList *occupants, const char *const presence);
void mucwin_history(ProfMucWin *mucwin, const char *const nick, GDateTime *timestamp, const char *const message);
void mucwin_outgoing_msg(ProfMucWin *mucwin, const char *const message, const char *const id, prof_enc_t enc_mode);
void mucwin_incoming_msg(ProfMucWin *mucwin, const char *const nick, const char *const message, const char *const id, GSList *mentions, GList *triggers, prof_enc_t enc_mode);
void mucwin_incoming_msg(ProfMucWin *mucwin, ProfMessage *message, GSList *mentions, GList *triggers);
void mucwin_subject(ProfMucWin *mucwin, const char *const nick, const char *const subject);
void mucwin_requires_config(ProfMucWin *mucwin);
void mucwin_info(ProfMucWin *mucwin);
@ -202,7 +197,7 @@ void mucwin_set_message_char(ProfMucWin *mucwin, const char *const ch);
void mucwin_unset_message_char(ProfMucWin *mucwin);
// MUC private chat window
void privwin_incoming_msg(ProfPrivateWin *privatewin, const char *const message, GDateTime *timestamp);
void privwin_incoming_msg(ProfPrivateWin *privatewin, ProfMessage *message);
void privwin_outgoing_msg(ProfPrivateWin *privwin, const char *const message);
void privwin_message_occupant_offline(ProfPrivateWin *privwin);

32
src/ui/window.c
View File

@ -1044,10 +1044,14 @@ win_show_status_string(ProfWin *window, const char *const from,
}
void
win_print_incoming(ProfWin *window, GDateTime *timestamp,
const char *const from, const char *const message, prof_enc_t enc_mode)
win_print_incoming(ProfWin *window, const char *const from, ProfMessage *message)
{
char enc_char = '-';
int flags = NO_ME;
if (!message->trusted) {
flags |= UNTRUSTED;
}
switch (window->type)
{
@ -1056,18 +1060,18 @@ win_print_incoming(ProfWin *window, GDateTime *timestamp,
ProfChatWin *chatwin = (ProfChatWin*)window;
if (chatwin->incoming_char) {
enc_char = chatwin->incoming_char[0];
} else if (enc_mode == PROF_MSG_OTR) {
} else if (message->enc == PROF_MSG_ENC_OTR) {
enc_char = prefs_get_otr_char();
} else if (enc_mode == PROF_MSG_PGP) {
} else if (message->enc == PROF_MSG_ENC_PGP) {
enc_char = prefs_get_pgp_char();
} else if (enc_mode == PROF_MSG_OMEMO) {
} else if (message->enc == PROF_MSG_ENC_OMEMO) {
enc_char = prefs_get_omemo_char();
}
_win_printf(window, enc_char, 0, timestamp, NO_ME, THEME_TEXT_THEM, from, "%s", message);
_win_printf(window, enc_char, 0, message->timestamp, flags, THEME_TEXT_THEM, from, "%s", message->plain);
break;
}
case WIN_PRIVATE:
_win_printf(window, '-', 0, timestamp, NO_ME, THEME_TEXT_THEM, from, "%s", message);
_win_printf(window, '-', 0, message->timestamp, flags, THEME_TEXT_THEM, from, "%s", message->plain);
break;
default:
assert(FALSE);
@ -1076,13 +1080,13 @@ win_print_incoming(ProfWin *window, GDateTime *timestamp,
}
void
win_print_them(ProfWin *window, theme_item_t theme_item, char ch, const char *const them)
win_print_them(ProfWin *window, theme_item_t theme_item, char ch, int flags, const char *const them)
{
_win_printf(window, ch, 0, NULL, NO_ME | NO_EOL, theme_item, them, "");
_win_printf(window, ch, 0, NULL, flags | NO_ME | NO_EOL, theme_item, them, "");
}
void
win_println_them_message(ProfWin *window, char ch, const char *const them, const char *const message, ...)
win_println_them_message(ProfWin *window, char ch, int flags, const char *const them, const char *const message, ...)
{
GDateTime *timestamp = g_date_time_new_now_local();
@ -1091,9 +1095,9 @@ win_println_them_message(ProfWin *window, char ch, const char *const them, const
GString *fmt_msg = g_string_new(NULL);
g_string_vprintf(fmt_msg, message, arg);
buffer_append(window->layout->buffer, ch, 0, timestamp, NO_ME, THEME_TEXT_THEM, them, fmt_msg->str, NULL);
buffer_append(window->layout->buffer, ch, 0, timestamp, flags | NO_ME, THEME_TEXT_THEM, them, fmt_msg->str, NULL);
_win_print(window, ch, 0, timestamp, NO_ME, THEME_TEXT_THEM, them, fmt_msg->str, NULL);
_win_print(window, ch, 0, timestamp, flags | NO_ME, THEME_TEXT_THEM, them, fmt_msg->str, NULL);
inp_nonblocking(TRUE);
g_date_time_unref(timestamp);
@ -1384,6 +1388,7 @@ _win_print(ProfWin *window, const char show_char, int pad_indent, GDateTime *tim
// 3rd bit = 0/1 - eol/no eol
// 4th bit = 0/1 - color from/no color from
// 5th bit = 0/1 - color date/no date
// 6th bit = 0/1 - trusted/untrusted
gboolean me_message = FALSE;
int offset = 0;
int colour = theme_attrs(THEME_ME);
@ -1466,6 +1471,9 @@ _win_print(ProfWin *window, const char show_char, int pad_indent, GDateTime *tim
if (receipt && !receipt->received) {
wbkgdset(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
wattron(window->layout->win, theme_attrs(THEME_RECEIPT_SENT));
} else if (flags & UNTRUSTED) {
wbkgdset(window->layout->win, theme_attrs(THEME_UNTRUSTED));
wattron(window->layout->win, theme_attrs(THEME_UNTRUSTED));
} else {
wbkgdset(window->layout->win, theme_attrs(theme_item));
wattron(window->layout->win, theme_attrs(theme_item));

7
src/ui/window.h
View File

@ -60,13 +60,12 @@ void win_show_status_string(ProfWin *window, const char *const from,
GDateTime *last_activity, const char *const pre,
const char *const default_show);
void win_print_them(ProfWin *window, theme_item_t theme_item, char ch, const char *const them);
void win_println_them_message(ProfWin *window, char ch, const char *const them, const char *const message, ...);
void win_print_them(ProfWin *window, theme_item_t theme_item, char ch, int flags, const char *const them);
void win_println_them_message(ProfWin *window, char ch, int flags, const char *const them, const char *const message, ...);
void win_println_me_message(ProfWin *window, char ch, const char *const me, const char *const message, ...);
void win_print_outgoing(ProfWin *window, const char ch, const char *const message, ...);
void win_print_incoming(ProfWin *window, GDateTime *timestamp,
const char *const from, const char *const message, prof_enc_t enc_mode);
void win_print_incoming(ProfWin *window, const char *const from, ProfMessage *message);
void win_print_history(ProfWin *window, GDateTime *timestamp, const char *const message, ...);
void win_print_http_upload(ProfWin *window, const char *const message, char *url);

241
src/xmpp/message.c
View File

@ -75,6 +75,7 @@ typedef struct p_message_handle_t {
} ProfMessageHandler;
static int _message_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata);
static void _private_chat_handler(xmpp_stanza_t *const stanza);
static void _handle_error(xmpp_stanza_t *const stanza);
static void _handle_groupchat(xmpp_stanza_t *const stanza);
@ -178,6 +179,53 @@ message_handlers_init(void)
pubsub_event_handlers = g_hash_table_new_full(g_str_hash, g_str_equal, free, free);
}
ProfMessage *
message_init(void)
{
ProfMessage *message = malloc(sizeof(ProfMessage));
message->jid = NULL;
message->id = NULL;
message->body = NULL;
message->encrypted = NULL;
message->plain = NULL;
message->enc = PROF_MSG_ENC_PLAIN;
message->timestamp = NULL;
return message;
}
void
message_free(ProfMessage *message)
{
xmpp_ctx_t *ctx = connection_get_ctx();
if (message->jid) {
jid_destroy(message->jid);
}
if (message->id) {
xmpp_free(ctx, message->id);
}
if (message->body) {
xmpp_free(ctx, message->body);
}
if (message->encrypted) {
xmpp_free(ctx, message->encrypted);
}
if (message->plain) {
free(message->plain);
}
if (message->timestamp) {
g_date_time_unref(message->timestamp);
}
free(message);
}
void
message_handlers_clear(void)
{
@ -696,7 +744,6 @@ static void
_handle_groupchat(xmpp_stanza_t *const stanza)
{
xmpp_ctx_t *ctx = connection_get_ctx();
char *message = NULL;
const char *id = xmpp_stanza_get_id(stanza);
@ -711,9 +758,10 @@ _handle_groupchat(xmpp_stanza_t *const stanza)
// handle room subject
xmpp_stanza_t *subject = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_SUBJECT);
if (subject) {
message = xmpp_stanza_get_text(subject);
sv_ev_room_subject(jid->barejid, jid->resourcepart, message);
xmpp_free(ctx, message);
char *subject_text;
subject_text = xmpp_stanza_get_text(subject);
sv_ev_room_subject(jid->barejid, jid->resourcepart, subject_text);
xmpp_free(ctx, subject_text);
jid_destroy(jid);
return;
@ -721,14 +769,15 @@ _handle_groupchat(xmpp_stanza_t *const stanza)
// handle room broadcasts
if (!jid->resourcepart) {
message = xmpp_message_get_body(stanza);
if (!message) {
char *broadcast;
broadcast = xmpp_message_get_body(stanza);
if (!broadcast) {
jid_destroy(jid);
return;
}
sv_ev_room_broadcast(room_jid, message);
xmpp_free(ctx, message);
sv_ev_room_broadcast(room_jid, broadcast);
xmpp_free(ctx, broadcast);
jid_destroy(jid);
return;
@ -747,32 +796,29 @@ _handle_groupchat(xmpp_stanza_t *const stanza)
return;
}
ProfMessage *message = message_init();
message->jid = jid;
message->id = strdup(id);
// check omemo encryption
gboolean omemo = FALSE;
#ifdef HAVE_OMEMO
message = omemo_receive_message(stanza);
omemo = message != NULL;
message->plain = omemo_receive_message(stanza, &message->trusted);
if (message->plain != NULL) {
message->enc = PROF_MSG_ENC_OMEMO;
}
#endif
if (!message) {
message = xmpp_message_get_body(stanza);
if (!message) {
jid_destroy(jid);
return;
}
}
message->body = xmpp_message_get_body(stanza);
// determine if the notifications happened whilst offline
GDateTime *timestamp = stanza_get_delay(stanza);
if (timestamp) {
sv_ev_room_history(jid->barejid, jid->resourcepart, timestamp, message, omemo);
g_date_time_unref(timestamp);
message->timestamp = stanza_get_delay(stanza);
if (message->timestamp) {
sv_ev_room_history(message);
} else {
sv_ev_room_message(jid->barejid, jid->resourcepart, message, id, omemo);
sv_ev_room_message(message);
}
xmpp_free(ctx, message);
jid_destroy(jid);
message_free(message);
}
void
@ -848,30 +894,38 @@ _receipt_request_handler(xmpp_stanza_t *const stanza)
jid_destroy(jid);
}
void
_private_chat_handler(xmpp_stanza_t *const stanza, const char *const fulljid)
static void
_private_chat_handler(xmpp_stanza_t *const stanza)
{
char *message = xmpp_message_get_body(stanza);
if (!message) {
return;
}
// standard chat message, use jid without resource
ProfMessage *message = message_init();
GDateTime *timestamp = stanza_get_delay(stanza);
if (timestamp) {
sv_ev_delayed_private_message(fulljid, message, timestamp);
g_date_time_unref(timestamp);
const gchar *from = xmpp_stanza_get_from(stanza);
message->jid = jid_create(from);
// check omemo encryption
#ifdef HAVE_OMEMO
message->plain = omemo_receive_message(stanza, &message->trusted);
if (message->plain != NULL) {
message->enc = PROF_MSG_ENC_OMEMO;
}
#endif
message->timestamp = stanza_get_delay(stanza);
message->body = xmpp_message_get_body(stanza);
if (message->timestamp) {
sv_ev_delayed_private_message(message);
} else {
sv_ev_incoming_private_message(fulljid, message);
sv_ev_incoming_private_message(message);
}
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_free(ctx, message);
message_free(message);
}
static gboolean
_handle_carbons(xmpp_stanza_t *const stanza)
{
char *message_txt = NULL;
xmpp_stanza_t *carbons = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CARBONS);
if (!carbons) {
return FALSE;
@ -899,27 +953,12 @@ _handle_carbons(xmpp_stanza_t *const stanza)
return TRUE;
}
xmpp_stanza_t *message = xmpp_stanza_get_child_by_name(forwarded, STANZA_NAME_MESSAGE);
if (!message) {
xmpp_stanza_t *message_stanza = xmpp_stanza_get_child_by_name(forwarded, STANZA_NAME_MESSAGE);
if (!message_stanza) {
log_warning("Carbon received with no message element");
return TRUE;
}
// check omemo encryption
gboolean omemo = FALSE;
#ifdef HAVE_OMEMO
message_txt = omemo_receive_message(message);
omemo = message_txt != NULL;
#endif
if (!message_txt) {
message_txt = xmpp_message_get_body(message);
if (!message_txt) {
log_warning("Carbon received with no message.");
return TRUE;
}
}
Jid *my_jid = jid_create(connection_get_fulljid());
const char *const stanza_from = xmpp_stanza_get_from(stanza);
if (g_strcmp0(my_jid->barejid, stanza_from) != 0) {
@ -927,8 +966,20 @@ _handle_carbons(xmpp_stanza_t *const stanza)
return TRUE;
}
const gchar *to = xmpp_stanza_get_to(message);
const gchar *from = xmpp_stanza_get_from(message);
ProfMessage *message = message_init();
// check omemo encryption
#ifdef HAVE_OMEMO
message->plain = omemo_receive_message(message_stanza, &message->trusted);
if (message->plain != NULL) {
message->enc = PROF_MSG_ENC_OMEMO;
}
#endif
message->body = xmpp_message_get_body(message_stanza);
const gchar *to = xmpp_stanza_get_to(message_stanza);
const gchar *from = xmpp_stanza_get_from(message_stanza);
// happens when receive a carbon of a self sent message
if (!to) to = from;
@ -937,27 +988,25 @@ _handle_carbons(xmpp_stanza_t *const stanza)
Jid *jid_to = jid_create(to);
// check for pgp encrypted message
char *enc_message = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(message, STANZA_NS_ENCRYPTED);
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(message_stanza, STANZA_NS_ENCRYPTED);
if (x) {
enc_message = xmpp_stanza_get_text(x);
message->encrypted = xmpp_stanza_get_text(x);
}
// if we are the recipient, treat as standard incoming message
if (g_strcmp0(my_jid->barejid, jid_to->barejid) == 0) {
sv_ev_incoming_carbon(jid_from->barejid, jid_from->resourcepart, message_txt, enc_message, omemo);
jid_destroy(jid_to);
message->jid = jid_from;
sv_ev_incoming_carbon(message);
// else treat as a sent message
} else {
sv_ev_outgoing_carbon(jid_to->barejid, message_txt, enc_message, omemo);
jid_destroy(jid_from);
message->jid = jid_to;
sv_ev_outgoing_carbon(message);
}
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_free(ctx, message_txt);
xmpp_free(ctx, enc_message);
jid_destroy(jid_from);
jid_destroy(jid_to);
message_free(message);
jid_destroy(my_jid);
return TRUE;
@ -966,7 +1015,6 @@ _handle_carbons(xmpp_stanza_t *const stanza)
static void
_handle_chat(xmpp_stanza_t *const stanza)
{
char *message = NULL;
// ignore if type not chat or absent
const char *type = xmpp_stanza_get_type(stanza);
if (!(g_strcmp0(type, "chat") == 0 || type == NULL)) {
@ -979,13 +1027,6 @@ _handle_chat(xmpp_stanza_t *const stanza)
return;
}
// check omemo encryption
gboolean omemo = FALSE;
#ifdef HAVE_OMEMO
message = omemo_receive_message(stanza);
omemo = message != NULL;
#endif
// ignore handled namespaces
xmpp_stanza_t *conf = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CONFERENCE);
xmpp_stanza_t *captcha = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CAPTCHA);
@ -1007,38 +1048,41 @@ _handle_chat(xmpp_stanza_t *const stanza)
// private message from chat room use full jid (room/nick)
if (muc_active(jid->barejid)) {
_private_chat_handler(stanza, jid->fulljid);
_private_chat_handler(stanza);
jid_destroy(jid);
return;
}
// standard chat message, use jid without resource
xmpp_ctx_t *ctx = connection_get_ctx();
GDateTime *timestamp = stanza_get_delay(stanza);
if (!message && body) {
message = xmpp_stanza_get_text(body);
ProfMessage *message = message_init();
message->jid = jid;
message->timestamp = stanza_get_delay(stanza);
if (body) {
message->body = xmpp_stanza_get_text(body);
}
if (message) {
char *enc_message = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_ENCRYPTED);
if (x) {
enc_message = xmpp_stanza_get_text(x);
}
sv_ev_incoming_message(jid->barejid, jid->resourcepart, message, enc_message, timestamp, omemo);
xmpp_free(ctx, enc_message);
// check omemo encryption
#ifdef HAVE_OMEMO
message->plain = omemo_receive_message(stanza, &message->trusted);
if (message->plain != NULL) {
message->enc = PROF_MSG_ENC_OMEMO;
}
#endif
xmpp_stanza_t *encrypted = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_ENCRYPTED);
if (encrypted) {
message->encrypted = xmpp_stanza_get_text(encrypted);
}
if (message->plain || message->body || message->encrypted) {
sv_ev_incoming_message(message);
_receipt_request_handler(stanza);
if (omemo) {
free(message);
} else {
xmpp_free(ctx, message);
}
}
// handle chat sessions and states
if (!timestamp && jid->resourcepart) {
if (!message->timestamp && jid->resourcepart) {
gboolean gone = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_GONE) != NULL;
gboolean typing = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_COMPOSING) != NULL;
gboolean paused = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_PAUSED) != NULL;
@ -1058,8 +1102,7 @@ _handle_chat(xmpp_stanza_t *const stanza)
}
}
if (timestamp) g_date_time_unref(timestamp);
jid_destroy(jid);
message_free(message);
}
static void

25
src/xmpp/message.h
View File

@ -35,9 +35,34 @@
#ifndef XMPP_MESSAGE_H
#define XMPP_MESSAGE_H
#include "xmpp/xmpp.h"
typedef enum {
PROF_MSG_ENC_PLAIN,
PROF_MSG_ENC_OTR,
PROF_MSG_ENC_PGP,
PROF_MSG_ENC_OMEMO
} prof_enc_t;
typedef struct prof_message_t {
Jid *jid;
char *id;
/* The raw body from xmpp message, either plaintext or OTR encrypted text */
char *body;
/* The encrypted message as for PGP */
char *encrypted;
/* The message that will be printed on screen and logs */
char *plain;
GDateTime *timestamp;
prof_enc_t enc;
gboolean trusted;
} ProfMessage;
typedef int(*ProfMessageCallback)(xmpp_stanza_t *const stanza, void *const userdata);
typedef void(*ProfMessageFreeCallback)(void *userdata);
ProfMessage *message_init(void);
void message_free(ProfMessage *message);
void message_handlers_init(void);
void message_handlers_clear(void);
void message_pubsub_event_handler_add(const char *const node, ProfMessageCallback func, ProfMessageFreeCallback free_func, void *userdata);

4
src/xmpp/omemo.c
View File

@ -237,7 +237,7 @@ omemo_start_device_session_handle_bundle(xmpp_stanza_t *const stanza, void *cons
}
char *
omemo_receive_message(xmpp_stanza_t *const stanza)
omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted)
{
const char *type = xmpp_stanza_get_type(stanza);
@ -312,7 +312,7 @@ skip:
char *plaintext = omemo_on_message_recv(from, sid, iv_raw, iv_len,
keys, payload_raw, payload_len,
g_strcmp0(type, STANZA_TYPE_GROUPCHAT) == 0);
g_strcmp0(type, STANZA_TYPE_GROUPCHAT) == 0, trusted);
g_list_free_full(keys, (GDestroyNotify)omemo_key_free);
g_free(iv_raw);

2
src/xmpp/omemo.h
View File

@ -8,4 +8,4 @@ void omemo_devicelist_request(const char * const jid);
void omemo_bundle_publish(gboolean first);
void omemo_bundle_request(const char * const jid, uint32_t device_id, ProfIqCallback func, ProfIqFreeCallback free_func, void *userdata);
int omemo_start_device_session_handle_bundle(xmpp_stanza_t *const stanza, void *const userdata);
char * omemo_receive_message(xmpp_stanza_t *const stanza);
char * omemo_receive_message(xmpp_stanza_t *const stanza, gboolean *trusted);

8
tests/unittests/log/stub_log.c
View File

@ -60,10 +60,10 @@ void chat_log_otr_msg_out(const char * const barejid, const char * const msg) {}
void chat_log_pgp_msg_out(const char * const barejid, const char * const msg) {}
void chat_log_omemo_msg_out(const char *const barejid, const char *const msg) {}
void chat_log_msg_in(const char * const barejid, const char * const msg, GDateTime *timestamp) {}
void chat_log_otr_msg_in(const char * const barejid, const char * const msg, gboolean was_decrypted, GDateTime *timestamp) {}
void chat_log_pgp_msg_in(const char * const barejid, const char * const msg, GDateTime *timestamp) {}
void chat_log_omemo_msg_in(const char *const barejid, const char *const msg, GDateTime *timestamp) {}
void chat_log_msg_in(ProfMessage *message) {}
void chat_log_otr_msg_in(ProfMessage *message) {}
void chat_log_pgp_msg_in(ProfMessage *message) {}
void chat_log_omemo_msg_in(ProfMessage *message) {}
void chat_log_close(void) {}
GSList * chat_log_get_previous(const gchar * const login,

6
tests/unittests/ui/stub_ui.c
View File

@ -152,10 +152,10 @@ void ui_contact_online(char *barejid, Resource *resource, GDateTime *last_activi
}
void ui_contact_typing(const char * const barejid, const char * const resource) {}
void chatwin_incoming_msg(ProfChatWin *chatwin, const char * const resource, const char * const message, GDateTime *timestamp, gboolean win_created, prof_enc_t enc_mode) {}
void chatwin_incoming_msg(ProfChatWin *chatwin, ProfMessage *message, gboolean win_created) {}
void chatwin_receipt_received(ProfChatWin *chatwin, const char * const id) {}
void privwin_incoming_msg(ProfPrivateWin *privatewin, const char * const message, GDateTime *timestamp) {}
void privwin_incoming_msg(ProfPrivateWin *privatewin, ProfMessage *message) {}
void ui_disconnected(void) {}
void chatwin_recipient_gone(ProfChatWin *chatwin) {}
@ -190,7 +190,7 @@ void mucwin_occupant_role_and_affiliation_change(ProfMucWin *mucwin, const char
const char * const affiliation, const char * const actor, const char * const reason) {}
void mucwin_roster(ProfMucWin *mucwin, GList *occupants, const char * const presence) {}
void mucwin_history(ProfMucWin *mucwin, const char * const nick, GDateTime *timestamp, const char * const message) {}
void mucwin_incoming_msg(ProfMucWin *mucwin, const char *const nick, const char *const message, const char *const id, GSList *mentions, GList *triggers, prof_enc_t enc_mode) {}
void mucwin_incoming_msg(ProfMucWin *mucwin, ProfMessage *message, GSList *mentions, GList *triggers) {}
void mucwin_outgoing_msg(ProfMucWin *mucwin, const char *const message, const char *const id, prof_enc_t enc_mode) {}
void mucwin_subject(ProfMucWin *mucwin, const char * const nick, const char * const subject) {}
void mucwin_requires_config(ProfMucWin *mucwin) {}

1
theme_template
View File

@ -76,6 +76,7 @@ roster.room.trigger=
roster.room.mention=
occupants.header=
receipt.sent=
untrusted=
[ui]
beep=

1
themes/boothj5
View File

@ -77,6 +77,7 @@ roster.room.mention=bold_cyan
roster.room.trigger=bold_blue
occupants.header=bold_yellow
receipt.sent=bold_black
receipt.sent=bold_red
[ui]
beep=false