Context Navigation

source: protocols/jabber/conference.c @ aa3b61e

Last change on this file since aa3b61e was 3c23681, checked in by dequis <dx@…>, at 2015-08-26T05:58:54Z

jabber: Improvements to the MUC part reason handling

Look for a status message right inside <presence> (seen with ejabberd as a result of a s2s connection error)
Check status codes in a while loop, skipping unknown ones (such as 110, which means "Inform user that presence refers to itself")

Property mode set to 100644

File size: 13.5 KB

Line
1	/***************************************************************************\
2	* *
3	* BitlBee - An IRC to IM gateway *
4	* Jabber module - Conference rooms *
5	* *
6	* Copyright 2007-2012 Wilmer van der Gaast <wilmer@gaast.net> *
7	* *
8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License along *
19	* with this program; if not, write to the Free Software Foundation, Inc., *
20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
21	* *
22	\***************************************************************************/
23
24	#include "jabber.h"
25	#include "sha1.h"
26
27	static xt_status jabber_chat_join_failed(struct im_connection ic, struct xt_node node, struct xt_node *orig);
28
29	struct groupchat jabber_chat_join(struct im_connection ic, const char room, const char nick, const char *password)
30	{
31	struct jabber_chat *jc;
32	struct xt_node *node;
33	struct groupchat *c;
34	char *roomjid;
35
36	roomjid = g_strdup_printf("%s/%s", room, nick);
37	node = xt_new_node("x", NULL, NULL);
38	xt_add_attr(node, "xmlns", XMLNS_MUC);
39	if (password) {
40	xt_add_child(node, xt_new_node("password", password, NULL));
41	}
42	node = jabber_make_packet("presence", NULL, roomjid, node);
43	jabber_cache_add(ic, node, jabber_chat_join_failed);
44
45	if (!jabber_write_packet(ic, node)) {
46	g_free(roomjid);
47	return NULL;
48	}
49
50	jc = g_new0(struct jabber_chat, 1);
51	jc->name = jabber_normalize(room);
52
53	if ((jc->me = jabber_buddy_add(ic, roomjid)) == NULL) {
54	g_free(roomjid);
55	g_free(jc->name);
56	g_free(jc);
57	return NULL;
58	}
59
60	/* roomjid isn't normalized yet, and we need an original version
61	of the nick to send a proper presence update. */
62	jc->my_full_jid = roomjid;
63
64	c = imcb_chat_new(ic, room);
65	c->data = jc;
66
67	return c;
68	}
69
70	struct groupchat jabber_chat_with(struct im_connection ic, char *who)
71	{
72	struct jabber_data *jd = ic->proto_data;
73	struct jabber_chat *jc;
74	struct groupchat *c;
75	sha1_state_t sum;
76	double now = gettime();
77	char uuid, rjid, *cserv;
78
79	sha1_init(&sum);
80	sha1_append(&sum, (uint8_t *) ic->acc->user, strlen(ic->acc->user));
81	sha1_append(&sum, (uint8_t *) &now, sizeof(now));
82	sha1_append(&sum, (uint8_t *) who, strlen(who));
83	uuid = sha1_random_uuid(&sum);
84
85	if (jd->flags & JFLAG_GTALK) {
86	cserv = g_strdup("groupchat.google.com");
87	} else {
88	/* Guess... */
89	cserv = g_strdup_printf("conference.%s", jd->server);
90	}
91
92	rjid = g_strdup_printf("private-chat-%s@%s", uuid, cserv);
93	g_free(uuid);
94	g_free(cserv);
95
96	c = jabber_chat_join(ic, rjid, jd->username, NULL);
97	g_free(rjid);
98	if (c == NULL) {
99	return NULL;
100	}
101
102	jc = c->data;
103	jc->invite = g_strdup(who);
104
105	return c;
106	}
107
108	static xt_status jabber_chat_join_failed(struct im_connection ic, struct xt_node node, struct xt_node *orig)
109	{
110	struct jabber_error *err;
111	struct jabber_buddy *bud;
112	char *room;
113
114	room = xt_find_attr(orig, "to");
115	bud = jabber_buddy_by_jid(ic, room, 0);
116	err = jabber_error_parse(xt_find_node(node->children, "error"), XMLNS_STANZA_ERROR);
117	if (err) {
118	imcb_error(ic, "Error joining groupchat %s: %s%s%s", room, err->code,
119	err->text ? ": " : "", err->text ? err->text : "");
120	jabber_error_free(err);
121	}
122	if (bud) {
123	jabber_chat_free(jabber_chat_by_jid(ic, bud->bare_jid));
124	}
125
126	return XT_HANDLED;
127	}
128
129	struct groupchat jabber_chat_by_jid(struct im_connection ic, const char *name)
130	{
131	char *normalized = jabber_normalize(name);
132	GSList *l;
133	struct groupchat *ret;
134	struct jabber_chat *jc;
135
136	for (l = ic->groupchats; l; l = l->next) {
137	ret = l->data;
138	jc = ret->data;
139	if (strcmp(normalized, jc->name) == 0) {
140	break;
141	}
142	}
143	g_free(normalized);
144
145	return l ? ret : NULL;
146	}
147
148	void jabber_chat_free(struct groupchat *c)
149	{
150	struct jabber_chat *jc = c->data;
151
152	jabber_buddy_remove_bare(c->ic, jc->name);
153
154	g_free(jc->my_full_jid);
155	g_free(jc->name);
156	g_free(jc->invite);
157	g_free(jc);
158
159	imcb_chat_free(c);
160	}
161
162	int jabber_chat_msg(struct groupchat c, char message, int flags)
163	{
164	struct im_connection *ic = c->ic;
165	struct jabber_chat *jc = c->data;
166	struct xt_node *node;
167
168	jc->flags \|= JCFLAG_MESSAGE_SENT;
169
170	node = xt_new_node("body", message, NULL);
171	node = jabber_make_packet("message", "groupchat", jc->name, node);
172
173	if (!jabber_write_packet(ic, node)) {
174	xt_free_node(node);
175	return 0;
176	}
177	xt_free_node(node);
178
179	return 1;
180	}
181
182	int jabber_chat_topic(struct groupchat c, char topic)
183	{
184	struct im_connection *ic = c->ic;
185	struct jabber_chat *jc = c->data;
186	struct xt_node *node;
187
188	node = xt_new_node("subject", topic, NULL);
189	node = jabber_make_packet("message", "groupchat", jc->name, node);
190
191	if (!jabber_write_packet(ic, node)) {
192	xt_free_node(node);
193	return 0;
194	}
195	xt_free_node(node);
196
197	return 1;
198	}
199
200	int jabber_chat_leave(struct groupchat c, const char reason)
201	{
202	struct im_connection *ic = c->ic;
203	struct jabber_chat *jc = c->data;
204	struct xt_node *node;
205
206	node = xt_new_node("x", NULL, NULL);
207	xt_add_attr(node, "xmlns", XMLNS_MUC);
208	node = jabber_make_packet("presence", "unavailable", jc->my_full_jid, node);
209
210	if (!jabber_write_packet(ic, node)) {
211	xt_free_node(node);
212	return 0;
213	}
214	xt_free_node(node);
215
216	return 1;
217	}
218
219	void jabber_chat_invite(struct groupchat c, char who, char *message)
220	{
221	struct xt_node *node;
222	struct im_connection *ic = c->ic;
223	struct jabber_chat *jc = c->data;
224
225	node = xt_new_node("reason", message, NULL);
226
227	node = xt_new_node("invite", NULL, node);
228	xt_add_attr(node, "to", who);
229
230	node = xt_new_node("x", NULL, node);
231	xt_add_attr(node, "xmlns", XMLNS_MUC_USER);
232
233	node = jabber_make_packet("message", NULL, jc->name, node);
234
235	jabber_write_packet(ic, node);
236
237	xt_free_node(node);
238	}
239
240	/* Not really the same syntax as the normal pkt_ functions, but this isn't
241	called by the xmltree parser directly and this way I can add some extra
242	parameters so we won't have to repeat too many things done by the caller
243	already. */
244	void jabber_chat_pkt_presence(struct im_connection ic, struct jabber_buddy bud, struct xt_node *node)
245	{
246	struct groupchat *chat;
247	struct xt_node *c;
248	char *type = xt_find_attr(node, "type");
249	struct jabber_data *jd = ic->proto_data;
250	struct jabber_chat *jc;
251	char *s;
252
253	if ((chat = jabber_chat_by_jid(ic, bud->bare_jid)) == NULL) {
254	/* How could this happen?? We could do kill( self, 11 )
255	now or just wait for the OS to do it. :-) */
256	return;
257	}
258
259	jc = chat->data;
260
261	if (type == NULL && !(bud->flags & JBFLAG_IS_CHATROOM)) {
262	bud->flags \|= JBFLAG_IS_CHATROOM;
263	/* If this one wasn't set yet, this buddy just joined the chat.
264	Slightly hackish way of finding out eh? ;-) */
265
266	/* This is pretty messy... Here it sets ext_jid to the real
267	JID of the participant. Works for non-anonymized channels.
268	Might break if someone joins a chat twice, though. */
269	for (c = node->children; (c = xt_find_node(c, "x")); c = c->next) {
270	if ((s = xt_find_attr(c, "xmlns")) &&
271	(strcmp(s, XMLNS_MUC_USER) == 0)) {
272	struct xt_node *item;
273
274	item = xt_find_node(c->children, "item");
275	if ((s = xt_find_attr(item, "jid"))) {
276	/* Yay, found what we need. :-) */
277	bud->ext_jid = jabber_normalize(s);
278	break;
279	}
280	}
281	}
282
283	/* Make up some other handle, if necessary. */
284	if (bud->ext_jid == NULL) {
285	if (bud == jc->me) {
286	bud->ext_jid = g_strdup(jd->me);
287	} else {
288	int i;
289
290	/* Don't want the nick to be at the end, so let's
291	think of some slightly different notation to use
292	for anonymous groupchat participants in BitlBee. */
293	bud->ext_jid = g_strdup_printf("%s=%s", bud->resource, bud->bare_jid);
294
295	/* And strip any unwanted characters. */
296	for (i = 0; bud->resource[i]; i++) {
297	if (bud->ext_jid[i] == '=' \|\| bud->ext_jid[i] == '@') {
298	bud->ext_jid[i] = '_';
299	}
300	}
301
302	/* Some program-specific restrictions. */
303	imcb_clean_handle(ic, bud->ext_jid);
304	}
305	bud->flags \|= JBFLAG_IS_ANONYMOUS;
306	}
307
308	if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
309	/* If JIDs are anonymized, add them to the local
310	list for the duration of this chat. */
311	imcb_add_buddy(ic, bud->ext_jid, NULL);
312	imcb_buddy_nick_hint(ic, bud->ext_jid, bud->resource);
313	}
314
315	if (bud == jc->me && jc->invite != NULL) {
316	char *msg = g_strdup_printf("Please join me in room %s", jc->name);
317	jabber_chat_invite(chat, jc->invite, msg);
318	g_free(jc->invite);
319	g_free(msg);
320	jc->invite = NULL;
321	}
322
323	s = strchr(bud->ext_jid, '/');
324	if (s) {
325	s = 0; / Should NEVER be NULL, but who knows... */
326	}
327	imcb_chat_add_buddy(chat, bud->ext_jid);
328	if (s) {
329	*s = '/';
330	}
331	} else if (type) { /* type can only be NULL or "unavailable" in this function */
332	if ((bud->flags & JBFLAG_IS_CHATROOM) && bud->ext_jid) {
333	char *reason = NULL;
334	char *status = NULL;
335	char *status_text = NULL;
336
337	if ((c = xt_find_node_by_attr(node->children, "x", "xmlns", XMLNS_MUC_USER))) {
338	struct xt_node *c2 = c->children;
339
340	while ((c2 = xt_find_node(c2, "status"))) {
341	char *code = xt_find_attr(c2, "code");
342	if (g_strcmp0(code, "301") == 0) {
343	status = "Banned";
344	break;
345	} else if (g_strcmp0(code, "303") == 0) {
346	/* This could be handled in a cleverer way,
347	* but let's just show a literal part/join for now */
348	status = "Changing nicks";
349	break;
350	} else if (g_strcmp0(code, "307") == 0) {
351	status = "Kicked";
352	break;
353	}
354	c2 = c2->next;
355	}
356
357	/* Sometimes the status message is in presence/x/item/reason */
358	if ((c2 = xt_find_path(c, "item/reason")) && c2->text && c2->text_len) {
359	status_text = c2->text;
360	}
361	}
362
363	/* Sometimes the status message is right inside <presence> */
364	if ((c = xt_find_node(node->children, "status")) && c->text && c->text_len) {
365	status_text = c->text;
366	}
367
368	if (status_text && status) {
369	reason = g_strdup_printf("%s: %s", status, status_text);
370	} else {
371	reason = g_strdup(status_text ? : status);
372	}
373
374	s = strchr(bud->ext_jid, '/');
375	if (s) {
376	*s = 0;
377	}
378	imcb_chat_remove_buddy(chat, bud->ext_jid, reason);
379	if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
380	imcb_remove_buddy(ic, bud->ext_jid, reason);
381	}
382	if (s) {
383	*s = '/';
384	}
385
386	g_free(reason);
387	}
388
389	if (bud == jc->me) {
390	jabber_chat_free(chat);
391	}
392	}
393	}
394
395	void jabber_chat_pkt_message(struct im_connection ic, struct jabber_buddy bud, struct xt_node *node)
396	{
397	struct xt_node *subject = xt_find_node(node->children, "subject");
398	struct xt_node *body = xt_find_node(node->children, "body");
399	struct groupchat *chat = NULL;
400	struct jabber_chat *jc = NULL;
401	char *from = NULL;
402	char *nick = NULL;
403	char *final_from = NULL;
404	char *bare_jid = NULL;
405
406	from = (bud) ? bud->full_jid : xt_find_attr(node, "from");
407
408	if (from) {
409	nick = strchr(from, '/');
410	if (nick) {
411	*nick = 0;
412	}
413	chat = jabber_chat_by_jid(ic, from);
414	if (nick) {
415	*nick = '/';
416	nick++;
417	}
418	}
419
420	jc = (chat) ? chat->data : NULL;
421
422	if (!bud) {
423	struct xt_node *c;
424	char *s;
425
426	/* Try some clever stuff to find out the real JID here */
427	c = xt_find_node_by_attr(node->children, "delay", "xmlns", XMLNS_DELAY);
428
429	if (c && ((s = xt_find_attr(c, "from")) \|\|
430	(s = xt_find_attr(c, "from_jid")))) {
431	/* This won't be useful if it's the MUC JID */
432	if (!(jc && jabber_compare_jid(s, jc->name))) {
433	/* Hopefully this one makes more sense! */
434	bud = jabber_buddy_by_jid(ic, s, GET_BUDDY_FIRST \| GET_BUDDY_CREAT);
435	}
436	}
437
438	}
439
440	if (subject && chat) {
441	char *subject_text = subject->text_len > 0 ? subject->text : NULL;
442	if (g_strcmp0(chat->topic, subject_text) != 0) {
443	bare_jid = (bud) ? jabber_get_bare_jid(bud->ext_jid) : NULL;
444	imcb_chat_topic(chat, bare_jid, subject_text,
445	jabber_get_timestamp(node));
446	g_free(bare_jid);
447	}
448	}
449
450	if (body == NULL \|\| body->text_len == 0) {
451	/* Meh. Empty messages aren't very interesting, no matter
452	how much some servers love to send them. */
453	return;
454	}
455
456	if (chat == NULL) {
457	if (nick == NULL) {
458	imcb_log(ic, "System message from unknown groupchat %s: %s", from, body->text);
459	} else {
460	imcb_log(ic, "Groupchat message from unknown JID %s: %s", from, body->text);
461	}
462
463	return;
464	} else if (chat != NULL && bud == NULL && nick == NULL) {
465	imcb_chat_log(chat, "From conference server: %s", body->text);
466	return;
467	} else if (jc && jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me) {
468	/* exclude self-messages since they would get filtered out
469	* but not the ones in the backlog */
470	return;
471	}
472
473	if (bud && jc && bud != jc->me) {
474	bare_jid = jabber_get_bare_jid(bud->ext_jid ? bud->ext_jid : bud->full_jid);
475	final_from = bare_jid;
476	} else {
477	final_from = nick;
478	}
479
480	imcb_chat_msg(chat, final_from, body->text, 0, jabber_get_timestamp(node));
481
482	g_free(bare_jid);
483	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: