Context Navigation

source: irc_im.c @ 49108f3

Last change on this file since 49108f3 was 7801298, checked in by dequis <dx@…>, at 2016-12-27T17:24:50Z

Per-account handle_unknown

Credit for the idea goes to russian XMPP spammers. Thanks!

Property mode set to 100644

File size: 27.9 KB

Line
1	/********************************************************************\
2	* BitlBee -- An IRC to other IM-networks gateway *
3	* *
4	* Copyright 2002-2012 Wilmer van der Gaast and others *
5	\********************************************************************/
6
7	/* Some glue to put the IRC and the IM stuff together. */
8
9	/*
10	This program is free software; you can redistribute it and/or modify
11	it under the terms of the GNU General Public License as published by
12	the Free Software Foundation; either version 2 of the License, or
13	(at your option) any later version.
14
15	This program is distributed in the hope that it will be useful,
16	but WITHOUT ANY WARRANTY; without even the implied warranty of
17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	GNU General Public License for more details.
19
20	You should have received a copy of the GNU General Public License with
21	the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22	if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
23	Fifth Floor, Boston, MA 02110-1301 USA
24	*/
25
26	#include "bitlbee.h"
27	#include "dcc.h"
28
29	/* IM->IRC callbacks: Simple IM/buddy-related stuff. */
30
31	static const struct irc_user_funcs irc_user_im_funcs;
32
33	static void bee_irc_imc_connected(struct im_connection *ic)
34	{
35	irc_t irc = (irc_t ) ic->bee->ui_data;
36
37	irc_channel_auto_joins(irc, ic->acc);
38	}
39
40	static void bee_irc_imc_disconnected(struct im_connection *ic)
41	{
42	/* Maybe try to send /QUITs here instead of later on. */
43	}
44
45	static gboolean bee_irc_user_new(bee_t bee, bee_user_t bu)
46	{
47	irc_user_t *iu;
48	irc_t irc = (irc_t ) bee->ui_data;
49	char nick[MAX_NICK_LENGTH + 1], *s;
50
51	memset(nick, 0, MAX_NICK_LENGTH + 1);
52	strncpy(nick, nick_get(bu), MAX_NICK_LENGTH);
53
54	bu->ui_data = iu = irc_user_new(irc, nick);
55	iu->bu = bu;
56
57	if (set_getbool(&irc->b->set, "private")) {
58	iu->last_channel = NULL;
59	} else {
60	iu->last_channel = irc_channel_with_user(irc, iu);
61	}
62
63	if ((s = strchr(bu->handle, '@'))) {
64	iu->host = g_strdup(s + 1);
65	iu->user = g_strndup(bu->handle, s - bu->handle);
66	} else {
67	iu->user = g_strdup(bu->handle);
68	if (bu->ic->acc->server) {
69	iu->host = g_strdup(bu->ic->acc->server);
70	} else {
71	char *s;
72	for (s = bu->ic->acc->tag; g_ascii_isalnum(*s); s++) {
73	;
74	}
75	/* Only use the tag if we got to the end of the string.
76	(So allow alphanumerics only. Hopefully not too
77	restrictive.) */
78	if (*s) {
79	iu->host = g_strdup(bu->ic->acc->prpl->name);
80	} else {
81	iu->host = g_strdup(bu->ic->acc->tag);
82	}
83	}
84	}
85
86	/* Sanitize */
87	str_reject_chars(iu->user, " ", '_');
88	str_reject_chars(iu->host, " ", '_');
89
90	if (bu->flags & BEE_USER_LOCAL) {
91	char *s = set_getstr(&bu->ic->acc->set, "handle_unknown") ? :
92	set_getstr(&bee->set, "handle_unknown");
93
94	if (g_strcasecmp(s, "add_private") == 0) {
95	iu->last_channel = NULL;
96	} else if (g_strcasecmp(s, "add_channel") == 0) {
97	iu->last_channel = irc->default_channel;
98	}
99	}
100
101	iu->f = &irc_user_im_funcs;
102
103	return TRUE;
104	}
105
106	static gboolean bee_irc_user_free(bee_t bee, bee_user_t bu)
107	{
108	return irc_user_free(bee->ui_data, (irc_user_t *) bu->ui_data);
109	}
110
111	static gboolean bee_irc_user_status(bee_t bee, bee_user_t bu, bee_user_t *old)
112	{
113	irc_t *irc = bee->ui_data;
114	irc_user_t *iu = bu->ui_data;
115
116	/* Do this outside the if below since away state can change without
117	the online state changing. */
118	iu->flags &= ~IRC_USER_AWAY;
119	if (bu->flags & BEE_USER_AWAY \|\| !(bu->flags & BEE_USER_ONLINE)) {
120	iu->flags \|= IRC_USER_AWAY;
121	}
122
123	if ((bu->flags & BEE_USER_ONLINE) != (old->flags & BEE_USER_ONLINE)) {
124	if (bu->flags & BEE_USER_ONLINE) {
125	if (g_hash_table_lookup(irc->watches, iu->key)) {
126	irc_send_num(irc, 600, "%s %s %s %d :%s", iu->nick, iu->user,
127	iu->host, (int) time(NULL), "logged online");
128	}
129	} else {
130	if (g_hash_table_lookup(irc->watches, iu->key)) {
131	irc_send_num(irc, 601, "%s %s %s %d :%s", iu->nick, iu->user,
132	iu->host, (int) time(NULL), "logged offline");
133	}
134
135	/* Send a QUIT since those will also show up in any
136	query windows the user may have, plus it's only
137	one QUIT instead of possibly many (in case of
138	multiple control chans). If there's a channel that
139	shows offline people, a JOIN will follow. */
140	if (set_getbool(&bee->set, "offline_user_quits")) {
141	irc_user_quit(iu, "Leaving...");
142	}
143	}
144	}
145
146	/* Reset this one since the info may have changed. */
147	iu->away_reply_timeout = 0;
148
149	bee_irc_channel_update(irc, NULL, iu);
150
151	/* If away-notify enabled, send status updates when:
152	* Away or Online state changes
153	* Status changes (e.g. "Away" to "Mobile")
154	* Status message changes
155	*/
156	if ((irc->caps & CAP_AWAY_NOTIFY) &&
157	((bu->flags & BEE_USER_AWAY) != (old->flags & BEE_USER_AWAY) \|\|
158	(bu->flags & BEE_USER_ONLINE) != (old->flags & BEE_USER_ONLINE) \|\|
159	(g_strcmp0(bu->status, old->status) != 0) \|\|
160	(g_strcmp0(bu->status_msg, old->status_msg) != 0))) {
161	irc_send_away_notify(iu);
162	}
163
164	return TRUE;
165	}
166
167	void bee_irc_channel_update(irc_t irc, irc_channel_t ic, irc_user_t *iu)
168	{
169	GSList *l;
170
171	if (ic == NULL) {
172	for (l = irc->channels; l; l = l->next) {
173	ic = l->data;
174	/* TODO: Just add a type flag or so.. */
175	if (ic->f == irc->default_channel->f &&
176	(ic->flags & IRC_CHANNEL_JOINED)) {
177	bee_irc_channel_update(irc, ic, iu);
178	}
179	}
180	return;
181	}
182	if (iu == NULL) {
183	for (l = irc->users; l; l = l->next) {
184	iu = l->data;
185	if (iu->bu) {
186	bee_irc_channel_update(irc, ic, l->data);
187	}
188	}
189	return;
190	}
191
192	if (!irc_channel_wants_user(ic, iu)) {
193	irc_channel_del_user(ic, iu, IRC_CDU_PART, NULL);
194	} else {
195	struct irc_control_channel *icc = ic->data;
196	int mode = 0;
197
198	if (!(iu->bu->flags & BEE_USER_ONLINE)) {
199	mode = icc->modes[0];
200	} else if (iu->bu->flags & BEE_USER_AWAY) {
201	mode = icc->modes[1];
202	} else if (iu->bu->flags & BEE_USER_SPECIAL) {
203	mode = icc->modes[2];
204	} else {
205	mode = icc->modes[3];
206	}
207
208	if (!mode) {
209	irc_channel_del_user(ic, iu, IRC_CDU_PART, NULL);
210	} else {
211	irc_channel_add_user(ic, iu);
212	irc_channel_user_set_mode(ic, iu, mode);
213	}
214	}
215	}
216
217	static gboolean bee_irc_user_msg(bee_t bee, bee_user_t bu, const char *msg_, guint32 flags, time_t sent_at)
218	{
219	irc_t *irc = bee->ui_data;
220	irc_user_t iu = (irc_user_t ) bu->ui_data;
221	irc_user_t *src_iu = iu;
222	irc_user_t *dst_iu = irc->user;
223	const char *dst;
224	char *prefix = NULL;
225	char wrapped, ts = NULL;
226	char *msg = g_strdup(msg_);
227	char *message_type = "PRIVMSG";
228	GSList *l;
229
230	if (sent_at > 0 && set_getbool(&irc->b->set, "display_timestamps")) {
231	ts = irc_format_timestamp(irc, sent_at);
232	}
233
234	dst = irc_user_msgdest(iu);
235
236	if (flags & OPT_SELFMESSAGE) {
237	char *setting = set_getstr(&irc->b->set, "self_messages");
238
239	if (is_bool(setting)) {
240	if (bool2int(setting)) {
241	/* set to true, send it with src/dst flipped */
242
243	dst_iu = iu;
244	src_iu = irc->user;
245
246	if (dst == irc->user->nick) {
247	dst = dst_iu->nick;
248	}
249	} else {
250	/* set to false, skip the message completely */
251	goto cleanup;
252	}
253	} else if (g_strncasecmp(setting, "prefix", 6) == 0) {
254	/* third state, prefix, loosely imitates the znc privmsg_prefix module */
255
256	g_free(msg);
257	if (g_strncasecmp(msg_, "/me ", 4) == 0) {
258	msg = g_strdup_printf("/me -> %s", msg_ + 4);
259	} else {
260	msg = g_strdup_printf("-> %s", msg_);
261	}
262
263	if (g_strcasecmp(setting, "prefix_notice") == 0) {
264	message_type = "NOTICE";
265	}
266	}
267
268	}
269
270	if (dst != dst_iu->nick) {
271	/* if not messaging directly (control channel), call user by name */
272	prefix = g_strdup_printf("%s%s%s", dst_iu->nick, set_getstr(&bee->set, "to_char"), ts ? : "");
273	} else {
274	prefix = ts;
275	ts = NULL; /* don't double-free */
276	}
277
278	for (l = irc_plugins; l; l = l->next) {
279	irc_plugin_t *p = l->data;
280	if (p->filter_msg_in) {
281	char *s = p->filter_msg_in(iu, msg, 0);
282	if (s) {
283	if (s != msg) {
284	g_free(msg);
285	}
286	msg = s;
287	} else {
288	/* Modules can swallow messages. */
289	goto cleanup;
290	}
291	}
292	}
293
294	if ((g_strcasecmp(set_getstr(&bee->set, "strip_html"), "always") == 0) \|\|
295	((bu->ic->flags & OPT_DOES_HTML) && set_getbool(&bee->set, "strip_html"))) {
296	char *s = g_strdup(msg);
297	strip_html(s);
298	g_free(msg);
299	msg = s;
300	}
301
302	wrapped = word_wrap(msg, IRC_WORD_WRAP);
303	irc_send_msg(src_iu, message_type, dst, wrapped, prefix);
304	g_free(wrapped);
305
306	cleanup:
307	g_free(prefix);
308	g_free(msg);
309	g_free(ts);
310
311	return TRUE;
312	}
313
314	static gboolean bee_irc_user_typing(bee_t bee, bee_user_t bu, guint32 flags)
315	{
316	irc_t irc = (irc_t ) bee->ui_data;
317
318	if (set_getbool(&bee->set, "typing_notice")) {
319	irc_send_msg_f((irc_user_t *) bu->ui_data, "PRIVMSG", irc->user->nick,
320	"\001TYPING %d\001", (flags >> 8) & 3);
321	} else {
322	return FALSE;
323	}
324
325	return TRUE;
326	}
327
328	static gboolean bee_irc_user_action_response(bee_t bee, bee_user_t bu, const char action, char const args[],
329	void *data)
330	{
331	irc_t irc = (irc_t ) bee->ui_data;
332	GString *msg = g_string_new("\001");
333
334	g_string_append(msg, action);
335	while (*args) {
336	if (strchr(*args, ' ')) {
337	g_string_append_printf(msg, " \"%s\"", *args);
338	} else {
339	g_string_append_printf(msg, " %s", *args);
340	}
341	args++;
342	}
343	g_string_append_c(msg, '\001');
344
345	irc_send_msg((irc_user_t *) bu->ui_data, "NOTICE", irc->user->nick, msg->str, NULL);
346
347	g_string_free(msg, TRUE);
348
349	return TRUE;
350	}
351
352	static gboolean bee_irc_user_nick_update(irc_user_t *iu, gboolean offline_only);
353
354	static gboolean bee_irc_user_fullname(bee_t bee, bee_user_t bu)
355	{
356	irc_user_t iu = (irc_user_t ) bu->ui_data;
357	char *s;
358
359	if (iu->fullname != iu->nick) {
360	g_free(iu->fullname);
361	}
362	iu->fullname = g_strdup(bu->fullname);
363
364	/* Strip newlines (unlikely, but IRC-unfriendly so they must go)
365	TODO(wilmer): Do the same with away msgs again! */
366	for (s = iu->fullname; *s; s++) {
367	if (g_ascii_isspace(*s)) {
368	*s = ' ';
369	}
370	}
371
372	if ((bu->ic->flags & OPT_LOGGED_IN) && set_getbool(&bee->set, "display_namechanges")) {
373	/* People don't like this /NOTICE. Meh, let's go back to the old one.
374	char *msg = g_strdup_printf( "<< \002BitlBee\002 - Changed name to `%s' >>", iu->fullname );
375	irc_send_msg( iu, "NOTICE", irc->user->nick, msg, NULL );
376	*/
377	imcb_log(bu->ic, "User `%s' changed name to `%s'", iu->nick, iu->fullname);
378	}
379
380	bee_irc_user_nick_update(iu, TRUE);
381
382	return TRUE;
383	}
384
385	static gboolean bee_irc_user_nick_hint(bee_t bee, bee_user_t bu, const char *hint)
386	{
387	bee_irc_user_nick_update((irc_user_t *) bu->ui_data, TRUE);
388
389	return TRUE;
390	}
391
392	static gboolean bee_irc_user_nick_change(bee_t bee, bee_user_t bu, const char *nick)
393	{
394	bee_irc_user_nick_update((irc_user_t *) bu->ui_data, FALSE);
395
396	return TRUE;
397	}
398
399	static gboolean bee_irc_user_group(bee_t bee, bee_user_t bu)
400	{
401	irc_user_t iu = (irc_user_t ) bu->ui_data;
402	irc_t irc = (irc_t ) bee->ui_data;
403
404	bee_irc_channel_update(irc, NULL, iu);
405	bee_irc_user_nick_update(iu, FALSE);
406
407	return TRUE;
408	}
409
410	static gboolean bee_irc_user_nick_update(irc_user_t *iu, gboolean offline_only)
411	{
412	bee_user_t *bu = iu->bu;
413	char *newnick;
414
415	if (offline_only && bu->flags & BEE_USER_ONLINE) {
416	/* Ignore if the user is visible already. */
417	return TRUE;
418	}
419
420	if (nick_saved(bu)) {
421	/* The user already assigned a nickname to this person. */
422	return TRUE;
423	}
424
425	newnick = nick_get(bu);
426
427	if (strcmp(iu->nick, newnick) != 0) {
428	nick_dedupe(bu, newnick);
429	irc_user_set_nick(iu, newnick);
430	}
431
432	return TRUE;
433	}
434
435	void bee_irc_user_nick_reset(irc_user_t *iu)
436	{
437	bee_user_t *bu = iu->bu;
438
439	if (bu == FALSE) {
440	return;
441	}
442
443	nick_del(bu);
444	bee_irc_user_nick_update(iu, FALSE);
445
446	}
447
448	/* IRC->IM calls */
449
450	static gboolean bee_irc_user_privmsg_cb(gpointer data, gint fd, b_input_condition cond);
451
452	static gboolean bee_irc_user_privmsg(irc_user_t iu, const char msg)
453	{
454	const char *away;
455
456	if (iu->bu == NULL) {
457	return FALSE;
458	}
459
460	if (iu->last_channel == NULL &&
461	(away = irc_user_get_away(iu)) &&
462	time(NULL) >= iu->away_reply_timeout) {
463	irc_send_num(iu->irc, 301, "%s :%s", iu->nick, away);
464	iu->away_reply_timeout = time(NULL) +
465	set_getint(&iu->irc->b->set, "away_reply_timeout");
466	}
467
468	if (iu->pastebuf == NULL) {
469	iu->pastebuf = g_string_new(msg);
470	} else {
471	b_event_remove(iu->pastebuf_timer);
472	g_string_append_printf(iu->pastebuf, "\n%s", msg);
473	}
474
475	if (set_getbool(&iu->irc->b->set, "paste_buffer")) {
476	int delay;
477
478	if ((delay = set_getint(&iu->irc->b->set, "paste_buffer_delay")) <= 5) {
479	delay *= 1000;
480	}
481
482	iu->pastebuf_timer = b_timeout_add(delay, bee_irc_user_privmsg_cb, iu);
483
484	return TRUE;
485	} else {
486	bee_irc_user_privmsg_cb(iu, 0, 0);
487
488	return TRUE;
489	}
490	}
491
492	static gboolean bee_irc_user_privmsg_cb(gpointer data, gint fd, b_input_condition cond)
493	{
494	irc_user_t *iu = data;
495	char *msg;
496	GSList *l;
497
498	msg = g_string_free(iu->pastebuf, FALSE);
499	iu->pastebuf = NULL;
500	iu->pastebuf_timer = 0;
501
502	for (l = irc_plugins; l; l = l->next) {
503	irc_plugin_t *p = l->data;
504	if (p->filter_msg_out) {
505	char *s = p->filter_msg_out(iu, msg, 0);
506	if (s) {
507	if (s != msg) {
508	g_free(msg);
509	}
510	msg = s;
511	} else {
512	/* Modules can swallow messages. */
513	iu->pastebuf = NULL;
514	g_free(msg);
515	return FALSE;
516	}
517	}
518	}
519
520	bee_user_msg(iu->irc->b, iu->bu, msg, 0);
521
522	g_free(msg);
523
524	return FALSE;
525	}
526
527	static gboolean bee_irc_user_ctcp(irc_user_t iu, char const *ctcp)
528	{
529	if (ctcp[1] && g_strcasecmp(ctcp[0], "DCC") == 0
530	&& g_strcasecmp(ctcp[1], "SEND") == 0) {
531	if (iu->bu && iu->bu->ic && iu->bu->ic->acc->prpl->transfer_request) {
532	file_transfer_t *ft = dcc_request(iu->bu->ic, ctcp);
533	if (ft) {
534	iu->bu->ic->acc->prpl->transfer_request(iu->bu->ic, ft, iu->bu->handle);
535	}
536
537	return TRUE;
538	}
539	} else if (g_strcasecmp(ctcp[0], "TYPING") == 0) {
540	if (iu->bu && iu->bu->ic && iu->bu->ic->acc->prpl->send_typing && ctcp[1]) {
541	int st = ctcp[1][0];
542	if (st >= '0' && st <= '2') {
543	st <<= 8;
544	iu->bu->ic->acc->prpl->send_typing(iu->bu->ic, iu->bu->handle, st);
545	}
546
547	return TRUE;
548	}
549	} else if (g_strcasecmp(ctcp[0], "HELP") == 0 && iu->bu) {
550	GString *supp = g_string_new("Supported CTCPs:");
551	GList *l;
552
553	if (iu->bu->ic && iu->bu->ic->acc->prpl->transfer_request) {
554	g_string_append(supp, " DCC SEND,");
555	}
556	if (iu->bu->ic && iu->bu->ic->acc->prpl->send_typing) {
557	g_string_append(supp, " TYPING,");
558	}
559	if (iu->bu->ic->acc->prpl->buddy_action_list) {
560	for (l = iu->bu->ic->acc->prpl->buddy_action_list(iu->bu); l; l = l->next) {
561	struct buddy_action *ba = l->data;
562	g_string_append_printf(supp, " %s (%s),",
563	ba->name, ba->description);
564	}
565	}
566	g_string_truncate(supp, supp->len - 1);
567	irc_send_msg_f(iu, "NOTICE", iu->irc->user->nick, "\001HELP %s\001", supp->str);
568	g_string_free(supp, TRUE);
569	} else if (iu->bu && iu->bu->ic && iu->bu->ic->acc->prpl->buddy_action) {
570	iu->bu->ic->acc->prpl->buddy_action(iu->bu, ctcp[0], ctcp + 1, NULL);
571	}
572
573	return FALSE;
574	}
575
576	static const struct irc_user_funcs irc_user_im_funcs = {
577	bee_irc_user_privmsg,
578	bee_irc_user_ctcp,
579	};
580
581
582	/* IM->IRC: Groupchats */
583	const struct irc_channel_funcs irc_channel_im_chat_funcs;
584
585	static gboolean bee_irc_chat_new(bee_t bee, struct groupchat c)
586	{
587	irc_t *irc = bee->ui_data;
588	irc_channel_t *ic;
589	char *topic;
590	GSList *l;
591	int i;
592
593	/* Try to find a channel that expects to receive a groupchat.
594	This flag is set earlier in our current call trace. */
595	for (l = irc->channels; l; l = l->next) {
596	ic = l->data;
597	if (ic->flags & IRC_CHANNEL_CHAT_PICKME) {
598	break;
599	}
600	}
601
602	/* If we found none, just generate some stupid name. */
603	if (l == NULL) {
604	for (i = 0; i <= 999; i++) {
605	char name[16];
606	sprintf(name, "#chat_%03d", i);
607	if ((ic = irc_channel_new(irc, name))) {
608	break;
609	}
610	}
611	}
612
613	if (ic == NULL) {
614	return FALSE;
615	}
616
617	c->ui_data = ic;
618	ic->data = c;
619
620	topic = g_strdup_printf(
621	"BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!",
622	c->title);
623	irc_channel_set_topic(ic, topic, irc->root);
624	g_free(topic);
625
626	return TRUE;
627	}
628
629	static gboolean bee_irc_chat_free(bee_t bee, struct groupchat c)
630	{
631	irc_channel_t *ic = c->ui_data;
632
633	if (ic == NULL) {
634	return FALSE;
635	}
636
637	ic->data = NULL;
638	c->ui_data = NULL;
639	irc_channel_del_user(ic, ic->irc->user, IRC_CDU_KICK, "Chatroom closed by server");
640
641	return TRUE;
642	}
643
644	static gboolean bee_irc_chat_log(bee_t bee, struct groupchat c, const char *text)
645	{
646	irc_channel_t *ic = c->ui_data;
647
648	if (ic == NULL) {
649	return FALSE;
650	}
651
652	irc_channel_printf(ic, "%s", text);
653
654	return TRUE;
655	}
656
657	static gboolean bee_irc_chat_msg(bee_t bee, struct groupchat c, bee_user_t bu, const char msg, guint32 flags, time_t sent_at)
658	{
659	irc_t *irc = bee->ui_data;
660	irc_user_t *iu = flags & OPT_SELFMESSAGE ? irc->user : bu->ui_data;
661	irc_channel_t *ic = c->ui_data;
662	char wrapped, ts = NULL;
663
664	if (ic == NULL) {
665	return FALSE;
666	}
667
668	if (sent_at > 0 && set_getbool(&bee->set, "display_timestamps")) {
669	ts = irc_format_timestamp(irc, sent_at);
670	}
671
672	wrapped = word_wrap(msg, IRC_WORD_WRAP);
673	irc_send_msg(iu, "PRIVMSG", ic->name, wrapped, ts);
674	g_free(ts);
675	g_free(wrapped);
676
677	return TRUE;
678	}
679
680	static gboolean bee_irc_chat_add_user(bee_t bee, struct groupchat c, bee_user_t *bu)
681	{
682	irc_t *irc = bee->ui_data;
683	irc_channel_t *ic = c->ui_data;
684
685	if (ic == NULL) {
686	return FALSE;
687	}
688
689	irc_channel_add_user(ic, bu == bee->user ? irc->user : bu->ui_data);
690
691	return TRUE;
692	}
693
694	static gboolean bee_irc_chat_remove_user(bee_t bee, struct groupchat c, bee_user_t bu, const char reason)
695	{
696	irc_t *irc = bee->ui_data;
697	irc_channel_t *ic = c->ui_data;
698
699	if (ic == NULL \|\| bu == NULL) {
700	return FALSE;
701	}
702
703	/* TODO: Possible bug here: If a module removes $user here instead of just
704	using imcb_chat_free() and the channel was IRC_CHANNEL_TEMP, we get into
705	a broken state around here. */
706	irc_channel_del_user(ic, bu == bee->user ? irc->user : bu->ui_data, IRC_CDU_PART, reason);
707
708	return TRUE;
709	}
710
711	static gboolean bee_irc_chat_topic(bee_t bee, struct groupchat c, const char new, bee_user_t bu)
712	{
713	irc_channel_t *ic = c->ui_data;
714	irc_t *irc = bee->ui_data;
715	irc_user_t *iu;
716
717	if (ic == NULL) {
718	return FALSE;
719	}
720
721	if (bu == NULL) {
722	iu = irc->root;
723	} else if (bu == bee->user) {
724	iu = irc->user;
725	} else {
726	iu = bu->ui_data;
727	}
728
729	irc_channel_set_topic(ic, new, iu);
730
731	return TRUE;
732	}
733
734	static gboolean bee_irc_chat_name_hint(bee_t bee, struct groupchat c, const char *name)
735	{
736	return irc_channel_name_hint(c->ui_data, name);
737	}
738
739	static gboolean bee_irc_chat_invite(bee_t bee, bee_user_t bu, const char name, const char msg)
740	{
741	char channel, s;
742	irc_t *irc = bee->ui_data;
743	irc_user_t *iu = bu->ui_data;
744	irc_channel_t *chan;
745
746	if (strchr(CTYPES, name[0])) {
747	channel = g_strdup(name);
748	} else {
749	channel = g_strdup_printf("#%s", name);
750	}
751
752	if ((s = strchr(channel, '@'))) {
753	*s = '\0';
754	}
755
756	if (strlen(channel) > MAX_NICK_LENGTH) {
757	/* If the channel name is very long (like those insane GTalk
758	UUID names), try if we can use the inviter's nick. */
759	s = g_strdup_printf("#%s", iu->nick);
760	if (irc_channel_by_name(irc, s) == NULL) {
761	g_free(channel);
762	channel = s;
763	} else {
764	g_free(s);
765	}
766	}
767
768	if ((chan = irc_channel_new(irc, channel)) &&
769	set_setstr(&chan->set, "type", "chat") &&
770	set_setstr(&chan->set, "chat_type", "room") &&
771	set_setstr(&chan->set, "account", bu->ic->acc->tag) &&
772	set_setstr(&chan->set, "room", (char *) name)) {
773	/* I'm assuming that if the user didn't "chat add" the room
774	himself but got invited, it's temporary, so make this a
775	temporary mapping that is removed as soon as we /PART. */
776	chan->flags \|= IRC_CHANNEL_TEMP;
777	} else {
778	irc_channel_free(chan);
779	chan = NULL;
780	}
781	g_free(channel);
782
783	irc_send_msg_f(iu, "PRIVMSG", irc->user->nick, "<< \002BitlBee\002 - Invitation to chatroom %s >>", name);
784	if (msg) {
785	irc_send_msg(iu, "PRIVMSG", irc->user->nick, msg, NULL);
786	}
787	if (chan) {
788	irc_send_msg_f(iu, "PRIVMSG", irc->user->nick, "To join the room, just /join %s", chan->name);
789	irc_send_invite(iu, chan);
790	}
791
792	return TRUE;
793	}
794
795	/* IRC->IM */
796	static gboolean bee_irc_channel_chat_privmsg_cb(gpointer data, gint fd, b_input_condition cond);
797
798	static gboolean bee_irc_channel_chat_privmsg(irc_channel_t ic, const char msg)
799	{
800	struct groupchat *c = ic->data;
801	char trans = NULL, s;
802
803	if (c == NULL) {
804	return FALSE;
805	}
806
807	if (set_getbool(&ic->set, "translate_to_nicks")) {
808	char nick[MAX_NICK_LENGTH + 1];
809	irc_user_t *iu;
810
811	strncpy(nick, msg, MAX_NICK_LENGTH);
812	nick[MAX_NICK_LENGTH] = '\0';
813	if ((s = strchr(nick, ':')) \|\| (s = strchr(nick, ','))) {
814	*s = '\0';
815	if ((iu = irc_user_by_name(ic->irc, nick)) && iu->bu &&
816	iu->bu->nick && irc_channel_has_user(ic, iu)) {
817	trans = g_strconcat(iu->bu->nick, msg + (s - nick), NULL);
818	msg = trans;
819	}
820	}
821	}
822
823	if (set_getbool(&ic->irc->b->set, "paste_buffer")) {
824	int delay;
825
826	if (ic->pastebuf == NULL) {
827	ic->pastebuf = g_string_new(msg);
828	} else {
829	b_event_remove(ic->pastebuf_timer);
830	g_string_append_printf(ic->pastebuf, "\n%s", msg);
831	}
832
833	if ((delay = set_getint(&ic->irc->b->set, "paste_buffer_delay")) <= 5) {
834	delay *= 1000;
835	}
836
837	ic->pastebuf_timer = b_timeout_add(delay, bee_irc_channel_chat_privmsg_cb, ic);
838
839	g_free(trans);
840	return TRUE;
841	} else {
842	bee_chat_msg(ic->irc->b, c, msg, 0);
843	}
844
845	g_free(trans);
846	return TRUE;
847	}
848
849	static gboolean bee_irc_channel_chat_privmsg_cb(gpointer data, gint fd, b_input_condition cond)
850	{
851	irc_channel_t *ic = data;
852
853	if (ic->data) {
854	bee_chat_msg(ic->irc->b, ic->data, ic->pastebuf->str, 0);
855	}
856
857	g_string_free(ic->pastebuf, TRUE);
858	ic->pastebuf = 0;
859	ic->pastebuf_timer = 0;
860
861	return FALSE;
862	}
863
864	static gboolean bee_irc_channel_chat_join(irc_channel_t *ic)
865	{
866	char acc_s, room;
867	account_t *acc;
868
869	if (strcmp(set_getstr(&ic->set, "chat_type"), "room") != 0) {
870	return TRUE;
871	}
872
873	if ((acc_s = set_getstr(&ic->set, "account")) &&
874	(room = set_getstr(&ic->set, "room")) &&
875	(acc = account_get(ic->irc->b, acc_s)) &&
876	acc->ic && (acc->ic->flags & OPT_LOGGED_IN) &&
877	acc->prpl->chat_join) {
878	char *nick;
879	struct groupchat *gc;
880
881	if (!(nick = set_getstr(&ic->set, "nick"))) {
882	nick = ic->irc->user->nick;
883	}
884
885	ic->flags \|= IRC_CHANNEL_CHAT_PICKME;
886	gc = acc->prpl->chat_join(acc->ic, room, nick, NULL, &ic->set);
887	ic->flags &= ~IRC_CHANNEL_CHAT_PICKME;
888
889	if (!gc) {
890	irc_send_num(ic->irc, 403, "%s :Error joining channel (check control channel?)", ic->name);
891	}
892
893	return FALSE;
894	} else {
895	irc_send_num(ic->irc, 403, "%s :Can't join channel, account offline?", ic->name);
896	return FALSE;
897	}
898	}
899
900	static gboolean bee_irc_channel_chat_part(irc_channel_t ic, const char msg)
901	{
902	struct groupchat *c = ic->data;
903
904	if (c && c->ic->acc->prpl->chat_leave) {
905	c->ic->acc->prpl->chat_leave(c);
906	}
907
908	if (!(ic->flags & IRC_CHANNEL_TEMP)) {
909	/* Remove the reference.
910	* We only need it for temp channels that are being freed */
911	ic->data = NULL;
912	}
913
914	return TRUE;
915	}
916
917	static gboolean bee_irc_channel_chat_topic(irc_channel_t ic, const char new)
918	{
919	struct groupchat *c = ic->data;
920
921	if (c == NULL) {
922	return FALSE;
923	}
924
925	if (c->ic->acc->prpl->chat_topic == NULL) {
926	irc_send_num(ic->irc, 482, "%s :IM network does not support channel topics", ic->name);
927	} else {
928	/* TODO: Need more const goodness here, sigh */
929	char *topic = g_strdup(new);
930	c->ic->acc->prpl->chat_topic(c, topic);
931	g_free(topic);
932	}
933
934	/* Whatever happened, the IM module should ack the topic change. */
935	return FALSE;
936	}
937
938	static gboolean bee_irc_channel_chat_invite(irc_channel_t ic, irc_user_t iu)
939	{
940	struct groupchat *c = ic->data;
941	bee_user_t *bu = iu->bu;
942
943	if (bu == NULL) {
944	return FALSE;
945	}
946
947	if (c) {
948	if (iu->bu->ic != c->ic) {
949	irc_send_num(ic->irc, 482, "%s :Can't mix different IM networks in one groupchat", ic->name);
950	} else if (c->ic->acc->prpl->chat_invite) {
951	c->ic->acc->prpl->chat_invite(c, iu->bu->handle, NULL);
952	} else {
953	irc_send_num(ic->irc, 482, "%s :IM protocol does not support room invitations", ic->name);
954	}
955	} else if (bu->ic->acc->prpl->chat_with &&
956	strcmp(set_getstr(&ic->set, "chat_type"), "groupchat") == 0) {
957	ic->flags \|= IRC_CHANNEL_CHAT_PICKME;
958	iu->bu->ic->acc->prpl->chat_with(bu->ic, bu->handle);
959	ic->flags &= ~IRC_CHANNEL_CHAT_PICKME;
960	} else {
961	irc_send_num(ic->irc, 482, "%s :IM protocol does not support room invitations", ic->name);
962	}
963
964	return TRUE;
965	}
966
967	static void bee_irc_channel_chat_kick(irc_channel_t ic, irc_user_t iu, const char *msg)
968	{
969	struct groupchat *c = ic->data;
970	bee_user_t *bu = iu->bu;
971
972	if ((c == NULL) \|\| (bu == NULL)) {
973	return;
974	}
975
976	if (!c->ic->acc->prpl->chat_kick) {
977	irc_send_num(ic->irc, 482, "%s :IM protocol does not support room kicking", ic->name);
978	return;
979	}
980
981	c->ic->acc->prpl->chat_kick(c, iu->bu->handle, msg);
982	}
983
984	static char set_eval_room_account(set_t set, char *value);
985	static char set_eval_chat_type(set_t set, char *value);
986
987	static gboolean bee_irc_channel_init(irc_channel_t *ic)
988	{
989	set_t *s;
990
991	set_add(&ic->set, "account", NULL, set_eval_room_account, ic);
992	set_add(&ic->set, "chat_type", "groupchat", set_eval_chat_type, ic);
993
994	s = set_add(&ic->set, "nick", NULL, NULL, ic);
995	s->flags \|= SET_NULL_OK;
996
997	set_add(&ic->set, "room", NULL, NULL, ic);
998	set_add(&ic->set, "translate_to_nicks", "true", set_eval_bool, ic);
999
1000	/* chat_type == groupchat */
1001	ic->flags \|= IRC_CHANNEL_TEMP;
1002
1003	return TRUE;
1004	}
1005
1006	static char set_eval_room_account(set_t set, char *value)
1007	{
1008	struct irc_channel *ic = set->data;
1009	account_t acc, oa;
1010
1011	if (!(acc = account_get(ic->irc->b, value))) {
1012	return SET_INVALID;
1013	} else if (!acc->prpl->chat_join && acc->prpl != &protocol_missing) {
1014	irc_rootmsg(ic->irc, "Named chatrooms not supported on that account.");
1015	return SET_INVALID;
1016	}
1017
1018	if (set->value && (oa = account_get(ic->irc->b, set->value)) &&
1019	oa->prpl->chat_free_settings) {
1020	oa->prpl->chat_free_settings(oa, &ic->set);
1021	}
1022
1023	if (acc->prpl->chat_add_settings) {
1024	acc->prpl->chat_add_settings(acc, &ic->set);
1025	}
1026
1027	return g_strdup(acc->tag);
1028	}
1029
1030	static char set_eval_chat_type(set_t set, char *value)
1031	{
1032	struct irc_channel *ic = set->data;
1033
1034	if (strcmp(value, "groupchat") == 0) {
1035	ic->flags \|= IRC_CHANNEL_TEMP;
1036	} else if (strcmp(value, "room") == 0) {
1037	ic->flags &= ~IRC_CHANNEL_TEMP;
1038	} else {
1039	return NULL;
1040	}
1041
1042	return value;
1043	}
1044
1045	static gboolean bee_irc_channel_free(irc_channel_t *ic)
1046	{
1047	struct groupchat *c = ic->data;
1048
1049	set_del(&ic->set, "account");
1050	set_del(&ic->set, "chat_type");
1051	set_del(&ic->set, "nick");
1052	set_del(&ic->set, "room");
1053	set_del(&ic->set, "translate_to_nicks");
1054
1055	ic->flags &= ~IRC_CHANNEL_TEMP;
1056
1057	/* That one still points at this channel. Don't. */
1058	if (c) {
1059	c->ui_data = NULL;
1060	}
1061
1062	return TRUE;
1063	}
1064
1065	const struct irc_channel_funcs irc_channel_im_chat_funcs = {
1066	bee_irc_channel_chat_privmsg,
1067	bee_irc_channel_chat_join,
1068	bee_irc_channel_chat_part,
1069	bee_irc_channel_chat_topic,
1070	bee_irc_channel_chat_invite,
1071	bee_irc_channel_chat_kick,
1072
1073	bee_irc_channel_init,
1074	bee_irc_channel_free,
1075	};
1076
1077
1078	/* IM->IRC: File transfers */
1079	static file_transfer_t bee_irc_ft_in_start(bee_t bee, bee_user_t bu, const char file_name, size_t file_size)
1080	{
1081	return dccs_send_start(bu->ic, (irc_user_t *) bu->ui_data, file_name, file_size);
1082	}
1083
1084	static gboolean bee_irc_ft_out_start(struct im_connection ic, file_transfer_t ft)
1085	{
1086	return dccs_recv_start(ft);
1087	}
1088
1089	static void bee_irc_ft_close(struct im_connection ic, file_transfer_t ft)
1090	{
1091	return dcc_close(ft);
1092	}
1093
1094	static void bee_irc_ft_finished(struct im_connection ic, file_transfer_t file)
1095	{
1096	dcc_file_transfer_t *df = file->priv;
1097
1098	if (file->bytes_transferred >= file->file_size) {
1099	dcc_finish(file);
1100	} else {
1101	df->proto_finished = TRUE;
1102	}
1103	}
1104
1105	static void bee_irc_log(bee_t bee, const char tag, const char *msg)
1106	{
1107	irc_t irc = (irc_t ) bee->ui_data;
1108
1109	irc_rootmsg(irc, "%s - %s", tag, msg);
1110	}
1111
1112	const struct bee_ui_funcs irc_ui_funcs = {
1113	bee_irc_imc_connected,
1114	bee_irc_imc_disconnected,
1115
1116	bee_irc_user_new,
1117	bee_irc_user_free,
1118	bee_irc_user_fullname,
1119	bee_irc_user_nick_hint,
1120	bee_irc_user_group,
1121	bee_irc_user_status,
1122	bee_irc_user_msg,
1123	bee_irc_user_typing,
1124	bee_irc_user_action_response,
1125
1126	bee_irc_chat_new,
1127	bee_irc_chat_free,
1128	bee_irc_chat_log,
1129	bee_irc_chat_msg,
1130	bee_irc_chat_add_user,
1131	bee_irc_chat_remove_user,
1132	bee_irc_chat_topic,
1133	bee_irc_chat_name_hint,
1134	bee_irc_chat_invite,
1135
1136	bee_irc_ft_in_start,
1137	bee_irc_ft_out_start,
1138	bee_irc_ft_close,
1139	bee_irc_ft_finished,
1140
1141	bee_irc_log,
1142	bee_irc_user_nick_change,
1143	};

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

Download in other formats: