Context Navigation

source: irc_im.c @ f1cf01c

Last change on this file since f1cf01c was 5f74987, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-06-11T16:09:50Z
Crash-bug (NULL-ptr deref) fix in channel part routine.
Property mode set to `100644`
File size: 26.9 KB

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

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

Download in other formats: