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 #1306 from profanity-im/feature/mam

Browse Source 
Add basic MAM support
This commit is contained in:
Michael Vetter 2020-04-13 10:50:18 +02:00 committed by GitHub
commit a800bfcbf8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 302 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/config/preferences.c
View File

@ -1799,6 +1799,7 @@ _get_group(preference_t pref)
case PREF_REVEAL_OS:
case PREF_TLS_CERTPATH:
case PREF_CORRECTION_ALLOW:
case PREF_MAM:
return PREF_GROUP_CONNECTION;
case PREF_OTR_LOG:
case PREF_OTR_POLICY:
@ -2070,6 +2071,8 @@ _get_key(preference_t pref)
return "avatar.cmd";
case PREF_SLASH_GUARD:
return "slashguard";
case PREF_MAM:
return "mam";
default:
return NULL;
}

1
src/config/preferences.h
View File

@ -170,6 +170,7 @@ typedef enum {
PREF_HISTORY_COLOR_MUC,
PREF_AVATAR_CMD,
PREF_SLASH_GUARD,
PREF_MAM,
} preference_t;
typedef struct prof_alias_t {

9
src/database.c
View File

@ -166,7 +166,7 @@ log_database_add_incoming(ProfMessage *message)
const char *jid = connection_get_fulljid();
Jid *myjid = jid_create(jid);
_add_to_db(message, NULL, message->jid, myjid);
_add_to_db(message, NULL, message->from_jid, myjid);
jid_destroy(myjid);
}
@ -177,7 +177,7 @@ _log_database_add_outgoing(char *type, const char * const id, const char * const
ProfMessage *msg = message_init();
msg->id = id ? strdup(id) : NULL;
msg->jid = jid_create(barejid);
msg->from_jid = jid_create(barejid);
msg->plain = message ? strdup(message) : NULL;
msg->replace_id = replace_id ? strdup(replace_id) : NULL;
msg->timestamp = g_date_time_new_now_local(); //TODO: get from outside. best to have whole ProfMessage from outside
@ -186,7 +186,7 @@ _log_database_add_outgoing(char *type, const char * const id, const char * const
const char *jid = connection_get_fulljid();
Jid *myjid = jid_create(jid);
_add_to_db(msg, type, myjid, msg->jid);
_add_to_db(msg, type, myjid, msg->from_jid); // TODO: myjid now in profmessage
jid_destroy(myjid);
message_free(msg);
@ -234,13 +234,14 @@ log_database_get_previous_chat(const gchar *const contact_barejid)
GSList *history = NULL;
while( sqlite3_step(stmt) == SQLITE_ROW ) {
// TODO: also save to jid. since now part of profmessage
char *message = (char*)sqlite3_column_text(stmt, 0);
char *date = (char*)sqlite3_column_text(stmt, 1);
char *from = (char*)sqlite3_column_text(stmt, 2);
char *type = (char*)sqlite3_column_text(stmt, 3);
ProfMessage *msg = message_init();
msg->jid = jid_create(from);
msg->from_jid = jid_create(from);
msg->plain = strdup(message);
msg->timestamp = g_date_time_new_from_iso8601(date, NULL);
msg->type = _get_message_type_type(type);

82
src/event/server_events.c
View File

@ -275,7 +275,7 @@ sv_ev_room_subject(const char *const room, const char *const nick, const char *c
void
sv_ev_room_history(ProfMessage *message)
{
ProfMucWin *mucwin = wins_get_muc(message->jid->barejid);
ProfMucWin *mucwin = wins_get_muc(message->from_jid->barejid);
if (mucwin) {
// if this is the first successful connection
if (ev_is_first_connect()) {
@ -297,9 +297,9 @@ sv_ev_room_history(ProfMessage *message)
static void _log_muc(ProfMessage *message)
{
if (message->enc == PROF_MSG_ENC_OMEMO) {
groupchat_log_omemo_msg_in(message->jid->barejid, message->jid->resourcepart, message->plain);
groupchat_log_omemo_msg_in(message->from_jid->barejid, message->from_jid->resourcepart, message->plain);
} else {
groupchat_log_msg_in(message->jid->barejid, message->jid->resourcepart, message->plain);
groupchat_log_msg_in(message->from_jid->barejid, message->from_jid->resourcepart, message->plain);
}
log_database_add_incoming(message);
}
@ -307,7 +307,7 @@ static void _log_muc(ProfMessage *message)
void
sv_ev_room_message(ProfMessage *message)
{
ProfMucWin *mucwin = wins_get_muc(message->jid->barejid);
ProfMucWin *mucwin = wins_get_muc(message->from_jid->barejid);
if (!mucwin) {
return;
}
@ -316,12 +316,12 @@ sv_ev_room_message(ProfMessage *message)
// only log message not coming from this client (but maybe same account, different client)
// our messages are logged when outgoing
if (!(g_strcmp0(mynick, message->jid->resourcepart) == 0 && message_is_sent_by_us(message, TRUE))) {
if (!(g_strcmp0(mynick, message->from_jid->resourcepart) == 0 && message_is_sent_by_us(message, TRUE))) {
_log_muc(message);
}
char *old_plain = message->plain;
message->plain = plugins_pre_room_message_display(message->jid->barejid, message->jid->resourcepart, message->plain);
message->plain = plugins_pre_room_message_display(message->from_jid->barejid, message->from_jid->resourcepart, message->plain);
GSList *mentions = get_mentions(prefs_get_boolean(PREF_NOTIFY_MENTION_WHOLE_WORD), prefs_get_boolean(PREF_NOTIFY_MENTION_CASE_SENSITIVE), message->plain, mynick);
gboolean mention = g_slist_length(mentions) > 0;
@ -341,7 +341,7 @@ sv_ev_room_message(ProfMessage *message)
is_current = TRUE;
status_bar_active(num, WIN_MUC, mucwin->roomjid);
if ((g_strcmp0(mynick, message->jid->resourcepart) != 0) && (prefs_get_boolean(PREF_BEEP))) {
if ((g_strcmp0(mynick, message->from_jid->resourcepart) != 0) && (prefs_get_boolean(PREF_BEEP))) {
beep();
}
@ -349,11 +349,11 @@ sv_ev_room_message(ProfMessage *message)
} else {
status_bar_new(num, WIN_MUC, mucwin->roomjid);
if ((g_strcmp0(mynick, message->jid->resourcepart) != 0) && (prefs_get_boolean(PREF_FLASH))) {
if ((g_strcmp0(mynick, message->from_jid->resourcepart) != 0) && (prefs_get_boolean(PREF_FLASH))) {
flash();
}
cons_show_incoming_room_message(message->jid->resourcepart, mucwin->roomjid, num, mention, triggers, mucwin->unread);
cons_show_incoming_room_message(message->from_jid->resourcepart, mucwin->roomjid, num, mention, triggers, mucwin->unread);
mucwin->unread++;
@ -371,9 +371,9 @@ sv_ev_room_message(ProfMessage *message)
}
mucwin->last_msg_timestamp = g_date_time_new_now_local();
if (prefs_do_room_notify(is_current, mucwin->roomjid, mynick, message->jid->resourcepart, message->plain, mention, triggers != NULL)) {
if (prefs_do_room_notify(is_current, mucwin->roomjid, mynick, message->from_jid->resourcepart, message->plain, mention, triggers != NULL)) {
Jid *jidp = jid_create(mucwin->roomjid);
notify_room_message(message->jid->resourcepart, jidp->localpart, num, message->plain);
notify_room_message(message->from_jid->resourcepart, jidp->localpart, num, message->plain);
jid_destroy(jidp);
}
@ -383,7 +383,7 @@ sv_ev_room_message(ProfMessage *message)
rosterwin_roster();
plugins_post_room_message_display(message->jid->barejid, message->jid->resourcepart, message->plain);
plugins_post_room_message_display(message->from_jid->barejid, message->from_jid->resourcepart, message->plain);
free(message->plain);
message->plain = old_plain;
}
@ -392,11 +392,11 @@ void
sv_ev_incoming_private_message(ProfMessage *message)
{
char *old_plain = message->plain;
message->plain = plugins_pre_priv_message_display(message->jid->fulljid, message->plain);
message->plain = plugins_pre_priv_message_display(message->from_jid->fulljid, message->plain);
ProfPrivateWin *privatewin = wins_get_private(message->jid->fulljid);
ProfPrivateWin *privatewin = wins_get_private(message->from_jid->fulljid);
if (privatewin == NULL) {
ProfWin *window = wins_new_private(message->jid->fulljid);
ProfWin *window = wins_new_private(message->from_jid->fulljid);
privatewin = (ProfPrivateWin*)window;
}
@ -405,7 +405,7 @@ sv_ev_incoming_private_message(ProfMessage *message)
log_database_add_incoming(message);
chat_log_msg_in(message);
plugins_post_priv_message_display(message->jid->fulljid, message->plain);
plugins_post_priv_message_display(message->from_jid->fulljid, message->plain);
free(message->plain);
message->plain = old_plain;
@ -416,11 +416,11 @@ void
sv_ev_delayed_private_message(ProfMessage *message)
{
char *old_plain = message->plain;
message->plain = plugins_pre_priv_message_display(message->jid->fulljid, message->plain);
message->plain = plugins_pre_priv_message_display(message->from_jid->fulljid, message->plain);
ProfPrivateWin *privatewin = wins_get_private(message->jid->fulljid);
ProfPrivateWin *privatewin = wins_get_private(message->from_jid->fulljid);
if (privatewin == NULL) {
ProfWin *window = wins_new_private(message->jid->fulljid);
ProfWin *window = wins_new_private(message->from_jid->fulljid);
privatewin = (ProfPrivateWin*)window;
}
@ -428,7 +428,7 @@ sv_ev_delayed_private_message(ProfMessage *message)
privwin_incoming_msg(privatewin, message);
chat_log_msg_in(message);
plugins_post_priv_message_display(message->jid->fulljid, message->plain);
plugins_post_priv_message_display(message->from_jid->fulljid, message->plain);
free(message->plain);
message->plain = old_plain;
@ -437,19 +437,20 @@ sv_ev_delayed_private_message(ProfMessage *message)
void
sv_ev_outgoing_carbon(ProfMessage *message)
{
ProfChatWin *chatwin = wins_get_chat(message->jid->barejid);
ProfChatWin *chatwin = wins_get_chat(message->from_jid->barejid);
if (!chatwin) {
chatwin = chatwin_new(message->jid->barejid);
chatwin = chatwin_new(message->from_jid->barejid);
}
chat_state_active(chatwin->state);
//TODO: check whether we need to change from and to for carbon. now that we have profmessage->to_jid?
if (message->plain) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
// MUC PM, should have resource (nick) in filename
chat_log_msg_out(message->jid->barejid, message->plain, message->jid->resourcepart);
chat_log_msg_out(message->from_jid->barejid, message->plain, message->from_jid->resourcepart);
} else {
chat_log_msg_out(message->jid->barejid, message->plain, NULL);
chat_log_msg_out(message->from_jid->barejid, message->plain, NULL);
}
}
@ -566,7 +567,7 @@ static void
_sv_ev_incoming_otr(ProfChatWin *chatwin, gboolean new_win, ProfMessage *message)
{
gboolean decrypted = FALSE;
message->plain = otr_on_message_recv(message->jid->barejid, message->jid->resourcepart, message->body, &decrypted);
message->plain = otr_on_message_recv(message->from_jid->barejid, message->from_jid->resourcepart, message->body, &decrypted);
if (message->plain) {
if (decrypted) {
message->enc = PROF_MSG_ENC_OTR;
@ -621,17 +622,31 @@ void
sv_ev_incoming_message(ProfMessage *message)
{
gboolean new_win = FALSE;
ProfChatWin *chatwin = wins_get_chat(message->jid->barejid);
ProfChatWin *chatwin;
char *looking_for_jid = message->from_jid->barejid;
if (message->is_mam) {
Jid *my_jid = jid_create(connection_get_fulljid());
if (g_strcmp0(my_jid->barejid, message->from_jid->barejid) == 0) {
looking_for_jid = message->to_jid->barejid;
}
jid_destroy(my_jid);
}
chatwin = wins_get_chat(looking_for_jid);
if (!chatwin) {
ProfWin *window = wins_new_chat(message->jid->barejid);
ProfWin *window = wins_new_chat(looking_for_jid);
chatwin = (ProfChatWin*)window;
new_win = TRUE;
#ifdef HAVE_OMEMO
if (omemo_automatic_start(message->jid->barejid)) {
omemo_start_session(message->jid->barejid);
if (!message->is_mam) {
if (omemo_automatic_start(message->from_jid->barejid)) {
omemo_start_session(message->from_jid->barejid);
chatwin->is_omemo = TRUE;
}
}
#endif
}
@ -763,16 +778,17 @@ sv_ev_incoming_message(ProfMessage *message)
void
sv_ev_incoming_carbon(ProfMessage *message)
{
//TODO: check whether we need to change from and to for carbon. now that we have profmessage->to_jid?
gboolean new_win = FALSE;
ProfChatWin *chatwin = wins_get_chat(message->jid->barejid);
ProfChatWin *chatwin = wins_get_chat(message->from_jid->barejid);
if (!chatwin) {
ProfWin *window = wins_new_chat(message->jid->barejid);
ProfWin *window = wins_new_chat(message->from_jid->barejid);
chatwin = (ProfChatWin*)window;
new_win = TRUE;
#ifdef HAVE_OMEMO
if (omemo_automatic_start(message->jid->barejid)) {
omemo_start_session(message->jid->barejid);
if (omemo_automatic_start(message->from_jid->barejid)) {
omemo_start_session(message->from_jid->barejid);
chatwin->is_omemo = TRUE;
}
#endif

28
src/log.c
View File

@ -357,15 +357,15 @@ chat_log_otr_msg_in(ProfMessage *message)
char *pref_otr_log = prefs_get_string(PREF_OTR_LOG);
if (message->enc == PROF_MSG_ENC_NONE || (strcmp(pref_otr_log, "on") == 0)) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
} else if (strcmp(pref_otr_log, "redact") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, NULL);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, NULL);
}
}
prefs_free_string(pref_otr_log);
@ -382,15 +382,15 @@ chat_log_pgp_msg_in(ProfMessage *message)
char *pref_pgp_log = prefs_get_string(PREF_PGP_LOG);
if (strcmp(pref_pgp_log, "on") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
} else if (strcmp(pref_pgp_log, "redact") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, NULL);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, NULL);
}
}
prefs_free_string(pref_pgp_log);
@ -407,15 +407,15 @@ chat_log_omemo_msg_in(ProfMessage *message)
char *pref_omemo_log = prefs_get_string(PREF_OMEMO_LOG);
if (strcmp(pref_omemo_log, "on") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
} else if (strcmp(pref_omemo_log, "redact") == 0) {
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, "[redacted]", PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
}
}
prefs_free_string(pref_omemo_log);
@ -431,9 +431,9 @@ chat_log_msg_in(ProfMessage *message)
Jid *jidp = jid_create(jid);
if (message->type == PROF_MSG_TYPE_MUCPM) {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->jid->resourcepart);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, message->from_jid->resourcepart);
} else {
_chat_log_chat(jidp->barejid, message->jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
_chat_log_chat(jidp->barejid, message->from_jid->barejid, message->plain, PROF_IN_LOG, message->timestamp, NULL);
}
jid_destroy(jidp);
}

2
src/plugins/api.c
View File

@ -475,7 +475,7 @@ void
api_incoming_message(const char *const barejid, const char *const resource, const char *const plain)
{
ProfMessage *message = message_init();
message->jid = jid_create_from_bare_and_resource(barejid, resource);
message->from_jid = jid_create_from_bare_and_resource(barejid, resource);
message->plain = strdup(plain);
sv_ev_incoming_message(message);

25
src/ui/chatwin.c
View File

@ -66,7 +66,7 @@ chatwin_new(const char *const barejid)
ProfWin *window = wins_new_chat(barejid);
ProfChatWin *chatwin = (ProfChatWin *)window;
if (prefs_get_boolean(PREF_CHLOG) && prefs_get_boolean(PREF_HISTORY)) {
if (!prefs_get_boolean(PREF_MAM) && prefs_get_boolean(PREF_CHLOG) && prefs_get_boolean(PREF_HISTORY)) {
_chatwin_history(chatwin, barejid);
}
@ -87,6 +87,9 @@ chatwin_new(const char *const barejid)
}
#endif
if (prefs_get_boolean(PREF_MAM)) {
iq_mam_request(chatwin);
}
return chatwin;
}
@ -250,12 +253,19 @@ chatwin_incoming_msg(ProfChatWin *chatwin, ProfMessage *message, gboolean win_cr
assert(chatwin != NULL);
char *old_plain = message->plain;
message->plain = plugins_pre_chat_message_display(chatwin->barejid, message->jid->resourcepart, message->plain);
message->plain = plugins_pre_chat_message_display(message->from_jid->barejid, message->from_jid->resourcepart, message->plain);
ProfWin *window = (ProfWin*)chatwin;
int num = wins_get_num(window);
char *display_name = roster_get_msg_display_name(chatwin->barejid, message->jid->resourcepart);
char *display_name;
Jid *my_jid = jid_create(connection_get_fulljid());
if (g_strcmp0(my_jid->barejid, message->from_jid->barejid) == 0) {
display_name = strdup("me");
} else {
display_name = roster_get_msg_display_name(message->from_jid->barejid, message->from_jid->resourcepart);
}
jid_destroy(my_jid);
gboolean is_current = wins_is_current(window);
gboolean notify = prefs_do_chat_notify(is_current);
@ -277,7 +287,12 @@ chatwin_incoming_msg(ProfChatWin *chatwin, ProfMessage *message, gboolean win_cr
chatwin->unread++;
if (prefs_get_boolean(PREF_CHLOG) && prefs_get_boolean(PREF_HISTORY)) {
//TODO: so far we don't ask for MAM when incoming message occurs.
//Need to figure out:
//1) only send IQ once
//2) sort incoming messages on timestamp
//for now if experimental MAM is enabled we dont show no history from sql either
if (!prefs_get_boolean(PREF_MAM) && prefs_get_boolean(PREF_CHLOG) && prefs_get_boolean(PREF_HISTORY)) {
_chatwin_history(chatwin, chatwin->barejid);
}
@ -303,7 +318,7 @@ chatwin_incoming_msg(ProfChatWin *chatwin, ProfMessage *message, gboolean win_cr
free(display_name);
plugins_post_chat_message_display(chatwin->barejid, message->jid->resourcepart, message->plain);
plugins_post_chat_message_display(message->from_jid->barejid, message->from_jid->resourcepart, message->plain);
free(message->plain);
message->plain = old_plain;

6
src/ui/mucwin.c
View File

@ -366,7 +366,7 @@ mucwin_history(ProfMucWin *mucwin, const ProfMessage *const message)
assert(mucwin != NULL);
ProfWin *window = (ProfWin*)mucwin;
char *nick = message->jid->resourcepart;
char *nick = message->from_jid->resourcepart;
// 'unanimous' all in one color (like always was)
// 'regular' colored like new messages too
@ -570,9 +570,9 @@ mucwin_incoming_msg(ProfMucWin *mucwin, const ProfMessage *const message, GSList
win_insert_last_read_position_marker((ProfWin*)mucwin, mucwin->roomjid);
if (g_slist_length(mentions) > 0) {
_mucwin_print_mention(window, message->plain, message->jid->resourcepart, mynick, mentions, ch, flags);
_mucwin_print_mention(window, message->plain, message->from_jid->resourcepart, mynick, mentions, ch, flags);
} else if (triggers) {
win_print_them(window, THEME_ROOMTRIGGER, ch, flags, message->jid->resourcepart);
win_print_them(window, THEME_ROOMTRIGGER, ch, flags, message->from_jid->resourcepart);
_mucwin_print_triggers(window, message->plain, triggers);
} else {
win_println_incoming_muc_msg(window, ch, flags, message);

16
src/ui/window.c
View File

@ -1150,16 +1150,16 @@ win_print_incoming(ProfWin *window, const char *const display_name_from, ProfMes
}
if (prefs_get_boolean(PREF_CORRECTION_ALLOW) && message->replace_id) {
_win_correct(window, message->plain, message->id, message->replace_id, message->jid->barejid);
_win_correct(window, message->plain, message->id, message->replace_id, message->from_jid->barejid);
} else {
_win_printf(window, enc_char, 0, message->timestamp, flags, THEME_TEXT_THEM, display_name_from, message->jid->barejid, message->id, "%s", message->plain);
_win_printf(window, enc_char, 0, message->timestamp, flags, THEME_TEXT_THEM, display_name_from, message->from_jid->barejid, message->id, "%s", message->plain);
}
free(enc_char);
break;
}
case WIN_PRIVATE:
_win_printf(window, "-", 0, message->timestamp, flags, THEME_TEXT_THEM, display_name_from, message->jid->barejid, message->id, "%s", message->plain);
_win_printf(window, "-", 0, message->timestamp, flags, THEME_TEXT_THEM, display_name_from, message->from_jid->barejid, message->id, "%s", message->plain);
break;
default:
assert(FALSE);
@ -1177,9 +1177,9 @@ void
win_println_incoming_muc_msg(ProfWin *window, char *show_char, int flags, const ProfMessage *const message)
{
if (prefs_get_boolean(PREF_CORRECTION_ALLOW) && message->replace_id) {
_win_correct(window, message->plain, message->id, message->replace_id, message->jid->fulljid);
_win_correct(window, message->plain, message->id, message->replace_id, message->from_jid->fulljid);
} else {
_win_printf(window, show_char, 0, message->timestamp, flags | NO_ME, THEME_TEXT_THEM, message->jid->resourcepart, message->jid->fulljid, message->id, "%s", message->plain);
_win_printf(window, show_char, 0, message->timestamp, flags | NO_ME, THEME_TEXT_THEM, message->from_jid->resourcepart, message->from_jid->fulljid, message->id, "%s", message->plain);
}
inp_nonblocking(TRUE);
@ -1226,7 +1226,7 @@ win_print_history(ProfWin *window, const ProfMessage *const message)
char *display_name;
if (message->type == PROF_MSG_TYPE_MUC) {
display_name = strdup(message->jid->resourcepart);
display_name = strdup(message->from_jid->resourcepart);
char *muc_history_color = prefs_get_string(PREF_HISTORY_COLOR_MUC);
if (g_strcmp0(muc_history_color, "unanimous") == 0) {
@ -1237,10 +1237,10 @@ win_print_history(ProfWin *window, const ProfMessage *const message)
const char *jid = connection_get_fulljid();
Jid *jidp = jid_create(jid);
if (g_strcmp0(jidp->barejid, message->jid->barejid) == 0) {
if (g_strcmp0(jidp->barejid, message->from_jid->barejid) == 0) {
display_name = strdup("me");
} else {
display_name = roster_get_msg_display_name(message->jid->barejid, message->jid->resourcepart);
display_name = roster_get_msg_display_name(message->from_jid->barejid, message->from_jid->resourcepart);
}
jid_destroy(jidp);
}

29
src/xmpp/iq.c
View File

@ -2499,3 +2499,32 @@ _iq_free_affiliation_list(ProfAffiliationList *affiliation_list)
free(affiliation_list);
}
}
void
iq_mam_request(ProfChatWin *win)
{
if (connection_supports(XMPP_FEATURE_MAM2) == FALSE) {
log_warning("Server doesn't advertise %s feature.", XMPP_FEATURE_PING);
cons_show_error("Server doesn't support MAM.");
return;
}
xmpp_ctx_t * const ctx = connection_get_ctx();
char *id = connection_create_stanza_id();
GDateTime *now = g_date_time_new_now_local();
GDateTime *timestamp = g_date_time_add_days(now, -1);
g_date_time_unref(now);
gchar *datestr = g_date_time_format(timestamp,"%FT%T%:::z");
xmpp_stanza_t *iq = stanza_create_mam_iq(ctx, win->barejid, datestr);
g_free(datestr);
g_date_time_unref(timestamp);
// iq_id_handler_add(id, _http_upload_response_id_handler, NULL, upload);
free(id);
iq_send_stanza(iq);
xmpp_stanza_release(iq);
return;
}

106
src/xmpp/message.c
View File

@ -84,7 +84,8 @@ static void _handle_muc_private_message(xmpp_stanza_t *const stanza);
static void _handle_conference(xmpp_stanza_t *const stanza);
static void _handle_captcha(xmpp_stanza_t *const stanza);
static void _handle_receipt_received(xmpp_stanza_t *const stanza);
static void _handle_chat(xmpp_stanza_t *const stanza);
static void _handle_chat(xmpp_stanza_t *const stanza, gboolean is_mam);
static gboolean _handle_mam(xmpp_stanza_t *const stanza);
static void _send_message_stanza(xmpp_stanza_t *const stanza);
@ -99,13 +100,26 @@ _message_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *con
size_t text_size;
xmpp_stanza_to_text(stanza, &text, &text_size);
gboolean cont = plugins_on_message_stanza_receive(text);
xmpp_free(connection_get_ctx(), text);
if (!cont) {
xmpp_free(connection_get_ctx(), text);
return 1;
}
const char *type = xmpp_stanza_get_type(stanza);
if (type == NULL) {
if (_handle_mam(stanza)) {
xmpp_free(connection_get_ctx(), text);
return 1;
}
log_info("Received <message> without 'type': %s", text);
xmpp_free(connection_get_ctx(), text);
return 1;
}
xmpp_free(connection_get_ctx(), text);
if (g_strcmp0(type, STANZA_TYPE_ERROR) == 0) {
_handle_error(stanza);
}
@ -152,7 +166,7 @@ _message_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *con
}
}
_handle_chat(stanza);
_handle_chat(stanza, FALSE);
return 1;
}
@ -186,7 +200,8 @@ message_init(void)
{
ProfMessage *message = malloc(sizeof(ProfMessage));
message->jid = NULL;
message->from_jid = NULL;
message->to_jid = NULL;
message->id = NULL;
message->originid = NULL;
message->replace_id = NULL;
@ -205,8 +220,12 @@ void
message_free(ProfMessage *message)
{
xmpp_ctx_t *ctx = connection_get_ctx();
if (message->jid) {
jid_destroy(message->jid);
if (message->from_jid) {
jid_destroy(message->from_jid);
}
if (message->to_jid) {
jid_destroy(message->to_jid);
}
if (message->id) {
@ -787,51 +806,51 @@ _handle_groupchat(xmpp_stanza_t *const stanza)
}
const char *room_jid = xmpp_stanza_get_from(stanza);
Jid *jid = jid_create(room_jid);
Jid *from_jid = jid_create(room_jid);
// handle room subject
xmpp_stanza_t *subject = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_SUBJECT);
if (subject) {
char *subject_text;
subject_text = xmpp_stanza_get_text(subject);
sv_ev_room_subject(jid->barejid, jid->resourcepart, subject_text);
sv_ev_room_subject(from_jid->barejid, from_jid->resourcepart, subject_text);
xmpp_free(ctx, subject_text);
jid_destroy(jid);
jid_destroy(from_jid);
return;
}
// handle room broadcasts
if (!jid->resourcepart) {
if (!from_jid->resourcepart) {
char *broadcast;
broadcast = xmpp_message_get_body(stanza);
if (!broadcast) {
jid_destroy(jid);
jid_destroy(from_jid);
return;
}
sv_ev_room_broadcast(room_jid, broadcast);
xmpp_free(ctx, broadcast);
jid_destroy(jid);
jid_destroy(from_jid);
return;
}
if (!jid_is_valid_room_form(jid)) {
log_error("Invalid room JID: %s", jid->str);
jid_destroy(jid);
if (!jid_is_valid_room_form(from_jid)) {
log_error("Invalid room JID: %s", from_jid->str);
jid_destroy(from_jid);
return;
}
// room not active in profanity
if (!muc_active(jid->barejid)) {
log_error("Message received for inactive chat room: %s", jid->str);
jid_destroy(jid);
if (!muc_active(from_jid->barejid)) {
log_error("Message received for inactive chat room: %s", from_jid->str);
jid_destroy(from_jid);
return;
}
ProfMessage *message = message_init();
message->jid = jid;
message->from_jid = from_jid;
message->type = PROF_MSG_TYPE_MUC;
if (id) {
@ -861,17 +880,17 @@ _handle_groupchat(xmpp_stanza_t *const stanza)
#endif
if (!message->plain && !message->body) {
log_error("Message received without body for room: %s", jid->str);
log_error("Message received without body for room: %s", from_jid->str);
goto out;
} else if (!message->plain) {
message->plain = strdup(message->body);
}
// determine if the notifications happened whilst offline (MUC history)
message->timestamp = stanza_get_delay_from(stanza, jid->barejid);
message->timestamp = stanza_get_delay_from(stanza, from_jid->barejid);
if (message->timestamp == NULL) {
// checking the domainpart is a workaround for some prosody versions (gh#1190)
message->timestamp = stanza_get_delay_from(stanza, jid->domainpart);
message->timestamp = stanza_get_delay_from(stanza, from_jid->domainpart);
}
bool is_muc_history = FALSE;
@ -982,7 +1001,7 @@ _handle_muc_private_message(xmpp_stanza_t *const stanza)
message->type = PROF_MSG_TYPE_MUCPM;
const gchar *from = xmpp_stanza_get_from(stanza);
message->jid = jid_create(from);
message->from_jid = jid_create(from);
// message stanza id
const char *id = xmpp_stanza_get_id(stanza);
@ -1002,7 +1021,7 @@ _handle_muc_private_message(xmpp_stanza_t *const stanza)
message->body = xmpp_message_get_body(stanza);
if (!message->plain && !message->body) {
log_error("Message received without body from: %s", message->jid->str);
log_error("Message received without body from: %s", message->from_jid->str);
goto out;
} else if (!message->plain) {
message->plain = strdup(message->body);
@ -1119,17 +1138,18 @@ _handle_carbons(xmpp_stanza_t *const stanza)
message->encrypted = xmpp_stanza_get_text(x);
}
//TODO: now that profmessage has from_jid AND to_jid we should save both. and maybe also add is_carbon so we can decide later on.
if (message->plain || message->encrypted || message->body) {
// if we are the recipient, treat as standard incoming message
if (g_strcmp0(my_jid->barejid, jid_to->barejid) == 0) {
jid_destroy(jid_to);
message->jid = jid_from;
message->from_jid = jid_from;
sv_ev_incoming_carbon(message);
// else treat as a sent message
} else {
jid_destroy(jid_from);
message->jid = jid_to;
message->from_jid = jid_to;
sv_ev_outgoing_carbon(message);
}
}
@ -1141,7 +1161,7 @@ out:
}
static void
_handle_chat(xmpp_stanza_t *const stanza)
_handle_chat(xmpp_stanza_t *const stanza, gboolean is_mam)
{
// ignore if type not chat or absent
const char *type = xmpp_stanza_get_type(stanza);
@ -1172,6 +1192,9 @@ _handle_chat(xmpp_stanza_t *const stanza)
}
const gchar *from = xmpp_stanza_get_from(stanza);
if (!from) {
return;
}
Jid *jid = jid_create(from);
// private message from chat room use full jid (room/nick)
@ -1183,8 +1206,15 @@ _handle_chat(xmpp_stanza_t *const stanza)
// standard chat message, use jid without resource
ProfMessage *message = message_init();
message->jid = jid;
message->type = PROF_MSG_TYPE_CHAT;
message->from_jid = jid;
const gchar *to_text = xmpp_stanza_get_to(stanza);
if (to_text) {
message->to_jid = jid_create(to_text);
}
message->is_mam = is_mam;
// message stanza id
const char *id = xmpp_stanza_get_id(stanza);
@ -1256,6 +1286,26 @@ _handle_chat(xmpp_stanza_t *const stanza)
message_free(message);
}
static gboolean
_handle_mam(xmpp_stanza_t *const stanza)
{
xmpp_stanza_t *result = stanza_get_child_by_name_and_ns(stanza, "result", STANZA_NS_MAM2);
if (!result) {
return FALSE;
}
xmpp_stanza_t *forwarded = xmpp_stanza_get_child_by_ns(result, STANZA_NS_FORWARD);
if (!forwarded) {
log_warning("MAM received with no forwarded element");
return FALSE;
}
xmpp_stanza_t *message_stanza = xmpp_stanza_get_child_by_ns(forwarded, "jabber:client");
_handle_chat(message_stanza, TRUE);
return TRUE;
}
static void
_send_message_stanza(xmpp_stanza_t *const stanza)
{

82
src/xmpp/stanza.c
View File

@ -2635,3 +2635,85 @@ stanza_attach_correction(xmpp_ctx_t *ctx, xmpp_stanza_t *stanza, const char *con
return stanza;
}
xmpp_stanza_t*
stanza_create_mam_iq(xmpp_ctx_t *ctx, const char *const jid, const char *const startdate)
{
char *id = connection_create_stanza_id();
xmpp_stanza_t *iq = xmpp_iq_new(ctx, STANZA_TYPE_SET, id);
free(id);
//xmpp_stanza_set_to(iq, jid);
xmpp_stanza_t *query = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(query, STANZA_NAME_QUERY);
xmpp_stanza_set_ns(query, STANZA_NS_MAM2);
xmpp_stanza_t *x = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(x, STANZA_NAME_X);
xmpp_stanza_set_ns(x, STANZA_NS_DATA);
xmpp_stanza_set_type(x, "submit");
// field FORM_TYPE MAM2
xmpp_stanza_t *field_form_type = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(field_form_type, STANZA_NAME_FIELD);
xmpp_stanza_set_attribute(field_form_type, STANZA_ATTR_VAR, "FORM_TYPE");
xmpp_stanza_set_type(field_form_type, "hidden");
xmpp_stanza_t *value_mam = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(value_mam, STANZA_NAME_VALUE);
xmpp_stanza_t *mam_text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(mam_text, STANZA_NS_MAM2);
xmpp_stanza_add_child(value_mam, mam_text);
xmpp_stanza_add_child(field_form_type, value_mam);
// field 'with'
xmpp_stanza_t *field_with = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(field_with, STANZA_NAME_FIELD);
xmpp_stanza_set_attribute(field_with, STANZA_ATTR_VAR, "with");
xmpp_stanza_t *value_with = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(value_with, STANZA_NAME_VALUE);
xmpp_stanza_t *with_text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(with_text, jid);
xmpp_stanza_add_child(value_with, with_text);
xmpp_stanza_add_child(field_with, value_with);
// field 'start'
xmpp_stanza_t *field_start = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(field_start, STANZA_NAME_FIELD);
xmpp_stanza_set_attribute(field_start, STANZA_ATTR_VAR, "start");
xmpp_stanza_t *value_start = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(value_start, STANZA_NAME_VALUE);
xmpp_stanza_t *date_text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(date_text, startdate);
xmpp_stanza_add_child(value_start, date_text);
xmpp_stanza_add_child(field_start, value_start);
// add and release
xmpp_stanza_add_child(iq, query);
xmpp_stanza_add_child(query, x);
xmpp_stanza_add_child(x, field_form_type);
xmpp_stanza_add_child(x, field_with);
xmpp_stanza_add_child(x, field_start);
xmpp_stanza_release(mam_text);
xmpp_stanza_release(with_text);
xmpp_stanza_release(date_text);
xmpp_stanza_release(value_mam);
xmpp_stanza_release(value_with);
xmpp_stanza_release(value_start);
xmpp_stanza_release(field_form_type);
xmpp_stanza_release(field_with);
xmpp_stanza_release(field_start);
xmpp_stanza_release(x);
xmpp_stanza_release(query);
return iq;
}

3
src/xmpp/stanza.h
View File

@ -202,6 +202,7 @@
#define STANZA_NS_USER_AVATAR_DATA "urn:xmpp:avatar:data"
#define STANZA_NS_USER_AVATAR_METADATA "urn:xmpp:avatar:metadata"
#define STANZA_NS_LAST_MESSAGE_CORRECTION "urn:xmpp:message-correct:0"
#define STANZA_NS_MAM2 "urn:xmpp:mam:2"
#define STANZA_DATAFORM_SOFTWARE "urn:xmpp:dataforms:softwareinfo"
@ -359,4 +360,6 @@ xmpp_stanza_t* stanza_get_child_by_name_and_ns(xmpp_stanza_t * const stanza, con
xmpp_stanza_t* stanza_create_avatar_retrieve_data_request(xmpp_ctx_t *ctx, const char *stanza_id, const char *const item_id, const char *const jid);
xmpp_stanza_t* stanza_create_mam_iq(xmpp_ctx_t *ctx, const char *const jid, const char *const startdate);
#endif

6
src/xmpp/xmpp.h
View File

@ -69,6 +69,7 @@
#define XMPP_FEATURE_PUBSUB_PUBLISH_OPTIONS "http://jabber.org/protocol/pubsub#publish-options"
#define XMPP_FEATURE_USER_AVATAR_METADATA_NOTIFY "urn:xmpp:avatar:metadata+notify"
#define XMPP_FEATURE_LAST_MESSAGE_CORRECTION "urn:xmpp:message-correct:0"
#define XMPP_FEATURE_MAM2 "urn:xmpp:mam:2"
typedef enum {
JABBER_CONNECTING,
@ -137,7 +138,8 @@ typedef enum {
} prof_msg_type_t;
typedef struct prof_message_t {
Jid *jid;
Jid *from_jid;
Jid *to_jid;
/* regular <message id=""> */
char *id;
/* </origin-id> XEP-0359 */
@ -154,6 +156,7 @@ typedef struct prof_message_t {
GDateTime *timestamp;
prof_enc_t enc;
gboolean trusted;
gboolean is_mam;
prof_msg_type_t type;
} ProfMessage;
@ -237,6 +240,7 @@ void iq_autoping_check(void);
void iq_http_upload_request(HTTPUpload *upload);
void iq_command_list(const char *const target);
void iq_command_exec(const char *const target, const char *const command);
void iq_mam_request(ProfChatWin *win);
EntityCapabilities* caps_lookup(const char *const jid);
void caps_close(void);