Context Navigation

source: irc_im.c @ d16e951

Last change on this file since d16e951 was 1522faf, checked in by dequis <dx@…>, at 2015-04-06T02:26:44Z

Merge branch 'develop' into feat/hip-cat

Conflicts:

irc_im.c
protocols/jabber/conference.c

Property mode set to 100644

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

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

Download in other formats: