Context Navigation

source: protocols/jabber/conference.c

Last change on this file was a4ac9c4, checked in by GitHub <noreply@…>, at 2023-04-01T20:09:39Z

Deprecate sha1_* functions (#172)

Migrate sha1 calls to direct use of GChecksum

Mark sha1.h functions as deprecated

Property mode set to 100644

File size: 15.0 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
26	static xt_status jabber_chat_join_failed(struct im_connection ic, struct xt_node node, struct xt_node *orig);
27	static xt_status jabber_chat_self_message(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	gboolean always_use_nicks)
31	{
32	struct jabber_chat *jc;
33	struct xt_node *node;
34	struct groupchat *c;
35	char *roomjid;
36
37	roomjid = g_strdup_printf("%s/%s", room, nick);
38	node = xt_new_node("x", NULL, NULL);
39	xt_add_attr(node, "xmlns", XMLNS_MUC);
40	if (password) {
41	xt_add_child(node, xt_new_node("password", password, NULL));
42	}
43	node = jabber_make_packet("presence", NULL, roomjid, node);
44	jabber_cache_add(ic, node, jabber_chat_join_failed);
45
46	if (!jabber_write_packet(ic, node)) {
47	g_free(roomjid);
48	return NULL;
49	}
50
51	jc = g_new0(struct jabber_chat, 1);
52	jc->name = jabber_normalize(room);
53
54	if ((jc->me = jabber_buddy_add(ic, roomjid)) == NULL) {
55	g_free(roomjid);
56	g_free(jc->name);
57	g_free(jc);
58	return NULL;
59	}
60
61	if (always_use_nicks) {
62	jc->flags = JCFLAG_ALWAYS_USE_NICKS;
63	}
64
65	/* roomjid isn't normalized yet, and we need an original version
66	of the nick to send a proper presence update. */
67	jc->my_full_jid = roomjid;
68
69	c = imcb_chat_new(ic, room);
70	c->data = jc;
71
72	return c;
73	}
74
75	struct groupchat jabber_chat_with(struct im_connection ic, char *who)
76	{
77	struct jabber_data *jd = ic->proto_data;
78	struct jabber_chat *jc;
79	struct groupchat *c;
80	GChecksum *sum;
81	double now = gettime();
82	char uuid, rjid, *cserv;
83
84	sum = g_checksum_new(G_CHECKSUM_SHA1);
85	g_checksum_update(sum, (uint8_t *) ic->acc->user, strlen(ic->acc->user));
86	g_checksum_update(sum, (uint8_t *) &now, sizeof(now));
87	g_checksum_update(sum, (uint8_t *) who, strlen(who));
88	uuid = sha1_random_uuid(sum);
89
90	if (jd->flags & JFLAG_GTALK) {
91	cserv = g_strdup("groupchat.google.com");
92	} else {
93	/* Guess... */
94	cserv = g_strdup_printf("conference.%s", jd->server);
95	}
96
97	rjid = g_strdup_printf("private-chat-%s@%s", uuid, cserv);
98	g_free(uuid);
99	g_free(cserv);
100
101	c = jabber_chat_join(ic, rjid, jd->username, NULL, FALSE);
102	g_free(rjid);
103	if (c == NULL) {
104	return NULL;
105	}
106
107	jc = c->data;
108	jc->invite = g_strdup(who);
109
110	return c;
111	}
112
113	static xt_status jabber_chat_join_failed(struct im_connection ic, struct xt_node node, struct xt_node *orig)
114	{
115	struct jabber_error *err;
116	struct jabber_buddy *bud;
117	char *room;
118
119	room = xt_find_attr(orig, "to");
120	bud = jabber_buddy_by_jid(ic, room, 0);
121	err = jabber_error_parse(xt_find_node(node->children, "error"), XMLNS_STANZA_ERROR);
122	if (err) {
123	imcb_error(ic, "Error joining groupchat %s: %s%s%s", room, err->code,
124	err->text ? ": " : "", err->text ? err->text : "");
125	jabber_error_free(err);
126	}
127	if (bud) {
128	struct groupchat *c = jabber_chat_by_jid(ic, bud->bare_jid);
129	if (c) {
130	jabber_chat_free(c);
131	}
132	}
133
134	return XT_HANDLED;
135	}
136
137	static xt_status jabber_chat_self_message(struct im_connection ic, struct xt_node node, struct xt_node *orig)
138	{
139	/* This is a self message sent by this bitlbee - just drop it */
140	return XT_ABORT;
141	}
142
143	struct groupchat jabber_chat_by_jid(struct im_connection ic, const char *name)
144	{
145	char *normalized = jabber_normalize(name);
146	GSList *l;
147	struct groupchat *ret;
148	struct jabber_chat *jc;
149
150	for (l = ic->groupchats; l; l = l->next) {
151	ret = l->data;
152	jc = ret->data;
153	if (strcmp(normalized, jc->name) == 0) {
154	break;
155	}
156	}
157	g_free(normalized);
158
159	return l ? ret : NULL;
160	}
161
162	void jabber_chat_free(struct groupchat *c)
163	{
164	struct jabber_chat *jc = c->data;
165
166	jabber_buddy_remove_bare(c->ic, jc->name);
167
168	g_free(jc->last_sent_message);
169	g_free(jc->my_full_jid);
170	g_free(jc->name);
171	g_free(jc->invite);
172	g_free(jc);
173
174	imcb_chat_free(c);
175	}
176
177	int jabber_chat_msg(struct groupchat c, char message, int flags)
178	{
179	struct im_connection *ic = c->ic;
180	struct jabber_chat *jc = c->data;
181	struct xt_node *node;
182
183	jc->flags \|= JCFLAG_MESSAGE_SENT;
184
185	node = xt_new_node("body", message, NULL);
186	node = jabber_make_packet("message", "groupchat", jc->name, node);
187
188	jabber_cache_add(ic, node, jabber_chat_self_message);
189
190	g_free(jc->last_sent_message);
191	jc->last_sent_message = g_strdup(message);
192
193	return !jabber_write_packet(ic, node);
194	}
195
196	int jabber_chat_topic(struct groupchat c, char topic)
197	{
198	struct im_connection *ic = c->ic;
199	struct jabber_chat *jc = c->data;
200	struct xt_node *node;
201
202	node = xt_new_node("subject", topic, NULL);
203	node = jabber_make_packet("message", "groupchat", jc->name, node);
204
205	if (!jabber_write_packet(ic, node)) {
206	xt_free_node(node);
207	return 0;
208	}
209	xt_free_node(node);
210
211	return 1;
212	}
213
214	int jabber_chat_leave(struct groupchat c, const char reason)
215	{
216	struct im_connection *ic = c->ic;
217	struct jabber_chat *jc = c->data;
218	struct xt_node *node;
219
220	node = xt_new_node("x", NULL, NULL);
221	xt_add_attr(node, "xmlns", XMLNS_MUC);
222	node = jabber_make_packet("presence", "unavailable", jc->my_full_jid, node);
223
224	if (!jabber_write_packet(ic, node)) {
225	xt_free_node(node);
226	return 0;
227	}
228	xt_free_node(node);
229
230	return 1;
231	}
232
233	void jabber_chat_invite(struct groupchat c, char who, char *message)
234	{
235	struct xt_node *node;
236	struct im_connection *ic = c->ic;
237	struct jabber_chat *jc = c->data;
238
239	node = xt_new_node("reason", message, NULL);
240
241	node = xt_new_node("invite", NULL, node);
242	xt_add_attr(node, "to", who);
243
244	node = xt_new_node("x", NULL, node);
245	xt_add_attr(node, "xmlns", XMLNS_MUC_USER);
246
247	node = jabber_make_packet("message", NULL, jc->name, node);
248
249	jabber_write_packet(ic, node);
250
251	xt_free_node(node);
252	}
253
254	static int jabber_chat_has_other_resources(struct im_connection ic, struct jabber_buddy bud)
255	{
256	struct jabber_buddy *cur;
257
258	for (cur = jabber_buddy_by_jid(ic, bud->bare_jid, GET_BUDDY_FIRST); cur; cur = cur->next) {
259	if (cur != bud && jabber_compare_jid(cur->ext_jid, bud->ext_jid)) {
260	return TRUE;
261	}
262	}
263
264	return FALSE;
265	}
266
267	/* Not really the same syntax as the normal pkt_ functions, but this isn't
268	called by the xmltree parser directly and this way I can add some extra
269	parameters so we won't have to repeat too many things done by the caller
270	already. */
271	void jabber_chat_pkt_presence(struct im_connection ic, struct jabber_buddy bud, struct xt_node *node)
272	{
273	struct groupchat *chat;
274	struct xt_node *c;
275	char *type = xt_find_attr(node, "type");
276	struct jabber_data *jd = ic->proto_data;
277	struct jabber_chat *jc;
278	char *s;
279
280	if ((chat = jabber_chat_by_jid(ic, bud->bare_jid)) == NULL) {
281	/* How could this happen?? We could do kill( self, 11 )
282	now or just wait for the OS to do it. :-) */
283	return;
284	}
285
286	jc = chat->data;
287
288	if (type == NULL && !(bud->flags & JBFLAG_IS_CHATROOM)) {
289	bud->flags \|= JBFLAG_IS_CHATROOM;
290	/* If this one wasn't set yet, this buddy just joined the chat.
291	Slightly hackish way of finding out eh? ;-) */
292
293	/* This is pretty messy... Here it sets ext_jid to the real
294	JID of the participant. Works for non-anonymized channels.
295	Might break if someone joins a chat twice, though. */
296	for (c = node->children; (c = xt_find_node(c, "x")); c = c->next) {
297	if ((s = xt_find_attr(c, "xmlns")) &&
298	(strcmp(s, XMLNS_MUC_USER) == 0)) {
299	struct xt_node *item;
300
301	item = xt_find_node(c->children, "item");
302	if ((s = xt_find_attr(item, "jid"))) {
303	/* Yay, found what we need. :-) */
304	bud->ext_jid = jabber_normalize(s);
305	break;
306	}
307	}
308	}
309
310	/* Make up some other handle, if necessary. */
311	if (bud->ext_jid == NULL) {
312	if (bud == jc->me) {
313	bud->ext_jid = g_strdup(jd->me);
314	} else {
315	int i;
316
317	/* Don't want the nick to be at the end, so let's
318	think of some slightly different notation to use
319	for anonymous groupchat participants in BitlBee. */
320	bud->ext_jid = g_strdup_printf("%s=%s", bud->resource, bud->bare_jid);
321
322	/* And strip any unwanted characters. */
323	for (i = 0; bud->resource[i]; i++) {
324	if (bud->ext_jid[i] == '=' \|\| bud->ext_jid[i] == '@') {
325	bud->ext_jid[i] = '_';
326	}
327	}
328	}
329	bud->flags \|= JBFLAG_IS_ANONYMOUS;
330	} else if (bud == jc->me) {
331	g_free(bud->ext_jid);
332	bud->ext_jid = g_strdup(jd->me);
333	}
334
335	if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
336	/* If JIDs are anonymized, add them to the local
337	list for the duration of this chat. */
338	imcb_add_buddy(ic, bud->ext_jid, NULL);
339	imcb_buddy_nick_hint(ic, bud->ext_jid, bud->resource);
340	}
341
342	if (bud == jc->me && jc->invite != NULL) {
343	char *msg = g_strdup_printf("Please join me in room %s", jc->name);
344	jabber_chat_invite(chat, jc->invite, msg);
345	g_free(jc->invite);
346	g_free(msg);
347	jc->invite = NULL;
348	}
349
350	s = strchr(bud->ext_jid, '/');
351	if (s) {
352	s = 0; / Should NEVER be NULL, but who knows... */
353	}
354
355	imcb_chat_add_buddy(chat, bud->ext_jid);
356
357	if (bud != jc->me && (jc->flags & JCFLAG_ALWAYS_USE_NICKS) && !(bud->flags & JBFLAG_IS_ANONYMOUS)) {
358	imcb_buddy_nick_change(ic, bud->ext_jid, bud->resource);
359	}
360
361	if (s) {
362	*s = '/';
363	}
364	} else if (type) { /* type can only be NULL or "unavailable" in this function */
365	if ((bud->flags & JBFLAG_IS_CHATROOM) && bud->ext_jid && !jabber_chat_has_other_resources(ic, bud)) {
366	char *reason = NULL;
367	char *status = NULL;
368	char *status_text = NULL;
369
370	if ((c = xt_find_node_by_attr(node->children, "x", "xmlns", XMLNS_MUC_USER))) {
371	struct xt_node *c2 = c->children;
372
373	while ((c2 = xt_find_node(c2, "status"))) {
374	char *code = xt_find_attr(c2, "code");
375	if (g_strcmp0(code, "301") == 0) {
376	status = "Banned";
377	break;
378	} else if (g_strcmp0(code, "303") == 0) {
379	/* This could be handled in a cleverer way,
380	* but let's just show a literal part/join for now */
381	status = "Changing nicks";
382	break;
383	} else if (g_strcmp0(code, "307") == 0) {
384	status = "Kicked";
385	break;
386	}
387	c2 = c2->next;
388	}
389
390	/* Sometimes the status message is in presence/x/item/reason */
391	if ((c2 = xt_find_path(c, "item/reason")) && c2->text && c2->text_len) {
392	status_text = c2->text;
393	}
394	}
395
396	/* Sometimes the status message is right inside <presence> */
397	if ((c = xt_find_node(node->children, "status")) && c->text && c->text_len) {
398	status_text = c->text;
399	}
400
401	if (status_text && status) {
402	reason = g_strdup_printf("%s: %s", status, status_text);
403	} else {
404	reason = g_strdup(status_text ? : status);
405	}
406
407	s = strchr(bud->ext_jid, '/');
408	if (s) {
409	*s = 0;
410	}
411	imcb_chat_remove_buddy(chat, bud->ext_jid, reason);
412	if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) {
413	imcb_remove_buddy(ic, bud->ext_jid, reason);
414	}
415	if (s) {
416	*s = '/';
417	}
418
419	g_free(reason);
420	}
421
422	if (bud == jc->me) {
423	jabber_chat_free(chat);
424	}
425	}
426	}
427
428	void jabber_chat_pkt_message(struct im_connection ic, struct jabber_buddy bud, struct xt_node *node)
429	{
430	struct xt_node *subject = xt_find_node(node->children, "subject");
431	struct xt_node *body = xt_find_node(node->children, "body");
432	struct groupchat *chat = NULL;
433	struct jabber_chat *jc = NULL;
434	char *from = NULL;
435	char *nick = NULL;
436	char *final_from = NULL;
437	char *bare_jid = NULL;
438	guint32 flags = 0;
439
440	from = (bud) ? bud->full_jid : xt_find_attr(node, "from");
441
442	if (from) {
443	nick = strchr(from, '/');
444	if (nick) {
445	*nick = 0;
446	}
447	chat = jabber_chat_by_jid(ic, from);
448	if (nick) {
449	*nick = '/';
450	nick++;
451	}
452	}
453
454	jc = (chat) ? chat->data : NULL;
455
456	if (!bud) {
457	struct xt_node *c;
458	char *s;
459
460	/* Try some clever stuff to find out the real JID here */
461	c = xt_find_node_by_attr(node->children, "delay", "xmlns", XMLNS_DELAY);
462
463	if (c && ((s = xt_find_attr(c, "from")) \|\|
464	(s = xt_find_attr(c, "from_jid")))) {
465	/* This won't be useful if it's the MUC JID */
466	if (!(jc && jabber_compare_jid(s, jc->name))) {
467	/* Hopefully this one makes more sense! */
468	bud = jabber_buddy_by_jid(ic, s, GET_BUDDY_FIRST \| GET_BUDDY_CREAT);
469	}
470	}
471
472	}
473
474	if (subject && chat) {
475	char empty[1] = "";
476	char *subject_text = subject->text_len > 0 ? subject->text : empty;
477	if (g_strcmp0(chat->topic, subject_text) != 0) {
478	bare_jid = (bud) ? jabber_get_bare_jid(bud->ext_jid) : NULL;
479	imcb_chat_topic(chat, bare_jid, subject_text,
480	jabber_get_timestamp(node));
481	g_free(bare_jid);
482	bare_jid = NULL;
483	}
484	}
485
486	if (body == NULL \|\| body->text_len == 0) {
487	/* Meh. Empty messages aren't very interesting, no matter
488	how much some servers love to send them. */
489	return;
490	}
491
492	if (chat == NULL) {
493	if (nick == NULL) {
494	imcb_log(ic, "System message from unknown groupchat %s: %s", from, body->text);
495	} else {
496	imcb_log(ic, "Groupchat message from unknown JID %s: %s", from, body->text);
497	}
498
499	return;
500	} else if (chat != NULL && bud == NULL && nick == NULL) {
501	imcb_chat_log(chat, "From conference server: %s", body->text);
502	return;
503	} else if (jc && jc->flags & JCFLAG_MESSAGE_SENT && bud == jc->me) {
504	if (jabber_cache_handle_packet(ic, node) == XT_ABORT) {
505	/* Self message marked by this bitlbee, don't show it */
506	return;
507	} else if (xt_find_attr(node, "id") == NULL &&
508	g_strcmp0(body->text, jc->last_sent_message) == 0) {
509	/* Some misbehaving servers (like slack) eat the ids and echo anyway.
510	* Try to detect those cases by comparing against the last sent message. */
511	return;
512	}
513	}
514
515	if (bud) {
516	bare_jid = jabber_get_bare_jid(bud->ext_jid ? bud->ext_jid : bud->full_jid);
517	final_from = bare_jid;
518	if (bud == jc->me \|\| (g_strcasecmp(final_from, ic->acc->user) == 0)) {
519	flags = OPT_SELFMESSAGE;
520	}
521	} else {
522	final_from = nick;
523	}
524
525	imcb_chat_msg(chat, final_from, body->text, flags, jabber_get_timestamp(node));
526
527	g_free(bare_jid);
528	}

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

Download in other formats: