Mercurial > ~mikael > mcabber > hg
annotate mcabber/mcabber/xmpp.c @ 1731:4fbfae993c24
Improve login process
The roster and private storage elements are requested before broadcasting
our presence, because we want the roster before we receive our contacts
presence notifications.
This is more efficients, and also solves an issue with entity capabilities
(as we do not store caps for unknown items).
| author | Mikael Berthe <mikael@lilotux.net> |
|---|---|
| date | Sun, 28 Feb 2010 18:50:30 +0100 |
| parents | 860b58a0e8da |
| children | a9b0364c0cb2 |
| rev | line source |
|---|---|
| 29 | 1 /* |
| 1599 | 2 * xmpp.c -- Jabber protocol handling |
| 393 | 3 * |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
4 * Copyright (C) 2008-2010 Frank Zschockelt <mcabber@freakysoft.de> |
|
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
5 * Copyright (C) 2005-2010 Mikael Berthe <mikael@lilotux.net> |
| 29 | 6 * Parts come from the centericq project: |
| 7 * Copyright (C) 2002-2005 by Konstantin Klyagin <konst@konst.org.ua> | |
| 8 * | |
| 9 * This program is free software; you can redistribute it and/or modify | |
| 10 * it under the terms of the GNU General Public License as published by | |
| 11 * the Free Software Foundation; either version 2 of the License, or (at | |
| 12 * your option) any later version. | |
| 13 * | |
| 14 * This program is distributed in the hope that it will be useful, but | |
| 15 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 17 * General Public License for more details. | |
| 18 * | |
| 19 * You should have received a copy of the GNU General Public License | |
| 20 * along with this program; if not, write to the Free Software | |
| 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | |
| 22 * USA | |
| 23 */ | |
| 1598 | 24 #include <stdlib.h> |
| 25 #include <string.h> | |
| 29 | 26 |
|
1604
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
27 #include "xmpp.h" |
|
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
28 #include "xmpp_helper.h" |
|
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
29 #include "xmpp_iq.h" |
|
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
30 #include "xmpp_iqrequest.h" |
|
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
31 #include "xmpp_muc.h" |
|
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
32 #include "xmpp_s10n.h" |
| 1600 | 33 #include "caps.h" |
| 1598 | 34 #include "events.h" |
| 35 #include "histolog.h" | |
| 36 #include "hooks.h" | |
| 37 #include "otr.h" | |
| 81 | 38 #include "roster.h" |
| 29 | 39 #include "screen.h" |
| 1598 | 40 #include "settings.h" |
| 29 | 41 #include "utils.h" |
|
1653
fca9a4c17432
Improve UI latency and CPU usage
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1647
diff
changeset
|
42 #include "main.h" |
| 29 | 43 |
|
1001
dff25377c11f
Auto-reconnect after a network/server failure
Mikael Berthe <mikael@lilotux.net>
parents:
999
diff
changeset
|
44 #define RECONNECTION_TIMEOUT 60L |
|
dff25377c11f
Auto-reconnect after a network/server failure
Mikael Berthe <mikael@lilotux.net>
parents:
999
diff
changeset
|
45 |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
46 LmConnection* lconnection = NULL; |
| 1598 | 47 static guint AutoConnection; |
| 48 | |
| 49 inline void update_last_use(void); | |
| 50 inline gboolean xmpp_reconnect(); | |
| 51 | |
|
1604
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
52 enum imstatus mystatus = offline; |
| 1598 | 53 static enum imstatus mywantedstatus = available; |
|
1604
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
54 gchar *mystatusmsg; |
| 29 | 55 |
|
353
3fe43f6daa5a
Make imstatus2char a null-terminated string
Mikael Berthe <mikael@lilotux.net>
parents:
325
diff
changeset
|
56 char imstatus2char[imstatus_size+1] = { |
|
1311
0dda8238af21
Implement "/roster display"
Mikael Berthe <mikael@lilotux.net>
parents:
1310
diff
changeset
|
57 '_', 'o', 'f', 'd', 'n', 'a', 'i', '\0' |
| 46 | 58 }; |
| 59 | |
|
1604
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
60 char *imstatus_showmap[] = { |
| 1378 | 61 "", |
| 62 "", | |
| 63 "chat", | |
| 64 "dnd", | |
| 65 "xa", | |
| 66 "away", | |
| 67 "" | |
| 68 }; | |
| 69 | |
|
1604
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
70 LmMessageNode *bookmarks = NULL; |
|
351427ef0b4b
Remove #include's of C files
Mikael Berthe <mikael@lilotux.net>
parents:
1602
diff
changeset
|
71 LmMessageNode *rosternotes = NULL; |
| 29 | 72 |
| 1598 | 73 static struct IqHandlers |
| 116 | 74 { |
| 1598 | 75 const gchar *xmlns; |
| 76 LmHandleMessageFunction handler; | |
| 77 } iq_handlers[] = { | |
| 78 {NS_PING, &handle_iq_ping}, | |
| 79 {NS_VERSION, &handle_iq_version}, | |
| 80 {NS_TIME, &handle_iq_time}, | |
| 81 {NS_ROSTER, &handle_iq_roster}, | |
| 82 {NS_XMPP_TIME, &handle_iq_time202}, | |
| 83 {NS_LAST, &handle_iq_last}, | |
| 84 {NS_DISCO_INFO, &handle_iq_disco_info}, | |
| 85 {NS_DISCO_ITEMS,&handle_iq_disco_items}, | |
| 86 {NS_COMMANDS, &handle_iq_commands}, | |
|
1615
171ae5a258fa
Add dummy vcard IQ handler
Mikael Berthe <mikael@lilotux.net>
parents:
1614
diff
changeset
|
87 {NS_VCARD, &handle_iq_vcard}, |
| 1598 | 88 {NULL, NULL} |
| 89 }; | |
|
519
5c338d31de56
Show current global status message in "/status"
Mikael Berthe <mikael@lilotux.net>
parents:
513
diff
changeset
|
90 |
|
1558
3df441efb7c2
Fix gcc warnings related to inline/static uses
Mikael Berthe <mikael@lilotux.net>
parents:
1546
diff
changeset
|
91 void update_last_use(void) |
|
1254
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
92 { |
|
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
93 iqlast = time(NULL); |
|
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
94 } |
|
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
95 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
96 gboolean xmpp_is_online(void) |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
97 { |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
98 if (lconnection && lm_connection_is_authenticated(lconnection)) |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
99 return TRUE; |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
100 else |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
101 return FALSE; |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
102 } |
|
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
103 |
| 1598 | 104 // Note: the caller should check the jid is correct |
| 105 void xmpp_addbuddy(const char *bjid, const char *name, const char *group) | |
|
1215
80c095886fb5
Entity Capabilities support (XEP-0115)
Mikael Berthe <mikael@lilotux.net>
parents:
1213
diff
changeset
|
106 { |
| 1598 | 107 LmMessageNode *query, *y; |
| 108 LmMessage *iq; | |
|
1701
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
109 LmMessageHandler *handler; |
| 1598 | 110 char *cleanjid; |
|
1255
ceada40bbe20
Update Entity Capabilities (add iq:last)
Mikael Berthe <mikael@lilotux.net>
parents:
1254
diff
changeset
|
111 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
112 if (!xmpp_is_online()) |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
113 return; |
| 1598 | 114 |
| 115 cleanjid = jidtodisp(bjid); // Stripping resource, just in case... | |
| 116 | |
| 117 // We don't check if the jabber user already exists in the roster, | |
| 118 // because it allows to re-ask for notification. | |
|
1215
80c095886fb5
Entity Capabilities support (XEP-0115)
Mikael Berthe <mikael@lilotux.net>
parents:
1213
diff
changeset
|
119 |
| 1598 | 120 iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, |
| 121 LM_MESSAGE_SUB_TYPE_SET); | |
| 122 query = lm_message_node_add_child(iq->node, "query", NULL); | |
| 123 lm_message_node_set_attribute(query, "xmlns", NS_ROSTER); | |
| 124 y = lm_message_node_add_child(query, "item", NULL); | |
| 125 lm_message_node_set_attribute(y, "jid", cleanjid); | |
| 126 | |
| 127 if (name) | |
| 128 lm_message_node_set_attribute(y, "name", name); | |
|
1215
80c095886fb5
Entity Capabilities support (XEP-0115)
Mikael Berthe <mikael@lilotux.net>
parents:
1213
diff
changeset
|
129 |
| 1598 | 130 if (group) |
| 131 lm_message_node_add_child(y, "group", group); | |
| 132 | |
|
1701
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
133 handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE); |
|
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
134 lm_connection_send_with_reply(lconnection, iq, handler, NULL); |
|
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
135 lm_message_handler_unref(handler); |
| 1598 | 136 lm_message_unref(iq); |
|
532
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
531
diff
changeset
|
137 |
| 1598 | 138 xmpp_send_s10n(cleanjid, LM_MESSAGE_SUB_TYPE_SUBSCRIBE); |
|
532
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
531
diff
changeset
|
139 |
| 1598 | 140 roster_add_user(cleanjid, name, group, ROSTER_TYPE_USER, sub_pending, -1); |
| 141 g_free(cleanjid); | |
| 142 buddylist_build(); | |
|
532
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
531
diff
changeset
|
143 |
| 1598 | 144 update_roster = TRUE; |
|
532
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
531
diff
changeset
|
145 } |
|
2ac8d8e49e81
Send status changes to chatrooms
Mikael Berthe <mikael@lilotux.net>
parents:
531
diff
changeset
|
146 |
| 1598 | 147 void xmpp_updatebuddy(const char *bjid, const char *name, const char *group) |
| 29 | 148 { |
| 1598 | 149 LmMessage *iq; |
|
1701
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
150 LmMessageHandler *handler; |
| 1598 | 151 LmMessageNode *x; |
| 152 char *cleanjid; | |
| 29 | 153 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
154 if (!xmpp_is_online()) |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
155 return; |
| 444 | 156 |
| 1598 | 157 // XXX We should check name's and group's correctness |
| 158 | |
| 159 cleanjid = jidtodisp(bjid); // Stripping resource, just in case... | |
| 29 | 160 |
| 1598 | 161 iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, |
| 162 LM_MESSAGE_SUB_TYPE_SET); | |
| 163 x = lm_message_node_add_child(iq->node, "query", NULL); | |
| 164 lm_message_node_set_attribute(x, "xmlns", NS_ROSTER); | |
| 165 x = lm_message_node_add_child(x, "item", NULL); | |
| 166 lm_message_node_set_attributes(x, | |
| 167 "jid", cleanjid, | |
| 168 "name", name, | |
| 169 NULL); | |
| 29 | 170 |
| 1598 | 171 if (group) |
| 172 lm_message_node_add_child(x, "group", group); | |
|
1419
fb438482b28e
New option to customize the away/notavail priority (Michael Gehring)
Mikael Berthe <mikael@lilotux.net>
parents:
1415
diff
changeset
|
173 |
|
1701
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
174 handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE); |
|
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
175 lm_connection_send_with_reply(lconnection, iq, handler, NULL); |
|
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
176 lm_message_handler_unref(handler); |
| 1598 | 177 lm_message_unref(iq); |
| 178 g_free(cleanjid); | |
| 534 | 179 } |
| 180 | |
| 1598 | 181 void xmpp_delbuddy(const char *bjid) |
| 534 | 182 { |
| 1598 | 183 LmMessageNode *y, *z; |
| 184 LmMessage *iq; | |
|
1701
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
185 LmMessageHandler *handler; |
| 1598 | 186 char *cleanjid; |
| 187 | |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
188 if (!xmpp_is_online()) |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
189 return; |
| 1598 | 190 |
| 191 cleanjid = jidtodisp(bjid); // Stripping resource, just in case... | |
| 534 | 192 |
| 1598 | 193 // If the current buddy is an agent, unsubscribe from it |
| 194 if (roster_gettype(cleanjid) == ROSTER_TYPE_AGENT) { | |
| 195 scr_LogPrint(LPRINT_LOGNORM, "Unregistering from the %s agent", cleanjid); | |
| 29 | 196 |
| 1598 | 197 iq = lm_message_new_with_sub_type(cleanjid, LM_MESSAGE_TYPE_IQ, |
| 198 LM_MESSAGE_SUB_TYPE_SET); | |
| 199 y = lm_message_node_add_child(iq->node, "query", NULL); | |
| 200 lm_message_node_set_attribute(y, "xmlns", NS_REGISTER); | |
| 201 lm_message_node_add_child(y, "remove", NULL); | |
| 202 lm_connection_send(lconnection, iq, NULL); | |
| 203 lm_message_unref(iq); | |
|
1014
99c5278bf6b8
Keep the status and status messages when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1013
diff
changeset
|
204 } |
| 29 | 205 |
| 1598 | 206 // Cancel the subscriptions |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
207 xmpp_send_s10n(cleanjid, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED); // cancel "from" |
|
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
208 xmpp_send_s10n(cleanjid, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE); // cancel "to" |
| 1598 | 209 |
| 210 // Ask for removal from roster | |
| 211 iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, | |
| 212 LM_MESSAGE_SUB_TYPE_SET); | |
| 444 | 213 |
| 1598 | 214 y = lm_message_node_add_child(iq->node, "query", NULL); |
| 215 lm_message_node_set_attribute(y, "xmlns", NS_ROSTER); | |
| 216 z = lm_message_node_add_child(y, "item", NULL); | |
| 217 lm_message_node_set_attributes(z, | |
| 218 "jid", cleanjid, | |
| 219 "subscription", "remove", | |
| 220 NULL); | |
|
1701
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
221 handler = lm_message_handler_new(handle_iq_dummy, NULL, FALSE); |
|
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
222 lm_connection_send_with_reply(lconnection, iq, handler, NULL); |
|
44e023ad99ed
Add dummy handler for roster manipulation IQ responses
Mikael Berthe <mikael@lilotux.net>
parents:
1693
diff
changeset
|
223 lm_message_handler_unref(handler); |
| 1598 | 224 lm_message_unref(iq); |
| 225 | |
| 226 roster_del_user(cleanjid); | |
| 227 g_free(cleanjid); | |
| 228 buddylist_build(); | |
| 229 | |
| 230 update_roster = TRUE; | |
| 231 } | |
| 1365 | 232 |
| 1598 | 233 void xmpp_request(const char *fjid, enum iqreq_type reqtype) |
| 234 { | |
| 235 GSList *resources, *p_res; | |
| 236 GSList *roster_elt; | |
| 237 const char *strreqtype, *xmlns; | |
|
1722
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
238 gboolean vcard2user; |
| 1365 | 239 |
| 1598 | 240 if (reqtype == iqreq_version) { |
| 241 xmlns = NS_VERSION; | |
| 242 strreqtype = "version"; | |
| 243 } else if (reqtype == iqreq_time) { | |
| 244 xmlns = NS_TIME; | |
| 245 strreqtype = "time"; | |
| 246 } else if (reqtype == iqreq_last) { | |
| 247 xmlns = NS_LAST; | |
| 248 strreqtype = "last"; | |
|
1705
ac881b5f9248
Add /request ping (XEP-0199), by merging isbear's module
Mikael Berthe <mikael@lilotux.net>
parents:
1701
diff
changeset
|
249 } else if (reqtype == iqreq_ping) { |
|
ac881b5f9248
Add /request ping (XEP-0199), by merging isbear's module
Mikael Berthe <mikael@lilotux.net>
parents:
1701
diff
changeset
|
250 xmlns = NS_PING; |
| 1711 | 251 strreqtype = "ping"; |
| 1598 | 252 } else if (reqtype == iqreq_vcard) { |
| 253 xmlns = NS_VCARD; | |
| 254 strreqtype = "vCard"; | |
| 255 } else | |
| 256 return; | |
| 1365 | 257 |
|
1722
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
258 // Is it a vCard request to a regular user? |
|
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
259 // (vCard requests are sent to bare JIDs, except in MUC rooms...) |
|
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
260 vcard2user = (reqtype == iqreq_vcard && |
|
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
261 !roster_find(fjid, jidsearch, ROSTER_TYPE_ROOM)); |
|
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
262 |
|
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
263 if (strchr(fjid, JID_RESOURCE_SEPARATOR) || vcard2user) { |
|
b18142457ca9
Fix vCard requests in MUC rooms
Mikael Berthe <mikael@lilotux.net>
parents:
1721
diff
changeset
|
264 // This is a full JID or a vCard request to a contact |
| 1598 | 265 xmpp_iq_request(fjid, xmlns); |
| 266 scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fjid); | |
| 267 return; | |
| 521 | 268 } |
| 713 | 269 |
| 1598 | 270 // The resource has not been specified |
| 271 roster_elt = roster_find(fjid, jidsearch, ROSTER_TYPE_USER|ROSTER_TYPE_ROOM); | |
| 272 if (!roster_elt) { | |
| 273 scr_LogPrint(LPRINT_NORMAL, "No known resource for <%s>...", fjid); | |
| 274 xmpp_iq_request(fjid, xmlns); // Let's send a request anyway... | |
| 275 scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fjid); | |
| 276 return; | |
| 277 } | |
|
1254
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
278 |
| 1598 | 279 // Send a request to each resource |
| 280 resources = buddy_getresources(roster_elt->data); | |
| 281 if (!resources) { | |
| 282 scr_LogPrint(LPRINT_NORMAL, "No known resource for <%s>...", fjid); | |
| 283 xmpp_iq_request(fjid, xmlns); // Let's send a request anyway... | |
| 284 scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fjid); | |
| 285 } | |
| 286 for (p_res = resources ; p_res ; p_res = g_slist_next(p_res)) { | |
| 287 gchar *fulljid; | |
| 288 fulljid = g_strdup_printf("%s/%s", fjid, (char*)p_res->data); | |
| 289 xmpp_iq_request(fulljid, xmlns); | |
| 290 scr_LogPrint(LPRINT_NORMAL, "Sent %s request to <%s>", strreqtype, fulljid); | |
| 291 g_free(fulljid); | |
| 292 g_free(p_res->data); | |
| 293 } | |
| 294 g_slist_free(resources); | |
|
1014
99c5278bf6b8
Keep the status and status messages when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1013
diff
changeset
|
295 } |
|
99c5278bf6b8
Keep the status and status messages when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1013
diff
changeset
|
296 |
| 1602 | 297 static LmHandlerResult cb_xep184(LmMessageHandler *h, LmConnection *c, |
| 298 LmMessage *m, gpointer user_data) | |
| 299 { | |
| 300 char *from = jidtodisp(lm_message_get_from(m)); | |
| 301 scr_RemoveReceiptFlag(from, h); | |
| 302 g_free(from); | |
| 303 return LM_HANDLER_RESULT_REMOVE_MESSAGE; | |
| 304 } | |
| 305 | |
| 1598 | 306 // xmpp_send_msg(jid, text, type, subject, |
| 307 // otrinject, *encrypted, type_overwrite) | |
| 1197 | 308 // When encrypted is not NULL, the function set *encrypted to 1 if the |
| 309 // message has been PGP-encrypted. If encryption enforcement is set and | |
| 310 // encryption fails, *encrypted is set to -1. | |
| 1598 | 311 void xmpp_send_msg(const char *fjid, const char *text, int type, |
| 312 const char *subject, gboolean otrinject, gint *encrypted, | |
| 1602 | 313 LmMessageSubType type_overwrite, gpointer *xep184) |
| 35 | 314 { |
| 1598 | 315 LmMessage *x; |
| 316 LmMessageSubType subtype; | |
| 1304 | 317 #ifdef HAVE_LIBOTR |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
318 int otr_msg = 0; |
| 1304 | 319 #endif |
| 1691 | 320 #if defined HAVE_GPGME || defined XEP0022 || defined XEP0085 |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
321 char *rname, *barejid; |
|
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
322 GSList *sl_buddy; |
|
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
323 #endif |
| 1691 | 324 #if defined XEP0022 || defined XEP0085 |
| 1598 | 325 LmMessageNode *event; |
| 997 | 326 guint use_jep85 = 0; |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
327 struct jep0085 *jep85 = NULL; |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
328 #endif |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
329 gchar *enc = NULL; |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
444
diff
changeset
|
330 |
|
1055
6eb1efea75d0
PGP: Visual encryption flag
Mikael Berthe <mikael@lilotux.net>
parents:
1053
diff
changeset
|
331 if (encrypted) |
| 1197 | 332 *encrypted = 0; |
|
1055
6eb1efea75d0
PGP: Visual encryption flag
Mikael Berthe <mikael@lilotux.net>
parents:
1053
diff
changeset
|
333 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
334 if (!xmpp_is_online()) |
|
1435
9bf7f3ddff10
Do not send a groupchat-style message when changing a MUC room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1426
diff
changeset
|
335 return; |
|
9bf7f3ddff10
Do not send a groupchat-style message when changing a MUC room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1426
diff
changeset
|
336 |
|
9bf7f3ddff10
Do not send a groupchat-style message when changing a MUC room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1426
diff
changeset
|
337 if (!text && type == ROSTER_TYPE_USER) |
|
9bf7f3ddff10
Do not send a groupchat-style message when changing a MUC room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1426
diff
changeset
|
338 return; |
|
472
75442262c082
Disable some commands when not connected
Mikael Berthe <mikael@lilotux.net>
parents:
470
diff
changeset
|
339 |
| 1598 | 340 if (type_overwrite != LM_MESSAGE_SUB_TYPE_NOT_SET) |
| 341 subtype = type_overwrite; | |
|
1305
9bc68473f8a3
-n and -f flags to message-sending commands
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1304
diff
changeset
|
342 else { |
|
9bc68473f8a3
-n and -f flags to message-sending commands
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1304
diff
changeset
|
343 if (type == ROSTER_TYPE_ROOM) |
| 1598 | 344 subtype = LM_MESSAGE_SUB_TYPE_GROUPCHAT; |
|
1305
9bc68473f8a3
-n and -f flags to message-sending commands
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1304
diff
changeset
|
345 else |
| 1598 | 346 subtype = LM_MESSAGE_SUB_TYPE_CHAT; |
|
1305
9bc68473f8a3
-n and -f flags to message-sending commands
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1304
diff
changeset
|
347 } |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
444
diff
changeset
|
348 |
| 1598 | 349 #if defined HAVE_GPGME || defined HAVE_LIBOTR || \ |
| 1691 | 350 defined XEP0022 || defined XEP0085 |
| 1058 | 351 rname = strchr(fjid, JID_RESOURCE_SEPARATOR); |
| 352 barejid = jidtodisp(fjid); | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
353 sl_buddy = roster_find(barejid, jidsearch, ROSTER_TYPE_USER); |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
354 |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
355 // If we can get a resource name, we use it. Else we use NULL, |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
356 // which hopefully will give us the most likely resource. |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
357 if (rname) |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
358 rname++; |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
359 |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
360 #ifdef HAVE_LIBOTR |
| 1598 | 361 if (otr_enabled() && !otrinject) { |
| 362 if (type == ROSTER_TYPE_USER) { | |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
363 otr_msg = otr_send((char **)&text, barejid); |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
364 if (!text) { |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
365 g_free(barejid); |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
366 if (encrypted) |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
367 *encrypted = -1; |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
368 return; |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
369 } |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
370 } |
|
1484
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
371 if (otr_msg && encrypted) |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
372 *encrypted = ENCRYPTED_OTR; |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
373 } |
|
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
374 #endif |
|
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
375 |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
376 #ifdef HAVE_GPGME |
|
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
377 if (type == ROSTER_TYPE_USER && sl_buddy && gpg_enabled()) { |
| 1197 | 378 if (!settings_pgp_getdisabled(barejid)) { // not disabled for this contact? |
| 379 guint force; | |
|
1065
230dca34dbea
Extand pgp_data structure
Mikael Berthe <mikael@lilotux.net>
parents:
1058
diff
changeset
|
380 struct pgp_data *res_pgpdata; |
| 1197 | 381 force = settings_pgp_getforce(barejid); |
|
1065
230dca34dbea
Extand pgp_data structure
Mikael Berthe <mikael@lilotux.net>
parents:
1058
diff
changeset
|
382 res_pgpdata = buddy_resource_pgp(sl_buddy->data, rname); |
| 1197 | 383 if (force || (res_pgpdata && res_pgpdata->sign_keyid)) { |
| 384 /* Remote client has PGP support (we have a signature) | |
| 385 * OR encryption is enforced (force = TRUE). | |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
386 * If the contact has a specific KeyId, we'll use it; |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
387 * if not, we'll use the key used for the signature. |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
388 * Both keys should match, in theory (cf. XEP-0027). */ |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
389 const char *key; |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
390 key = settings_pgp_getkeyid(barejid); |
| 1197 | 391 if (!key && res_pgpdata) |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
392 key = res_pgpdata->sign_keyid; |
| 1197 | 393 if (key) |
| 394 enc = gpg_encrypt(text, key); | |
| 395 if (!enc && force) { | |
| 396 if (encrypted) | |
| 397 *encrypted = -1; | |
| 398 g_free(barejid); | |
| 399 return; | |
| 400 } | |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
401 } |
|
1065
230dca34dbea
Extand pgp_data structure
Mikael Berthe <mikael@lilotux.net>
parents:
1058
diff
changeset
|
402 } |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
403 } |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
404 #endif // HAVE_GPGME |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
405 |
|
1065
230dca34dbea
Extand pgp_data structure
Mikael Berthe <mikael@lilotux.net>
parents:
1058
diff
changeset
|
406 g_free(barejid); |
| 1691 | 407 #endif // HAVE_GPGME || defined XEP0022 || defined XEP0085 |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
408 |
| 1598 | 409 x = lm_message_new_with_sub_type(fjid, LM_MESSAGE_TYPE_MESSAGE, subtype); |
| 410 lm_message_node_add_child(x->node, "body", | |
| 411 enc ? "This message is PGP-encrypted." : text); | |
| 412 | |
| 413 if (subject) | |
| 414 lm_message_node_add_child(x->node, "subject", subject); | |
| 415 | |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
416 if (enc) { |
| 1598 | 417 LmMessageNode *y; |
| 418 y = lm_message_node_add_child(x->node, "x", enc); | |
| 419 lm_message_node_set_attribute(y, "xmlns", NS_ENCRYPTED); | |
|
1055
6eb1efea75d0
PGP: Visual encryption flag
Mikael Berthe <mikael@lilotux.net>
parents:
1053
diff
changeset
|
420 if (encrypted) |
|
1484
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
421 *encrypted = ENCRYPTED_PGP; |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
422 g_free(enc); |
|
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
423 } |
|
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
424 |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
425 // XEP-0184: Message Receipts |
|
1730
860b58a0e8da
Update XEP-0184 support
Mikael Berthe <mikael@lilotux.net>
parents:
1729
diff
changeset
|
426 if (sl_buddy && xep184 && |
| 1602 | 427 caps_has_feature(buddy_resource_getcaps(sl_buddy->data, rname), |
| 428 NS_RECEIPTS)) { | |
| 429 lm_message_node_set_attribute | |
| 430 (lm_message_node_add_child(x->node, "request", NULL), | |
| 431 "xmlns", NS_RECEIPTS); | |
| 432 *xep184 = lm_message_handler_new(cb_xep184, NULL, NULL); | |
| 433 } | |
| 434 | |
| 1691 | 435 #if defined XEP0022 || defined XEP0085 |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
436 // If typing notifications are disabled, we can skip all this stuff... |
|
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
437 if (chatstates_disabled || type == ROSTER_TYPE_ROOM) |
| 1598 | 438 goto xmpp_send_msg_no_chatstates; |
|
1044
52cfe9bf9840
Encryption support for outgoing messages
Mikael Berthe <mikael@lilotux.net>
parents:
1043
diff
changeset
|
439 |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
440 if (sl_buddy) |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
441 jep85 = buddy_resource_jep85(sl_buddy->data, rname); |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
442 #endif |
|
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
443 |
| 1691 | 444 #ifdef XEP0085 |
| 445 /* XEP-0085 5.1 | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
446 * "Until receiving a reply to the initial content message (or a standalone |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
447 * notification) from the Contact, the User MUST NOT send subsequent chat |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
448 * state notifications to the Contact." |
| 1378 | 449 * In our implementation support is initially "unknown", then it's "probed" |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
450 * and can become "ok". |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
451 */ |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
452 if (jep85 && (jep85->support == CHATSTATES_SUPPORT_OK || |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
453 jep85->support == CHATSTATES_SUPPORT_UNKNOWN)) { |
| 1598 | 454 event = lm_message_node_add_child(x->node, "active", NULL); |
| 455 lm_message_node_set_attribute(event, "xmlns", NS_CHATSTATES); | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
456 if (jep85->support == CHATSTATES_SUPPORT_UNKNOWN) |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
457 jep85->support = CHATSTATES_SUPPORT_PROBED; |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
458 else |
| 997 | 459 use_jep85 = 1; |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
460 jep85->last_state_sent = ROSTER_EVENT_ACTIVE; |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
461 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
462 #endif |
| 1691 | 463 #ifdef XEP0022 |
| 464 /* XEP-22 | |
| 465 * If the Contact supports XEP-0085, we do not use XEP-0022. | |
| 466 * If not, we try to fall back to XEP-0022. | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
467 */ |
| 997 | 468 if (!use_jep85) { |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
469 struct jep0022 *jep22 = NULL; |
| 1598 | 470 event = lm_message_node_add_child(x->node, "x", NULL); |
| 471 lm_message_node_set_attribute(event, "xmlns", NS_EVENT); | |
| 472 lm_message_node_add_child(event, "composing", NULL); | |
|
988
6e2bfd1ffded
Add ids to message stanzas if needed
Mikael Berthe <mikael@lilotux.net>
parents:
987
diff
changeset
|
473 |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
474 if (sl_buddy) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
475 jep22 = buddy_resource_jep22(sl_buddy->data, rname); |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
476 if (jep22) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
477 jep22->last_state_sent = ROSTER_EVENT_ACTIVE; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
478 |
| 1691 | 479 // An id is mandatory when using XEP-0022. |
| 1598 | 480 if (text || subject) { |
| 481 const gchar *msgid = lm_message_get_id(x); | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
482 // Let's update last_msgid_sent |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
483 if (jep22) { |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
484 g_free(jep22->last_msgid_sent); |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
485 jep22->last_msgid_sent = g_strdup(msgid); |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
486 } |
|
988
6e2bfd1ffded
Add ids to message stanzas if needed
Mikael Berthe <mikael@lilotux.net>
parents:
987
diff
changeset
|
487 } |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
488 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
489 #endif |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
490 |
| 1598 | 491 xmpp_send_msg_no_chatstates: |
|
1254
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
492 if (mystatus != invisible) |
|
401639413340
More jabber:iq:last support... (misc)
Mikael Berthe <mikael@lilotux.net>
parents:
1244
diff
changeset
|
493 update_last_use(); |
| 1602 | 494 if (xep184 && *xep184) { |
| 495 lm_connection_send_with_reply(lconnection, x, *xep184, NULL); | |
| 496 lm_message_handler_unref(*xep184); | |
| 497 } else | |
| 498 lm_connection_send(lconnection, x, NULL); | |
| 1598 | 499 lm_message_unref(x); |
| 35 | 500 } |
| 501 | |
| 1691 | 502 #ifdef XEP0085 |
| 1598 | 503 // xmpp_send_jep85_chatstate() |
| 1691 | 504 // Send a XEP-85 chatstate. |
| 1598 | 505 static void xmpp_send_jep85_chatstate(const char *bjid, const char *resname, |
| 506 guint state) | |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
507 { |
| 1598 | 508 LmMessage *m; |
| 509 LmMessageNode *event; | |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
510 GSList *sl_buddy; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
511 const char *chattag; |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
512 char *rjid, *fjid = NULL; |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
513 struct jep0085 *jep85 = NULL; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
514 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
515 if (!xmpp_is_online()) |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
516 return; |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
517 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
518 sl_buddy = roster_find(bjid, jidsearch, ROSTER_TYPE_USER); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
519 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
520 // If we have a resource name, we use it. Else we use NULL, |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
521 // which hopefully will give us the most likely resource. |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
522 if (sl_buddy) |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
523 jep85 = buddy_resource_jep85(sl_buddy->data, resname); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
524 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
525 if (!jep85 || (jep85->support != CHATSTATES_SUPPORT_OK)) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
526 return; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
527 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
528 if (state == jep85->last_state_sent) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
529 return; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
530 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
531 if (state == ROSTER_EVENT_ACTIVE) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
532 chattag = "active"; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
533 else if (state == ROSTER_EVENT_COMPOSING) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
534 chattag = "composing"; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
535 else if (state == ROSTER_EVENT_PAUSED) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
536 chattag = "paused"; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
537 else { |
| 1691 | 538 scr_LogPrint(LPRINT_LOGNORM, "Error: unsupported XEP-85 state (%d)", state); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
539 return; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
540 } |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
541 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
542 jep85->last_state_sent = state; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
543 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
544 if (resname) |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
545 fjid = g_strdup_printf("%s/%s", bjid, resname); |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
546 |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
547 rjid = resname ? fjid : (char*)bjid; |
| 1598 | 548 m = lm_message_new_with_sub_type(rjid, LM_MESSAGE_TYPE_MESSAGE, |
| 549 LM_MESSAGE_SUB_TYPE_CHAT); | |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
550 |
| 1598 | 551 event = lm_message_node_add_child(m->node, chattag, NULL); |
| 552 lm_message_node_set_attribute(event, "xmlns", NS_CHATSTATES); | |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
553 |
| 1598 | 554 lm_connection_send(lconnection, m, NULL); |
| 555 lm_message_unref(m); | |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
556 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
557 g_free(fjid); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
558 } |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
559 #endif |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
560 |
| 1691 | 561 #ifdef XEP0022 |
| 1598 | 562 // xmpp_send_jep22_event() |
| 1691 | 563 // Send a XEP-22 message event (delivered, composing...). |
| 1598 | 564 static void xmpp_send_jep22_event(const char *fjid, guint type) |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
565 { |
| 1598 | 566 LmMessage *x; |
| 567 LmMessageNode *event; | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
568 const char *msgid; |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
569 char *rname, *barejid; |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
570 GSList *sl_buddy; |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
571 struct jep0022 *jep22 = NULL; |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
572 guint jep22_state; |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
573 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
574 if (!xmpp_is_online()) |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
575 return; |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
576 |
| 1058 | 577 rname = strchr(fjid, JID_RESOURCE_SEPARATOR); |
| 578 barejid = jidtodisp(fjid); | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
579 sl_buddy = roster_find(barejid, jidsearch, ROSTER_TYPE_USER); |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
580 g_free(barejid); |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
581 |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
582 // If we can get a resource name, we use it. Else we use NULL, |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
583 // which hopefully will give us the most likely resource. |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
584 if (rname) |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
585 rname++; |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
586 if (sl_buddy) |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
587 jep22 = buddy_resource_jep22(sl_buddy->data, rname); |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
588 |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
589 if (!jep22) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
590 return; // XXX Maybe we could try harder (other resources?) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
591 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
592 msgid = jep22->last_msgid_rcvd; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
593 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
594 // For composing events (composing, active, inactive, paused...), |
| 1691 | 595 // XEP22 only has 2 states; we'll use composing and active. |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
596 if (type == ROSTER_EVENT_COMPOSING) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
597 jep22_state = ROSTER_EVENT_COMPOSING; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
598 else if (type == ROSTER_EVENT_ACTIVE || |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
599 type == ROSTER_EVENT_PAUSED) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
600 jep22_state = ROSTER_EVENT_ACTIVE; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
601 else |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
602 jep22_state = 0; // ROSTER_EVENT_NONE |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
603 |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
604 if (jep22_state) { |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
605 // Do not re-send a same event |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
606 if (jep22_state == jep22->last_state_sent) |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
607 return; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
608 jep22->last_state_sent = jep22_state; |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
609 } |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
610 |
| 1598 | 611 x = lm_message_new_with_sub_type(fjid, LM_MESSAGE_TYPE_MESSAGE, |
| 612 LM_MESSAGE_SUB_TYPE_CHAT); | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
613 |
| 1598 | 614 event = lm_message_node_add_child(x->node, "x", NULL); |
| 615 lm_message_node_set_attribute(event, "xmlns", NS_EVENT); | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
616 if (type == ROSTER_EVENT_DELIVERED) |
| 1598 | 617 lm_message_node_add_child(event, "delivered", NULL); |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
618 else if (type == ROSTER_EVENT_COMPOSING) |
| 1598 | 619 lm_message_node_add_child(event, "composing", NULL); |
| 620 lm_message_node_add_child(event, "id", msgid); | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
621 |
| 1598 | 622 lm_connection_send(lconnection, x, NULL); |
| 623 lm_message_unref(x); | |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
624 } |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
625 #endif |
|
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
626 |
| 1598 | 627 // xmpp_send_chatstate(buddy, state) |
| 1691 | 628 // Send a chatstate or event (XEP-22/85) according to the buddy's capabilities. |
| 997 | 629 // The message is sent to one of the resources with the highest priority. |
| 1691 | 630 #if defined XEP0022 || defined XEP0085 |
| 1598 | 631 void xmpp_send_chatstate(gpointer buddy, guint chatstate) |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
632 { |
| 1058 | 633 const char *bjid; |
| 1691 | 634 #ifdef XEP0085 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
635 GSList *resources, *p_res, *p_next; |
|
1476
77afd831f8f7
Avoid mixed declarations and code
Mikael Berthe <mikael@lilotux.net>
parents:
1448
diff
changeset
|
636 struct jep0085 *jep85 = NULL; |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
637 #endif |
| 1691 | 638 #ifdef XEP0022 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
639 struct jep0022 *jep22; |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
640 #endif |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
641 |
| 1058 | 642 bjid = buddy_getjid(buddy); |
| 643 if (!bjid) return; | |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
644 |
| 1691 | 645 #ifdef XEP0085 |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
646 /* Send the chatstate to the last resource (which should have the highest |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
647 priority). |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
648 If chatstate is "active", send an "active" state to all resources |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
649 which do not curently have this state. |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
650 */ |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
651 resources = buddy_getresources(buddy); |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
652 for (p_res = resources ; p_res ; p_res = p_next) { |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
653 p_next = g_slist_next(p_res); |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
654 jep85 = buddy_resource_jep85(buddy, p_res->data); |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
655 if (jep85 && jep85->support == CHATSTATES_SUPPORT_OK) { |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
656 // If p_next is NULL, this is the highest (prio) resource, i.e. |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
657 // the one we are probably writing to. |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
658 if (!p_next || (jep85->last_state_sent != ROSTER_EVENT_ACTIVE && |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
659 chatstate == ROSTER_EVENT_ACTIVE)) |
| 1598 | 660 xmpp_send_jep85_chatstate(bjid, p_res->data, chatstate); |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
661 } |
|
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
662 g_free(p_res->data); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
663 } |
|
1091
10f9d6fcfeab
JEP85: Reset composing/paused state when a resource with higher prio comes up
Mikael Berthe <mikael@lilotux.net>
parents:
1072
diff
changeset
|
664 g_slist_free(resources); |
|
1099
7804dbac3875
Fix a potential JEP22/85 issue introduced by changeset 10f9d6fcfeab
Mikael Berthe <mikael@lilotux.net>
parents:
1091
diff
changeset
|
665 // If the last resource had chatstates support when can return now, |
| 1691 | 666 // we don't want to send a XEP22 event. |
|
1099
7804dbac3875
Fix a potential JEP22/85 issue introduced by changeset 10f9d6fcfeab
Mikael Berthe <mikael@lilotux.net>
parents:
1091
diff
changeset
|
667 if (jep85 && jep85->support == CHATSTATES_SUPPORT_OK) |
|
7804dbac3875
Fix a potential JEP22/85 issue introduced by changeset 10f9d6fcfeab
Mikael Berthe <mikael@lilotux.net>
parents:
1091
diff
changeset
|
668 return; |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
669 #endif |
| 1691 | 670 #ifdef XEP0022 |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
671 jep22 = buddy_resource_jep22(buddy, NULL); |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
672 if (jep22 && jep22->support == CHATSTATES_SUPPORT_OK) { |
| 1598 | 673 xmpp_send_jep22_event(bjid, chatstate); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
674 } |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
675 #endif |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
676 } |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
677 #endif |
|
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
678 |
| 1598 | 679 |
|
999
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
680 // chatstates_reset_probed(fulljid) |
| 1691 | 681 // If the XEP has been probed for this contact, set it back to unknown so |
|
999
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
682 // that we probe it again. The parameter must be a full jid (w/ resource). |
| 1691 | 683 #if defined XEP0022 || defined XEP0085 |
|
999
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
684 static void chatstates_reset_probed(const char *fulljid) |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
685 { |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
686 char *rname, *barejid; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
687 GSList *sl_buddy; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
688 struct jep0085 *jep85; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
689 struct jep0022 *jep22; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
690 |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
691 rname = strchr(fulljid, JID_RESOURCE_SEPARATOR); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
692 if (!rname++) |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
693 return; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
694 |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
695 barejid = jidtodisp(fulljid); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
696 sl_buddy = roster_find(barejid, jidsearch, ROSTER_TYPE_USER); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
697 g_free(barejid); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
698 |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
699 if (!sl_buddy) |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
700 return; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
701 |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
702 jep85 = buddy_resource_jep85(sl_buddy->data, rname); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
703 jep22 = buddy_resource_jep22(sl_buddy->data, rname); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
704 |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
705 if (jep85 && jep85->support == CHATSTATES_SUPPORT_PROBED) |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
706 jep85->support = CHATSTATES_SUPPORT_UNKNOWN; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
707 if (jep22 && jep22->support == CHATSTATES_SUPPORT_PROBED) |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
708 jep22->support = CHATSTATES_SUPPORT_UNKNOWN; |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
709 } |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
710 #endif |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
711 |
|
1194
03d8fafe8104
Remove a warning when gpgme is disabled
Mikael Berthe <mikael@lilotux.net>
parents:
1166
diff
changeset
|
712 #ifdef HAVE_GPGME |
|
1104
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
713 // keys_mismatch(key, expectedkey) |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
714 // Return TRUE if both keys are non-null and "expectedkey" doesn't match |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
715 // the end of "key". |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
716 // If one of the keys is null, return FALSE. |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
717 // If expectedkey is less than 8 bytes long, return TRUE. |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
718 // |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
719 // Example: keys_mismatch("C9940A9BB0B92210", "B0B92210") will return FALSE. |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
720 static bool keys_mismatch(const char *key, const char *expectedkey) |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
721 { |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
722 int lk, lek; |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
723 |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
724 if (!expectedkey || !key) |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
725 return FALSE; |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
726 |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
727 lk = strlen(key); |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
728 lek = strlen(expectedkey); |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
729 |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
730 // If the expectedkey is less than 8 bytes long, this is probably a |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
731 // user mistake so we consider it's a mismatch. |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
732 if (lek < 8) |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
733 return TRUE; |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
734 |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
735 if (lek < lk) |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
736 key += lk - lek; |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
737 |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
738 return strcasecmp(key, expectedkey); |
|
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
739 } |
|
1194
03d8fafe8104
Remove a warning when gpgme is disabled
Mikael Berthe <mikael@lilotux.net>
parents:
1166
diff
changeset
|
740 #endif |
|
1104
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
741 |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
742 // check_signature(barejid, resourcename, xmldata, text) |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
743 // Verify the signature (in xmldata) of "text" for the contact |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
744 // barejid/resourcename. |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
745 // xmldata is the 'jabber:x:signed' stanza. |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
746 // If the key id is found, the contact's PGP data are updated. |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
747 static void check_signature(const char *barejid, const char *rname, |
| 1598 | 748 LmMessageNode *node, const char *text) |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
749 { |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
750 #ifdef HAVE_GPGME |
| 1598 | 751 const char *p, *key; |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
752 GSList *sl_buddy; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
753 struct pgp_data *res_pgpdata; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
754 gpgme_sigsum_t sigsum; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
755 |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
756 // All parameters must be valid |
| 1598 | 757 if (!(node && barejid && rname && text)) |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
758 return; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
759 |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
760 if (!gpg_enabled()) |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
761 return; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
762 |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
763 // Get the resource PGP data structure |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
764 sl_buddy = roster_find(barejid, jidsearch, ROSTER_TYPE_USER); |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
765 if (!sl_buddy) |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
766 return; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
767 res_pgpdata = buddy_resource_pgp(sl_buddy->data, rname); |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
768 if (!res_pgpdata) |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
769 return; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
770 |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
771 if (!node->name || strcmp(node->name, "x")) // XXX: probably useless |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
772 return; // We expect "<x xmlns='jabber:x:signed'>" |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
773 |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
774 // Get signature |
| 1598 | 775 p = lm_message_node_get_value(node); |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
776 if (!p) |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
777 return; |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
778 |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
779 key = gpg_verify(p, text, &sigsum); |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
780 if (key) { |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
781 const char *expectedkey; |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
782 char *buf; |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
783 g_free(res_pgpdata->sign_keyid); |
| 1598 | 784 res_pgpdata->sign_keyid = (char *)key; |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
785 res_pgpdata->last_sigsum = sigsum; |
|
1046
a3748bd3d010
Tell the user when a signature is bad
Mikael Berthe <mikael@lilotux.net>
parents:
1045
diff
changeset
|
786 if (sigsum & GPGME_SIGSUM_RED) { |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
787 buf = g_strdup_printf("Bad signature from <%s/%s>", barejid, rname); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
788 scr_WriteIncomingMessage(barejid, buf, 0, HBB_PREFIX_INFO, 0); |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
789 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
790 g_free(buf); |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
791 } |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
792 // Verify that the key id is the one we expect. |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
793 expectedkey = settings_pgp_getkeyid(barejid); |
|
1104
382972712208
Allow short key format in check_signature()
Mikael Berthe <mikael@lilotux.net>
parents:
1099
diff
changeset
|
794 if (keys_mismatch(key, expectedkey)) { |
|
1067
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
795 buf = g_strdup_printf("Warning: The KeyId from <%s/%s> doesn't match " |
|
a5dc85fdebde
Add key comparison for signatures & use user-provided PGP keys for encryption
Mikael Berthe <mikael@lilotux.net>
parents:
1065
diff
changeset
|
796 "the key you set up", barejid, rname); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
797 scr_WriteIncomingMessage(barejid, buf, 0, HBB_PREFIX_INFO, 0); |
|
1046
a3748bd3d010
Tell the user when a signature is bad
Mikael Berthe <mikael@lilotux.net>
parents:
1045
diff
changeset
|
798 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
a3748bd3d010
Tell the user when a signature is bad
Mikael Berthe <mikael@lilotux.net>
parents:
1045
diff
changeset
|
799 g_free(buf); |
|
a3748bd3d010
Tell the user when a signature is bad
Mikael Berthe <mikael@lilotux.net>
parents:
1045
diff
changeset
|
800 } |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
801 } |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
802 #endif |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
803 } |
|
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
804 |
| 1598 | 805 static LmSSLResponse ssl_cb(LmSSL *ssl, LmSSLStatus status, gpointer ud) |
| 806 { | |
| 807 scr_LogPrint(LPRINT_LOGNORM, "SSL status:%d", status); | |
| 808 | |
| 809 switch (status) { | |
| 810 case LM_SSL_STATUS_NO_CERT_FOUND: | |
| 811 scr_LogPrint(LPRINT_LOGNORM, "No certificate found!"); | |
| 812 break; | |
| 813 case LM_SSL_STATUS_UNTRUSTED_CERT: | |
| 814 scr_LogPrint(LPRINT_LOGNORM, "Certificate is not trusted!"); | |
| 815 break; | |
| 816 case LM_SSL_STATUS_CERT_EXPIRED: | |
| 817 scr_LogPrint(LPRINT_LOGNORM, "Certificate has expired!"); | |
| 818 break; | |
| 819 case LM_SSL_STATUS_CERT_NOT_ACTIVATED: | |
| 820 scr_LogPrint(LPRINT_LOGNORM, "Certificate has not been activated!"); | |
| 821 break; | |
| 822 case LM_SSL_STATUS_CERT_HOSTNAME_MISMATCH: | |
| 823 scr_LogPrint(LPRINT_LOGNORM, | |
| 824 "Certificate hostname does not match expected hostname!"); | |
| 825 break; | |
| 826 case LM_SSL_STATUS_CERT_FINGERPRINT_MISMATCH: { | |
| 827 char fpr[49]; | |
| 828 fingerprint_to_hex((const unsigned char*)lm_ssl_get_fingerprint(ssl), | |
| 829 fpr); | |
| 830 scr_LogPrint(LPRINT_LOGNORM, | |
| 831 "Certificate fingerprint does not match expected fingerprint!"); | |
| 832 scr_LogPrint(LPRINT_LOGNORM, "Remote fingerprint: %s", fpr); | |
| 833 | |
| 834 scr_LogPrint(LPRINT_LOGNORM, "Expected fingerprint: %s", | |
| 835 settings_opt_get("ssl_fingerprint")); | |
| 836 | |
| 837 return LM_SSL_RESPONSE_STOP; | |
| 838 break; | |
| 839 } | |
| 840 case LM_SSL_STATUS_GENERIC_ERROR: | |
| 841 scr_LogPrint(LPRINT_LOGNORM, "Generic SSL error!"); | |
| 842 break; | |
| 843 } | |
| 844 | |
|
1656
fbab3c1300d5
Update fix for ssl_ignore_checks option (changeset 8effa82ae593)
franky
parents:
1655
diff
changeset
|
845 if (settings_opt_get_int("ssl_ignore_checks")) |
| 1598 | 846 return LM_SSL_RESPONSE_CONTINUE; |
| 847 return LM_SSL_RESPONSE_STOP; | |
| 848 } | |
| 849 | |
| 850 static void connection_auth_cb(LmConnection *connection, gboolean success, | |
| 851 gpointer user_data) | |
| 852 { | |
| 853 if (success) { | |
| 1731 | 854 |
| 855 xmpp_iq_request(NULL, NS_ROSTER); | |
| 856 xmpp_request_storage("storage:bookmarks"); | |
| 857 xmpp_request_storage("storage:rosternotes"); | |
| 858 | |
| 859 /* XXX Not needed before xmpp_setprevstatus() | |
| 1598 | 860 LmMessage *m; |
| 861 m = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_PRESENCE, | |
| 862 LM_MESSAGE_SUB_TYPE_AVAILABLE); | |
| 863 lm_connection_send(connection, m, NULL); | |
| 1731 | 864 lm_message_unref(m); |
| 865 */ | |
| 1598 | 866 |
| 867 xmpp_setprevstatus(); | |
| 868 | |
| 869 AutoConnection = TRUE; | |
| 870 } else | |
| 871 scr_LogPrint(LPRINT_LOGNORM, "Authentication failed"); | |
| 872 } | |
| 873 | |
| 874 gboolean xmpp_reconnect() | |
| 875 { | |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
876 if (!lconnection) |
| 1598 | 877 xmpp_connect(); |
| 878 return FALSE; | |
| 879 } | |
| 880 | |
| 881 static void _try_to_reconnect(void) | |
| 882 { | |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
883 xmpp_disconnect(); |
| 1598 | 884 if (AutoConnection) |
| 885 g_timeout_add_seconds(RECONNECTION_TIMEOUT, xmpp_reconnect, NULL); | |
| 886 } | |
| 887 | |
| 888 static void connection_open_cb(LmConnection *connection, gboolean success, | |
| 889 gpointer user_data) | |
| 890 { | |
|
1663
dcb0b4522ded
Fix GError handling
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1656
diff
changeset
|
891 GError *error = NULL; |
| 1598 | 892 |
| 893 if (success) { | |
| 1613 | 894 const char *password, *resource; |
| 895 char *username; | |
|
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1610
diff
changeset
|
896 username = jid_get_username(settings_opt_get("jid")); |
| 1598 | 897 password = settings_opt_get("password"); |
| 898 resource = strchr(lm_connection_get_jid(connection), | |
| 899 JID_RESOURCE_SEPARATOR); | |
| 900 if (resource) | |
| 901 resource++; | |
| 902 | |
|
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1610
diff
changeset
|
903 if (!lm_connection_authenticate(lconnection, username, password, resource, |
| 1598 | 904 connection_auth_cb, NULL, FALSE, &error)) { |
|
1717
c12455fec611
Remove extra newlines in scr_LogPrint() calls
Mikael Berthe <mikael@lilotux.net>
parents:
1716
diff
changeset
|
905 scr_LogPrint(LPRINT_LOGNORM, "Failed to authenticate: %s", |
| 1598 | 906 error->message); |
|
1663
dcb0b4522ded
Fix GError handling
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1656
diff
changeset
|
907 g_error_free (error); |
| 1598 | 908 _try_to_reconnect(); |
| 909 } | |
|
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1610
diff
changeset
|
910 g_free(username); |
| 1598 | 911 } else { |
| 912 scr_LogPrint(LPRINT_LOGNORM, "There was an error while connecting."); | |
| 913 _try_to_reconnect(); | |
| 914 } | |
| 915 } | |
| 916 | |
| 917 static void connection_close_cb(LmConnection *connection, | |
| 918 LmDisconnectReason reason, | |
| 919 gpointer user_data) | |
| 920 { | |
| 921 const char *str; | |
| 922 | |
| 923 switch (reason) { | |
| 924 case LM_DISCONNECT_REASON_OK: | |
| 925 str = "LM_DISCONNECT_REASON_OK"; | |
| 926 break; | |
| 927 case LM_DISCONNECT_REASON_PING_TIME_OUT: | |
| 928 str = "LM_DISCONNECT_REASON_PING_TIME_OUT"; | |
| 929 break; | |
| 930 case LM_DISCONNECT_REASON_HUP: | |
| 931 str = "LM_DISCONNECT_REASON_HUP"; | |
| 932 break; | |
| 933 case LM_DISCONNECT_REASON_ERROR: | |
| 934 str = "LM_DISCONNECT_REASON_ERROR"; | |
| 935 break; | |
| 936 case LM_DISCONNECT_REASON_UNKNOWN: | |
| 937 default: | |
| 938 str = "LM_DISCONNECT_REASON_UNKNOWN"; | |
| 939 break; | |
| 940 } | |
| 941 | |
| 942 if (reason != LM_DISCONNECT_REASON_OK) | |
| 943 _try_to_reconnect(); | |
| 944 | |
| 945 // Free bookmarks | |
| 946 if (bookmarks) | |
| 947 lm_message_node_unref(bookmarks); | |
| 948 bookmarks = NULL; | |
| 949 // Free roster | |
| 950 roster_free(); | |
| 951 if (rosternotes) | |
| 952 lm_message_node_unref(rosternotes); | |
| 953 rosternotes = NULL; | |
| 954 // Update display | |
| 955 update_roster = TRUE; | |
| 956 scr_UpdateBuddyWindow(); | |
| 957 | |
|
1715
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
958 if (!reason) |
|
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
959 scr_LogPrint(LPRINT_LOGNORM, "Disconnected."); |
|
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
960 else |
|
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
961 scr_LogPrint(LPRINT_NORMAL, "Disconnected, reason: %d->'%s'", reason, str); |
|
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
962 |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
963 xmpp_setstatus(offline, NULL, mystatusmsg, TRUE); |
| 1598 | 964 } |
| 965 | |
| 966 static void handle_state_events(const char *from, LmMessageNode *node) | |
| 967 { | |
| 1691 | 968 #if defined XEP0022 || defined XEP0085 |
| 1598 | 969 LmMessageNode *state_ns = NULL; |
| 970 const char *body; | |
| 971 char *rname, *bjid; | |
| 972 GSList *sl_buddy; | |
| 973 guint events; | |
| 974 struct jep0022 *jep22 = NULL; | |
| 975 struct jep0085 *jep85 = NULL; | |
| 976 enum { | |
| 1691 | 977 XEP_none, |
| 978 XEP_85, | |
| 979 XEP_22 | |
| 980 } which_jep = XEP_none; | |
| 1598 | 981 |
| 982 rname = strchr(from, JID_RESOURCE_SEPARATOR); | |
| 983 if (rname) | |
| 984 ++rname; | |
| 985 else | |
| 986 rname = (char *)from + strlen(from); | |
| 987 bjid = jidtodisp(from); | |
| 988 sl_buddy = roster_find(bjid, jidsearch, ROSTER_TYPE_USER); | |
| 989 g_free(bjid); | |
| 990 | |
| 991 /* XXX Actually that's wrong, since it filters out server "offline" | |
| 1691 | 992 messages (for XEP-0022). This XEP is (almost) deprecated so |
| 1598 | 993 we don't really care. */ |
| 994 if (!sl_buddy) { | |
| 995 return; | |
| 996 } | |
| 997 | |
| 1691 | 998 /* Let's see chich XEP the contact uses. If possible, we'll use |
| 999 XEP-85, if not we'll look for XEP-22 support. */ | |
| 1598 | 1000 events = buddy_resource_getevents(sl_buddy->data, rname); |
| 1001 | |
| 1002 jep85 = buddy_resource_jep85(sl_buddy->data, rname); | |
| 1003 if (jep85) { | |
| 1004 state_ns = lm_message_node_find_xmlns(node, NS_CHATSTATES); | |
| 1005 if (state_ns) | |
| 1691 | 1006 which_jep = XEP_85; |
| 1598 | 1007 } |
| 1008 | |
| 1691 | 1009 if (which_jep != XEP_85) { /* Fall back to XEP-0022 */ |
| 1598 | 1010 jep22 = buddy_resource_jep22(sl_buddy->data, rname); |
| 1011 if (jep22) { | |
| 1012 state_ns = lm_message_node_find_xmlns(node, NS_EVENT); | |
| 1013 if (state_ns) | |
| 1691 | 1014 which_jep = XEP_22; |
| 1598 | 1015 } |
| 1016 } | |
| 1017 | |
| 1018 if (!which_jep) { /* Sender does not use chat states */ | |
| 1019 return; | |
| 1020 } | |
| 1021 | |
| 1022 body = lm_message_node_get_child_value(node, "body"); | |
| 1023 | |
| 1691 | 1024 if (which_jep == XEP_85) { /* XEP-0085 */ |
| 1598 | 1025 jep85->support = CHATSTATES_SUPPORT_OK; |
| 1026 | |
| 1027 if (!strcmp(state_ns->name, "composing")) { | |
| 1028 jep85->last_state_rcvd = ROSTER_EVENT_COMPOSING; | |
| 1029 } else if (!strcmp(state_ns->name, "active")) { | |
| 1030 jep85->last_state_rcvd = ROSTER_EVENT_ACTIVE; | |
| 1031 } else if (!strcmp(state_ns->name, "paused")) { | |
| 1032 jep85->last_state_rcvd = ROSTER_EVENT_PAUSED; | |
| 1033 } else if (!strcmp(state_ns->name, "inactive")) { | |
| 1034 jep85->last_state_rcvd = ROSTER_EVENT_INACTIVE; | |
| 1035 } else if (!strcmp(state_ns->name, "gone")) { | |
| 1036 jep85->last_state_rcvd = ROSTER_EVENT_GONE; | |
| 1037 } | |
| 1038 events = jep85->last_state_rcvd; | |
| 1691 | 1039 } else { /* XEP-0022 */ |
| 1040 #ifdef XEP0022 | |
| 1598 | 1041 const char *msgid; |
| 1042 jep22->support = CHATSTATES_SUPPORT_OK; | |
| 1043 jep22->last_state_rcvd = ROSTER_EVENT_NONE; | |
| 1044 | |
| 1045 msgid = lm_message_node_get_attribute(node, "id"); | |
| 1046 | |
| 1047 if (lm_message_node_get_child(state_ns, "composing")) { | |
| 1048 // Clear composing if the message contains a body | |
| 1049 if (body) | |
| 1050 events &= ~ROSTER_EVENT_COMPOSING; | |
| 1051 else | |
| 1052 events |= ROSTER_EVENT_COMPOSING; | |
| 1053 jep22->last_state_rcvd |= ROSTER_EVENT_COMPOSING; | |
| 1054 | |
| 1055 } else { | |
| 1056 events &= ~ROSTER_EVENT_COMPOSING; | |
| 1057 } | |
| 1058 | |
| 1059 // Cache the message id | |
| 1060 g_free(jep22->last_msgid_rcvd); | |
| 1061 if (msgid) | |
| 1062 jep22->last_msgid_rcvd = g_strdup(msgid); | |
| 1063 else | |
| 1064 jep22->last_msgid_rcvd = NULL; | |
| 1065 | |
| 1066 if (lm_message_node_get_child(state_ns, "delivered")) { | |
| 1067 jep22->last_state_rcvd |= ROSTER_EVENT_DELIVERED; | |
| 1068 | |
| 1069 // Do we have to send back an ACK? | |
| 1070 if (body) | |
| 1071 xmpp_send_jep22_event(from, ROSTER_EVENT_DELIVERED); | |
| 1072 } | |
| 1073 #endif | |
| 1074 } | |
| 1075 | |
| 1076 buddy_resource_setevents(sl_buddy->data, rname, events); | |
| 1077 | |
| 1078 update_roster = TRUE; | |
| 1079 #endif | |
| 1080 } | |
| 1081 | |
| 1082 static void gotmessage(LmMessageSubType type, const char *from, | |
| 1083 const char *body, const char *enc, const char *subject, | |
| 1084 time_t timestamp, LmMessageNode *node_signed) | |
| 29 | 1085 { |
| 1058 | 1086 char *bjid; |
|
1689
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1087 const char *rname; |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1088 char *decrypted_pgp = NULL; |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1089 char *decrypted_otr = NULL; |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1090 int otr_msg = 0, free_msg = 0; |
| 29 | 1091 |
| 1058 | 1092 bjid = jidtodisp(from); |
|
441
51b8f10cfeb8
Handle g_locale_from_utf8() failures
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1093 |
|
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
960
diff
changeset
|
1094 rname = strchr(from, JID_RESOURCE_SEPARATOR); |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
444
diff
changeset
|
1095 if (rname) rname++; |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1096 |
|
1042
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1097 #ifdef HAVE_GPGME |
|
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1098 if (enc && gpg_enabled()) { |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1099 decrypted_pgp = gpg_decrypt(enc); |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1100 if (decrypted_pgp) { |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1101 body = decrypted_pgp; |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
1102 } |
|
1042
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1103 } |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
1104 // Check signature of an unencrypted message |
| 1598 | 1105 if (node_signed && gpg_enabled()) |
| 1106 check_signature(bjid, rname, node_signed, decrypted_pgp); | |
|
1042
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1107 #endif |
|
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1108 |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1109 #ifdef HAVE_LIBOTR |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1110 if (otr_enabled()) { |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1111 decrypted_otr = (char*)body; |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1112 otr_msg = otr_receive(&decrypted_otr, bjid, &free_msg); |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1113 if (!decrypted_otr) { |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1114 goto gotmessage_return; |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1115 } |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1116 body = decrypted_otr; |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1117 } |
|
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1118 #endif |
|
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1119 |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1120 // Check for unexpected groupchat messages |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1121 // If we receive a groupchat message from a room we're not a member of, |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1122 // this is probably a server issue and the best we can do is to send |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1123 // a type unavailable. |
| 1598 | 1124 if (type == LM_MESSAGE_SUB_TYPE_GROUPCHAT && !roster_getnickname(bjid)) { |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1125 // It shouldn't happen, probably a server issue |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1126 GSList *room_elt; |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1127 char *mbuf; |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1128 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1129 mbuf = g_strdup_printf("Unexpected groupchat packet!"); |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1130 scr_LogPrint(LPRINT_LOGNORM, "%s", mbuf); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1131 scr_WriteIncomingMessage(bjid, mbuf, 0, HBB_PREFIX_INFO, 0); |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1132 g_free(mbuf); |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1133 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1134 // Send back an unavailable packet |
| 1598 | 1135 xmpp_setstatus(offline, bjid, "", TRUE); |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1136 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1137 // MUC |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1138 // Make sure this is a room (it can be a conversion user->room) |
| 1058 | 1139 room_elt = roster_find(bjid, jidsearch, 0); |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1140 if (!room_elt) { |
|
1665
1a4890514eb9
Clean up some dead assignments/dead variables
Ulrich Spörlein
parents:
1663
diff
changeset
|
1141 roster_add_user(bjid, NULL, NULL, ROSTER_TYPE_ROOM, sub_none, -1); |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1142 } else { |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1143 buddy_settype(room_elt->data, ROSTER_TYPE_ROOM); |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1144 } |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1145 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1146 buddylist_build(); |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1147 scr_DrawRoster(); |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1148 goto gotmessage_return; |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1149 } |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1150 |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1151 // We don't call the message_in hook if 'block_unsubscribed' is true and |
|
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1152 // this is a regular message from an unsubscribed user. |
|
956
819396bebdf5
Do not block system messages when block_unsubscribed is set
Mikael Berthe <mikael@lilotux.net>
parents:
940
diff
changeset
|
1153 // System messages (from our server) are allowed. |
|
1689
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1154 if (settings_opt_get_int("block_unsubscribed") && |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1155 !(roster_getsubscription(bjid) & sub_from) && |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1156 (type != LM_MESSAGE_SUB_TYPE_GROUPCHAT)) { |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1157 char *sbjid = jidtodisp(lm_connection_get_jid(lconnection)); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1158 const char *server = strchr(sbjid, JID_DOMAIN_SEPARATOR); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1159 if (g_strcmp0(server, bjid)) { |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1160 scr_LogPrint(LPRINT_LOGNORM, "Blocked a message from <%s>", bjid); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1161 g_free(sbjid); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1162 goto gotmessage_return; |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1163 } |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1164 g_free(sbjid); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1165 } |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1166 |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1167 { // format and pass message for further processing |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1168 gchar *fullbody = NULL; |
|
1484
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1169 guint encrypted; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1170 |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1171 if (decrypted_pgp) |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1172 encrypted = ENCRYPTED_PGP; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1173 else if (otr_msg) |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1174 encrypted = ENCRYPTED_OTR; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1175 else |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1176 encrypted = 0; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1177 |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1178 if (subject) { |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1179 if (body) |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1180 fullbody = g_strdup_printf("[%s]\n%s", subject, body); |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1181 else |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1182 fullbody = g_strdup_printf("[%s]\n", subject); |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1183 body = fullbody; |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1184 } |
|
1484
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1185 hk_message_in(bjid, rname, timestamp, body, type, encrypted); |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1186 g_free(fullbody); |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1187 } |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1188 |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1189 gotmessage_return: |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1190 // Clean up and exit |
| 1058 | 1191 g_free(bjid); |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1192 g_free(decrypted_pgp); |
|
1333
e30a9d907105
Minor coding style adjustments
Mikael Berthe <mikael@lilotux.net>
parents:
1330
diff
changeset
|
1193 if (free_msg) |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1194 g_free(decrypted_otr); |
| 29 | 1195 } |
| 1196 | |
|
420
04a0b450380b
Display error code/message when receiving a message packet with "error" type
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
1197 |
| 1598 | 1198 static LmHandlerResult handle_messages(LmMessageHandler *handler, |
| 1199 LmConnection *connection, | |
| 1200 LmMessage *m, gpointer user_data) | |
|
579
0c67755e0fa7
Introduce a handle_presence_muc() function
Mikael Berthe <mikael@lilotux.net>
parents:
578
diff
changeset
|
1201 { |
| 1598 | 1202 const char *p, *from=lm_message_get_from(m); |
| 1203 char *r, *s; | |
| 1204 LmMessageNode *x; | |
| 1205 const char *body = NULL; | |
| 1206 const char *enc = NULL; | |
| 1207 const char *subject = NULL; | |
|
1001
dff25377c11f
Auto-reconnect after a network/server failure
Mikael Berthe <mikael@lilotux.net>
parents:
999
diff
changeset
|
1208 time_t timestamp = 0L; |
| 1646 | 1209 LmMessageSubType mstype; |
| 1210 | |
| 1211 mstype = lm_message_get_sub_type(m); | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1212 |
| 1598 | 1213 body = lm_message_node_get_child_value(m->node, "body"); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1214 |
| 1598 | 1215 x = lm_message_node_find_xmlns(m->node, NS_ENCRYPTED); |
| 1216 if (x && (p = lm_message_node_get_value(x)) != NULL) | |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1217 enc = p; |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1218 |
| 1598 | 1219 p = lm_message_node_get_child_value(m->node, "subject"); |
| 1220 if (p != NULL) { | |
| 1646 | 1221 if (mstype != LM_MESSAGE_SUB_TYPE_GROUPCHAT) { |
| 1598 | 1222 // Chat message |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1223 subject = p; |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1224 } else { // Room topic |
|
549
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1225 GSList *roombuddy; |
| 1598 | 1226 gchar *mbuf; |
| 1227 const gchar *subj = p; | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1228 // Get the room (s) and the nickname (r) |
| 1598 | 1229 s = g_strdup(lm_message_get_from(m)); |
|
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
960
diff
changeset
|
1230 r = strchr(s, JID_RESOURCE_SEPARATOR); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1231 if (r) *r++ = 0; |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1232 else r = s; |
|
549
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1233 // Set the new topic |
|
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1234 roombuddy = roster_find(s, jidsearch, 0); |
|
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1235 if (roombuddy) |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1236 buddy_settopic(roombuddy->data, subj); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1237 // Display inside the room window |
|
560
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1238 if (r == s) { |
|
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1239 // No specific resource (this is certainly history) |
| 1598 | 1240 mbuf = g_strdup_printf("The topic has been set to: %s", subj); |
|
560
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1241 } else { |
| 1598 | 1242 mbuf = g_strdup_printf("%s has set the topic to: %s", r, subj); |
|
560
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1243 } |
| 1598 | 1244 scr_WriteIncomingMessage(s, mbuf, 0, |
| 1245 HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0); | |
| 1246 if (settings_opt_get_int("log_muc_conf")) | |
| 1247 hlog_write_message(s, 0, -1, mbuf); | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1248 g_free(s); |
| 1598 | 1249 g_free(mbuf); |
|
732
ab623c2df964
MUC: Update the chat status line when the topic is updated
Mikael Berthe <mikael@lilotux.net>
parents:
724
diff
changeset
|
1250 // The topic is displayed in the chat status line, so refresh now. |
|
ab623c2df964
MUC: Update the chat status line when the topic is updated
Mikael Berthe <mikael@lilotux.net>
parents:
724
diff
changeset
|
1251 scr_UpdateChatStatus(TRUE); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1252 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1253 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1254 |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1255 // Timestamp? |
| 1598 | 1256 timestamp = lm_message_node_get_timestamp(m->node); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1257 |
| 1646 | 1258 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
| 1598 | 1259 x = lm_message_node_get_child(m->node, "error"); |
|
1213
4a7db2870685
Improve Private Storage detection.
Mikael Berthe <mikael@lilotux.net>
parents:
1212
diff
changeset
|
1260 display_server_error(x); |
| 1691 | 1261 #if defined XEP0022 || defined XEP0085 |
| 1262 // If the XEP85/22 support is probed, set it back to unknown so that | |
|
999
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
1263 // we probe it again. |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
1264 chatstates_reset_probed(from); |
|
9687ecc59303
Redo chat states detection if we receive a message error packet from a contact
Mikael Berthe <mikael@lilotux.net>
parents:
998
diff
changeset
|
1265 #endif |
|
1132
1650056b96fc
Do not use chat states of error messages :)
Mikael Berthe <mikael@lilotux.net>
parents:
1128
diff
changeset
|
1266 } else { |
| 1598 | 1267 handle_state_events(from, m->node); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1268 } |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1269 if (from && (body || subject)) |
| 1646 | 1270 gotmessage(mstype, from, body, enc, subject, timestamp, |
| 1598 | 1271 lm_message_node_find_xmlns(m->node, NS_SIGNED)); |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
1272 // Report received message if message receipt was requested |
| 1602 | 1273 if (lm_message_node_get_child(m->node, "request")) { |
| 1274 LmMessage *rcvd = lm_message_new(from, LM_MESSAGE_TYPE_MESSAGE); | |
| 1275 lm_message_node_set_attribute(rcvd->node, "id", lm_message_get_id(m)); | |
| 1276 lm_message_node_set_attribute | |
| 1277 (lm_message_node_add_child(rcvd->node, "received", NULL), | |
| 1278 "xmlns", NS_RECEIPTS); | |
| 1279 lm_connection_send(connection, rcvd, NULL); | |
| 1280 lm_message_unref(rcvd); | |
| 1281 } | |
| 1128 | 1282 |
| 1283 if (from) { | |
| 1598 | 1284 x = lm_message_node_find_xmlns(m->node, |
| 1285 "http://jabber.org/protocol/muc#user"); | |
| 1286 if (x && !strcmp(x->name, "x")) | |
| 1128 | 1287 got_muc_message(from, x); |
| 1288 } | |
| 1598 | 1289 |
| 1290 return LM_HANDLER_RESULT_REMOVE_MESSAGE; | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1291 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1292 |
| 1600 | 1293 static LmHandlerResult cb_caps(LmMessageHandler *h, LmConnection *c, |
| 1294 LmMessage *m, gpointer user_data) | |
| 1295 { | |
| 1296 char *ver = user_data; | |
| 1646 | 1297 LmMessageSubType mstype = lm_message_get_sub_type(m); |
| 1600 | 1298 |
| 1637 | 1299 caps_add(ver); |
| 1646 | 1300 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
| 1600 | 1301 display_server_error(lm_message_node_get_child(m->node, "error")); |
| 1646 | 1302 } else if (mstype == LM_MESSAGE_SUB_TYPE_RESULT) { |
| 1600 | 1303 LmMessageNode *info; |
| 1304 LmMessageNode *query = lm_message_node_get_child(m->node, "query"); | |
| 1305 | |
| 1306 info = lm_message_node_get_child(query, "identity"); | |
| 1307 if (info) | |
| 1308 caps_set_identity(ver, lm_message_node_get_attribute(info, "category"), | |
| 1309 lm_message_node_get_attribute(info, "name"), | |
| 1310 lm_message_node_get_attribute(info, "type")); | |
| 1311 info = lm_message_node_get_child(query, "feature"); | |
| 1312 while (info) { | |
| 1313 if (!g_strcmp0(info->name, "feature")) | |
| 1314 caps_add_feature(ver, lm_message_node_get_attribute(info, "var")); | |
| 1315 info = info->next; | |
| 1316 } | |
| 1317 } | |
| 1318 g_free(ver); | |
| 1319 return LM_HANDLER_RESULT_REMOVE_MESSAGE; | |
| 1320 } | |
| 1321 | |
| 1598 | 1322 static LmHandlerResult handle_presence(LmMessageHandler *handler, |
| 1323 LmConnection *connection, | |
| 1324 LmMessage *m, gpointer user_data) | |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1325 { |
| 1731 | 1326 char *bjid; |
| 1598 | 1327 const char *from, *rname, *p=NULL, *ustmsg=NULL; |
| 1328 enum imstatus ust; | |
| 1329 char bpprio; | |
| 1330 time_t timestamp = 0L; | |
| 1600 | 1331 LmMessageNode *muc_packet, *caps; |
| 1646 | 1332 LmMessageSubType mstype; |
| 1598 | 1333 |
|
1644
73fc85ea0b4b
Do not send disco requests to offline resources
Mikael Berthe <mikael@lilotux.net>
parents:
1637
diff
changeset
|
1334 // Check for MUC presence packet |
| 1598 | 1335 muc_packet = lm_message_node_find_xmlns |
| 1336 (m->node, "http://jabber.org/protocol/muc#user"); | |
| 1337 | |
| 1338 from = lm_message_get_from(m); | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1339 |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1340 rname = strchr(from, JID_RESOURCE_SEPARATOR); |
| 1598 | 1341 if (rname) rname++; |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1342 |
| 1598 | 1343 if (settings_opt_get_int("ignore_self_presence")) { |
| 1344 const char *self_fjid = lm_connection_get_jid(connection); | |
| 1345 if (self_fjid && !strcasecmp(self_fjid, from)) { | |
| 1346 return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; // Ignoring self presence | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1347 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1348 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1349 |
| 1731 | 1350 bjid = jidtodisp(from); |
| 1646 | 1351 mstype = lm_message_get_sub_type(m); |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1352 |
| 1646 | 1353 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
| 1598 | 1354 LmMessageNode *x; |
| 1731 | 1355 scr_LogPrint(LPRINT_LOGNORM, "Error presence packet from <%s>", bjid); |
| 1598 | 1356 x = lm_message_node_find_child(m->node, "error"); |
| 1357 display_server_error(x); | |
| 1358 // Let's check it isn't a nickname conflict. | |
| 1359 // XXX Note: We should handle the <conflict/> string condition. | |
| 1360 if ((p = lm_message_node_get_attribute(x, "code")) != NULL) { | |
| 1361 if (atoi(p) == 409) { | |
| 1362 // 409 = conflict (nickname is in use or registered by another user) | |
| 1363 // If we are not inside this room, we should reset the nickname | |
| 1731 | 1364 GSList *room_elt = roster_find(bjid, jidsearch, 0); |
| 1598 | 1365 if (room_elt && !buddy_getinsideroom(room_elt->data)) |
| 1366 buddy_setnickname(room_elt->data, NULL); | |
| 1367 } | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1368 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1369 |
| 1731 | 1370 g_free(bjid); |
| 1598 | 1371 return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1372 } |
|
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1373 |
| 1598 | 1374 p = lm_message_node_get_child_value(m->node, "priority"); |
| 1375 if (p && *p) bpprio = (gchar)atoi(p); | |
| 1376 else bpprio = 0; | |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1377 |
| 1598 | 1378 ust = available; |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1379 |
| 1598 | 1380 p = lm_message_node_get_child_value(m->node, "show"); |
| 1381 if (p) { | |
| 1382 if (!strcmp(p, "away")) ust = away; | |
| 1383 else if (!strcmp(p, "dnd")) ust = dontdisturb; | |
| 1384 else if (!strcmp(p, "xa")) ust = notavail; | |
| 1385 else if (!strcmp(p, "chat")) ust = freeforchat; | |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1386 } |
|
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1387 |
| 1646 | 1388 if (mstype == LM_MESSAGE_SUB_TYPE_UNAVAILABLE) |
| 1598 | 1389 ust = offline; |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1390 |
| 1598 | 1391 ustmsg = lm_message_node_get_child_value(m->node, "status"); |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1392 |
| 1598 | 1393 // Timestamp? |
| 1394 timestamp = lm_message_node_get_timestamp(m->node); | |
| 1395 | |
| 1396 if (muc_packet) { | |
| 1397 // This is a MUC presence message | |
| 1731 | 1398 handle_muc_presence(from, muc_packet, bjid, rname, |
| 1598 | 1399 ust, ustmsg, timestamp, bpprio); |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1400 } else { |
| 1598 | 1401 // Not a MUC message, so this is a regular buddy... |
| 1402 // Call hk_statuschange() if status has changed or if the | |
| 1403 // status message is different | |
| 1404 const char *msg; | |
| 1731 | 1405 msg = roster_getstatusmsg(bjid, rname); |
| 1406 if ((ust != roster_getstatus(bjid, rname)) || | |
|
1728
15b3834cbe5f
Handle priority changes when the contact status doesn't change
Mikael Berthe <mikael@lilotux.net>
parents:
1722
diff
changeset
|
1407 (!ustmsg && msg && msg[0]) || |
|
15b3834cbe5f
Handle priority changes when the contact status doesn't change
Mikael Berthe <mikael@lilotux.net>
parents:
1722
diff
changeset
|
1408 (ustmsg && (!msg || strcmp(ustmsg, msg))) || |
| 1731 | 1409 (bpprio != roster_getprio(bjid, rname))) |
| 1410 hk_statuschange(bjid, rname, bpprio, timestamp, ust, ustmsg); | |
| 1598 | 1411 // Presence signature processing |
| 1412 if (!ustmsg) | |
| 1413 ustmsg = ""; // Some clients omit the <status/> element :-( | |
| 1731 | 1414 check_signature(bjid, rname, |
| 1415 lm_message_node_find_xmlns(m->node, NS_SIGNED), ustmsg); | |
| 1128 | 1416 } |
| 1417 | |
|
1644
73fc85ea0b4b
Do not send disco requests to offline resources
Mikael Berthe <mikael@lilotux.net>
parents:
1637
diff
changeset
|
1418 // XEP-0115 Entity Capabilities |
| 1600 | 1419 caps = lm_message_node_find_xmlns(m->node, NS_CAPS); |
|
1644
73fc85ea0b4b
Do not send disco requests to offline resources
Mikael Berthe <mikael@lilotux.net>
parents:
1637
diff
changeset
|
1420 if (caps && ust != offline) { |
| 1600 | 1421 const char *ver = lm_message_node_get_attribute(caps, "ver"); |
| 1422 GSList *sl_buddy = NULL; | |
| 1423 if (rname) | |
| 1731 | 1424 sl_buddy = roster_find(bjid, jidsearch, ROSTER_TYPE_USER); |
|
1644
73fc85ea0b4b
Do not send disco requests to offline resources
Mikael Berthe <mikael@lilotux.net>
parents:
1637
diff
changeset
|
1425 // Only cache the caps if the user is on the roster |
| 1600 | 1426 if (sl_buddy && buddy_getonserverflag(sl_buddy->data)) { |
| 1427 buddy_resource_setcaps(sl_buddy->data, rname, ver); | |
| 1428 | |
| 1429 if (!caps_has_hash(ver)) { | |
| 1430 char *node; | |
| 1431 LmMessageHandler *handler; | |
| 1432 LmMessage *iq = lm_message_new_with_sub_type(from, LM_MESSAGE_TYPE_IQ, | |
| 1433 LM_MESSAGE_SUB_TYPE_GET); | |
| 1434 node = g_strdup_printf("%s#%s", | |
| 1435 lm_message_node_get_attribute(caps, "node"), | |
| 1436 ver); | |
| 1437 lm_message_node_set_attributes | |
| 1438 (lm_message_node_add_child(iq->node, "query", NULL), | |
| 1439 "xmlns", NS_DISCO_INFO, | |
| 1440 "node", node, | |
| 1441 NULL); | |
| 1442 g_free(node); | |
| 1443 handler = lm_message_handler_new(cb_caps, g_strdup(ver), NULL); | |
| 1444 lm_connection_send_with_reply(connection, iq, handler, NULL); | |
| 1445 lm_message_unref(iq); | |
| 1446 lm_message_handler_unref(handler); | |
| 1447 } | |
| 1448 } | |
| 1449 } | |
| 1450 | |
| 1731 | 1451 g_free(bjid); |
| 1598 | 1452 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
| 1128 | 1453 } |
| 1454 | |
| 1455 | |
| 1598 | 1456 static LmHandlerResult handle_iq(LmMessageHandler *handler, |
| 1457 LmConnection *connection, | |
| 1458 LmMessage *m, gpointer user_data) | |
| 1459 { | |
| 1460 int i; | |
| 1461 const char *xmlns = NULL; | |
| 1462 LmMessageNode *x; | |
| 1646 | 1463 LmMessageSubType mstype = lm_message_get_sub_type(m); |
| 1598 | 1464 |
|
1647
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1465 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
|
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1466 display_server_error(lm_message_node_get_child(m->node, "error")); |
|
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1467 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
|
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1468 } |
|
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1469 |
| 1598 | 1470 for (x = m->node->children; x; x=x->next) { |
| 1471 xmlns = lm_message_node_get_attribute(x, "xmlns"); | |
| 1472 if (xmlns) | |
| 1473 for (i=0; iq_handlers[i].xmlns; ++i) | |
| 1474 if (!strcmp(iq_handlers[i].xmlns, xmlns)) | |
| 1475 return iq_handlers[i].handler(NULL, connection, m, user_data); | |
| 1476 xmlns = NULL; | |
| 1128 | 1477 } |
| 1478 | |
| 1646 | 1479 if ((mstype == LM_MESSAGE_SUB_TYPE_SET) || |
| 1480 (mstype == LM_MESSAGE_SUB_TYPE_GET)) | |
| 1598 | 1481 send_iq_error(connection, m, XMPP_ERROR_NOT_IMPLEMENTED); |
| 1482 | |
|
1721
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1483 scr_LogPrint(LPRINT_DEBUG, "Unhandled IQ: %s", lm_message_node_to_string(m->node)); |
|
1621
eec2fa456d0f
Do not print Unhandled IQ results to the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1616
diff
changeset
|
1484 |
|
1721
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1485 if (mstype != LM_MESSAGE_SUB_TYPE_RESULT) { |
|
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1486 scr_LogPrint(LPRINT_NORMAL, "Received unhandled IQ request from <%s>.", |
|
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1487 lm_message_get_from(m)); |
|
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1488 } |
|
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1489 |
| 1598 | 1490 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
| 1128 | 1491 } |
| 1492 | |
| 1598 | 1493 static LmHandlerResult handle_s10n(LmMessageHandler *handler, |
| 1494 LmConnection *connection, | |
| 1495 LmMessage *m, gpointer user_data) | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1496 { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1497 char *r; |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1498 char *buf; |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1499 int newbuddy; |
| 1598 | 1500 const char *from = lm_message_get_from(m); |
| 1646 | 1501 LmMessageSubType mstype; |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1502 |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1503 r = jidtodisp(from); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1504 |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1505 newbuddy = !roster_find(r, jidsearch, 0); |
| 1646 | 1506 mstype = lm_message_get_sub_type(m); |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1507 |
| 1646 | 1508 if (mstype == LM_MESSAGE_SUB_TYPE_SUBSCRIBE) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1509 /* The sender wishes to subscribe to our presence */ |
| 1598 | 1510 const char *msg; |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1511 |
| 1598 | 1512 msg = lm_message_node_get_child_value(m->node, "status"); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1513 |
|
617
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1514 buf = g_strdup_printf("<%s> wants to subscribe to your presence updates", |
|
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1515 from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1516 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
617
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1517 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1518 g_free(buf); |
|
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1519 |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1520 if (msg) { |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1521 buf = g_strdup_printf("<%s> said: %s", from, msg); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1522 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1523 replace_nl_with_dots(buf); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1524 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1525 g_free(buf); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1526 } |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1527 |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1528 // Create a new event item |
|
1685
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1529 { |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1530 const char *id; |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1531 char *desc = g_strdup_printf("<%s> wants to subscribe to your " |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1532 "presence updates", r); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1533 |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1534 id = evs_new(desc, NULL, 0, evscallback_subscription, g_strdup(r), |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1535 (GDestroyNotify)g_free); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1536 g_free(desc); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1537 if (id) |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1538 buf = g_strdup_printf("Please use /event %s accept|reject", id); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1539 else |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1540 buf = g_strdup_printf("Unable to create a new event!"); |
|
751
4a7271e69694
Avoid reusing events ids
Mikael Berthe <mikael@lilotux.net>
parents:
749
diff
changeset
|
1541 } |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1542 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
617
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1543 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1544 g_free(buf); |
| 1646 | 1545 } else if (mstype == LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1546 /* The sender is unsubscribing from our presence */ |
| 1598 | 1547 xmpp_send_s10n(from, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1548 buf = g_strdup_printf("<%s> is unsubscribing from your " |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1549 "presence updates", from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1550 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1551 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1552 g_free(buf); |
| 1646 | 1553 } else if (mstype == LM_MESSAGE_SUB_TYPE_SUBSCRIBED) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1554 /* The sender has allowed us to receive their presence */ |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1555 buf = g_strdup_printf("<%s> has allowed you to receive their " |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1556 "presence updates", from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1557 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1558 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1559 g_free(buf); |
| 1646 | 1560 } else if (mstype == LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1561 /* The subscription request has been denied or a previously-granted |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1562 subscription has been cancelled */ |
|
610
0e8247cf2bd1
Consider buddies as offline when they have cancelled our subscription
Mikael Berthe <mikael@lilotux.net>
parents:
609
diff
changeset
|
1563 roster_unsubscribed(from); |
|
859
cb2a3a1d985f
Make sure we update the roster when a subscription is cancelled
Mikael Berthe <mikael@lilotux.net>
parents:
845
diff
changeset
|
1564 update_roster = TRUE; |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1565 buf = g_strdup_printf("<%s> has cancelled your subscription to " |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1566 "their presence updates", from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1567 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1568 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1569 g_free(buf); |
| 603 | 1570 } else { |
| 1634 | 1571 g_free(r); |
| 1598 | 1572 return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1573 } |
|
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1574 |
|
1010
54405d09b15a
Add a call to buddylist_build()
Mikael Berthe <mikael@lilotux.net>
parents:
1008
diff
changeset
|
1575 if (newbuddy) |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1576 update_roster = TRUE; |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1577 g_free(r); |
| 1598 | 1578 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
| 1579 } | |
| 1580 | |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
1581 // TODO: Use the enum of loudmouth, when it's included in the header... |
| 1598 | 1582 typedef enum { |
| 1583 LM_LOG_LEVEL_VERBOSE = 1 << (G_LOG_LEVEL_USER_SHIFT), | |
| 1584 LM_LOG_LEVEL_NET = 1 << (G_LOG_LEVEL_USER_SHIFT + 1), | |
| 1585 LM_LOG_LEVEL_PARSER = 1 << (G_LOG_LEVEL_USER_SHIFT + 2), | |
| 1586 LM_LOG_LEVEL_SSL = 1 << (G_LOG_LEVEL_USER_SHIFT + 3), | |
| 1587 LM_LOG_LEVEL_SASL = 1 << (G_LOG_LEVEL_USER_SHIFT + 4), | |
| 1588 LM_LOG_LEVEL_ALL = (LM_LOG_LEVEL_NET | | |
| 1589 LM_LOG_LEVEL_VERBOSE | | |
| 1590 LM_LOG_LEVEL_PARSER | | |
| 1591 LM_LOG_LEVEL_SSL | | |
| 1592 LM_LOG_LEVEL_SASL) | |
| 1593 } LmLogLevelFlags; | |
| 1594 | |
| 1595 static void lm_debug_handler (const gchar *log_domain, | |
| 1596 GLogLevelFlags log_level, | |
| 1597 const gchar *message, | |
| 1598 gpointer user_data) | |
| 1599 { | |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1600 if (message && *message) { |
| 1598 | 1601 char *msg; |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1602 int mcabber_loglevel = settings_opt_get_int("tracelog_level"); |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1603 |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1604 if (mcabber_loglevel < 2) |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1605 return; |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1606 |
| 1598 | 1607 if (message[0] == '\n') |
| 1608 msg = g_strdup(&message[1]); | |
| 1609 else | |
| 1610 msg = g_strdup(message); | |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1611 |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1612 if (msg[strlen(msg)-1] == '\n') |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1613 msg[strlen(msg)-1] = '\0'; |
| 1598 | 1614 |
| 1615 if (log_level & LM_LOG_LEVEL_VERBOSE) { | |
| 1616 scr_LogPrint(LPRINT_DEBUG, "LM-VERBOSE: %s", msg); | |
| 1617 } | |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1618 if (log_level & LM_LOG_LEVEL_NET) { |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1619 if (mcabber_loglevel > 2) |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1620 scr_LogPrint(LPRINT_DEBUG, "LM-NET: %s", msg); |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1621 } else if (log_level & LM_LOG_LEVEL_PARSER) { |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1622 if (mcabber_loglevel > 3) |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1623 scr_LogPrint(LPRINT_DEBUG, "LM-PARSER: %s", msg); |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1624 } else if (log_level & LM_LOG_LEVEL_SASL) { |
| 1598 | 1625 scr_LogPrint(LPRINT_DEBUG, "LM-SASL: %s", msg); |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1626 } else if (log_level & LM_LOG_LEVEL_SSL) { |
| 1598 | 1627 scr_LogPrint(LPRINT_DEBUG, "LM-SSL: %s", msg); |
| 1628 } | |
| 1629 g_free(msg); | |
| 1630 } | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1631 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1632 |
| 1598 | 1633 |
| 1634 void xmpp_connect(void) | |
| 31 | 1635 { |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1636 const char *userjid, *password, *resource, *servername, *ssl_fpr; |
| 1598 | 1637 char *dynresource = NULL; |
| 1638 char fpr[16]; | |
| 1639 const char *proxy_host; | |
| 1640 const char *resource_prefix = PACKAGE_NAME; | |
| 1641 char *fjid; | |
| 1642 int ssl, tls; | |
| 1643 LmSSL *lssl; | |
| 1644 unsigned int port; | |
| 1645 unsigned int ping; | |
| 1646 LmMessageHandler *handler; | |
| 1647 GError *error = NULL; | |
| 1648 | |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1649 xmpp_disconnect(); |
| 1598 | 1650 |
| 1651 servername = settings_opt_get("server"); | |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1652 userjid = settings_opt_get("jid"); |
| 1598 | 1653 password = settings_opt_get("password"); |
| 1654 resource = settings_opt_get("resource"); | |
| 1655 proxy_host = settings_opt_get("proxy_host"); | |
| 1656 ssl_fpr = settings_opt_get("ssl_fingerprint"); | |
| 1657 | |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1658 if (!userjid) { |
|
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1659 scr_LogPrint(LPRINT_LOGNORM, "Your JID has not been specified!"); |
| 1598 | 1660 return; |
| 1661 } | |
| 1662 if (!password) { | |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1663 scr_LogPrint(LPRINT_LOGNORM, "Your password has not been specified!"); |
| 1598 | 1664 return; |
| 1665 } | |
| 1666 | |
|
1653
fca9a4c17432
Improve UI latency and CPU usage
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1647
diff
changeset
|
1667 lconnection = lm_connection_new_with_context(NULL, main_context); |
| 1598 | 1668 |
| 1669 g_log_set_handler("LM", LM_LOG_LEVEL_ALL, lm_debug_handler, NULL); | |
| 1670 | |
| 1671 ping = 40; | |
| 1672 if (settings_opt_get("pinginterval")) | |
| 1673 ping = (unsigned int) settings_opt_get_int("pinginterval"); | |
| 1674 lm_connection_set_keep_alive_rate(lconnection, ping); | |
| 1675 scr_LogPrint(LPRINT_DEBUG, "Ping interval established: %d secs", ping); | |
| 1676 | |
| 1677 lm_connection_set_disconnect_function(lconnection, connection_close_cb, | |
| 1678 NULL, NULL); | |
| 1679 | |
| 1680 handler = lm_message_handler_new(handle_messages, NULL, NULL); | |
| 1681 lm_connection_register_message_handler(lconnection, handler, | |
| 1682 LM_MESSAGE_TYPE_MESSAGE, | |
| 1683 LM_HANDLER_PRIORITY_NORMAL); | |
| 1684 lm_message_handler_unref(handler); | |
| 1685 | |
| 1686 handler = lm_message_handler_new(handle_iq, NULL, NULL); | |
| 1687 lm_connection_register_message_handler(lconnection, handler, | |
| 1688 LM_MESSAGE_TYPE_IQ, | |
| 1689 LM_HANDLER_PRIORITY_NORMAL); | |
| 1690 lm_message_handler_unref(handler); | |
| 1691 | |
| 1692 handler = lm_message_handler_new(handle_presence, NULL, NULL); | |
| 1693 lm_connection_register_message_handler(lconnection, handler, | |
| 1694 LM_MESSAGE_TYPE_PRESENCE, | |
| 1695 LM_HANDLER_PRIORITY_LAST); | |
| 1696 lm_message_handler_unref(handler); | |
| 1697 | |
| 1698 handler = lm_message_handler_new(handle_s10n, NULL, NULL); | |
| 1699 lm_connection_register_message_handler(lconnection, handler, | |
| 1700 LM_MESSAGE_TYPE_PRESENCE, | |
| 1701 LM_HANDLER_PRIORITY_NORMAL); | |
| 1702 lm_message_handler_unref(handler); | |
| 1703 | |
| 1704 /* Connect to server */ | |
|
1614
816fb624801d
Slightly change debugging output
Mikael Berthe <mikael@lilotux.net>
parents:
1613
diff
changeset
|
1705 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, "Connecting to server: %s", |
|
816fb624801d
Slightly change debugging output
Mikael Berthe <mikael@lilotux.net>
parents:
1613
diff
changeset
|
1706 servername ? servername : "..."); |
| 1598 | 1707 if (!resource) |
| 1708 resource = resource_prefix; | |
| 31 | 1709 |
| 1598 | 1710 if (!settings_opt_get("disable_random_resource")) { |
| 1711 #if HAVE_ARC4RANDOM | |
| 1712 dynresource = g_strdup_printf("%s.%08x", resource, arc4random()); | |
| 1713 #else | |
| 1714 unsigned int tab[2]; | |
| 1715 srand(time(NULL)); | |
| 1716 tab[0] = (unsigned int) (0xffff * (rand() / (RAND_MAX + 1.0))); | |
| 1717 tab[1] = (unsigned int) (0xffff * (rand() / (RAND_MAX + 1.0))); | |
| 1718 dynresource = g_strdup_printf("%s.%04x%04x", resource, tab[0], tab[1]); | |
| 1719 #endif | |
| 1720 resource = dynresource; | |
| 1721 } | |
| 1722 | |
| 1723 port = (unsigned int) settings_opt_get_int("port"); | |
| 1724 | |
| 1725 if (port) | |
| 1726 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, " using port %d", port); | |
| 1727 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, " resource %s", resource); | |
| 1728 | |
| 1729 if (proxy_host) { | |
| 1730 int proxy_port = settings_opt_get_int("proxy_port"); | |
| 1731 if (proxy_port <= 0 || proxy_port > 65535) { | |
| 1732 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, "Invalid proxy port: %d", | |
| 1733 proxy_port); | |
| 1734 } else { | |
| 1735 const char *proxy_user, *proxy_pass; | |
| 1736 LmProxy *lproxy; | |
| 1737 proxy_user = settings_opt_get("proxy_user"); | |
| 1738 proxy_pass = settings_opt_get("proxy_pass"); | |
| 1739 // Proxy initialization | |
| 1740 lproxy = lm_proxy_new_with_server(LM_PROXY_TYPE_HTTP, | |
| 1741 proxy_host, proxy_port); | |
| 1742 lm_proxy_set_username(lproxy, proxy_user); | |
| 1743 lm_proxy_set_password(lproxy, proxy_pass); | |
| 1744 lm_connection_set_proxy(lconnection, lproxy); | |
| 1745 lm_proxy_unref(lproxy); | |
| 1746 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, " using proxy %s:%d", | |
| 1747 proxy_host, proxy_port); | |
| 1748 } | |
| 1749 } | |
| 31 | 1750 |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1751 fjid = compose_jid(userjid, servername, resource); |
| 1598 | 1752 lm_connection_set_jid(lconnection, fjid); |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1753 if (servername) |
|
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1754 lm_connection_set_server(lconnection, servername); |
| 1598 | 1755 #if defined(HAVE_LIBOTR) |
| 1756 otr_init(fjid); | |
| 1757 #endif | |
| 1758 g_free(fjid); | |
| 1759 g_free(dynresource); | |
| 1760 | |
| 1761 ssl = settings_opt_get_int("ssl"); | |
| 1762 tls = settings_opt_get_int("tls"); | |
| 1763 | |
| 1764 if (!lm_ssl_is_supported()) { | |
| 1765 if (ssl || tls) { | |
| 1766 scr_LogPrint(LPRINT_LOGNORM, "** Error: SSL is NOT available, " | |
| 1767 "please recompile loudmouth with SSL enabled."); | |
| 1768 return; | |
| 1769 } | |
| 1770 } | |
| 1771 | |
| 1772 if (ssl && tls) { | |
| 1773 scr_LogPrint(LPRINT_LOGNORM, "You can only set ssl or tls, not both."); | |
| 1774 return; | |
| 1775 } | |
| 1776 | |
| 1777 if (!port) | |
| 1778 port = (ssl ? LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT); | |
| 1779 lm_connection_set_port(lconnection, port); | |
| 1780 | |
| 1781 if (ssl_fpr && (!hex_to_fingerprint(ssl_fpr, fpr))) { | |
| 1782 scr_LogPrint(LPRINT_LOGNORM, "** Plese set the fingerprint in the format " | |
| 1783 "97:5C:00:3F:1D:77:45:25:E2:C5:70:EC:83:C8:87:EE"); | |
| 1784 return; | |
| 1785 } | |
| 1786 | |
| 1787 lssl = lm_ssl_new((ssl_fpr ? fpr : NULL), ssl_cb, NULL, NULL); | |
| 1788 if (lssl) { | |
| 1789 lm_ssl_use_starttls(lssl, !ssl, tls); | |
| 1790 lm_connection_set_ssl(lconnection, lssl); | |
| 1791 lm_ssl_unref(lssl); | |
| 1792 } else if (ssl || tls) { | |
| 1793 scr_LogPrint(LPRINT_LOGNORM, "** Error: Couldn't create SSL struct."); | |
|
671
c5da36fd437a
Do not process packet if type = 0
Mikael Berthe <mikael@lilotux.net>
parents:
668
diff
changeset
|
1794 return; |
|
c5da36fd437a
Do not process packet if type = 0
Mikael Berthe <mikael@lilotux.net>
parents:
668
diff
changeset
|
1795 } |
|
c5da36fd437a
Do not process packet if type = 0
Mikael Berthe <mikael@lilotux.net>
parents:
668
diff
changeset
|
1796 |
| 1598 | 1797 if (!lm_connection_open(lconnection, connection_open_cb, |
| 1798 NULL, FALSE, &error)) { | |
| 1799 _try_to_reconnect(); | |
|
1717
c12455fec611
Remove extra newlines in scr_LogPrint() calls
Mikael Berthe <mikael@lilotux.net>
parents:
1716
diff
changeset
|
1800 scr_LogPrint(LPRINT_LOGNORM, "Failed to open: %s", error->message); |
|
1663
dcb0b4522ded
Fix GError handling
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1656
diff
changeset
|
1801 g_error_free (error); |
| 1598 | 1802 } |
| 1803 } | |
| 1804 | |
| 1805 // insert_entity_capabilities(presence_stanza) | |
| 1806 // Entity Capabilities (XEP-0115) | |
| 1600 | 1807 static void insert_entity_capabilities(LmMessageNode *x, enum imstatus status) |
| 1598 | 1808 { |
| 1809 LmMessageNode *y; | |
| 1600 | 1810 const char *ver = entity_version(status); |
| 1598 | 1811 |
| 1812 y = lm_message_node_add_child(x, "c", NULL); | |
| 1813 lm_message_node_set_attribute(y, "xmlns", NS_CAPS); | |
| 1600 | 1814 lm_message_node_set_attribute(y, "hash", "sha-1"); |
| 1598 | 1815 lm_message_node_set_attribute(y, "node", MCABBER_CAPS_NODE); |
| 1816 lm_message_node_set_attribute(y, "ver", ver); | |
| 1817 } | |
| 1818 | |
| 1819 void xmpp_disconnect(void) | |
| 1820 { | |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1821 if (!lconnection) |
| 1598 | 1822 return; |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1823 if (lm_connection_is_authenticated(lconnection)) { |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1824 // Launch pre-disconnect internal hook |
|
1683
b09f82f61745
Split HOOK_INTERNAL
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1682
diff
changeset
|
1825 hk_predisconnect(); |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1826 // Announce it to everyone else |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1827 xmpp_setstatus(offline, NULL, "", FALSE); |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1828 } |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1829 if (lm_connection_is_open(lconnection)) |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1830 lm_connection_close(lconnection, NULL); |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1831 lm_connection_unref(lconnection); |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1832 lconnection = NULL; |
| 1598 | 1833 } |
| 1834 | |
| 1835 void xmpp_setstatus(enum imstatus st, const char *recipient, const char *msg, | |
| 1836 int do_not_sign) | |
| 1837 { | |
| 1838 LmMessage *m; | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1839 gboolean isonline; |
| 1598 | 1840 |
| 1841 if (msg) { | |
| 1842 // The status message has been specified. We'll use it, unless it is | |
| 1843 // "-" which is a special case (option meaning "no status message"). | |
| 1844 if (!strcmp(msg, "-")) | |
| 1845 msg = ""; | |
| 1846 } else { | |
| 1847 // No status message specified; we'll use: | |
| 1848 // a) the default status message (if provided by the user); | |
| 1849 // b) the current status message; | |
| 1850 // c) no status message (i.e. an empty one). | |
| 1851 msg = settings_get_status_msg(st); | |
| 1852 if (!msg) { | |
| 1853 if (mystatusmsg) | |
| 1854 msg = mystatusmsg; | |
| 1855 else | |
| 1856 msg = ""; | |
| 1857 } | |
| 1858 } | |
| 1859 | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1860 isonline = xmpp_is_online(); |
|
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1861 |
| 1598 | 1862 // Only send the packet if we're online. |
| 1863 // (But we want to update internal status even when disconnected, | |
| 1864 // in order to avoid some problems during network failures) | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1865 if (isonline) { |
| 1598 | 1866 const char *s_msg = (st != invisible ? msg : NULL); |
| 1867 m = lm_message_new_presence(st, recipient, s_msg); | |
| 1600 | 1868 insert_entity_capabilities(m->node, st); // Entity Capabilities (XEP-0115) |
| 1598 | 1869 #ifdef HAVE_GPGME |
| 1870 if (!do_not_sign && gpg_enabled()) { | |
| 1871 char *signature; | |
| 1872 signature = gpg_sign(s_msg ? s_msg : ""); | |
| 1873 if (signature) { | |
| 1874 LmMessageNode *y; | |
| 1875 y = lm_message_node_add_child(m->node, "x", signature); | |
| 1876 lm_message_node_set_attribute(y, "xmlns", NS_SIGNED); | |
| 1877 g_free(signature); | |
| 1878 } | |
| 1879 } | |
| 1880 #endif | |
| 1881 lm_connection_send(lconnection, m, NULL); | |
| 1882 lm_message_unref(m); | |
| 1883 } | |
| 1884 | |
| 1885 // If we didn't change our _global_ status, we are done | |
| 1886 if (recipient) return; | |
| 1887 | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1888 if (isonline) { |
| 1598 | 1889 // Send presence to chatrooms |
| 1890 if (st != invisible) { | |
| 1891 struct T_presence room_presence; | |
| 1892 room_presence.st = st; | |
| 1893 room_presence.msg = msg; | |
| 1894 foreach_buddy(ROSTER_TYPE_ROOM, &roompresence, &room_presence); | |
| 1895 } | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1896 } |
| 1598 | 1897 |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1898 if (isonline || !st) { |
| 1598 | 1899 // We'll have to update the roster if we switch to/from offline because |
| 1900 // we don't know the presences of buddies when offline... | |
| 1901 if (mystatus == offline || st == offline) | |
| 1902 update_roster = TRUE; | |
| 1903 | |
|
1716
d30fb41725fe
Do not call hk_mystatuschange() twice when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1715
diff
changeset
|
1904 if (isonline || mystatus || st) |
|
d30fb41725fe
Do not call hk_mystatuschange() twice when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1715
diff
changeset
|
1905 hk_mystatuschange(0, mystatus, st, (st != invisible ? msg : "")); |
| 1598 | 1906 mystatus = st; |
| 1907 } | |
| 1908 | |
| 1909 if (st) | |
| 1910 mywantedstatus = st; | |
| 1911 | |
| 1912 if (msg != mystatusmsg) { | |
| 1913 g_free(mystatusmsg); | |
| 1914 if (*msg) | |
| 1915 mystatusmsg = g_strdup(msg); | |
| 1916 else | |
| 1917 mystatusmsg = NULL; | |
| 1918 } | |
| 1919 | |
| 1920 if (!Autoaway) | |
| 1921 update_last_use(); | |
| 1922 | |
| 1923 // Update status line | |
| 1924 scr_UpdateMainStatus(TRUE); | |
| 1925 } | |
| 1926 | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1927 |
| 1598 | 1928 enum imstatus xmpp_getstatus(void) |
| 1929 { | |
| 1930 return mystatus; | |
| 1931 } | |
| 1932 | |
| 1933 const char *xmpp_getstatusmsg(void) | |
| 1934 { | |
| 1935 return mystatusmsg; | |
| 1936 } | |
| 1937 | |
| 1938 // xmpp_setprevstatus() | |
| 1939 // Set previous status. This wrapper function is used after a disconnection. | |
| 1940 void xmpp_setprevstatus(void) | |
| 1941 { | |
| 1942 xmpp_setstatus(mywantedstatus, NULL, mystatusmsg, FALSE); | |
| 1943 } | |
| 1944 | |
| 1945 // send_storage(store) | |
| 1946 // Send the node "store" to update the server. | |
| 1947 // Note: the sender should check we're online. | |
| 1948 void send_storage(LmMessageNode *store) | |
| 1949 { | |
| 1950 LmMessage *iq; | |
| 1951 LmMessageNode *query; | |
| 1952 | |
| 1953 if (!rosternotes) return; | |
| 1954 | |
| 1955 iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, | |
| 1956 LM_MESSAGE_SUB_TYPE_SET); | |
| 1957 query = lm_message_node_add_child(iq->node, "query", NULL); | |
| 1958 lm_message_node_set_attribute(query, "xmlns", NS_PRIVATE); | |
| 1959 lm_message_node_insert_childnode(query, store); | |
| 1960 | |
| 1961 lm_connection_send(lconnection, iq, NULL); | |
| 1962 lm_message_unref(iq); | |
| 1963 } | |
| 1964 | |
| 1965 | |
| 1966 // xmpp_is_bookmarked(roomjid) | |
| 1967 // Return TRUE if there's a bookmark for the given jid. | |
| 1968 guint xmpp_is_bookmarked(const char *bjid) | |
| 1969 { | |
| 1970 LmMessageNode *x; | |
| 1971 | |
| 1972 if (!bookmarks) | |
| 1973 return FALSE; | |
| 1974 | |
| 1975 // Walk through the storage bookmark tags | |
| 1976 for (x = bookmarks->children ; x; x = x->next) { | |
| 1977 // If the node is a conference item, check the jid. | |
| 1978 if (x->name && !strcmp(x->name, "conference")) { | |
| 1979 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 1980 if (fjid && !strcasecmp(bjid, fjid)) | |
| 1981 return TRUE; | |
| 1982 } | |
| 1983 } | |
| 1984 return FALSE; | |
| 1985 } | |
| 1986 | |
| 1987 // xmpp_get_bookmark_nick(roomjid) | |
| 1988 // Return the room nickname if it is present in a bookmark. | |
| 1989 const char *xmpp_get_bookmark_nick(const char *bjid) | |
| 1990 { | |
| 1991 LmMessageNode *x; | |
| 1992 | |
| 1993 if (!bookmarks || !bjid) | |
| 1994 return NULL; | |
|
469
a926523d2392
Use UTF8 to handle resources and room nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
468
diff
changeset
|
1995 |
| 1598 | 1996 // Walk through the storage bookmark tags |
| 1997 for (x = bookmarks->children ; x; x = x->next) { | |
| 1998 // If the node is a conference item, check the jid. | |
| 1999 if (x->name && !strcmp(x->name, "conference")) { | |
| 2000 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2001 if (fjid && !strcasecmp(bjid, fjid)) | |
| 2002 return lm_message_node_get_child_value(x, "nick"); | |
| 2003 } | |
| 2004 } | |
| 2005 return NULL; | |
| 2006 } | |
| 2007 | |
| 2008 | |
| 2009 // xmpp_get_all_storage_bookmarks() | |
| 2010 // Return a GSList with all storage bookmarks. | |
| 2011 // The caller should g_free the list (not the MUC jids). | |
| 2012 GSList *xmpp_get_all_storage_bookmarks(void) | |
| 2013 { | |
| 2014 LmMessageNode *x; | |
| 2015 GSList *sl_bookmarks = NULL; | |
| 2016 | |
| 2017 // If we have no bookmarks, probably the server doesn't support them. | |
| 2018 if (!bookmarks) | |
| 2019 return NULL; | |
| 2020 | |
| 2021 // Walk through the storage bookmark tags | |
| 2022 for (x = bookmarks->children ; x; x = x->next) { | |
| 2023 // If the node is a conference item, let's add the note to our list. | |
| 2024 if (x->name && !strcmp(x->name, "conference")) { | |
| 2025 struct bookmark *bm_elt; | |
| 2026 const char *autojoin, *name, *nick; | |
| 2027 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2028 if (!fjid) | |
| 2029 continue; | |
| 2030 bm_elt = g_new0(struct bookmark, 1); | |
| 2031 bm_elt->roomjid = g_strdup(fjid); | |
| 2032 autojoin = lm_message_node_get_attribute(x, "autojoin"); | |
| 2033 nick = lm_message_node_get_attribute(x, "nick"); | |
| 2034 name = lm_message_node_get_attribute(x, "name"); | |
| 2035 if (autojoin && !strcmp(autojoin, "1")) | |
| 2036 bm_elt->autojoin = 1; | |
| 2037 if (nick) | |
| 2038 bm_elt->nick = g_strdup(nick); | |
| 2039 if (name) | |
| 2040 bm_elt->name = g_strdup(name); | |
| 2041 sl_bookmarks = g_slist_append(sl_bookmarks, bm_elt); | |
| 2042 } | |
| 2043 } | |
| 2044 return sl_bookmarks; | |
| 2045 } | |
| 2046 | |
| 2047 // xmpp_set_storage_bookmark(roomid, name, nick, passwd, autojoin, | |
| 2048 // printstatus, autowhois) | |
| 2049 // Update the private storage bookmarks: add a conference room. | |
| 2050 // If name is nil, we remove the bookmark. | |
| 2051 void xmpp_set_storage_bookmark(const char *roomid, const char *name, | |
| 2052 const char *nick, const char *passwd, | |
| 2053 int autojoin, enum room_printstatus pstatus, | |
| 2054 enum room_autowhois awhois) | |
| 2055 { | |
| 2056 LmMessageNode *x; | |
| 2057 bool changed = FALSE; | |
| 2058 | |
| 2059 if (!roomid) | |
| 2060 return; | |
| 2061 | |
| 2062 // If we have no bookmarks, probably the server doesn't support them. | |
| 2063 if (!bookmarks) { | |
| 2064 scr_LogPrint(LPRINT_NORMAL, | |
| 2065 "Sorry, your server doesn't seem to support private storage."); | |
|
469
a926523d2392
Use UTF8 to handle resources and room nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
468
diff
changeset
|
2066 return; |
|
a926523d2392
Use UTF8 to handle resources and room nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
468
diff
changeset
|
2067 } |
| 31 | 2068 |
| 1598 | 2069 // Walk through the storage tags |
| 2070 for (x = bookmarks->children ; x; x = x->next) { | |
| 2071 // If the current node is a conference item, see if we have to replace it. | |
| 2072 if (x->name && !strcmp(x->name, "conference")) { | |
| 2073 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2074 if (!fjid) | |
| 2075 continue; | |
| 2076 if (!strcmp(fjid, roomid)) { | |
| 2077 // We've found a bookmark for this room. Let's hide it and we'll | |
| 2078 // create a new one. | |
| 2079 lm_message_node_hide(x); | |
| 2080 changed = TRUE; | |
| 2081 if (!name) | |
| 2082 scr_LogPrint(LPRINT_LOGNORM, "Deleting bookmark..."); | |
| 2083 } | |
| 2084 } | |
| 2085 } | |
| 31 | 2086 |
| 1598 | 2087 // Let's create a node/bookmark for this roomid, if the name is not NULL. |
| 2088 if (name) { | |
| 2089 x = lm_message_node_add_child(bookmarks, "conference", NULL); | |
| 2090 lm_message_node_set_attributes(x, | |
| 2091 "jid", roomid, | |
| 2092 "name", name, | |
| 2093 "autojoin", autojoin ? "1" : "0", | |
| 2094 NULL); | |
| 2095 if (nick) | |
| 2096 lm_message_node_add_child(x, "nick", nick); | |
| 2097 if (passwd) | |
| 2098 lm_message_node_add_child(x, "password", passwd); | |
| 2099 if (pstatus) | |
| 2100 lm_message_node_add_child(x, "print_status", strprintstatus[pstatus]); | |
| 2101 if (awhois) | |
|
1633
e3afe1da8a5f
Fix saving autowhois option in bookmarks
Mikael Berthe <mikael@lilotux.net>
parents:
1621
diff
changeset
|
2102 lm_message_node_set_attributes(x, "autowhois", |
|
e3afe1da8a5f
Fix saving autowhois option in bookmarks
Mikael Berthe <mikael@lilotux.net>
parents:
1621
diff
changeset
|
2103 (awhois == autowhois_on) ? "1" : "0", |
|
e3afe1da8a5f
Fix saving autowhois option in bookmarks
Mikael Berthe <mikael@lilotux.net>
parents:
1621
diff
changeset
|
2104 NULL); |
| 1598 | 2105 changed = TRUE; |
| 2106 scr_LogPrint(LPRINT_LOGNORM, "Updating bookmarks..."); | |
| 2107 } | |
| 2108 | |
| 2109 if (!changed) | |
| 2110 return; | |
| 31 | 2111 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
2112 if (xmpp_is_online()) |
| 1598 | 2113 send_storage(bookmarks); |
| 2114 else | |
| 2115 scr_LogPrint(LPRINT_LOGNORM, | |
| 2116 "Warning: you're not connected to the server."); | |
| 2117 } | |
| 2118 | |
| 2119 static struct annotation *parse_storage_rosternote(LmMessageNode *notenode) | |
| 2120 { | |
| 2121 const char *p; | |
| 2122 struct annotation *note = g_new0(struct annotation, 1); | |
| 2123 p = lm_message_node_get_attribute(notenode, "cdate"); | |
| 2124 if (p) | |
| 2125 note->cdate = from_iso8601(p, 1); | |
| 2126 p = lm_message_node_get_attribute(notenode, "mdate"); | |
| 2127 if (p) | |
| 2128 note->mdate = from_iso8601(p, 1); | |
| 2129 note->text = g_strdup(lm_message_node_get_value(notenode)); | |
| 2130 note->jid = g_strdup(lm_message_node_get_attribute(notenode, "jid")); | |
| 2131 return note; | |
| 2132 } | |
| 31 | 2133 |
| 1598 | 2134 // xmpp_get_all_storage_rosternotes() |
| 2135 // Return a GSList with all storage annotations. | |
| 2136 // The caller should g_free the list and its contents. | |
| 2137 GSList *xmpp_get_all_storage_rosternotes(void) | |
| 2138 { | |
| 2139 LmMessageNode *x; | |
| 2140 GSList *sl_notes = NULL; | |
| 2141 | |
| 2142 // If we have no rosternotes, probably the server doesn't support them. | |
| 2143 if (!rosternotes) | |
| 2144 return NULL; | |
| 31 | 2145 |
| 1598 | 2146 // Walk through the storage rosternotes tags |
| 2147 for (x = rosternotes->children ; x; x = x->next) { | |
| 2148 struct annotation *note; | |
| 2149 | |
| 2150 // We want a note item | |
| 2151 if (!x->name || strcmp(x->name, "note")) | |
| 2152 continue; | |
| 2153 // Just in case, check the jid... | |
| 2154 if (!lm_message_node_get_attribute(x, "jid")) | |
| 2155 continue; | |
| 2156 // Ok, let's add the note to our list | |
| 2157 note = parse_storage_rosternote(x); | |
| 2158 sl_notes = g_slist_append(sl_notes, note); | |
| 31 | 2159 } |
| 1598 | 2160 return sl_notes; |
| 31 | 2161 } |
| 2162 | |
| 1598 | 2163 // xmpp_get_storage_rosternotes(barejid, silent) |
| 2164 // Return the annotation associated with this jid. | |
| 2165 // If silent is TRUE, no warning is displayed when rosternotes is disabled | |
| 2166 // The caller should g_free the string and structure after use. | |
| 2167 struct annotation *xmpp_get_storage_rosternotes(const char *barejid, int silent) | |
| 2168 { | |
| 2169 LmMessageNode *x; | |
| 2170 | |
| 2171 if (!barejid) | |
| 2172 return NULL; | |
| 2173 | |
| 2174 // If we have no rosternotes, probably the server doesn't support them. | |
| 2175 if (!rosternotes) { | |
| 2176 if (!silent) | |
| 2177 scr_LogPrint(LPRINT_NORMAL, "Sorry, " | |
| 2178 "your server doesn't seem to support private storage."); | |
| 2179 return NULL; | |
| 2180 } | |
| 2181 | |
| 2182 // Walk through the storage rosternotes tags | |
| 2183 for (x = rosternotes->children ; x; x = x->next) { | |
| 2184 const char *fjid; | |
| 2185 // We want a note item | |
| 2186 if (!x->name || strcmp(x->name, "note")) | |
| 2187 continue; | |
| 2188 // Just in case, check the jid... | |
| 2189 fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2190 if (fjid && !strcmp(fjid, barejid)) // We've found a note for this contact. | |
| 2191 return parse_storage_rosternote(x); | |
| 2192 } | |
| 2193 return NULL; // No note found | |
| 2194 } | |
| 2195 | |
| 2196 // xmpp_set_storage_rosternotes(barejid, note) | |
| 2197 // Update the private storage rosternotes: add/delete a note. | |
| 2198 // If note is nil, we remove the existing note. | |
| 2199 void xmpp_set_storage_rosternotes(const char *barejid, const char *note) | |
| 2200 { | |
| 2201 LmMessageNode *x; | |
| 2202 bool changed = FALSE; | |
| 2203 const char *cdate = NULL; | |
| 2204 | |
| 2205 if (!barejid) | |
| 2206 return; | |
| 2207 | |
| 2208 // If we have no rosternotes, probably the server doesn't support them. | |
| 2209 if (!rosternotes) { | |
| 2210 scr_LogPrint(LPRINT_NORMAL, | |
| 2211 "Sorry, your server doesn't seem to support private storage."); | |
| 2212 return; | |
| 2213 } | |
| 2214 | |
| 2215 // Walk through the storage tags | |
| 2216 for (x = rosternotes->children ; x; x = x->next) { | |
| 2217 // If the current node is a conference item, see if we have to replace it. | |
| 2218 if (x->name && !strcmp(x->name, "note")) { | |
| 2219 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2220 if (!fjid) | |
| 2221 continue; | |
| 2222 if (!strcmp(fjid, barejid)) { | |
| 2223 // We've found a note for this jid. Let's hide it and we'll | |
| 2224 // create a new one. | |
| 2225 cdate = lm_message_node_get_attribute(x, "cdate"); | |
| 2226 lm_message_node_hide(x); | |
| 2227 changed = TRUE; | |
| 2228 break; | |
| 2229 } | |
| 2230 } | |
| 2231 } | |
| 2232 | |
| 2233 // Let's create a node for this jid, if the note is not NULL. | |
| 2234 if (note) { | |
| 2235 char mdate[20]; | |
| 2236 time_t now; | |
| 2237 time(&now); | |
| 2238 to_iso8601(mdate, now); | |
| 2239 if (!cdate) | |
| 2240 cdate = mdate; | |
| 2241 x = lm_message_node_add_child(rosternotes, "note", note); | |
| 2242 lm_message_node_set_attributes(x, | |
| 2243 "jid", barejid, | |
| 2244 "cdate", cdate, | |
| 2245 "mdate", mdate, | |
| 2246 NULL); | |
| 2247 changed = TRUE; | |
| 2248 } | |
| 2249 | |
| 2250 if (!changed) | |
| 2251 return; | |
| 2252 | |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
2253 if (xmpp_is_online()) |
| 1598 | 2254 send_storage(rosternotes); |
| 2255 else | |
| 2256 scr_LogPrint(LPRINT_LOGNORM, | |
| 2257 "Warning: you're not connected to the server."); | |
| 2258 } | |
| 1599 | 2259 |
| 2260 /* vim: set expandtab cindent cinoptions=>2\:2(0: For Vim users... */ |