Mercurial > ~mikael > mcabber > hg
annotate mcabber/mcabber/xmpp.c @ 1909:9c14153e2580
Do not display unhandled IQ result messages to the log window
We display the message only in the debug log file, because these messages
are usually ignored anyway (ideally we would create a handler explicitly
when sending the initial IQ request).
Thanks to VarLog for the report!
| author | Mikael Berthe <mikael@lilotux.net> |
|---|---|
| date | Sun, 18 Apr 2010 14:14:05 +0200 |
| parents | e2def760c6d0 |
| children | 3695266e16c7 |
| 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)); | |
|
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1747
diff
changeset
|
301 scr_remove_receipt_flag(from, h); |
| 1602 | 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; |
| 1866 | 326 guint use_xep85 = 0; |
| 327 struct xep0085 *xep85 = NULL; | |
|
987
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) |
| 1866 | 441 xep85 = buddy_resource_xep85(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 */ |
| 1866 | 452 if (xep85 && (xep85->support == CHATSTATES_SUPPORT_OK || |
| 453 xep85->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); | |
| 1866 | 456 if (xep85->support == CHATSTATES_SUPPORT_UNKNOWN) |
| 457 xep85->support = CHATSTATES_SUPPORT_PROBED; | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
458 else |
| 1866 | 459 use_xep85 = 1; |
| 460 xep85->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 */ |
| 1866 | 468 if (!use_xep85) { |
| 469 struct xep0022 *xep22 = 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) |
| 1866 | 475 xep22 = buddy_resource_xep22(sl_buddy->data, rname); |
| 476 if (xep22) | |
| 477 xep22->last_state_sent = ROSTER_EVENT_ACTIVE; | |
|
990
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 |
| 1866 | 483 if (xep22) { |
| 484 g_free(xep22->last_msgid_sent); | |
| 485 xep22->last_msgid_sent = g_strdup(msgid); | |
|
989
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 |
| 1866 | 503 // xmpp_send_xep85_chatstate() |
| 1691 | 504 // Send a XEP-85 chatstate. |
| 1866 | 505 static void xmpp_send_xep85_chatstate(const char *bjid, const char *resname, |
| 1598 | 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; |
| 1866 | 513 struct xep0085 *xep85 = NULL; |
|
990
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) |
| 1866 | 523 xep85 = buddy_resource_xep85(sl_buddy->data, resname); |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
524 |
| 1866 | 525 if (!xep85 || (xep85->support != CHATSTATES_SUPPORT_OK)) |
|
990
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 |
| 1866 | 528 if (state == xep85->last_state_sent) |
|
990
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 |
| 1866 | 542 xep85->last_state_sent = state; |
|
990
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 |
| 1866 | 562 // xmpp_send_xep22_event() |
| 1691 | 563 // Send a XEP-22 message event (delivered, composing...). |
| 1866 | 564 static void xmpp_send_xep22_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; |
| 1866 | 571 struct xep0022 *xep22 = NULL; |
| 572 guint xep22_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) |
| 1866 | 587 xep22 = buddy_resource_xep22(sl_buddy->data, rname); |
|
989
859ab76e5093
Send JEP-22 delivered messages
Mikael Berthe <mikael@lilotux.net>
parents:
988
diff
changeset
|
588 |
| 1866 | 589 if (!xep22) |
|
990
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 |
| 1866 | 592 msgid = xep22->last_msgid_rcvd; |
|
990
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) |
| 1866 | 597 xep22_state = ROSTER_EVENT_COMPOSING; |
|
990
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) |
| 1866 | 600 xep22_state = ROSTER_EVENT_ACTIVE; |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
601 else |
| 1866 | 602 xep22_state = 0; // ROSTER_EVENT_NONE |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
603 |
| 1866 | 604 if (xep22_state) { |
|
990
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 |
| 1866 | 606 if (xep22_state == xep22->last_state_sent) |
|
990
35e7913affb7
Send events/chatstates notifications (JEP-22/JEP-85)
Mikael Berthe <mikael@lilotux.net>
parents:
989
diff
changeset
|
607 return; |
| 1866 | 608 xep22->last_state_sent = xep22_state; |
|
990
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; |
| 1866 | 636 struct xep0085 *xep85 = 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 |
| 1866 | 639 struct xep0022 *xep22; |
|
1091
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); |
| 1866 | 654 xep85 = buddy_resource_xep85(buddy, p_res->data); |
| 655 if (xep85 && xep85->support == CHATSTATES_SUPPORT_OK) { | |
|
1091
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. |
| 1866 | 658 if (!p_next || (xep85->last_state_sent != ROSTER_EVENT_ACTIVE && |
|
1091
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)) |
| 1866 | 660 xmpp_send_xep85_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. |
| 1866 | 667 if (xep85 && xep85->support == CHATSTATES_SUPPORT_OK) |
|
1099
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 |
| 1866 | 671 xep22 = buddy_resource_xep22(buddy, NULL); |
| 672 if (xep22 && xep22->support == CHATSTATES_SUPPORT_OK) { | |
| 673 xmpp_send_xep22_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; |
| 1866 | 688 struct xep0085 *xep85; |
| 689 struct xep0022 *xep22; | |
|
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
|
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 |
| 1866 | 702 xep85 = buddy_resource_xep85(sl_buddy->data, rname); |
| 703 xep22 = buddy_resource_xep22(sl_buddy->data, rname); | |
|
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
|
704 |
| 1866 | 705 if (xep85 && xep85->support == CHATSTATES_SUPPORT_PROBED) |
| 706 xep85->support = CHATSTATES_SUPPORT_UNKNOWN; | |
| 707 if (xep22 && xep22->support == CHATSTATES_SUPPORT_PROBED) | |
| 708 xep22->support = CHATSTATES_SUPPORT_UNKNOWN; | |
|
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
|
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) |
|
1747
c4f67e2e675f
Randomize reconnection delay
Mikael Berthe <mikael@lilotux.net>
parents:
1746
diff
changeset
|
885 g_timeout_add_seconds(RECONNECTION_TIMEOUT + (random() % 90L), |
|
c4f67e2e675f
Randomize reconnection delay
Mikael Berthe <mikael@lilotux.net>
parents:
1746
diff
changeset
|
886 xmpp_reconnect, NULL); |
| 1598 | 887 } |
| 888 | |
| 889 static void connection_open_cb(LmConnection *connection, gboolean success, | |
| 890 gpointer user_data) | |
| 891 { | |
|
1663
dcb0b4522ded
Fix GError handling
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1656
diff
changeset
|
892 GError *error = NULL; |
| 1598 | 893 |
| 894 if (success) { | |
| 1613 | 895 const char *password, *resource; |
| 896 char *username; | |
|
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1610
diff
changeset
|
897 username = jid_get_username(settings_opt_get("jid")); |
| 1598 | 898 password = settings_opt_get("password"); |
| 899 resource = strchr(lm_connection_get_jid(connection), | |
| 900 JID_RESOURCE_SEPARATOR); | |
| 901 if (resource) | |
| 902 resource++; | |
| 903 | |
|
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1610
diff
changeset
|
904 if (!lm_connection_authenticate(lconnection, username, password, resource, |
| 1598 | 905 connection_auth_cb, NULL, FALSE, &error)) { |
|
1717
c12455fec611
Remove extra newlines in scr_LogPrint() calls
Mikael Berthe <mikael@lilotux.net>
parents:
1716
diff
changeset
|
906 scr_LogPrint(LPRINT_LOGNORM, "Failed to authenticate: %s", |
| 1598 | 907 error->message); |
|
1663
dcb0b4522ded
Fix GError handling
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1656
diff
changeset
|
908 g_error_free (error); |
| 1598 | 909 _try_to_reconnect(); |
| 910 } | |
|
1611
f9bf561e54d0
Use the username for authentication, added jid_get_username() to utils.c
franky
parents:
1610
diff
changeset
|
911 g_free(username); |
| 1598 | 912 } else { |
| 913 scr_LogPrint(LPRINT_LOGNORM, "There was an error while connecting."); | |
| 914 _try_to_reconnect(); | |
| 915 } | |
| 916 } | |
| 917 | |
| 918 static void connection_close_cb(LmConnection *connection, | |
| 919 LmDisconnectReason reason, | |
| 920 gpointer user_data) | |
| 921 { | |
| 922 const char *str; | |
| 923 | |
| 924 switch (reason) { | |
| 925 case LM_DISCONNECT_REASON_OK: | |
| 926 str = "LM_DISCONNECT_REASON_OK"; | |
| 927 break; | |
| 928 case LM_DISCONNECT_REASON_PING_TIME_OUT: | |
| 929 str = "LM_DISCONNECT_REASON_PING_TIME_OUT"; | |
| 930 break; | |
| 931 case LM_DISCONNECT_REASON_HUP: | |
| 932 str = "LM_DISCONNECT_REASON_HUP"; | |
| 933 break; | |
| 934 case LM_DISCONNECT_REASON_ERROR: | |
| 935 str = "LM_DISCONNECT_REASON_ERROR"; | |
| 936 break; | |
| 937 case LM_DISCONNECT_REASON_UNKNOWN: | |
| 938 default: | |
| 939 str = "LM_DISCONNECT_REASON_UNKNOWN"; | |
| 940 break; | |
| 941 } | |
| 942 | |
| 943 if (reason != LM_DISCONNECT_REASON_OK) | |
| 944 _try_to_reconnect(); | |
| 945 | |
| 946 // Free bookmarks | |
| 947 if (bookmarks) | |
| 948 lm_message_node_unref(bookmarks); | |
| 949 bookmarks = NULL; | |
| 950 // Free roster | |
| 951 roster_free(); | |
| 952 if (rosternotes) | |
| 953 lm_message_node_unref(rosternotes); | |
| 954 rosternotes = NULL; | |
| 955 // Update display | |
| 956 update_roster = TRUE; | |
|
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1747
diff
changeset
|
957 scr_update_buddy_window(); |
| 1598 | 958 |
|
1715
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
959 if (!reason) |
|
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
960 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
|
961 else |
|
1b6a04703fa0
Do not display Loudmouth's disconnection value when disconnected normally
Mikael Berthe <mikael@lilotux.net>
parents:
1711
diff
changeset
|
962 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
|
963 |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
964 xmpp_setstatus(offline, NULL, mystatusmsg, TRUE); |
| 1598 | 965 } |
| 966 | |
| 967 static void handle_state_events(const char *from, LmMessageNode *node) | |
| 968 { | |
| 1691 | 969 #if defined XEP0022 || defined XEP0085 |
| 1598 | 970 LmMessageNode *state_ns = NULL; |
| 971 const char *body; | |
| 972 char *rname, *bjid; | |
| 973 GSList *sl_buddy; | |
| 974 guint events; | |
| 1866 | 975 struct xep0022 *xep22 = NULL; |
| 976 struct xep0085 *xep85 = NULL; | |
| 1598 | 977 enum { |
| 1691 | 978 XEP_none, |
| 979 XEP_85, | |
| 980 XEP_22 | |
| 1866 | 981 } which_xep = XEP_none; |
| 1598 | 982 |
| 983 rname = strchr(from, JID_RESOURCE_SEPARATOR); | |
| 984 if (rname) | |
| 985 ++rname; | |
| 986 else | |
| 987 rname = (char *)from + strlen(from); | |
| 988 bjid = jidtodisp(from); | |
| 989 sl_buddy = roster_find(bjid, jidsearch, ROSTER_TYPE_USER); | |
| 990 g_free(bjid); | |
| 991 | |
| 992 /* XXX Actually that's wrong, since it filters out server "offline" | |
| 1691 | 993 messages (for XEP-0022). This XEP is (almost) deprecated so |
| 1598 | 994 we don't really care. */ |
| 995 if (!sl_buddy) { | |
| 996 return; | |
| 997 } | |
| 998 | |
| 1691 | 999 /* Let's see chich XEP the contact uses. If possible, we'll use |
| 1000 XEP-85, if not we'll look for XEP-22 support. */ | |
| 1598 | 1001 events = buddy_resource_getevents(sl_buddy->data, rname); |
| 1002 | |
| 1866 | 1003 xep85 = buddy_resource_xep85(sl_buddy->data, rname); |
| 1004 if (xep85) { | |
| 1598 | 1005 state_ns = lm_message_node_find_xmlns(node, NS_CHATSTATES); |
| 1006 if (state_ns) | |
| 1866 | 1007 which_xep = XEP_85; |
| 1598 | 1008 } |
| 1009 | |
| 1866 | 1010 if (which_xep != XEP_85) { /* Fall back to XEP-0022 */ |
| 1011 xep22 = buddy_resource_xep22(sl_buddy->data, rname); | |
| 1012 if (xep22) { | |
| 1598 | 1013 state_ns = lm_message_node_find_xmlns(node, NS_EVENT); |
| 1014 if (state_ns) | |
| 1866 | 1015 which_xep = XEP_22; |
| 1598 | 1016 } |
| 1017 } | |
| 1018 | |
| 1866 | 1019 if (!which_xep) { /* Sender does not use chat states */ |
| 1598 | 1020 return; |
| 1021 } | |
| 1022 | |
| 1023 body = lm_message_node_get_child_value(node, "body"); | |
| 1024 | |
| 1866 | 1025 if (which_xep == XEP_85) { /* XEP-0085 */ |
| 1026 xep85->support = CHATSTATES_SUPPORT_OK; | |
| 1598 | 1027 |
| 1028 if (!strcmp(state_ns->name, "composing")) { | |
| 1866 | 1029 xep85->last_state_rcvd = ROSTER_EVENT_COMPOSING; |
| 1598 | 1030 } else if (!strcmp(state_ns->name, "active")) { |
| 1866 | 1031 xep85->last_state_rcvd = ROSTER_EVENT_ACTIVE; |
| 1598 | 1032 } else if (!strcmp(state_ns->name, "paused")) { |
| 1866 | 1033 xep85->last_state_rcvd = ROSTER_EVENT_PAUSED; |
| 1598 | 1034 } else if (!strcmp(state_ns->name, "inactive")) { |
| 1866 | 1035 xep85->last_state_rcvd = ROSTER_EVENT_INACTIVE; |
| 1598 | 1036 } else if (!strcmp(state_ns->name, "gone")) { |
| 1866 | 1037 xep85->last_state_rcvd = ROSTER_EVENT_GONE; |
| 1598 | 1038 } |
| 1866 | 1039 events = xep85->last_state_rcvd; |
| 1691 | 1040 } else { /* XEP-0022 */ |
| 1041 #ifdef XEP0022 | |
| 1598 | 1042 const char *msgid; |
| 1866 | 1043 xep22->support = CHATSTATES_SUPPORT_OK; |
| 1044 xep22->last_state_rcvd = ROSTER_EVENT_NONE; | |
| 1598 | 1045 |
| 1046 msgid = lm_message_node_get_attribute(node, "id"); | |
| 1047 | |
| 1048 if (lm_message_node_get_child(state_ns, "composing")) { | |
| 1049 // Clear composing if the message contains a body | |
| 1050 if (body) | |
| 1051 events &= ~ROSTER_EVENT_COMPOSING; | |
| 1052 else | |
| 1053 events |= ROSTER_EVENT_COMPOSING; | |
| 1866 | 1054 xep22->last_state_rcvd |= ROSTER_EVENT_COMPOSING; |
| 1598 | 1055 |
| 1056 } else { | |
| 1057 events &= ~ROSTER_EVENT_COMPOSING; | |
| 1058 } | |
| 1059 | |
| 1060 // Cache the message id | |
| 1866 | 1061 g_free(xep22->last_msgid_rcvd); |
| 1598 | 1062 if (msgid) |
| 1866 | 1063 xep22->last_msgid_rcvd = g_strdup(msgid); |
| 1598 | 1064 else |
| 1866 | 1065 xep22->last_msgid_rcvd = NULL; |
| 1598 | 1066 |
| 1067 if (lm_message_node_get_child(state_ns, "delivered")) { | |
| 1866 | 1068 xep22->last_state_rcvd |= ROSTER_EVENT_DELIVERED; |
| 1598 | 1069 |
| 1070 // Do we have to send back an ACK? | |
| 1071 if (body) | |
| 1866 | 1072 xmpp_send_xep22_event(from, ROSTER_EVENT_DELIVERED); |
| 1598 | 1073 } |
| 1074 #endif | |
| 1075 } | |
| 1076 | |
| 1077 buddy_resource_setevents(sl_buddy->data, rname, events); | |
| 1078 | |
| 1079 update_roster = TRUE; | |
| 1080 #endif | |
| 1081 } | |
| 1082 | |
| 1083 static void gotmessage(LmMessageSubType type, const char *from, | |
| 1084 const char *body, const char *enc, const char *subject, | |
| 1085 time_t timestamp, LmMessageNode *node_signed) | |
| 29 | 1086 { |
| 1058 | 1087 char *bjid; |
|
1689
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1088 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
|
1089 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
|
1090 char *decrypted_otr = NULL; |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1091 int otr_msg = 0, free_msg = 0; |
| 29 | 1092 |
| 1058 | 1093 bjid = jidtodisp(from); |
|
441
51b8f10cfeb8
Handle g_locale_from_utf8() failures
Mikael Berthe <mikael@lilotux.net>
parents:
438
diff
changeset
|
1094 |
|
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
960
diff
changeset
|
1095 rname = strchr(from, JID_RESOURCE_SEPARATOR); |
|
447
03bb57383cea
Initial Multi-User Chat support
Mikael Berthe <mikael@lilotux.net>
parents:
444
diff
changeset
|
1096 if (rname) rname++; |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1097 |
|
1042
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1098 #ifdef HAVE_GPGME |
|
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1099 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
|
1100 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
|
1101 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
|
1102 body = decrypted_pgp; |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
1103 } |
|
1042
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1104 } |
|
1043
ebbde723614b
Store contacts PGP keys
Mikael Berthe <mikael@lilotux.net>
parents:
1042
diff
changeset
|
1105 // Check signature of an unencrypted message |
| 1598 | 1106 if (node_signed && gpg_enabled()) |
| 1107 check_signature(bjid, rname, node_signed, decrypted_pgp); | |
|
1042
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1108 #endif |
|
8a395c2cafc4
Initial PGP support (decrypt)
Mikael Berthe <mikael@lilotux.net>
parents:
1023
diff
changeset
|
1109 |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1110 #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
|
1111 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
|
1112 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
|
1113 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
|
1114 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
|
1115 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
|
1116 } |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1117 body = decrypted_otr; |
|
1299
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1118 } |
|
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1119 #endif |
|
3b338a5c01fc
OTR support
Frank Zschockelt <mcabber_otr[at]freakysoft.de>
parents:
1290
diff
changeset
|
1120 |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1121 // Check for unexpected groupchat messages |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1122 // 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
|
1123 // 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
|
1124 // a type unavailable. |
| 1598 | 1125 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
|
1126 // It shouldn't happen, probably a server issue |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1127 GSList *room_elt; |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1128 char *mbuf; |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1129 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1130 mbuf = g_strdup_printf("Unexpected groupchat packet!"); |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1131 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
|
1132 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
|
1133 g_free(mbuf); |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1134 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1135 // Send back an unavailable packet |
| 1598 | 1136 xmpp_setstatus(offline, bjid, "", TRUE); |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1137 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1138 // MUC |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1139 // Make sure this is a room (it can be a conversion user->room) |
| 1058 | 1140 room_elt = roster_find(bjid, jidsearch, 0); |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1141 if (!room_elt) { |
|
1665
1a4890514eb9
Clean up some dead assignments/dead variables
Ulrich Spörlein
parents:
1663
diff
changeset
|
1142 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
|
1143 } else { |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1144 buddy_settype(room_elt->data, ROSTER_TYPE_ROOM); |
|
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 |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1147 buddylist_build(); |
|
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1747
diff
changeset
|
1148 scr_draw_roster(); |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1149 goto gotmessage_return; |
|
864
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1150 } |
|
a7b3409df6bc
MUC: Work around user server restart
Mikael Berthe <mikael@lilotux.net>
parents:
862
diff
changeset
|
1151 |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1152 // 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
|
1153 // 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
|
1154 // 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
|
1155 if (settings_opt_get_int("block_unsubscribed") && |
|
1895
7043542b3565
Do not block MUC private messages when 'block_unsubscribed' is set
Mikael Berthe <mikael@lilotux.net>
parents:
1869
diff
changeset
|
1156 (roster_gettype(bjid) != ROSTER_TYPE_ROOM) && |
|
1689
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1157 !(roster_getsubscription(bjid) & sub_from) && |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1158 (type != LM_MESSAGE_SUB_TYPE_GROUPCHAT)) { |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1159 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
|
1160 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
|
1161 if (g_strcmp0(server, bjid)) { |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1162 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
|
1163 g_free(sbjid); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1164 goto gotmessage_return; |
|
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 g_free(sbjid); |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1167 } |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1168 |
|
b8f9481dd0fe
Get server name from jid for block_unsubscribed
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1688
diff
changeset
|
1169 { // 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
|
1170 gchar *fullbody = NULL; |
|
1484
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1171 guint encrypted; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1172 |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1173 if (decrypted_pgp) |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1174 encrypted = ENCRYPTED_PGP; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1175 else if (otr_msg) |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1176 encrypted = ENCRYPTED_OTR; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1177 else |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1178 encrypted = 0; |
|
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1179 |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1180 if (subject) { |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1181 if (body) |
|
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%s", subject, body); |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1183 else |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1184 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
|
1185 body = fullbody; |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1186 } |
|
1484
7b36b91a4388
New UI message flag (O) when OTR is used
Mikael Berthe <mikael@lilotux.net>
parents:
1476
diff
changeset
|
1187 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
|
1188 g_free(fullbody); |
|
819
c2d7d9dd4193
New option 'block_unsubscribed'
Mikael Berthe <mikael@lilotux.net>
parents:
818
diff
changeset
|
1189 } |
|
1347
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1190 |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1191 gotmessage_return: |
|
07816313073b
Add an option 'otr' to enable OTR support in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1344
diff
changeset
|
1192 // Clean up and exit |
| 1058 | 1193 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
|
1194 g_free(decrypted_pgp); |
|
1333
e30a9d907105
Minor coding style adjustments
Mikael Berthe <mikael@lilotux.net>
parents:
1330
diff
changeset
|
1195 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
|
1196 g_free(decrypted_otr); |
| 29 | 1197 } |
| 1198 | |
|
420
04a0b450380b
Display error code/message when receiving a message packet with "error" type
Mikael Berthe <mikael@lilotux.net>
parents:
419
diff
changeset
|
1199 |
| 1598 | 1200 static LmHandlerResult handle_messages(LmMessageHandler *handler, |
| 1201 LmConnection *connection, | |
| 1202 LmMessage *m, gpointer user_data) | |
|
579
0c67755e0fa7
Introduce a handle_presence_muc() function
Mikael Berthe <mikael@lilotux.net>
parents:
578
diff
changeset
|
1203 { |
| 1598 | 1204 const char *p, *from=lm_message_get_from(m); |
| 1205 char *r, *s; | |
| 1206 LmMessageNode *x; | |
| 1207 const char *body = NULL; | |
| 1208 const char *enc = NULL; | |
| 1209 const char *subject = NULL; | |
|
1001
dff25377c11f
Auto-reconnect after a network/server failure
Mikael Berthe <mikael@lilotux.net>
parents:
999
diff
changeset
|
1210 time_t timestamp = 0L; |
| 1646 | 1211 LmMessageSubType mstype; |
| 1212 | |
| 1213 mstype = lm_message_get_sub_type(m); | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1214 |
| 1598 | 1215 body = lm_message_node_get_child_value(m->node, "body"); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1216 |
| 1598 | 1217 x = lm_message_node_find_xmlns(m->node, NS_ENCRYPTED); |
| 1218 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
|
1219 enc = p; |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1220 |
| 1598 | 1221 p = lm_message_node_get_child_value(m->node, "subject"); |
| 1222 if (p != NULL) { | |
| 1646 | 1223 if (mstype != LM_MESSAGE_SUB_TYPE_GROUPCHAT) { |
| 1598 | 1224 // Chat message |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1225 subject = p; |
|
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1226 } else { // Room topic |
|
549
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1227 GSList *roombuddy; |
| 1598 | 1228 gchar *mbuf; |
| 1229 const gchar *subj = p; | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1230 // Get the room (s) and the nickname (r) |
| 1598 | 1231 s = g_strdup(lm_message_get_from(m)); |
|
977
5b01de4ac5e1
Cosmetic changes
Alexis Hildebrandt <afh [at] 2drop [dot] net>
parents:
960
diff
changeset
|
1232 r = strchr(s, JID_RESOURCE_SEPARATOR); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1233 if (r) *r++ = 0; |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1234 else r = s; |
|
549
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1235 // Set the new topic |
|
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1236 roombuddy = roster_find(s, jidsearch, 0); |
|
448e299e45da
MUC: "/room topic" shows the current room topic
Mikael Berthe <mikael@lilotux.net>
parents:
547
diff
changeset
|
1237 if (roombuddy) |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1238 buddy_settopic(roombuddy->data, subj); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1239 // Display inside the room window |
|
560
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1240 if (r == s) { |
|
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1241 // No specific resource (this is certainly history) |
|
1896
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1242 if (*subj) |
|
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1243 mbuf = g_strdup_printf("The topic has been set to: %s", subj); |
|
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1244 else |
|
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1245 mbuf = g_strdup_printf("The topic has been cleared"); |
|
560
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1246 } else { |
|
1896
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1247 if (*subj) |
|
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1248 mbuf = g_strdup_printf("%s has set the topic to: %s", r, subj); |
|
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1249 else |
|
c5ab9cf3819a
[MUC] Fix handling of empty room topic
Mikael Berthe <mikael@lilotux.net>
parents:
1895
diff
changeset
|
1250 mbuf = g_strdup_printf("%s has cleared the topic", r); |
|
560
64cb4de94972
Better topic attribution
Mikael Berthe <mikael@lilotux.net>
parents:
549
diff
changeset
|
1251 } |
| 1598 | 1252 scr_WriteIncomingMessage(s, mbuf, 0, |
| 1253 HBB_PREFIX_INFO|HBB_PREFIX_NOFLAG, 0); | |
| 1254 if (settings_opt_get_int("log_muc_conf")) | |
| 1255 hlog_write_message(s, 0, -1, mbuf); | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1256 g_free(s); |
| 1598 | 1257 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
|
1258 // The topic is displayed in the chat status line, so refresh now. |
|
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1747
diff
changeset
|
1259 scr_update_chat_status(TRUE); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1260 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1261 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1262 |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1263 // Timestamp? |
| 1598 | 1264 timestamp = lm_message_node_get_timestamp(m->node); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1265 |
| 1646 | 1266 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
| 1598 | 1267 x = lm_message_node_get_child(m->node, "error"); |
|
1800
d2747442918a
When displaying a server error, show the sender JID
Mikael Berthe <mikael@lilotux.net>
parents:
1780
diff
changeset
|
1268 display_server_error(x, from); |
| 1691 | 1269 #if defined XEP0022 || defined XEP0085 |
| 1270 // 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
|
1271 // 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
|
1272 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
|
1273 #endif |
|
1132
1650056b96fc
Do not use chat states of error messages :)
Mikael Berthe <mikael@lilotux.net>
parents:
1128
diff
changeset
|
1274 } else { |
| 1598 | 1275 handle_state_events(from, m->node); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1276 } |
|
1399
187985455020
Correctly display PGP-encoded messages with a subject
Mikael Berthe <mikael@lilotux.net>
parents:
1397
diff
changeset
|
1277 if (from && (body || subject)) |
| 1646 | 1278 gotmessage(mstype, from, body, enc, subject, timestamp, |
| 1598 | 1279 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
|
1280 // Report received message if message receipt was requested |
| 1602 | 1281 if (lm_message_node_get_child(m->node, "request")) { |
|
1869
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1282 const gchar *mid; |
|
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1283 LmMessageNode *y; |
| 1602 | 1284 LmMessage *rcvd = lm_message_new(from, LM_MESSAGE_TYPE_MESSAGE); |
|
1869
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1285 mid = lm_message_get_id(m); |
|
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1286 // For backward compatibility (XEP184 < v.1.1): |
|
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1287 lm_message_node_set_attribute(rcvd->node, "id", mid); |
|
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1288 y = lm_message_node_add_child(rcvd->node, "received", NULL); |
|
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1289 lm_message_node_set_attribute(y, "xmlns", NS_RECEIPTS); |
|
fe385f2cfb93
Partial update for XEP-0184 v1.1
Mikael Berthe <mikael@lilotux.net>
parents:
1866
diff
changeset
|
1290 lm_message_node_set_attribute(y, "id", mid); |
| 1602 | 1291 lm_connection_send(connection, rcvd, NULL); |
| 1292 lm_message_unref(rcvd); | |
| 1293 } | |
| 1128 | 1294 |
| 1295 if (from) { | |
|
1908
e2def760c6d0
Introduce NS_MUC_{USER,ADMIN,OWNER}
Mikael Berthe <mikael@lilotux.net>
parents:
1906
diff
changeset
|
1296 x = lm_message_node_find_xmlns(m->node, NS_MUC_USER); |
| 1598 | 1297 if (x && !strcmp(x->name, "x")) |
| 1128 | 1298 got_muc_message(from, x); |
| 1299 } | |
| 1598 | 1300 |
| 1301 return LM_HANDLER_RESULT_REMOVE_MESSAGE; | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1302 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1303 |
| 1600 | 1304 static LmHandlerResult cb_caps(LmMessageHandler *h, LmConnection *c, |
| 1305 LmMessage *m, gpointer user_data) | |
| 1306 { | |
| 1307 char *ver = user_data; | |
| 1646 | 1308 LmMessageSubType mstype = lm_message_get_sub_type(m); |
| 1600 | 1309 |
| 1637 | 1310 caps_add(ver); |
| 1646 | 1311 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
|
1800
d2747442918a
When displaying a server error, show the sender JID
Mikael Berthe <mikael@lilotux.net>
parents:
1780
diff
changeset
|
1312 display_server_error(lm_message_node_get_child(m->node, "error"), |
|
d2747442918a
When displaying a server error, show the sender JID
Mikael Berthe <mikael@lilotux.net>
parents:
1780
diff
changeset
|
1313 lm_message_get_from(m)); |
| 1646 | 1314 } else if (mstype == LM_MESSAGE_SUB_TYPE_RESULT) { |
| 1600 | 1315 LmMessageNode *info; |
| 1316 LmMessageNode *query = lm_message_node_get_child(m->node, "query"); | |
| 1317 | |
| 1318 info = lm_message_node_get_child(query, "identity"); | |
| 1319 if (info) | |
| 1320 caps_set_identity(ver, lm_message_node_get_attribute(info, "category"), | |
| 1321 lm_message_node_get_attribute(info, "name"), | |
| 1322 lm_message_node_get_attribute(info, "type")); | |
| 1323 info = lm_message_node_get_child(query, "feature"); | |
| 1324 while (info) { | |
| 1325 if (!g_strcmp0(info->name, "feature")) | |
| 1326 caps_add_feature(ver, lm_message_node_get_attribute(info, "var")); | |
| 1327 info = info->next; | |
| 1328 } | |
| 1329 } | |
| 1330 g_free(ver); | |
| 1331 return LM_HANDLER_RESULT_REMOVE_MESSAGE; | |
| 1332 } | |
| 1333 | |
| 1598 | 1334 static LmHandlerResult handle_presence(LmMessageHandler *handler, |
| 1335 LmConnection *connection, | |
| 1336 LmMessage *m, gpointer user_data) | |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1337 { |
| 1731 | 1338 char *bjid; |
| 1598 | 1339 const char *from, *rname, *p=NULL, *ustmsg=NULL; |
| 1340 enum imstatus ust; | |
| 1341 char bpprio; | |
| 1342 time_t timestamp = 0L; | |
| 1600 | 1343 LmMessageNode *muc_packet, *caps; |
| 1646 | 1344 LmMessageSubType mstype; |
| 1598 | 1345 |
|
1644
73fc85ea0b4b
Do not send disco requests to offline resources
Mikael Berthe <mikael@lilotux.net>
parents:
1637
diff
changeset
|
1346 // Check for MUC presence packet |
|
1908
e2def760c6d0
Introduce NS_MUC_{USER,ADMIN,OWNER}
Mikael Berthe <mikael@lilotux.net>
parents:
1906
diff
changeset
|
1347 muc_packet = lm_message_node_find_xmlns(m->node, NS_MUC_USER); |
| 1598 | 1348 |
| 1349 from = lm_message_get_from(m); | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1350 |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1351 rname = strchr(from, JID_RESOURCE_SEPARATOR); |
| 1598 | 1352 if (rname) rname++; |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1353 |
| 1598 | 1354 if (settings_opt_get_int("ignore_self_presence")) { |
| 1355 const char *self_fjid = lm_connection_get_jid(connection); | |
| 1356 if (self_fjid && !strcasecmp(self_fjid, from)) { | |
| 1357 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
|
1358 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1359 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1360 |
| 1731 | 1361 bjid = jidtodisp(from); |
| 1646 | 1362 mstype = lm_message_get_sub_type(m); |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1363 |
| 1646 | 1364 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
| 1598 | 1365 LmMessageNode *x; |
| 1731 | 1366 scr_LogPrint(LPRINT_LOGNORM, "Error presence packet from <%s>", bjid); |
| 1598 | 1367 x = lm_message_node_find_child(m->node, "error"); |
|
1800
d2747442918a
When displaying a server error, show the sender JID
Mikael Berthe <mikael@lilotux.net>
parents:
1780
diff
changeset
|
1368 display_server_error(x, from); |
| 1598 | 1369 // Let's check it isn't a nickname conflict. |
| 1370 // XXX Note: We should handle the <conflict/> string condition. | |
| 1371 if ((p = lm_message_node_get_attribute(x, "code")) != NULL) { | |
| 1372 if (atoi(p) == 409) { | |
| 1373 // 409 = conflict (nickname is in use or registered by another user) | |
| 1374 // If we are not inside this room, we should reset the nickname | |
| 1731 | 1375 GSList *room_elt = roster_find(bjid, jidsearch, 0); |
| 1598 | 1376 if (room_elt && !buddy_getinsideroom(room_elt->data)) |
| 1377 buddy_setnickname(room_elt->data, NULL); | |
| 1378 } | |
|
987
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1379 } |
|
f47e312560af
Improve JEP22 + JEP85 support
Mikael Berthe <mikael@lilotux.net>
parents:
986
diff
changeset
|
1380 |
| 1731 | 1381 g_free(bjid); |
| 1598 | 1382 return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1383 } |
|
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1384 |
| 1598 | 1385 p = lm_message_node_get_child_value(m->node, "priority"); |
| 1386 if (p && *p) bpprio = (gchar)atoi(p); | |
| 1387 else bpprio = 0; | |
|
986
ed697234bd39
Chat states receival (Alexis Hildebrandt)
Mikael Berthe <mikael@lilotux.net>
parents:
977
diff
changeset
|
1388 |
| 1598 | 1389 ust = available; |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1390 |
| 1598 | 1391 p = lm_message_node_get_child_value(m->node, "show"); |
| 1392 if (p) { | |
| 1393 if (!strcmp(p, "away")) ust = away; | |
| 1394 else if (!strcmp(p, "dnd")) ust = dontdisturb; | |
| 1395 else if (!strcmp(p, "xa")) ust = notavail; | |
| 1396 else if (!strcmp(p, "chat")) ust = freeforchat; | |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1397 } |
|
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1398 |
| 1646 | 1399 if (mstype == LM_MESSAGE_SUB_TYPE_UNAVAILABLE) |
| 1598 | 1400 ust = offline; |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1401 |
| 1598 | 1402 ustmsg = lm_message_node_get_child_value(m->node, "status"); |
|
1899
decf94827efe
More lm_message_node_get_child_value() return value checks
Mikael Berthe <mikael@lilotux.net>
parents:
1896
diff
changeset
|
1403 if (ustmsg && !*ustmsg) |
|
decf94827efe
More lm_message_node_get_child_value() return value checks
Mikael Berthe <mikael@lilotux.net>
parents:
1896
diff
changeset
|
1404 ustmsg = NULL; |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1405 |
| 1598 | 1406 // Timestamp? |
| 1407 timestamp = lm_message_node_get_timestamp(m->node); | |
| 1408 | |
| 1409 if (muc_packet) { | |
| 1410 // This is a MUC presence message | |
| 1731 | 1411 handle_muc_presence(from, muc_packet, bjid, rname, |
| 1598 | 1412 ust, ustmsg, timestamp, bpprio); |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1413 } else { |
| 1598 | 1414 // Not a MUC message, so this is a regular buddy... |
| 1415 // Call hk_statuschange() if status has changed or if the | |
| 1416 // status message is different | |
| 1417 const char *msg; | |
| 1731 | 1418 msg = roster_getstatusmsg(bjid, rname); |
| 1419 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
|
1420 (!ustmsg && msg && msg[0]) || |
|
15b3834cbe5f
Handle priority changes when the contact status doesn't change
Mikael Berthe <mikael@lilotux.net>
parents:
1722
diff
changeset
|
1421 (ustmsg && (!msg || strcmp(ustmsg, msg))) || |
| 1731 | 1422 (bpprio != roster_getprio(bjid, rname))) |
| 1423 hk_statuschange(bjid, rname, bpprio, timestamp, ust, ustmsg); | |
| 1598 | 1424 // Presence signature processing |
| 1425 if (!ustmsg) | |
| 1426 ustmsg = ""; // Some clients omit the <status/> element :-( | |
| 1731 | 1427 check_signature(bjid, rname, |
| 1428 lm_message_node_find_xmlns(m->node, NS_SIGNED), ustmsg); | |
| 1128 | 1429 } |
| 1430 | |
|
1644
73fc85ea0b4b
Do not send disco requests to offline resources
Mikael Berthe <mikael@lilotux.net>
parents:
1637
diff
changeset
|
1431 // XEP-0115 Entity Capabilities |
| 1600 | 1432 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
|
1433 if (caps && ust != offline) { |
| 1600 | 1434 const char *ver = lm_message_node_get_attribute(caps, "ver"); |
| 1435 GSList *sl_buddy = NULL; | |
| 1436 if (rname) | |
| 1731 | 1437 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
|
1438 // Only cache the caps if the user is on the roster |
| 1600 | 1439 if (sl_buddy && buddy_getonserverflag(sl_buddy->data)) { |
| 1440 buddy_resource_setcaps(sl_buddy->data, rname, ver); | |
| 1441 | |
| 1442 if (!caps_has_hash(ver)) { | |
| 1443 char *node; | |
| 1444 LmMessageHandler *handler; | |
| 1445 LmMessage *iq = lm_message_new_with_sub_type(from, LM_MESSAGE_TYPE_IQ, | |
| 1446 LM_MESSAGE_SUB_TYPE_GET); | |
| 1447 node = g_strdup_printf("%s#%s", | |
| 1448 lm_message_node_get_attribute(caps, "node"), | |
| 1449 ver); | |
| 1450 lm_message_node_set_attributes | |
| 1451 (lm_message_node_add_child(iq->node, "query", NULL), | |
| 1452 "xmlns", NS_DISCO_INFO, | |
| 1453 "node", node, | |
| 1454 NULL); | |
| 1455 g_free(node); | |
| 1456 handler = lm_message_handler_new(cb_caps, g_strdup(ver), NULL); | |
| 1457 lm_connection_send_with_reply(connection, iq, handler, NULL); | |
| 1458 lm_message_unref(iq); | |
| 1459 lm_message_handler_unref(handler); | |
| 1460 } | |
| 1461 } | |
| 1462 } | |
| 1463 | |
| 1731 | 1464 g_free(bjid); |
| 1598 | 1465 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
| 1128 | 1466 } |
| 1467 | |
| 1468 | |
| 1598 | 1469 static LmHandlerResult handle_iq(LmMessageHandler *handler, |
| 1470 LmConnection *connection, | |
| 1471 LmMessage *m, gpointer user_data) | |
| 1472 { | |
| 1473 int i; | |
| 1474 const char *xmlns = NULL; | |
| 1475 LmMessageNode *x; | |
| 1646 | 1476 LmMessageSubType mstype = lm_message_get_sub_type(m); |
| 1598 | 1477 |
|
1647
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1478 if (mstype == LM_MESSAGE_SUB_TYPE_ERROR) { |
|
1800
d2747442918a
When displaying a server error, show the sender JID
Mikael Berthe <mikael@lilotux.net>
parents:
1780
diff
changeset
|
1479 display_server_error(lm_message_node_get_child(m->node, "error"), |
|
d2747442918a
When displaying a server error, show the sender JID
Mikael Berthe <mikael@lilotux.net>
parents:
1780
diff
changeset
|
1480 lm_message_get_from(m)); |
|
1647
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1481 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
|
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1482 } |
|
cfa1fff86f78
Reorder processing in handle_iq()
Mikael Berthe <mikael@lilotux.net>
parents:
1646
diff
changeset
|
1483 |
|
1904
9a3d7a7dada2
Fix looping issue spotted by isbear when sending manual IQ messages
Mikael Berthe <mikael@lilotux.net>
parents:
1902
diff
changeset
|
1484 if (mstype == LM_MESSAGE_SUB_TYPE_RESULT) { |
|
1905
68a4f8dda3e7
Clean up previous patch
Mikael Berthe <mikael@lilotux.net>
parents:
1904
diff
changeset
|
1485 scr_LogPrint(LPRINT_DEBUG, "Unhandled IQ result? %s", |
|
68a4f8dda3e7
Clean up previous patch
Mikael Berthe <mikael@lilotux.net>
parents:
1904
diff
changeset
|
1486 lm_message_node_to_string(m->node)); |
|
1904
9a3d7a7dada2
Fix looping issue spotted by isbear when sending manual IQ messages
Mikael Berthe <mikael@lilotux.net>
parents:
1902
diff
changeset
|
1487 return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; |
|
9a3d7a7dada2
Fix looping issue spotted by isbear when sending manual IQ messages
Mikael Berthe <mikael@lilotux.net>
parents:
1902
diff
changeset
|
1488 } |
|
9a3d7a7dada2
Fix looping issue spotted by isbear when sending manual IQ messages
Mikael Berthe <mikael@lilotux.net>
parents:
1902
diff
changeset
|
1489 |
| 1598 | 1490 for (x = m->node->children; x; x=x->next) { |
| 1491 xmlns = lm_message_node_get_attribute(x, "xmlns"); | |
| 1492 if (xmlns) | |
| 1493 for (i=0; iq_handlers[i].xmlns; ++i) | |
| 1494 if (!strcmp(iq_handlers[i].xmlns, xmlns)) | |
| 1495 return iq_handlers[i].handler(NULL, connection, m, user_data); | |
| 1496 xmlns = NULL; | |
| 1128 | 1497 } |
| 1498 | |
| 1646 | 1499 if ((mstype == LM_MESSAGE_SUB_TYPE_SET) || |
| 1500 (mstype == LM_MESSAGE_SUB_TYPE_GET)) | |
| 1598 | 1501 send_iq_error(connection, m, XMPP_ERROR_NOT_IMPLEMENTED); |
| 1502 | |
|
1905
68a4f8dda3e7
Clean up previous patch
Mikael Berthe <mikael@lilotux.net>
parents:
1904
diff
changeset
|
1503 scr_LogPrint(LPRINT_DEBUG, "Unhandled IQ: %s", |
|
68a4f8dda3e7
Clean up previous patch
Mikael Berthe <mikael@lilotux.net>
parents:
1904
diff
changeset
|
1504 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
|
1505 |
|
1904
9a3d7a7dada2
Fix looping issue spotted by isbear when sending manual IQ messages
Mikael Berthe <mikael@lilotux.net>
parents:
1902
diff
changeset
|
1506 scr_LogPrint(LPRINT_NORMAL, "Received unhandled IQ request from <%s>.", |
|
9a3d7a7dada2
Fix looping issue spotted by isbear when sending manual IQ messages
Mikael Berthe <mikael@lilotux.net>
parents:
1902
diff
changeset
|
1507 lm_message_get_from(m)); |
|
1721
8cfc2a386b1f
Do not display Unhandled IQ request stanzas in the log window
Mikael Berthe <mikael@lilotux.net>
parents:
1720
diff
changeset
|
1508 |
| 1598 | 1509 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
| 1128 | 1510 } |
| 1511 | |
| 1598 | 1512 static LmHandlerResult handle_s10n(LmMessageHandler *handler, |
| 1513 LmConnection *connection, | |
| 1514 LmMessage *m, gpointer user_data) | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1515 { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1516 char *r; |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1517 char *buf; |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1518 int newbuddy; |
|
1906
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1519 LmMessageSubType mstype; |
|
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1520 guint hook_result; |
| 1598 | 1521 const char *from = lm_message_get_from(m); |
|
1906
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1522 const char *msg = lm_message_node_get_child_value(m->node, "status"); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1523 |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1524 r = jidtodisp(from); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1525 |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1526 newbuddy = !roster_find(r, jidsearch, 0); |
| 1646 | 1527 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
|
1528 |
|
1906
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1529 hook_result = hk_subscription(mstype, r, msg); |
|
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1530 |
| 1646 | 1531 if (mstype == LM_MESSAGE_SUB_TYPE_SUBSCRIBE) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1532 /* The sender wishes to subscribe to our presence */ |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1533 |
|
1906
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1534 if (hook_result) { |
|
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1535 g_free(r); |
|
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1536 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
|
5d37cee8c6c6
Add "hook-subscription" hook and hk_subscription()
Mikael Berthe <mikael@lilotux.net>
parents:
1905
diff
changeset
|
1537 } |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1538 |
|
617
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1539 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
|
1540 from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1541 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
617
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1542 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1543 g_free(buf); |
|
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1544 |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1545 if (msg) { |
|
772
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1546 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
|
1547 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
|
1548 replace_nl_with_dots(buf); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1549 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
464be13343a9
Store most data in UTF-8 internally
Mikael Berthe <mikael@lilotux.net>
parents:
756
diff
changeset
|
1550 g_free(buf); |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1551 } |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1552 |
|
749
6c633adaae10
Use events system for subscription requests
Mikael Berthe <mikael@lilotux.net>
parents:
745
diff
changeset
|
1553 // Create a new event item |
|
1685
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1554 { |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1555 const char *id; |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1556 char *desc = g_strdup_printf("<%s> wants to subscribe to your " |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1557 "presence updates", r); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1558 |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1559 id = evs_new(desc, NULL, 0, evscallback_subscription, g_strdup(r), |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1560 (GDestroyNotify)g_free); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1561 g_free(desc); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1562 if (id) |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1563 buf = g_strdup_printf("Please use /event %s accept|reject", id); |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1564 else |
|
1342df44c814
Improved events interface
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1684
diff
changeset
|
1565 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
|
1566 } |
|
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); |
|
617
d3a8b43bf9e7
Add "/authorization" command
Mikael Berthe <mikael@lilotux.net>
parents:
616
diff
changeset
|
1568 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1569 g_free(buf); |
| 1646 | 1570 } else if (mstype == LM_MESSAGE_SUB_TYPE_UNSUBSCRIBE) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1571 /* The sender is unsubscribing from our presence */ |
| 1598 | 1572 xmpp_send_s10n(from, LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1573 buf = g_strdup_printf("<%s> is unsubscribing from your " |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1574 "presence updates", from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1575 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1576 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1577 g_free(buf); |
| 1646 | 1578 } else if (mstype == LM_MESSAGE_SUB_TYPE_SUBSCRIBED) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1579 /* The sender has allowed us to receive their presence */ |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1580 buf = g_strdup_printf("<%s> has allowed you to receive their " |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1581 "presence updates", from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1582 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1583 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1584 g_free(buf); |
| 1646 | 1585 } else if (mstype == LM_MESSAGE_SUB_TYPE_UNSUBSCRIBED) { |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1586 /* The subscription request has been denied or a previously-granted |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1587 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
|
1588 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
|
1589 update_roster = TRUE; |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1590 buf = g_strdup_printf("<%s> has cancelled your subscription to " |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1591 "their presence updates", from); |
|
1290
e42f48103609
Drawing the MUC nicks by a different color
Michal 'vorner' Vaner <vorner@ucw.cz>
parents:
1282
diff
changeset
|
1592 scr_WriteIncomingMessage(r, buf, 0, HBB_PREFIX_INFO, 0); |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1593 scr_LogPrint(LPRINT_LOGNORM, "%s", buf); |
|
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1594 g_free(buf); |
| 603 | 1595 } else { |
| 1634 | 1596 g_free(r); |
| 1598 | 1597 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
|
1598 } |
|
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1599 |
|
1010
54405d09b15a
Add a call to buddylist_build()
Mikael Berthe <mikael@lilotux.net>
parents:
1008
diff
changeset
|
1600 if (newbuddy) |
|
818
55cd45481a07
Fix a buddylist bug when receiving a subscription request
Mikael Berthe <mikael@lilotux.net>
parents:
793
diff
changeset
|
1601 update_roster = TRUE; |
|
611
ad737139a144
Improve subscription management
Mikael Berthe <mikael@lilotux.net>
parents:
610
diff
changeset
|
1602 g_free(r); |
| 1598 | 1603 return LM_HANDLER_RESULT_REMOVE_MESSAGE; |
| 1604 } | |
| 1605 | |
|
1729
e6e89b1d7831
Minor style and header updates
Mikael Berthe <mikael@lilotux.net>
parents:
1728
diff
changeset
|
1606 // TODO: Use the enum of loudmouth, when it's included in the header... |
| 1598 | 1607 typedef enum { |
| 1608 LM_LOG_LEVEL_VERBOSE = 1 << (G_LOG_LEVEL_USER_SHIFT), | |
| 1609 LM_LOG_LEVEL_NET = 1 << (G_LOG_LEVEL_USER_SHIFT + 1), | |
| 1610 LM_LOG_LEVEL_PARSER = 1 << (G_LOG_LEVEL_USER_SHIFT + 2), | |
| 1611 LM_LOG_LEVEL_SSL = 1 << (G_LOG_LEVEL_USER_SHIFT + 3), | |
| 1612 LM_LOG_LEVEL_SASL = 1 << (G_LOG_LEVEL_USER_SHIFT + 4), | |
| 1613 LM_LOG_LEVEL_ALL = (LM_LOG_LEVEL_NET | | |
| 1614 LM_LOG_LEVEL_VERBOSE | | |
| 1615 LM_LOG_LEVEL_PARSER | | |
| 1616 LM_LOG_LEVEL_SSL | | |
| 1617 LM_LOG_LEVEL_SASL) | |
| 1618 } LmLogLevelFlags; | |
| 1619 | |
| 1620 static void lm_debug_handler (const gchar *log_domain, | |
| 1621 GLogLevelFlags log_level, | |
| 1622 const gchar *message, | |
| 1623 gpointer user_data) | |
| 1624 { | |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1625 if (message && *message) { |
| 1598 | 1626 char *msg; |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1627 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
|
1628 |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1629 if (mcabber_loglevel < 2) |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1630 return; |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1631 |
| 1598 | 1632 if (message[0] == '\n') |
| 1633 msg = g_strdup(&message[1]); | |
| 1634 else | |
| 1635 msg = g_strdup(message); | |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1636 |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1637 if (msg[strlen(msg)-1] == '\n') |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1638 msg[strlen(msg)-1] = '\0'; |
| 1598 | 1639 |
| 1640 if (log_level & LM_LOG_LEVEL_VERBOSE) { | |
| 1641 scr_LogPrint(LPRINT_DEBUG, "LM-VERBOSE: %s", msg); | |
| 1642 } | |
|
1616
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1643 if (log_level & LM_LOG_LEVEL_NET) { |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1644 if (mcabber_loglevel > 2) |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1645 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
|
1646 } 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
|
1647 if (mcabber_loglevel > 3) |
|
4c7104ec5f3b
Add 2 debugging levels (for 'tracelog_level')
Mikael Berthe <mikael@lilotux.net>
parents:
1615
diff
changeset
|
1648 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
|
1649 } else if (log_level & LM_LOG_LEVEL_SASL) { |
| 1598 | 1650 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
|
1651 } else if (log_level & LM_LOG_LEVEL_SSL) { |
| 1598 | 1652 scr_LogPrint(LPRINT_DEBUG, "LM-SSL: %s", msg); |
| 1653 } | |
| 1654 g_free(msg); | |
| 1655 } | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1656 } |
|
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1657 |
| 1598 | 1658 |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1659 // xmpp_connect() |
|
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1660 // Return a non-zero value if there's an obvious problem |
|
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1661 // (no JID, no password, etc.) |
|
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1662 gint xmpp_connect(void) |
| 31 | 1663 { |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1664 const char *userjid, *password, *resource, *servername, *ssl_fpr; |
| 1598 | 1665 char *dynresource = NULL; |
| 1666 char fpr[16]; | |
| 1667 const char *proxy_host; | |
| 1668 const char *resource_prefix = PACKAGE_NAME; | |
| 1669 char *fjid; | |
| 1670 int ssl, tls; | |
| 1671 LmSSL *lssl; | |
| 1672 unsigned int port; | |
| 1673 unsigned int ping; | |
| 1674 LmMessageHandler *handler; | |
| 1675 GError *error = NULL; | |
| 1676 | |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1677 xmpp_disconnect(); |
| 1598 | 1678 |
| 1679 servername = settings_opt_get("server"); | |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1680 userjid = settings_opt_get("jid"); |
| 1598 | 1681 password = settings_opt_get("password"); |
| 1682 resource = settings_opt_get("resource"); | |
| 1683 proxy_host = settings_opt_get("proxy_host"); | |
| 1684 ssl_fpr = settings_opt_get("ssl_fingerprint"); | |
| 1685 | |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1686 if (!userjid) { |
|
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1687 scr_LogPrint(LPRINT_LOGNORM, "Your JID has not been specified!"); |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1688 return -1; |
| 1598 | 1689 } |
| 1690 if (!password) { | |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1691 scr_LogPrint(LPRINT_LOGNORM, "Your password has not been specified!"); |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1692 return -1; |
| 1598 | 1693 } |
| 1694 | |
|
1653
fca9a4c17432
Improve UI latency and CPU usage
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1647
diff
changeset
|
1695 lconnection = lm_connection_new_with_context(NULL, main_context); |
| 1598 | 1696 |
| 1697 g_log_set_handler("LM", LM_LOG_LEVEL_ALL, lm_debug_handler, NULL); | |
| 1698 | |
| 1699 ping = 40; | |
| 1700 if (settings_opt_get("pinginterval")) | |
| 1701 ping = (unsigned int) settings_opt_get_int("pinginterval"); | |
| 1702 lm_connection_set_keep_alive_rate(lconnection, ping); | |
| 1703 scr_LogPrint(LPRINT_DEBUG, "Ping interval established: %d secs", ping); | |
| 1704 | |
| 1705 lm_connection_set_disconnect_function(lconnection, connection_close_cb, | |
| 1706 NULL, NULL); | |
| 1707 | |
| 1708 handler = lm_message_handler_new(handle_messages, NULL, NULL); | |
| 1709 lm_connection_register_message_handler(lconnection, handler, | |
| 1710 LM_MESSAGE_TYPE_MESSAGE, | |
| 1711 LM_HANDLER_PRIORITY_NORMAL); | |
| 1712 lm_message_handler_unref(handler); | |
| 1713 | |
| 1714 handler = lm_message_handler_new(handle_iq, NULL, NULL); | |
| 1715 lm_connection_register_message_handler(lconnection, handler, | |
| 1716 LM_MESSAGE_TYPE_IQ, | |
| 1717 LM_HANDLER_PRIORITY_NORMAL); | |
| 1718 lm_message_handler_unref(handler); | |
| 1719 | |
| 1720 handler = lm_message_handler_new(handle_presence, NULL, NULL); | |
| 1721 lm_connection_register_message_handler(lconnection, handler, | |
| 1722 LM_MESSAGE_TYPE_PRESENCE, | |
| 1723 LM_HANDLER_PRIORITY_LAST); | |
| 1724 lm_message_handler_unref(handler); | |
| 1725 | |
| 1726 handler = lm_message_handler_new(handle_s10n, NULL, NULL); | |
| 1727 lm_connection_register_message_handler(lconnection, handler, | |
| 1728 LM_MESSAGE_TYPE_PRESENCE, | |
| 1729 LM_HANDLER_PRIORITY_NORMAL); | |
| 1730 lm_message_handler_unref(handler); | |
| 1731 | |
| 1732 /* Connect to server */ | |
|
1902
51cc01a1a5ec
Improve messages when connecting to the Jabber server
Mikael Berthe <mikael@lilotux.net>
parents:
1899
diff
changeset
|
1733 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, "Connecting to server%s%s", |
|
51cc01a1a5ec
Improve messages when connecting to the Jabber server
Mikael Berthe <mikael@lilotux.net>
parents:
1899
diff
changeset
|
1734 servername ? ": " : "", |
|
51cc01a1a5ec
Improve messages when connecting to the Jabber server
Mikael Berthe <mikael@lilotux.net>
parents:
1899
diff
changeset
|
1735 servername ? servername : ""); |
| 1598 | 1736 if (!resource) |
| 1737 resource = resource_prefix; | |
| 31 | 1738 |
|
1747
c4f67e2e675f
Randomize reconnection delay
Mikael Berthe <mikael@lilotux.net>
parents:
1746
diff
changeset
|
1739 // Initialize pseudo-random seed |
|
c4f67e2e675f
Randomize reconnection delay
Mikael Berthe <mikael@lilotux.net>
parents:
1746
diff
changeset
|
1740 srandom(time(NULL)); |
|
c4f67e2e675f
Randomize reconnection delay
Mikael Berthe <mikael@lilotux.net>
parents:
1746
diff
changeset
|
1741 |
| 1598 | 1742 if (!settings_opt_get("disable_random_resource")) { |
| 1743 #if HAVE_ARC4RANDOM | |
| 1744 dynresource = g_strdup_printf("%s.%08x", resource, arc4random()); | |
| 1745 #else | |
| 1746 unsigned int tab[2]; | |
|
1746
b7574de9ae4b
Use random() instead of rand()
Mikael Berthe <mikael@lilotux.net>
parents:
1733
diff
changeset
|
1747 tab[0] = (unsigned int) (0xffff * (random() / (RAND_MAX + 1.0))); |
|
b7574de9ae4b
Use random() instead of rand()
Mikael Berthe <mikael@lilotux.net>
parents:
1733
diff
changeset
|
1748 tab[1] = (unsigned int) (0xffff * (random() / (RAND_MAX + 1.0))); |
| 1598 | 1749 dynresource = g_strdup_printf("%s.%04x%04x", resource, tab[0], tab[1]); |
| 1750 #endif | |
| 1751 resource = dynresource; | |
| 1752 } | |
| 1753 | |
| 1754 port = (unsigned int) settings_opt_get_int("port"); | |
| 1755 | |
| 1756 if (port) | |
| 1757 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, " using port %d", port); | |
|
1902
51cc01a1a5ec
Improve messages when connecting to the Jabber server
Mikael Berthe <mikael@lilotux.net>
parents:
1899
diff
changeset
|
1758 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, " with resource %s", resource); |
| 1598 | 1759 |
| 1760 if (proxy_host) { | |
| 1761 int proxy_port = settings_opt_get_int("proxy_port"); | |
| 1762 if (proxy_port <= 0 || proxy_port > 65535) { | |
| 1763 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, "Invalid proxy port: %d", | |
| 1764 proxy_port); | |
| 1765 } else { | |
| 1766 const char *proxy_user, *proxy_pass; | |
| 1767 LmProxy *lproxy; | |
| 1768 proxy_user = settings_opt_get("proxy_user"); | |
| 1769 proxy_pass = settings_opt_get("proxy_pass"); | |
| 1770 // Proxy initialization | |
| 1771 lproxy = lm_proxy_new_with_server(LM_PROXY_TYPE_HTTP, | |
| 1772 proxy_host, proxy_port); | |
| 1773 lm_proxy_set_username(lproxy, proxy_user); | |
| 1774 lm_proxy_set_password(lproxy, proxy_pass); | |
| 1775 lm_connection_set_proxy(lconnection, lproxy); | |
| 1776 lm_proxy_unref(lproxy); | |
| 1777 scr_LogPrint(LPRINT_NORMAL|LPRINT_DEBUG, " using proxy %s:%d", | |
| 1778 proxy_host, proxy_port); | |
| 1779 } | |
| 1780 } | |
| 31 | 1781 |
|
1610
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1782 fjid = compose_jid(userjid, servername, resource); |
| 1598 | 1783 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
|
1784 if (servername) |
|
6db9f403f707
Replace 'username' with 'jid' in the configuration file
Mikael Berthe <mikael@lilotux.net>
parents:
1604
diff
changeset
|
1785 lm_connection_set_server(lconnection, servername); |
| 1598 | 1786 #if defined(HAVE_LIBOTR) |
| 1787 otr_init(fjid); | |
| 1788 #endif | |
| 1789 g_free(fjid); | |
| 1790 g_free(dynresource); | |
| 1791 | |
| 1792 ssl = settings_opt_get_int("ssl"); | |
| 1793 tls = settings_opt_get_int("tls"); | |
| 1794 | |
| 1795 if (!lm_ssl_is_supported()) { | |
| 1796 if (ssl || tls) { | |
| 1797 scr_LogPrint(LPRINT_LOGNORM, "** Error: SSL is NOT available, " | |
| 1798 "please recompile loudmouth with SSL enabled."); | |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1799 return -1; |
| 1598 | 1800 } |
| 1801 } | |
| 1802 | |
| 1803 if (ssl && tls) { | |
| 1804 scr_LogPrint(LPRINT_LOGNORM, "You can only set ssl or tls, not both."); | |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1805 return -1; |
| 1598 | 1806 } |
| 1807 | |
| 1808 if (!port) | |
| 1809 port = (ssl ? LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT); | |
| 1810 lm_connection_set_port(lconnection, port); | |
| 1811 | |
| 1812 if (ssl_fpr && (!hex_to_fingerprint(ssl_fpr, fpr))) { | |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1813 scr_LogPrint(LPRINT_LOGNORM, "** Please set the fingerprint in the format " |
| 1598 | 1814 "97:5C:00:3F:1D:77:45:25:E2:C5:70:EC:83:C8:87:EE"); |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1815 return -1; |
| 1598 | 1816 } |
| 1817 | |
| 1818 lssl = lm_ssl_new((ssl_fpr ? fpr : NULL), ssl_cb, NULL, NULL); | |
| 1819 if (lssl) { | |
| 1820 lm_ssl_use_starttls(lssl, !ssl, tls); | |
| 1821 lm_connection_set_ssl(lconnection, lssl); | |
| 1822 lm_ssl_unref(lssl); | |
| 1823 } else if (ssl || tls) { | |
| 1824 scr_LogPrint(LPRINT_LOGNORM, "** Error: Couldn't create SSL struct."); | |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1825 return -1; |
|
671
c5da36fd437a
Do not process packet if type = 0
Mikael Berthe <mikael@lilotux.net>
parents:
668
diff
changeset
|
1826 } |
|
c5da36fd437a
Do not process packet if type = 0
Mikael Berthe <mikael@lilotux.net>
parents:
668
diff
changeset
|
1827 |
| 1598 | 1828 if (!lm_connection_open(lconnection, connection_open_cb, |
| 1829 NULL, FALSE, &error)) { | |
| 1830 _try_to_reconnect(); | |
|
1717
c12455fec611
Remove extra newlines in scr_LogPrint() calls
Mikael Berthe <mikael@lilotux.net>
parents:
1716
diff
changeset
|
1831 scr_LogPrint(LPRINT_LOGNORM, "Failed to open: %s", error->message); |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1832 g_error_free(error); |
| 1598 | 1833 } |
|
1810
8c2651fc217a
Improve initial display when there is an error message
Mikael Berthe <mikael@lilotux.net>
parents:
1800
diff
changeset
|
1834 return 0; |
| 1598 | 1835 } |
| 1836 | |
| 1837 // insert_entity_capabilities(presence_stanza) | |
| 1838 // Entity Capabilities (XEP-0115) | |
| 1600 | 1839 static void insert_entity_capabilities(LmMessageNode *x, enum imstatus status) |
| 1598 | 1840 { |
| 1841 LmMessageNode *y; | |
| 1600 | 1842 const char *ver = entity_version(status); |
| 1598 | 1843 |
| 1844 y = lm_message_node_add_child(x, "c", NULL); | |
| 1845 lm_message_node_set_attribute(y, "xmlns", NS_CAPS); | |
| 1600 | 1846 lm_message_node_set_attribute(y, "hash", "sha-1"); |
| 1598 | 1847 lm_message_node_set_attribute(y, "node", MCABBER_CAPS_NODE); |
| 1848 lm_message_node_set_attribute(y, "ver", ver); | |
| 1849 } | |
| 1850 | |
| 1851 void xmpp_disconnect(void) | |
| 1852 { | |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1853 if (!lconnection) |
| 1598 | 1854 return; |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1855 if (lm_connection_is_authenticated(lconnection)) { |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1856 // Launch pre-disconnect internal hook |
|
1683
b09f82f61745
Split HOOK_INTERNAL
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1682
diff
changeset
|
1857 hk_predisconnect(); |
|
1682
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1858 // Announce it to everyone else |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1859 xmpp_setstatus(offline, NULL, "", FALSE); |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1860 } |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1861 if (lm_connection_is_open(lconnection)) |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1862 lm_connection_close(lconnection, NULL); |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1863 lm_connection_unref(lconnection); |
|
d1e8fb14ce2d
Destroy lm connection object on disconnect
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1668
diff
changeset
|
1864 lconnection = NULL; |
| 1598 | 1865 } |
| 1866 | |
| 1867 void xmpp_setstatus(enum imstatus st, const char *recipient, const char *msg, | |
| 1868 int do_not_sign) | |
| 1869 { | |
| 1870 LmMessage *m; | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1871 gboolean isonline; |
| 1598 | 1872 |
| 1873 if (msg) { | |
| 1874 // The status message has been specified. We'll use it, unless it is | |
| 1875 // "-" which is a special case (option meaning "no status message"). | |
| 1876 if (!strcmp(msg, "-")) | |
| 1877 msg = ""; | |
| 1878 } else { | |
| 1879 // No status message specified; we'll use: | |
| 1880 // a) the default status message (if provided by the user); | |
| 1881 // b) the current status message; | |
| 1882 // c) no status message (i.e. an empty one). | |
| 1883 msg = settings_get_status_msg(st); | |
| 1884 if (!msg) { | |
| 1885 if (mystatusmsg) | |
| 1886 msg = mystatusmsg; | |
| 1887 else | |
| 1888 msg = ""; | |
| 1889 } | |
| 1890 } | |
| 1891 | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1892 isonline = xmpp_is_online(); |
|
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1893 |
| 1598 | 1894 // Only send the packet if we're online. |
| 1895 // (But we want to update internal status even when disconnected, | |
| 1896 // 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
|
1897 if (isonline) { |
| 1598 | 1898 const char *s_msg = (st != invisible ? msg : NULL); |
| 1899 m = lm_message_new_presence(st, recipient, s_msg); | |
| 1600 | 1900 insert_entity_capabilities(m->node, st); // Entity Capabilities (XEP-0115) |
| 1598 | 1901 #ifdef HAVE_GPGME |
| 1902 if (!do_not_sign && gpg_enabled()) { | |
| 1903 char *signature; | |
| 1904 signature = gpg_sign(s_msg ? s_msg : ""); | |
| 1905 if (signature) { | |
| 1906 LmMessageNode *y; | |
| 1907 y = lm_message_node_add_child(m->node, "x", signature); | |
| 1908 lm_message_node_set_attribute(y, "xmlns", NS_SIGNED); | |
| 1909 g_free(signature); | |
| 1910 } | |
| 1911 } | |
| 1912 #endif | |
| 1913 lm_connection_send(lconnection, m, NULL); | |
| 1914 lm_message_unref(m); | |
| 1915 } | |
| 1916 | |
| 1917 // If we didn't change our _global_ status, we are done | |
| 1918 if (recipient) return; | |
| 1919 | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1920 if (isonline) { |
| 1598 | 1921 // Send presence to chatrooms |
| 1922 if (st != invisible) { | |
| 1923 struct T_presence room_presence; | |
| 1924 room_presence.st = st; | |
| 1925 room_presence.msg = msg; | |
| 1926 foreach_buddy(ROSTER_TYPE_ROOM, &roompresence, &room_presence); | |
| 1927 } | |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1928 } |
| 1598 | 1929 |
|
1693
32c6d81bd1ef
Update status when unexpectedly disconnected from server
Mikael Berthe <mikael@lilotux.net>
parents:
1691
diff
changeset
|
1930 if (isonline || !st) { |
| 1598 | 1931 // We'll have to update the roster if we switch to/from offline because |
| 1932 // we don't know the presences of buddies when offline... | |
| 1933 if (mystatus == offline || st == offline) | |
| 1934 update_roster = TRUE; | |
| 1935 | |
|
1716
d30fb41725fe
Do not call hk_mystatuschange() twice when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1715
diff
changeset
|
1936 if (isonline || mystatus || st) |
|
d30fb41725fe
Do not call hk_mystatuschange() twice when we're disconnected
Mikael Berthe <mikael@lilotux.net>
parents:
1715
diff
changeset
|
1937 hk_mystatuschange(0, mystatus, st, (st != invisible ? msg : "")); |
| 1598 | 1938 mystatus = st; |
| 1939 } | |
| 1940 | |
| 1941 if (st) | |
| 1942 mywantedstatus = st; | |
| 1943 | |
| 1944 if (msg != mystatusmsg) { | |
| 1945 g_free(mystatusmsg); | |
| 1946 if (*msg) | |
| 1947 mystatusmsg = g_strdup(msg); | |
| 1948 else | |
| 1949 mystatusmsg = NULL; | |
| 1950 } | |
| 1951 | |
|
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1747
diff
changeset
|
1952 if (!scr_curses_status()) |
|
1733
a9b0364c0cb2
Fix segfault introduced in previous commit
Mikael Berthe <mikael@lilotux.net>
parents:
1731
diff
changeset
|
1953 return; // Called from config. file |
|
a9b0364c0cb2
Fix segfault introduced in previous commit
Mikael Berthe <mikael@lilotux.net>
parents:
1731
diff
changeset
|
1954 |
| 1598 | 1955 if (!Autoaway) |
| 1956 update_last_use(); | |
| 1957 | |
| 1958 // Update status line | |
|
1780
e4378fbab5d7
Major API cleanup - bump API to 4
Mikael Berthe <mikael@lilotux.net>
parents:
1747
diff
changeset
|
1959 scr_update_main_status(TRUE); |
| 1598 | 1960 } |
| 1961 | |
|
547
1df26ff0ed8c
Break packethandler() out
Mikael Berthe <mikael@lilotux.net>
parents:
539
diff
changeset
|
1962 |
| 1598 | 1963 enum imstatus xmpp_getstatus(void) |
| 1964 { | |
| 1965 return mystatus; | |
| 1966 } | |
| 1967 | |
| 1968 const char *xmpp_getstatusmsg(void) | |
| 1969 { | |
| 1970 return mystatusmsg; | |
| 1971 } | |
| 1972 | |
| 1973 // xmpp_setprevstatus() | |
| 1974 // Set previous status. This wrapper function is used after a disconnection. | |
| 1975 void xmpp_setprevstatus(void) | |
| 1976 { | |
| 1977 xmpp_setstatus(mywantedstatus, NULL, mystatusmsg, FALSE); | |
| 1978 } | |
| 1979 | |
| 1980 // send_storage(store) | |
| 1981 // Send the node "store" to update the server. | |
| 1982 // Note: the sender should check we're online. | |
| 1983 void send_storage(LmMessageNode *store) | |
| 1984 { | |
| 1985 LmMessage *iq; | |
| 1986 LmMessageNode *query; | |
| 1987 | |
| 1988 if (!rosternotes) return; | |
| 1989 | |
| 1990 iq = lm_message_new_with_sub_type(NULL, LM_MESSAGE_TYPE_IQ, | |
| 1991 LM_MESSAGE_SUB_TYPE_SET); | |
| 1992 query = lm_message_node_add_child(iq->node, "query", NULL); | |
| 1993 lm_message_node_set_attribute(query, "xmlns", NS_PRIVATE); | |
| 1994 lm_message_node_insert_childnode(query, store); | |
| 1995 | |
| 1996 lm_connection_send(lconnection, iq, NULL); | |
| 1997 lm_message_unref(iq); | |
| 1998 } | |
| 1999 | |
| 2000 | |
| 2001 // xmpp_is_bookmarked(roomjid) | |
| 2002 // Return TRUE if there's a bookmark for the given jid. | |
| 2003 guint xmpp_is_bookmarked(const char *bjid) | |
| 2004 { | |
| 2005 LmMessageNode *x; | |
| 2006 | |
| 2007 if (!bookmarks) | |
| 2008 return FALSE; | |
| 2009 | |
| 2010 // Walk through the storage bookmark tags | |
| 2011 for (x = bookmarks->children ; x; x = x->next) { | |
| 2012 // If the node is a conference item, check the jid. | |
| 2013 if (x->name && !strcmp(x->name, "conference")) { | |
| 2014 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2015 if (fjid && !strcasecmp(bjid, fjid)) | |
| 2016 return TRUE; | |
| 2017 } | |
| 2018 } | |
| 2019 return FALSE; | |
| 2020 } | |
| 2021 | |
| 2022 // xmpp_get_bookmark_nick(roomjid) | |
| 2023 // Return the room nickname if it is present in a bookmark. | |
| 2024 const char *xmpp_get_bookmark_nick(const char *bjid) | |
| 2025 { | |
| 2026 LmMessageNode *x; | |
| 2027 | |
| 2028 if (!bookmarks || !bjid) | |
| 2029 return NULL; | |
|
469
a926523d2392
Use UTF8 to handle resources and room nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
468
diff
changeset
|
2030 |
| 1598 | 2031 // Walk through the storage bookmark tags |
| 2032 for (x = bookmarks->children ; x; x = x->next) { | |
| 2033 // If the node is a conference item, check the jid. | |
| 2034 if (x->name && !strcmp(x->name, "conference")) { | |
| 2035 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2036 if (fjid && !strcasecmp(bjid, fjid)) | |
| 2037 return lm_message_node_get_child_value(x, "nick"); | |
| 2038 } | |
| 2039 } | |
| 2040 return NULL; | |
| 2041 } | |
| 2042 | |
| 2043 | |
| 2044 // xmpp_get_all_storage_bookmarks() | |
| 2045 // Return a GSList with all storage bookmarks. | |
| 2046 // The caller should g_free the list (not the MUC jids). | |
| 2047 GSList *xmpp_get_all_storage_bookmarks(void) | |
| 2048 { | |
| 2049 LmMessageNode *x; | |
| 2050 GSList *sl_bookmarks = NULL; | |
| 2051 | |
| 2052 // If we have no bookmarks, probably the server doesn't support them. | |
| 2053 if (!bookmarks) | |
| 2054 return NULL; | |
| 2055 | |
| 2056 // Walk through the storage bookmark tags | |
| 2057 for (x = bookmarks->children ; x; x = x->next) { | |
| 2058 // If the node is a conference item, let's add the note to our list. | |
| 2059 if (x->name && !strcmp(x->name, "conference")) { | |
| 2060 struct bookmark *bm_elt; | |
| 2061 const char *autojoin, *name, *nick; | |
| 2062 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2063 if (!fjid) | |
| 2064 continue; | |
| 2065 bm_elt = g_new0(struct bookmark, 1); | |
| 2066 bm_elt->roomjid = g_strdup(fjid); | |
| 2067 autojoin = lm_message_node_get_attribute(x, "autojoin"); | |
|
1818
4694fad35ed8
Fix not displaying of MUC nick, set in bookmark
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1811
diff
changeset
|
2068 nick = lm_message_node_get_child_value(x, "nick"); |
| 1598 | 2069 name = lm_message_node_get_attribute(x, "name"); |
| 2070 if (autojoin && !strcmp(autojoin, "1")) | |
| 2071 bm_elt->autojoin = 1; | |
| 2072 if (nick) | |
| 2073 bm_elt->nick = g_strdup(nick); | |
| 2074 if (name) | |
| 2075 bm_elt->name = g_strdup(name); | |
| 2076 sl_bookmarks = g_slist_append(sl_bookmarks, bm_elt); | |
| 2077 } | |
| 2078 } | |
| 2079 return sl_bookmarks; | |
| 2080 } | |
| 2081 | |
| 2082 // xmpp_set_storage_bookmark(roomid, name, nick, passwd, autojoin, | |
| 2083 // printstatus, autowhois) | |
| 2084 // Update the private storage bookmarks: add a conference room. | |
| 2085 // If name is nil, we remove the bookmark. | |
| 2086 void xmpp_set_storage_bookmark(const char *roomid, const char *name, | |
| 2087 const char *nick, const char *passwd, | |
| 2088 int autojoin, enum room_printstatus pstatus, | |
| 2089 enum room_autowhois awhois) | |
| 2090 { | |
| 2091 LmMessageNode *x; | |
| 2092 bool changed = FALSE; | |
| 2093 | |
| 2094 if (!roomid) | |
| 2095 return; | |
| 2096 | |
| 2097 // If we have no bookmarks, probably the server doesn't support them. | |
| 2098 if (!bookmarks) { | |
| 2099 scr_LogPrint(LPRINT_NORMAL, | |
| 2100 "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
|
2101 return; |
|
a926523d2392
Use UTF8 to handle resources and room nicknames
Mikael Berthe <mikael@lilotux.net>
parents:
468
diff
changeset
|
2102 } |
| 31 | 2103 |
| 1598 | 2104 // Walk through the storage tags |
| 2105 for (x = bookmarks->children ; x; x = x->next) { | |
| 2106 // If the current node is a conference item, see if we have to replace it. | |
| 2107 if (x->name && !strcmp(x->name, "conference")) { | |
| 2108 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2109 if (!fjid) | |
| 2110 continue; | |
| 2111 if (!strcmp(fjid, roomid)) { | |
| 2112 // We've found a bookmark for this room. Let's hide it and we'll | |
| 2113 // create a new one. | |
| 2114 lm_message_node_hide(x); | |
| 2115 changed = TRUE; | |
| 2116 if (!name) | |
| 2117 scr_LogPrint(LPRINT_LOGNORM, "Deleting bookmark..."); | |
| 2118 } | |
| 2119 } | |
| 2120 } | |
| 31 | 2121 |
| 1598 | 2122 // Let's create a node/bookmark for this roomid, if the name is not NULL. |
| 2123 if (name) { | |
| 2124 x = lm_message_node_add_child(bookmarks, "conference", NULL); | |
| 2125 lm_message_node_set_attributes(x, | |
| 2126 "jid", roomid, | |
| 2127 "name", name, | |
| 2128 "autojoin", autojoin ? "1" : "0", | |
| 2129 NULL); | |
| 2130 if (nick) | |
| 2131 lm_message_node_add_child(x, "nick", nick); | |
| 2132 if (passwd) | |
| 2133 lm_message_node_add_child(x, "password", passwd); | |
| 2134 if (pstatus) | |
| 2135 lm_message_node_add_child(x, "print_status", strprintstatus[pstatus]); | |
| 2136 if (awhois) | |
|
1633
e3afe1da8a5f
Fix saving autowhois option in bookmarks
Mikael Berthe <mikael@lilotux.net>
parents:
1621
diff
changeset
|
2137 lm_message_node_set_attributes(x, "autowhois", |
|
e3afe1da8a5f
Fix saving autowhois option in bookmarks
Mikael Berthe <mikael@lilotux.net>
parents:
1621
diff
changeset
|
2138 (awhois == autowhois_on) ? "1" : "0", |
|
e3afe1da8a5f
Fix saving autowhois option in bookmarks
Mikael Berthe <mikael@lilotux.net>
parents:
1621
diff
changeset
|
2139 NULL); |
| 1598 | 2140 changed = TRUE; |
| 2141 scr_LogPrint(LPRINT_LOGNORM, "Updating bookmarks..."); | |
| 2142 } | |
| 2143 | |
| 2144 if (!changed) | |
| 2145 return; | |
| 31 | 2146 |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
2147 if (xmpp_is_online()) |
| 1598 | 2148 send_storage(bookmarks); |
| 2149 else | |
| 2150 scr_LogPrint(LPRINT_LOGNORM, | |
| 2151 "Warning: you're not connected to the server."); | |
| 2152 } | |
| 2153 | |
| 2154 static struct annotation *parse_storage_rosternote(LmMessageNode *notenode) | |
| 2155 { | |
| 2156 const char *p; | |
| 2157 struct annotation *note = g_new0(struct annotation, 1); | |
| 2158 p = lm_message_node_get_attribute(notenode, "cdate"); | |
| 2159 if (p) | |
| 2160 note->cdate = from_iso8601(p, 1); | |
| 2161 p = lm_message_node_get_attribute(notenode, "mdate"); | |
| 2162 if (p) | |
| 2163 note->mdate = from_iso8601(p, 1); | |
| 2164 note->text = g_strdup(lm_message_node_get_value(notenode)); | |
| 2165 note->jid = g_strdup(lm_message_node_get_attribute(notenode, "jid")); | |
| 2166 return note; | |
| 2167 } | |
| 31 | 2168 |
| 1598 | 2169 // xmpp_get_all_storage_rosternotes() |
| 2170 // Return a GSList with all storage annotations. | |
| 2171 // The caller should g_free the list and its contents. | |
| 2172 GSList *xmpp_get_all_storage_rosternotes(void) | |
| 2173 { | |
| 2174 LmMessageNode *x; | |
| 2175 GSList *sl_notes = NULL; | |
| 2176 | |
| 2177 // If we have no rosternotes, probably the server doesn't support them. | |
| 2178 if (!rosternotes) | |
| 2179 return NULL; | |
| 31 | 2180 |
| 1598 | 2181 // Walk through the storage rosternotes tags |
| 2182 for (x = rosternotes->children ; x; x = x->next) { | |
| 2183 struct annotation *note; | |
| 2184 | |
| 2185 // We want a note item | |
| 2186 if (!x->name || strcmp(x->name, "note")) | |
| 2187 continue; | |
| 2188 // Just in case, check the jid... | |
| 2189 if (!lm_message_node_get_attribute(x, "jid")) | |
| 2190 continue; | |
| 2191 // Ok, let's add the note to our list | |
| 2192 note = parse_storage_rosternote(x); | |
| 2193 sl_notes = g_slist_append(sl_notes, note); | |
| 31 | 2194 } |
| 1598 | 2195 return sl_notes; |
| 31 | 2196 } |
| 2197 | |
| 1598 | 2198 // xmpp_get_storage_rosternotes(barejid, silent) |
| 2199 // Return the annotation associated with this jid. | |
| 2200 // If silent is TRUE, no warning is displayed when rosternotes is disabled | |
| 2201 // The caller should g_free the string and structure after use. | |
| 2202 struct annotation *xmpp_get_storage_rosternotes(const char *barejid, int silent) | |
| 2203 { | |
| 2204 LmMessageNode *x; | |
| 2205 | |
| 2206 if (!barejid) | |
| 2207 return NULL; | |
| 2208 | |
| 2209 // If we have no rosternotes, probably the server doesn't support them. | |
| 2210 if (!rosternotes) { | |
| 2211 if (!silent) | |
| 2212 scr_LogPrint(LPRINT_NORMAL, "Sorry, " | |
| 2213 "your server doesn't seem to support private storage."); | |
| 2214 return NULL; | |
| 2215 } | |
| 2216 | |
| 2217 // Walk through the storage rosternotes tags | |
| 2218 for (x = rosternotes->children ; x; x = x->next) { | |
| 2219 const char *fjid; | |
| 2220 // We want a note item | |
| 2221 if (!x->name || strcmp(x->name, "note")) | |
| 2222 continue; | |
| 2223 // Just in case, check the jid... | |
| 2224 fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2225 if (fjid && !strcmp(fjid, barejid)) // We've found a note for this contact. | |
| 2226 return parse_storage_rosternote(x); | |
| 2227 } | |
| 2228 return NULL; // No note found | |
| 2229 } | |
| 2230 | |
| 2231 // xmpp_set_storage_rosternotes(barejid, note) | |
| 2232 // Update the private storage rosternotes: add/delete a note. | |
| 2233 // If note is nil, we remove the existing note. | |
| 2234 void xmpp_set_storage_rosternotes(const char *barejid, const char *note) | |
| 2235 { | |
| 2236 LmMessageNode *x; | |
| 2237 bool changed = FALSE; | |
| 2238 const char *cdate = NULL; | |
| 2239 | |
| 2240 if (!barejid) | |
| 2241 return; | |
| 2242 | |
| 2243 // If we have no rosternotes, probably the server doesn't support them. | |
| 2244 if (!rosternotes) { | |
| 2245 scr_LogPrint(LPRINT_NORMAL, | |
| 2246 "Sorry, your server doesn't seem to support private storage."); | |
| 2247 return; | |
| 2248 } | |
| 2249 | |
| 2250 // Walk through the storage tags | |
| 2251 for (x = rosternotes->children ; x; x = x->next) { | |
| 2252 // If the current node is a conference item, see if we have to replace it. | |
| 2253 if (x->name && !strcmp(x->name, "note")) { | |
| 2254 const char *fjid = lm_message_node_get_attribute(x, "jid"); | |
| 2255 if (!fjid) | |
| 2256 continue; | |
| 2257 if (!strcmp(fjid, barejid)) { | |
| 2258 // We've found a note for this jid. Let's hide it and we'll | |
| 2259 // create a new one. | |
| 2260 cdate = lm_message_node_get_attribute(x, "cdate"); | |
| 2261 lm_message_node_hide(x); | |
| 2262 changed = TRUE; | |
| 2263 break; | |
| 2264 } | |
| 2265 } | |
| 2266 } | |
| 2267 | |
| 2268 // Let's create a node for this jid, if the note is not NULL. | |
| 2269 if (note) { | |
| 2270 char mdate[20]; | |
| 2271 time_t now; | |
| 2272 time(&now); | |
| 2273 to_iso8601(mdate, now); | |
| 2274 if (!cdate) | |
| 2275 cdate = mdate; | |
| 2276 x = lm_message_node_add_child(rosternotes, "note", note); | |
| 2277 lm_message_node_set_attributes(x, | |
| 2278 "jid", barejid, | |
| 2279 "cdate", cdate, | |
| 2280 "mdate", mdate, | |
| 2281 NULL); | |
| 2282 changed = TRUE; | |
| 2283 } | |
| 2284 | |
| 2285 if (!changed) | |
| 2286 return; | |
| 2287 | |
|
1684
95df4ea512c8
Provide xmpp_is_online()
Myhailo Danylenko <isbear@ukrpost.net>
parents:
1683
diff
changeset
|
2288 if (xmpp_is_online()) |
| 1598 | 2289 send_storage(rosternotes); |
| 2290 else | |
| 2291 scr_LogPrint(LPRINT_LOGNORM, | |
| 2292 "Warning: you're not connected to the server."); | |
| 2293 } | |
| 1599 | 2294 |
| 1811 | 2295 /* vim: set et cindent cinoptions=>2\:2(0 ts=2 sw=2: For Vim users... */ |