mirrors/linphone-iphone
1
0
Fork 1
mirror of https://gitlab.linphone.org/BC/public/linphone-iphone.git synced 2026-02-07 14:18:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixed encryption when using old chat rooms + fixed decrypt async mechanism in chat message reception + fixed async b64 tester

Browse source
This commit is contained in:
Sylvain Berfini 2017-12-11 13:14:11 +01:00
parent 56fd4d9a49
commit 1614e6c126
5 changed files with 53 additions and 18 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
include/linphone/api/c-chat-room.h
View file

@ -141,6 +141,13 @@ LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_room_send_message2(Linpho
*/
LINPHONE_PUBLIC LINPHONE_DEPRECATED void linphone_chat_room_send_chat_message(LinphoneChatRoom *cr, LinphoneChatMessage *msg);
/**
* Used to receive a chat message when using async mechanism with IM encryption engine
* @param[in] cr LinphoneChatRoom object
* @param[in] msg LinphoneChatMessage object
*/
LINPHONE_PUBLIC void linphone_chat_room_receive_chat_message (LinphoneChatRoom *cr, LinphoneChatMessage *msg);
/**
* Mark all messages of the conversation as read
* @param[in] cr The #LinphoneChatRoom object corresponding to the conversation.

4
src/c-wrapper/api/c-chat-room.cpp
View file

@ -150,6 +150,10 @@ void linphone_chat_room_send_chat_message (LinphoneChatRoom *cr, LinphoneChatMes
L_GET_PRIVATE_FROM_C_OBJECT(cr)->sendMessage(L_GET_CPP_PTR_FROM_C_OBJECT(msg));
}
void linphone_chat_room_receive_chat_message (LinphoneChatRoom *cr, LinphoneChatMessage *msg) {
L_GET_PRIVATE_FROM_C_OBJECT(msg)->receive();
}
uint32_t linphone_chat_room_get_char (const LinphoneChatRoom *cr) {
if (linphone_core_realtime_text_enabled(linphone_chat_room_get_core(cr)))
return L_GET_CPP_PTR_FROM_C_OBJECT(cr, RealTimeTextChatRoom)->getChar();

37
src/chat/chat-message/chat-message.cpp
View file

@ -492,15 +492,18 @@ void ChatMessagePrivate::send () {
// Start of message modification
// ---------------------------------------
if (applyModifiers && q->getChatRoom()->canHandleParticipants()) { // Do not multipart, encrypt or encapsulate with CPIM in an old ChatRoom to maintain backward compatibility
if ((currentSendStep &ChatMessagePrivate::Step::Multipart) == ChatMessagePrivate::Step::Multipart) {
lInfo() << "Multipart step already done, skipping";
} else {
if (contents.size() > 1) {
MultipartChatMessageModifier mcmm;
mcmm.encode(q->getSharedFromThis(), errorCode);
if (applyModifiers) {
// Do not multipart or encapsulate with CPIM in an old ChatRoom to maintain backward compatibility
if (q->getChatRoom()->canHandleParticipants()) {
if ((currentSendStep &ChatMessagePrivate::Step::Multipart) == ChatMessagePrivate::Step::Multipart) {
lInfo() << "Multipart step already done, skipping";
} else {
if (contents.size() > 1) {
MultipartChatMessageModifier mcmm;
mcmm.encode(q->getSharedFromThis(), errorCode);
}
currentSendStep |= ChatMessagePrivate::Step::Multipart;
}
currentSendStep |= ChatMessagePrivate::Step::Multipart;
}
if ((currentSendStep &ChatMessagePrivate::Step::Encryption) == ChatMessagePrivate::Step::Encryption) {
@ -519,15 +522,17 @@ void ChatMessagePrivate::send () {
currentSendStep |= ChatMessagePrivate::Step::Encryption;
}
if ((currentSendStep &ChatMessagePrivate::Step::Cpim) == ChatMessagePrivate::Step::Cpim) {
lInfo() << "Cpim step already done, skipping";
} else {
int defaultValue = !!lp_config_get_string(core->getCCore()->config, "misc", "conference_factory_uri", nullptr);
if (lp_config_get_int(core->getCCore()->config, "sip", "use_cpim", defaultValue) == 1) {
CpimChatMessageModifier ccmm;
ccmm.encode(q->getSharedFromThis(), errorCode);
if (q->getChatRoom()->canHandleParticipants()) {
if ((currentSendStep &ChatMessagePrivate::Step::Cpim) == ChatMessagePrivate::Step::Cpim) {
lInfo() << "Cpim step already done, skipping";
} else {
int defaultValue = !!lp_config_get_string(core->getCCore()->config, "misc", "conference_factory_uri", nullptr);
if (lp_config_get_int(core->getCCore()->config, "sip", "use_cpim", defaultValue) == 1) {
CpimChatMessageModifier ccmm;
ccmm.encode(q->getSharedFromThis(), errorCode);
}
currentSendStep |= ChatMessagePrivate::Step::Cpim;
}
currentSendStep |= ChatMessagePrivate::Step::Cpim;
}
}

2
src/chat/modifier/encryption-chat-message-modifier.cpp
View file

@ -84,7 +84,7 @@ ChatMessageModifier::Result EncryptionChatMessageModifier::decode (
return ChatMessageModifier::Result::Skipped;
int retval = cbProcessIncomingMessage(imee, L_GET_C_BACK_PTR(chatRoom), L_GET_C_BACK_PTR(message));
if (retval != 0 && retval != -1) {
if (retval != 0 && retval != -1 && retval != 1) {
errorCode = retval;
return ChatMessageModifier::Result::Error;
}

21
tester/message_tester.c
View file

@ -2238,6 +2238,16 @@ static int im_encryption_engine_process_incoming_message_cb(LinphoneImEncryption
return 500;
}
static bool_t im_encryption_engine_process_incoming_message_async_impl(LinphoneChatMessage** msg) {
if (*msg) {
im_encryption_engine_process_incoming_message_cb(NULL,NULL,*msg);
linphone_chat_room_receive_chat_message(linphone_chat_message_get_chat_room(*msg), *msg);
linphone_chat_message_unref(*msg);
*msg=NULL;
}
return TRUE;
}
static int im_encryption_engine_process_outgoing_message_cb(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg) {
if (strcmp(linphone_chat_message_get_content_type(msg),"text/plain") == 0) {
size_t b64Size = 0;
@ -2265,6 +2275,7 @@ static bool_t im_encryption_engine_process_outgoing_message_async_impl(LinphoneC
}
static LinphoneChatMessage* pending_message=NULL; /*limited to one message at a time */
static LinphoneChatMessage* incoming_pending_message=NULL; /*limited to one message at a time */
static int im_encryption_engine_process_outgoing_message_async(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg) {
pending_message=msg;
@ -2273,6 +2284,13 @@ static int im_encryption_engine_process_outgoing_message_async(LinphoneImEncrypt
return 1;/*temporaly code to defer message sending*/
}
static int im_encryption_engine_process_incoming_message_async(LinphoneImEncryptionEngine *engine, LinphoneChatRoom *room, LinphoneChatMessage *msg) {
incoming_pending_message=msg;
linphone_chat_message_ref(incoming_pending_message);
linphone_core_add_iterate_hook(linphone_chat_room_get_core(room), (LinphoneCoreIterateHook)im_encryption_engine_process_incoming_message_async_impl,&incoming_pending_message);
return 1;/*temporaly code to defer message receiving*/
}
void im_encryption_engine_b64_base(bool_t async) {
LinphoneChatMessage *chat_msg = NULL;
LinphoneChatRoom* chat_room = NULL;
@ -2283,13 +2301,14 @@ void im_encryption_engine_b64_base(bool_t async) {
LinphoneImEncryptionEngine *pauline_imee = linphone_im_encryption_engine_new();
LinphoneImEncryptionEngineCbs *pauline_cbs = linphone_im_encryption_engine_get_callbacks(pauline_imee);
linphone_im_encryption_engine_cbs_set_process_incoming_message(marie_cbs, im_encryption_engine_process_incoming_message_cb);
linphone_im_encryption_engine_cbs_set_process_outgoing_message(marie_cbs, im_encryption_engine_process_outgoing_message_cb);
linphone_im_encryption_engine_cbs_set_process_incoming_message(pauline_cbs, im_encryption_engine_process_incoming_message_cb);
if (async) {
linphone_im_encryption_engine_cbs_set_process_outgoing_message(pauline_cbs, im_encryption_engine_process_outgoing_message_async);
linphone_im_encryption_engine_cbs_set_process_incoming_message(marie_cbs, im_encryption_engine_process_incoming_message_async);
} else {
linphone_im_encryption_engine_cbs_set_process_outgoing_message(pauline_cbs, im_encryption_engine_process_outgoing_message_cb);
linphone_im_encryption_engine_cbs_set_process_incoming_message(marie_cbs, im_encryption_engine_process_incoming_message_cb);
}
linphone_core_set_im_encryption_engine(marie->lc, marie_imee);