Context Navigation

source: irc_im.c @ b1d9c06

Last change on this file since b1d9c06 was 4543356c, checked in by Shane Synan <digitalcircuit36939@…>, at 2016-02-04T08:17:46Z

Send away-notify after join/part from IRC channel

Move irc_send_away_notify below bee_irc_channel_update to delay
sending the updated away-notify status until after any nicks have
joined/quit. Otherwise, some IRC clients will drop the status
messages as they go to nicks that the client doesn't know about.

Property mode set to 100644

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

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

Download in other formats: