6 * Copyright (C) 2011 SIPE Project <http://sipe.sourceforge.net/>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32 #include "sipe-common.h"
34 #include "sip-transport.h"
35 #include "sipe-backend.h"
36 #include "sipe-buddy.h"
37 #include "sipe-chat.h"
38 #include "sipe-core.h"
39 #include "sipe-core-private.h"
40 #include "sipe-dialog.h"
42 #include "sipe-groupchat.h"
45 #include "sipe-session.h"
46 #include "sipe-user.h"
47 #include "sipe-utils.h"
51 * Hash key template for unconfirmed messages
53 * Call-ID Recipient URI (or empty)
57 #define UNCONFIRMED_KEY_TEMPLATE(method, cseq) "<%s><" method "><%s><" cseq
59 /* key must be g_free()'d */
60 static gchar
*get_unconfirmed_message_key(const gchar
*callid
,
64 return(g_strdup_printf(UNCONFIRMED_KEY_TEMPLATE("%s", "%d>"),
66 with
? "MESSAGE" : "INVITE",
71 static void insert_unconfirmed_message(struct sip_session
*session
,
72 struct sip_dialog
*dialog
,
75 const gchar
*content_type
)
77 gchar
*key
= get_unconfirmed_message_key(dialog
->callid
, dialog
->cseq
+ 1, with
);
78 struct queued_message
*message
= g_new0(struct queued_message
, 1);
80 message
->body
= g_strdup(body
);
81 if (content_type
!= NULL
)
82 message
->content_type
= g_strdup(content_type
);
83 message
->cseq
= dialog
->cseq
+ 1;
85 g_hash_table_insert(session
->unconfirmed_messages
, key
, message
);
86 SIPE_DEBUG_INFO("insert_unconfirmed_message: added %s to list (count=%d)",
87 key
, g_hash_table_size(session
->unconfirmed_messages
));
90 static gboolean
remove_unconfirmed_message(struct sip_session
*session
,
93 gboolean found
= g_hash_table_remove(session
->unconfirmed_messages
, key
);
95 SIPE_DEBUG_INFO("remove_unconfirmed_message: removed %s from list (count=%d)",
96 key
, g_hash_table_size(session
->unconfirmed_messages
));
98 SIPE_DEBUG_INFO("remove_unconfirmed_message: key %s not found",
104 static void sipe_refer_notify(struct sipe_core_private
*sipe_private
,
105 struct sip_session
*session
,
112 struct sip_dialog
*dialog
= sipe_dialog_find(session
, who
);
114 hdr
= g_strdup_printf(
116 "Subscription-State: %s\r\n"
117 "Content-Type: message/sipfrag\r\n",
118 status
>= 200 ? "terminated" : "active");
120 body
= g_strdup_printf(
124 sip_transport_request(sipe_private
,
137 static gboolean
process_invite_response(struct sipe_core_private
*sipe_private
,
139 struct transaction
*trans
)
141 gchar
*with
= parse_from(sipmsg_find_header(msg
, "To"));
142 struct sip_session
*session
;
143 struct sip_dialog
*dialog
;
145 struct queued_message
*message
;
146 struct sipmsg
*request_msg
= trans
->msg
;
148 const gchar
*callid
= sipmsg_find_header(msg
, "Call-ID");
151 session
= sipe_session_find_chat_or_im(sipe_private
, callid
, with
);
153 SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: unable to find IM session");
158 dialog
= sipe_dialog_find(session
, with
);
160 SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: session outgoing dialog is NULL");
165 sipe_dialog_parse(dialog
, msg
, TRUE
);
167 key
= get_unconfirmed_message_key(dialog
->callid
, sipmsg_parse_cseq(msg
), NULL
);
168 message
= g_hash_table_lookup(session
->unconfirmed_messages
, key
);
170 if (msg
->response
!= 200) {
171 gchar
*alias
= sipe_buddy_get_alias(sipe_private
, with
);
172 int warning
= sipmsg_parse_warning(msg
, NULL
);
174 SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: INVITE response not 200");
176 /* cancel file transfer as rejected by server */
177 if (msg
->response
== 606 && /* Not acceptable all. */
178 warning
== 309 && /* Message contents not allowed by policy */
179 message
&& g_str_has_prefix(message
->content_type
, "text/x-msmsgsinvite"))
181 GSList
*parsed_body
= sipe_ft_parse_msg_body(message
->body
);
182 sipe_ft_incoming_cancel(dialog
, parsed_body
);
183 sipe_utils_nameval_free(parsed_body
);
187 /* generate error for each unprocessed message */
188 GSList
*entry
= session
->outgoing_message_queue
;
190 struct queued_message
*queued
= entry
->data
;
191 sipe_user_present_message_undelivered(sipe_private
, session
, msg
->response
, warning
, alias
? alias
: with
, queued
->body
);
192 entry
= sipe_session_dequeue_message(session
);
195 /* generate one error and remove all unprocessed messages */
196 gchar
*tmp_msg
= g_strdup_printf(_("Failed to invite %s"), alias
? alias
: with
);
197 sipe_user_present_error(sipe_private
, session
, tmp_msg
);
199 while (sipe_session_dequeue_message(session
));
203 remove_unconfirmed_message(session
, key
);
204 /* message is no longer valid */
207 sipe_dialog_remove(session
, with
);
210 if (session
->is_groupchat
) {
211 sipe_groupchat_invite_failed(sipe_private
, session
);
212 /* session is no longer valid */
219 sip_transport_ack(sipe_private
, dialog
);
220 dialog
->outgoing_invite
= NULL
;
221 dialog
->is_established
= TRUE
;
223 referred_by
= parse_from(sipmsg_find_header(request_msg
, "Referred-By"));
225 sipe_refer_notify(sipe_private
, session
, referred_by
, 200, "OK");
229 /* add user to chat if it is a multiparty session */
230 if (session
->chat_session
&&
231 (session
->chat_session
->type
== SIPE_CHAT_TYPE_MULTIPARTY
)) {
232 sipe_backend_chat_add(session
->chat_session
->backend
,
237 if (session
->is_groupchat
) {
238 sipe_groupchat_invite_response(sipe_private
, dialog
);
241 if(g_slist_find_custom(dialog
->supported
, "ms-text-format", (GCompareFunc
)g_ascii_strcasecmp
)) {
242 SIPE_DEBUG_INFO_NOFORMAT("process_invite_response: remote system accepted message in INVITE");
243 sipe_session_dequeue_message(session
);
246 sipe_im_process_queue(sipe_private
, session
);
248 remove_unconfirmed_message(session
, key
);
255 /* EndPoints: "alice alisson" <sip:alice@atlanta.local>, <sip:bob@atlanta.local>;epid=ebca82d94d, <sip:carol@atlanta.local> */
256 static gchar
*get_end_points(struct sipe_core_private
*sipe_private
,
257 struct sip_session
*session
)
261 if (session
== NULL
) {
265 res
= g_strdup_printf("<sip:%s>", sipe_private
->username
);
267 SIPE_DIALOG_FOREACH
{
269 res
= g_strdup_printf("%s, <%s>", res
, dialog
->with
);
272 if (dialog
->theirepid
) {
274 res
= g_strdup_printf("%s;epid=%s", res
, dialog
->theirepid
);
277 } SIPE_DIALOG_FOREACH_END
;
283 sipe_im_invite(struct sipe_core_private
*sipe_private
,
284 struct sip_session
*session
,
286 const gchar
*msg_body
,
287 const gchar
*content_type
,
288 const gchar
*referred_by
,
289 const gboolean is_triggered
)
296 char *ms_text_format
= NULL
;
297 char *ms_conversation_id
= NULL
;
298 gchar
*roster_manager
;
300 gchar
*referred_by_str
;
301 gboolean is_multiparty
=
302 session
->chat_session
&&
303 (session
->chat_session
->type
== SIPE_CHAT_TYPE_MULTIPARTY
);
304 struct sip_dialog
*dialog
= sipe_dialog_find(session
, who
);
306 if (dialog
&& dialog
->is_established
) {
307 SIPE_DEBUG_INFO("session with %s already has a dialog open", who
);
312 dialog
= sipe_dialog_add(session
);
313 dialog
->callid
= session
->callid
? g_strdup(session
->callid
) : gencallid();
314 dialog
->with
= g_strdup(who
);
317 if (!(dialog
->ourtag
)) {
318 dialog
->ourtag
= gentag();
324 char *msgtext
= NULL
;
326 const gchar
*msgr
= "";
329 if (!g_str_has_prefix(content_type
, "text/x-msmsgsinvite")) {
333 sipe_parse_html(msg_body
, &msgformat
, &msgtext
);
334 SIPE_DEBUG_INFO("sipe_invite: msgformat=%s", msgformat
);
336 msgr_value
= sipmsg_get_msgr_string(msgformat
);
339 msgr
= tmp
= g_strdup_printf(";msgr=%s", msgr_value
);
343 /* When Sipe reconnects after a crash, we are not able
344 * to send messages to contacts with which we had open
345 * conversations when the crash occured. Server sends
346 * error response with reason="This client has an IM
347 * session with the same conversation ID"
349 * Setting random Ms-Conversation-ID prevents this problem
350 * so we can continue the conversation. */
351 ms_conversation_id
= g_strdup_printf("Ms-Conversation-ID: %u\r\n",
352 rand() % 1000000000);
354 msgtext
= g_strdup(msg_body
);
357 base64_msg
= g_base64_encode((guchar
*) msgtext
, strlen(msgtext
));
358 ms_text_format
= g_strdup_printf("ms-text-format: %s; charset=UTF-8%s;ms-body=%s\r\n",
359 content_type
? content_type
: "text/plain",
366 insert_unconfirmed_message(session
, dialog
, NULL
,
367 msg_body
, content_type
);
370 contact
= get_contact(sipe_private
);
371 end_points
= get_end_points(sipe_private
, session
);
372 self
= sip_uri_self(sipe_private
);
373 roster_manager
= g_strdup_printf(
374 "Roster-Manager: %s\r\n"
378 referred_by_str
= referred_by
?
380 "Referred-By: %s\r\n",
383 hdr
= g_strdup_printf(
384 "Supported: ms-sender\r\n"
391 "Content-Type: application/sdp\r\n",
392 is_multiparty
&& sipe_strcase_equal(session
->chat_session
->id
, self
) ? roster_manager
: "",
394 is_triggered
? "TriggeredInvite: TRUE\r\n" : "",
395 is_triggered
|| is_multiparty
? "Require: com.microsoft.rtc-multiparty\r\n" : "",
397 ms_text_format
? ms_text_format
: "",
398 ms_conversation_id
? ms_conversation_id
: "");
399 g_free(ms_text_format
);
400 g_free(ms_conversation_id
);
403 body
= g_strdup_printf(
405 "o=- 0 0 IN IP4 %s\r\n"
409 "m=%s %d sip null\r\n"
410 "a=accept-types:" SDP_ACCEPT_TYPES
"\r\n",
411 sipe_backend_network_ip_address(),
412 sipe_backend_network_ip_address(),
413 SIPE_CORE_PRIVATE_FLAG_IS(OCS2007
) ? "message" : "x-ms-message",
414 sip_transport_port(sipe_private
));
416 dialog
->outgoing_invite
= sip_transport_request(sipe_private
,
423 process_invite_response
);
426 g_free(roster_manager
);
428 g_free(referred_by_str
);
435 process_message_response(struct sipe_core_private
*sipe_private
,
437 SIPE_UNUSED_PARAMETER
struct transaction
*trans
)
440 gchar
*with
= parse_from(sipmsg_find_header(msg
, "To"));
441 const gchar
*callid
= sipmsg_find_header(msg
, "Call-ID");
442 struct sip_session
*session
= sipe_session_find_chat_or_im(sipe_private
, callid
, with
);
443 struct sip_dialog
*dialog
;
445 struct queued_message
*message
;
448 SIPE_DEBUG_INFO_NOFORMAT("process_message_response: unable to find IM session");
453 dialog
= sipe_dialog_find(session
, with
);
455 SIPE_DEBUG_INFO_NOFORMAT("process_message_response: session outgoing dialog is NULL");
460 key
= get_unconfirmed_message_key(sipmsg_find_header(msg
, "Call-ID"), sipmsg_parse_cseq(msg
), with
);
461 message
= g_hash_table_lookup(session
->unconfirmed_messages
, key
);
463 if (msg
->response
>= 400) {
464 int warning
= sipmsg_parse_warning(msg
, NULL
);
466 SIPE_DEBUG_INFO_NOFORMAT("process_message_response: MESSAGE response >= 400");
468 /* cancel file transfer as rejected by server */
469 if (msg
->response
== 606 && /* Not acceptable all. */
470 warning
== 309 && /* Message contents not allowed by policy */
471 message
&& g_str_has_prefix(message
->content_type
, "text/x-msmsgsinvite"))
473 GSList
*parsed_body
= sipe_ft_parse_msg_body(msg
->body
);
474 sipe_ft_incoming_cancel(dialog
, parsed_body
);
475 sipe_utils_nameval_free(parsed_body
);
478 /* drop dangling IM sessions: assume that BYE from remote never reached us */
479 if (msg
->response
== 408 || /* Request timeout */
480 msg
->response
== 480 || /* Temporarily Unavailable */
481 msg
->response
== 481) { /* Call/Transaction Does Not Exist */
482 sipe_im_cancel_dangling(sipe_private
, session
, dialog
, with
,
483 sipe_im_cancel_unconfirmed
);
484 /* dialog is no longer valid */
486 gchar
*alias
= sipe_buddy_get_alias(sipe_private
, with
);
487 sipe_user_present_message_undelivered(sipe_private
, session
,
488 msg
->response
, warning
,
489 alias
? alias
: with
,
490 message
? message
->body
: NULL
);
491 remove_unconfirmed_message(session
, key
);
492 /* message is no longer valid */
498 const gchar
*message_id
= sipmsg_find_header(msg
, "Message-Id");
500 g_hash_table_insert(session
->conf_unconfirmed_messages
, g_strdup(message_id
), g_strdup(message
->body
));
501 SIPE_DEBUG_INFO("process_message_response: added message with id %s to conf_unconfirmed_messages(count=%d)",
502 message_id
, g_hash_table_size(session
->conf_unconfirmed_messages
));
504 remove_unconfirmed_message(session
, key
);
510 if (ret
) sipe_im_process_queue(sipe_private
, session
);
514 #ifndef ENABLE_OCS2005_MESSAGE_HACK
516 * Hack to circumvent problems reported in the bug report
518 * #3267073 - False "could not be delivered" errors
520 * The logs provided by the reporters indicate that OCS2005 clients DO NOT
521 * acknowledge our SIP MESSAGEs. Therefore the message timeout is triggered
522 * and messages are reported to the user as not delivered.
524 * Either this is a bug in the OCS2005 client or we do something wrong in our
525 * SIP MESSAGEs. This hack removes the message timeout and is provided for
526 * users who need to communicate with a still existing OCS2005 user base.
528 * Do not enable it by default!
531 process_message_timeout(struct sipe_core_private
*sipe_private
,
533 SIPE_UNUSED_PARAMETER
struct transaction
*trans
)
535 gchar
*with
= parse_from(sipmsg_find_header(msg
, "To"));
536 const gchar
*callid
= sipmsg_find_header(msg
, "Call-ID");
537 struct sip_session
*session
= sipe_session_find_chat_or_im(sipe_private
, callid
, with
);
542 SIPE_DEBUG_INFO_NOFORMAT("process_message_timeout: unable to find IM session");
547 /* Remove timed-out message from unconfirmed list */
548 key
= get_unconfirmed_message_key(sipmsg_find_header(msg
, "Call-ID"), sipmsg_parse_cseq(msg
), with
);
549 found
= remove_unconfirmed_message(session
, key
);
553 gchar
*alias
= sipe_buddy_get_alias(sipe_private
, with
);
554 sipe_user_present_message_undelivered(sipe_private
, session
, -1, -1,
555 alias
? alias
: with
,
565 static void sipe_im_send_message(struct sipe_core_private
*sipe_private
,
566 struct sip_dialog
*dialog
,
567 const gchar
*msg_body
,
568 const gchar
*content_type
)
572 char *msgtext
= NULL
;
573 const gchar
*msgr
= "";
576 if (content_type
== NULL
)
577 content_type
= "text/plain";
579 if (!g_str_has_prefix(content_type
, "text/x-msmsgsinvite")) {
583 sipe_parse_html(msg_body
, &msgformat
, &msgtext
);
584 SIPE_DEBUG_INFO("sipe_send_message: msgformat=%s", msgformat
);
586 msgr_value
= sipmsg_get_msgr_string(msgformat
);
589 msgr
= tmp2
= g_strdup_printf(";msgr=%s", msgr_value
);
593 msgtext
= g_strdup(msg_body
);
596 tmp
= get_contact(sipe_private
);
597 //hdr = g_strdup("Content-Type: text/plain; charset=UTF-8\r\n");
598 //hdr = g_strdup("Content-Type: text/rtf\r\n");
599 //hdr = g_strdup("Content-Type: text/plain; charset=UTF-8;msgr=WAAtAE0ATQBTAC....AoADQA\r\nSupported: timer\r\n");
601 hdr
= g_strdup_printf("Contact: %s\r\nContent-Type: %s; charset=UTF-8%s\r\n", tmp
, content_type
, msgr
);
605 #ifdef ENABLE_OCS2005_MESSAGE_HACK
606 sip_transport_request(
608 sip_transport_request_timeout(
617 process_message_response
618 #ifndef ENABLE_OCS2005_MESSAGE_HACK
621 process_message_timeout
628 void sipe_im_process_queue(struct sipe_core_private
*sipe_private
,
629 struct sip_session
*session
)
631 GSList
*entry2
= session
->outgoing_message_queue
;
633 struct queued_message
*msg
= entry2
->data
;
635 /* for multiparty chat or conference */
636 if (session
->chat_session
) {
637 gchar
*who
= sip_uri_self(sipe_private
);
638 sipe_backend_chat_message(SIPE_CORE_PUBLIC
,
639 session
->chat_session
->backend
,
645 SIPE_DIALOG_FOREACH
{
646 if (dialog
->outgoing_invite
) continue; /* do not send messages as INVITE is not responded. */
648 insert_unconfirmed_message(session
, dialog
, dialog
->with
,
649 msg
->body
, msg
->content_type
);
651 sipe_im_send_message(sipe_private
, dialog
, msg
->body
, msg
->content_type
);
652 } SIPE_DIALOG_FOREACH_END
;
654 entry2
= sipe_session_dequeue_message(session
);
658 struct unconfirmed_callback_data
{
663 struct unconfirmed_message
{
665 const struct queued_message
*msg
;
668 static gint
compare_cseq(gconstpointer a
,
671 return(((struct unconfirmed_message
*) a
)->msg
->cseq
-
672 ((struct unconfirmed_message
*) b
)->msg
->cseq
);
675 static void unconfirmed_message_callback(gpointer key
,
679 const gchar
*message_key
= key
;
680 struct unconfirmed_callback_data
*data
= user_data
;
682 SIPE_DEBUG_INFO("unconfirmed_message_callback: key %s", message_key
);
684 /* Put messages with the same prefix on a list sorted by CSeq */
685 if (g_str_has_prefix(message_key
, data
->prefix
)) {
686 struct unconfirmed_message
*msg
= g_malloc(sizeof(struct unconfirmed_message
));
687 msg
->key
= message_key
;
689 data
->list
= g_slist_insert_sorted(data
->list
, msg
,
694 static void foreach_unconfirmed_message(struct sipe_core_private
*sipe_private
,
695 struct sip_session
*session
,
698 unconfirmed_callback callback
,
699 const gchar
*callback_data
)
701 gchar
*prefix
= g_strdup_printf(UNCONFIRMED_KEY_TEMPLATE("MESSAGE", ""),
703 struct unconfirmed_callback_data data
= { prefix
, NULL
};
705 SIPE_DEBUG_INFO("foreach_unconfirmed_message: prefix %s", prefix
);
707 /* Generate list of matching unconfirmed messages */
708 g_hash_table_foreach(session
->unconfirmed_messages
,
709 unconfirmed_message_callback
,
713 /* Process list unconfirmed messages */
717 while ((entry
= data
.list
) != NULL
) {
718 struct unconfirmed_message
*unconfirmed
= entry
->data
;
719 data
.list
= g_slist_remove(data
.list
, unconfirmed
);
721 SIPE_DEBUG_INFO("foreach_unconfirmed_message: %s", unconfirmed
->key
);
722 (*callback
)(sipe_private
, session
, unconfirmed
->msg
->body
, callback_data
);
724 g_hash_table_remove(session
->unconfirmed_messages
, unconfirmed
->key
);
730 static void cancel_callback(struct sipe_core_private
*sipe_private
,
731 struct sip_session
*session
,
735 sipe_user_present_message_undelivered(sipe_private
, session
,
739 void sipe_im_cancel_unconfirmed(struct sipe_core_private
*sipe_private
,
740 struct sip_session
*session
,
744 gchar
*alias
= sipe_buddy_get_alias(sipe_private
, with
);
746 SIPE_DEBUG_INFO("sipe_im_cancel_unconfirmed: with %s callid '%s'",
749 foreach_unconfirmed_message(sipe_private
, session
, callid
, with
,
750 cancel_callback
, alias
? alias
: with
);
754 static void reenqueue_callback(SIPE_UNUSED_PARAMETER
struct sipe_core_private
*sipe_private
,
755 struct sip_session
*session
,
757 SIPE_UNUSED_PARAMETER
const gchar
*with
)
759 sipe_session_enqueue_message(session
, body
, NULL
);
762 void sipe_im_reenqueue_unconfirmed(struct sipe_core_private
*sipe_private
,
763 struct sip_session
*session
,
767 /* Remember original list, start with an empty list */
768 GSList
*first
= session
->outgoing_message_queue
;
769 session
->outgoing_message_queue
= NULL
;
771 SIPE_DEBUG_INFO("sipe_im_reenqueue_unconfirmed: with %s callid '%s'",
774 /* Enqueue unconfirmed messages */
775 foreach_unconfirmed_message(sipe_private
, session
, callid
, with
,
776 reenqueue_callback
, NULL
);
778 /* Append or restore original list */
779 if (session
->outgoing_message_queue
) {
780 GSList
*last
= g_slist_last(session
->outgoing_message_queue
);
783 session
->outgoing_message_queue
= first
;
787 void sipe_core_im_send(struct sipe_core_public
*sipe_public
,
791 struct sipe_core_private
*sipe_private
= SIPE_CORE_PRIVATE
;
792 struct sip_session
*session
;
793 struct sip_dialog
*dialog
;
794 gchar
*uri
= sip_uri(who
);
796 SIPE_DEBUG_INFO("sipe_core_im_send: '%s'", what
);
798 session
= sipe_session_find_or_add_im(sipe_private
, uri
);
799 dialog
= sipe_dialog_find(session
, uri
);
801 /* Queue the message */
802 sipe_session_enqueue_message(session
, what
, NULL
);
804 if (dialog
&& !dialog
->outgoing_invite
) {
805 sipe_im_process_queue(sipe_private
, session
);
806 } else if (!dialog
|| !dialog
->outgoing_invite
) {
807 /* Need to send the INVITE to get the outgoing dialog setup */
808 sipe_im_invite(sipe_private
, session
, uri
, what
, NULL
, NULL
, FALSE
);
814 void sipe_im_cancel_dangling(struct sipe_core_private
*sipe_private
,
815 struct sip_session
*session
,
816 struct sip_dialog
*dialog
,
818 unconfirmed_callback callback
)
820 SIPE_DEBUG_INFO_NOFORMAT("sipe_im_cancel_dangling: assuming dangling IM session, dropping it.");
821 sip_transport_bye(sipe_private
, dialog
);
823 (*callback
)(sipe_private
, session
, dialog
->callid
, with
);
825 /* We might not get a valid reply to our BYE,
826 so make sure the dialog is removed for sure. */
827 sipe_dialog_remove(session
, with
);
828 /* dialog is no longer valid */
831 void sipe_im_topic(struct sipe_core_private
*sipe_private
,
832 struct sip_session
*session
,
835 g_free(session
->subject
);
836 session
->subject
= g_strdup(topic
);
837 sipe_backend_im_topic(SIPE_CORE_PUBLIC
, session
->with
, topic
);
840 void process_incoming_info_conversation(struct sipe_core_private
*sipe_private
,
843 sipe_xml
*xml
= sipe_xml_parse(msg
->body
, msg
->bodylen
);
844 const gchar
*from
= NULL
;
845 const gchar
*subject
= NULL
;
851 if (sipe_strequal(sipe_xml_name(xml
), "ConversationInfo")) {
852 const sipe_xml
*node
= sipe_xml_child(xml
, "From");
854 from
= sipe_xml_attribute(node
, "uri");
856 node
= sipe_xml_child(xml
, "Subject");
858 subject
= sipe_xml_data(node
);
861 if (from
&& subject
) {
862 struct sip_session
*session
;
863 session
= sipe_session_find_im(sipe_private
, from
);
866 sipe_im_topic(sipe_private
, session
, subject
);
871 sip_transport_response(sipe_private
, msg
, 200, "OK", NULL
);