Context Navigation

source: irc_im.c @ c347a12

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

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

Download in other formats: