aniani/profanity
1
0
Fork 0
mirror of https://github.com/profanity-im/profanity.git synced 2024-06-09 21:30:42 +00:00
Code

Add prof_message_t to wrap all message attributes

Browse Source 
Probably missing copy of body to plain in carbon and privmessage.
Only covers the incoming message path because goal is OMEMO decryption
of untrusted message.
Cover some of the log functions but not all.
This commit is contained in:
Paul Fariello 2019-06-17 06:23:40 +02:00
parent 3bb3cc625d
commit 44d16e9141
20 changed files with 419 additions and 345 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 \

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, int flags)
sv_ev_room_history(prof_message_t *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, int flags)
sv_ev_room_message(prof_message_t *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 (flags & MSG_ENC_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 (flags & MSG_ENC_OMEMO) {
mucwin_incoming_msg(mucwin, nick, new_message, id, mentions, triggers, flags);
} 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(prof_message_t *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(prof_message_t *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, prof_message_t *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, prof_message_t *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, prof_message_t *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, prof_message_t *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(prof_message_t *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(prof_message_t *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(prof_message_t *message);
void sv_ev_room_message(prof_message_t *message);
void sv_ev_incoming_message(prof_message_t *message);
void sv_ev_incoming_private_message(prof_message_t *message);
void sv_ev_delayed_private_message(prof_message_t *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(prof_message_t *message);
void sv_ev_incoming_carbon(prof_message_t *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(prof_message_t *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(prof_message_t *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(prof_message_t *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(prof_message_t *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(prof_message_t *message);
void chat_log_otr_msg_in(prof_message_t *message);
void chat_log_pgp_msg_in(prof_message_t *message);
void chat_log_omemo_msg_in(prof_message_t *message);
void chat_log_close(void);
GSList* chat_log_get_previous(const gchar *const login, const gchar *const recipient);

2
src/omemo/store.c
View File

@ -414,7 +414,7 @@ is_trusted_identity(const signal_protocol_address *address, uint8_t *key_data,
if (identity_key_store->recv) {
identity_key_store->trusted = ret;
identity_key_store->trusted_msg = ret;
return 1;
} else {
return ret;

2
src/omemo/store.h
View File

@ -49,7 +49,7 @@ typedef struct {
uint32_t registration_id;
GHashTable *trusted;
bool recv;
bool trusted;
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);
prof_message_t *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, prof_message_t *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, prof_message_t *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 |= NO_TRUST;
}
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, prof_message_t *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);

10
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,6 +53,8 @@
#define NO_EOL 4
#define NO_COLOUR_FROM 8
#define NO_COLOUR_DATE 16
#define NO_TRUST 32
// core UI
void ui_init(void);
@ -117,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, prof_message_t *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,
@ -157,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, prof_message_t *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);
@ -195,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, prof_message_t *message);
void privwin_outgoing_msg(ProfPrivateWin *privwin, const char *const message);
void privwin_message_occupant_offline(ProfPrivateWin *privwin);

27
src/ui/window.c
View File

@ -1044,14 +1044,13 @@ 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, prof_message_t *message)
{
char enc_char = '-';
int flags = NO_ME;
if (!trusted) {
flags != NO_TRUST;
if (!message->trusted) {
flags |= NO_TRUST;
}
switch (window->type)
@ -1061,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, flags, 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, flags, THEME_TEXT_THEM, from, "%s", message);
_win_printf(window, '-', 0, message->timestamp, flags, THEME_TEXT_THEM, from, "%s", message->plain);
break;
default:
assert(FALSE);
@ -1081,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();
@ -1096,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);

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, prof_message_t *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);

252
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);
}
prof_message_t *
message_init(void)
{
prof_message_t *message = malloc(sizeof(prof_message_t));
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(prof_message_t *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,8 +744,6 @@ static void
_handle_groupchat(xmpp_stanza_t *const stanza)
{
xmpp_ctx_t *ctx = connection_get_ctx();
int flags = 0;
char *message = NULL;
const char *id = xmpp_stanza_get_id(stanza);
@ -712,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;
@ -722,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;
@ -748,37 +796,29 @@ _handle_groupchat(xmpp_stanza_t *const stanza)
return;
}
prof_message_t *message = message_init();
message->jid = jid;
message->id = strdup(id);
// check omemo encryption
#ifdef HAVE_OMEMO
gboolean trusted = FALSE;
message = omemo_receive_message(stanza, &trusted);
if (message != NULL) {
flags |= MSG_ENC_OMEMO;
if (trusted) {
flags |= MSG_TRUSTED;
}
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, flags);
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, flags);
sv_ev_room_message(message);
}
xmpp_free(ctx, message);
jid_destroy(jid);
message_free(message);
}
void
@ -854,31 +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
prof_message_t *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;
int flags = 0;
xmpp_stanza_t *carbons = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CARBONS);
if (!carbons) {
return FALSE;
@ -906,32 +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
#ifdef HAVE_OMEMO
gboolean trusted = FALSE;
message_txt = omemo_receive_message(message, &trusted);
if (message_txt != NULL) {
flags != MSG_ENC_OMEMO;
if (trusted) {
flags |= MSG_TRUSTED;
}
}
#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) {
@ -939,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);
prof_message_t *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;
@ -949,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, flags);
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, flags);
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;
@ -978,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)) {
@ -991,14 +1027,6 @@ _handle_chat(xmpp_stanza_t *const stanza)
return;
}
// check omemo encryption
gboolean omemo = FALSE;
gboolean trusted = FALSE;
#ifdef HAVE_OMEMO
message = omemo_receive_message(stanza, &trusted);
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);
@ -1020,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);
prof_message_t *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, trusted);
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;
@ -1071,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

28
src/xmpp/message.h
View File

@ -35,14 +35,34 @@
#ifndef XMPP_MESSAGE_H
#define XMPP_MESSAGE_H
#define PROF_MSG_ENC_OTR 1
#define PROF_MSG_ENC_PGP 2
#define PROF_MSG_ENC_OMEMO 4
#define PROF_MSG_TRUSTED 8
#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 {
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;
} prof_message_t;
typedef int(*ProfMessageCallback)(xmpp_stanza_t *const stanza, void *const userdata);
typedef void(*ProfMessageFreeCallback)(void *userdata);
prof_message_t *message_init(void);
void message_free(prof_message_t *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);

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(prof_message_t *message) {}
void chat_log_otr_msg_in(prof_message_t *message) {}
void chat_log_pgp_msg_in(prof_message_t *message) {}
void chat_log_omemo_msg_in(prof_message_t *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, prof_message_t *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, prof_message_t *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, prof_message_t *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) {}