Context Navigation

source: protocols/jabber/conference.c @ b39859e

Last change on this file since b39859e was 83f179d6, checked in by dequis <dx@…>, at 2015-08-08T04:29:54Z
jabber: Show MUC kick/ban/leave reasons
Property mode set to `100644`
File size: 13.1 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
335	if ((c = xt_find_node_by_attr(node->children, "x", "xmlns", XMLNS_MUC_USER))) {
336	struct xt_node *c2;
337	char *status = NULL;
338
339	if ((c2 = xt_find_node(c->children, "status"))) {
340	status = xt_find_attr(c2, "code");
341	if (g_strcmp0(status, "301") == 0) {
342	status = "Banned";
343	} else if (g_strcmp0(status, "303") == 0) {
344	/* This could be handled in a cleverer way,
345	* but let's just show a literal part/join for now */
346	status = "Changing nicks";
347	} else if (g_strcmp0(status, "307") == 0) {
348	status = "Kicked";
349	}
350	}
351
352	if ((c2 = xt_find_path(c, "item/reason")) && c2->text && c2->text_len) {
353	if (status) {
354	reason = g_strdup_printf("%s: %s", status, c2->text);
355	} else {
356	reason = g_strdup(c2->text);
357	}
358	} else {
359	reason = g_strdup(status);
360	}
361	}
362
363	s = strchr(bud->ext_jid, '/');
364	if (s) {
365	*s = 0;
366	}
367	imcb_chat_remove_buddy(chat, bud->ext_jid, reason);
368	if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
369	imcb_remove_buddy(ic, bud->ext_jid, reason);
370	}
371	if (s) {
372	*s = '/';
373	}
374
375	g_free(reason);
376	}
377
378	if (bud == jc->me) {
379	jabber_chat_free(chat);
380	}
381	}
382	}
383
384	void jabber_chat_pkt_message(struct im_connection ic, struct jabber_buddy bud, struct xt_node *node)
385	{
386	struct xt_node *subject = xt_find_node(node->children, "subject");
387	struct xt_node *body = xt_find_node(node->children, "body");
388	struct groupchat *chat = NULL;
389	struct jabber_chat *jc = NULL;
390	char *from = NULL;
391	char *nick = NULL;
392	char *final_from = NULL;
393	char *bare_jid = NULL;
394
395	from = (bud) ? bud->full_jid : xt_find_attr(node, "from");
396
397	if (from) {
398	nick = strchr(from, '/');
399	if (nick) {
400	*nick = 0;
401	}
402	chat = jabber_chat_by_jid(ic, from);
403	if (nick) {
404	*nick = '/';
405	nick++;
406	}
407	}
408
409	jc = (chat) ? chat->data : NULL;
410
411	if (!bud) {
412	struct xt_node *c;
413	char *s;
414
415	/* Try some clever stuff to find out the real JID here */
416	c = xt_find_node_by_attr(node->children, "delay", "xmlns", XMLNS_DELAY);
417
418	if (c && ((s = xt_find_attr(c, "from")) \|\|
419	(s = xt_find_attr(c, "from_jid")))) {
420	/* This won't be useful if it's the MUC JID */
421	if (!(jc && jabber_compare_jid(s, jc->name))) {
422	/* Hopefully this one makes more sense! */
423	bud = jabber_buddy_by_jid(ic, s, GET_BUDDY_FIRST \| GET_BUDDY_CREAT);
424	}
425	}
426
427	}
428
429	if (subject && chat) {
430	char *subject_text = subject->text_len > 0 ? subject->text : NULL;
431	if (g_strcmp0(chat->topic, subject_text) != 0) {
432	bare_jid = (bud) ? jabber_get_bare_jid(bud->ext_jid) : NULL;
433	imcb_chat_topic(chat, bare_jid, subject_text,
434	jabber_get_timestamp(node));
435	g_free(bare_jid);
436	}
437	}
438
439	if (body == NULL \|\| body->text_len == 0) {
440	/* Meh. Empty messages aren't very interesting, no matter
441	how much some servers love to send them. */
442	return;
443	}
444
445	if (chat == NULL) {
446	if (nick == NULL) {
447	imcb_log(ic, "System message from unknown groupchat %s: %s", from, body->text);
448	} else {
449	imcb_log(ic, "Groupchat message from unknown JID %s: %s", from, body->text);
450	}
451
452	return;
453	} else if (chat != NULL && bud == NULL && nick == NULL) {
454	imcb_chat_log(chat, "From conference server: %s", body->text);
455	return;
456	} else if (jc && jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me) {
457	/* exclude self-messages since they would get filtered out
458	* but not the ones in the backlog */
459	return;
460	}
461
462	if (bud && jc && bud != jc->me) {
463	bare_jid = jabber_get_bare_jid(bud->ext_jid ? bud->ext_jid : bud->full_jid);
464	final_from = bare_jid;
465	} else {
466	final_from = nick;
467	}
468
469	imcb_chat_msg(chat, final_from, body->text, 0, jabber_get_timestamp(node));
470
471	g_free(bare_jid);
472	}

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

Download in other formats: