source: irc_im.c @ 7add7ec

Last change on this file since 7add7ec was a97a336, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-12-07T23:14:30Z

Add CTCP HELP code. Also cleaning up some noop handlers in the Twitter
module (chat_with and send_typing) that suggested support for features
that obviously don't exist.

  • Property mode set to 100644
File size: 26.8 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
31static const struct irc_user_funcs irc_user_im_funcs;
32
33static 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
40static void bee_irc_imc_disconnected( struct im_connection *ic )
41{
42        /* Maybe try to send /QUITs here instead of later on. */
43}
44
45static 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
94static 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
99static 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
142void 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
195static 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
269static 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
282static 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
303static gboolean bee_irc_user_nick_update( irc_user_t *iu );
304
305static 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
333static 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
340static 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
362static 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
386void 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
406static gboolean bee_irc_user_privmsg_cb( gpointer data, gint fd, b_input_condition cond );
407
408static 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
450static 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
487static 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
543static 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 */
550const struct irc_channel_funcs irc_channel_im_chat_funcs;
551
552static 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
591static 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        irc_channel_del_user( ic, ic->irc->user, IRC_CDU_KICK, "Chatroom closed by server" );
603       
604        return TRUE;
605}
606
607static gboolean bee_irc_chat_log( bee_t *bee, struct groupchat *c, const char *text )
608{
609        irc_channel_t *ic = c->ui_data;
610       
611        if( ic == NULL )
612                return FALSE;
613       
614        irc_channel_printf( ic, "%s", text );
615       
616        return TRUE;
617}
618
619static gboolean bee_irc_chat_msg( bee_t *bee, struct groupchat *c, bee_user_t *bu, const char *msg, time_t sent_at )
620{
621        irc_t *irc = bee->ui_data;
622        irc_user_t *iu = bu->ui_data;
623        irc_channel_t *ic = c->ui_data;
624        char *ts = NULL;
625       
626        if( ic == NULL )
627                return FALSE;
628       
629        if( sent_at > 0 && set_getbool( &bee->set, "display_timestamps" ) )
630                ts = irc_format_timestamp( irc, sent_at );
631       
632        irc_send_msg( iu, "PRIVMSG", ic->name, msg, ts );
633        g_free( ts );
634       
635        return TRUE;
636}
637
638static gboolean bee_irc_chat_add_user( bee_t *bee, struct groupchat *c, bee_user_t *bu )
639{
640        irc_t *irc = bee->ui_data;
641        irc_channel_t *ic = c->ui_data;
642       
643        if( ic == NULL )
644                return FALSE;
645       
646        irc_channel_add_user( ic, bu == bee->user ? irc->user : bu->ui_data );
647       
648        return TRUE;
649}
650
651static gboolean bee_irc_chat_remove_user( bee_t *bee, struct groupchat *c, bee_user_t *bu )
652{
653        irc_t *irc = bee->ui_data;
654        irc_channel_t *ic = c->ui_data;
655       
656        if( ic == NULL || bu == NULL )
657                return FALSE;
658       
659        /* TODO: Possible bug here: If a module removes $user here instead of just
660           using imcb_chat_free() and the channel was IRC_CHANNEL_TEMP, we get into
661           a broken state around here. */
662        irc_channel_del_user( ic, bu == bee->user ? irc->user : bu->ui_data, IRC_CDU_PART, NULL );
663       
664        return TRUE;
665}
666
667static gboolean bee_irc_chat_topic( bee_t *bee, struct groupchat *c, const char *new, bee_user_t *bu )
668{
669        irc_channel_t *ic = c->ui_data;
670        irc_t *irc = bee->ui_data;
671        irc_user_t *iu;
672       
673        if( ic == NULL )
674                return FALSE;
675       
676        if( bu == NULL )
677                iu = irc->root;
678        else if( bu == bee->user )
679                iu = irc->user;
680        else
681                iu = bu->ui_data;
682       
683        irc_channel_set_topic( ic, new, iu );
684       
685        return TRUE;
686}
687
688static gboolean bee_irc_chat_name_hint( bee_t *bee, struct groupchat *c, const char *name )
689{
690        irc_t *irc = bee->ui_data;
691        irc_channel_t *ic = c->ui_data, *oic;
692        char stripped[MAX_NICK_LENGTH+1], *full_name;
693       
694        if( ic == NULL )
695                return FALSE;
696       
697        /* Don't rename a channel if the user's in it already. */
698        if( ic->flags & IRC_CHANNEL_JOINED )
699                return FALSE;
700       
701        strncpy( stripped, name, MAX_NICK_LENGTH );
702        stripped[MAX_NICK_LENGTH] = '\0';
703        irc_channel_name_strip( stripped );
704        if( set_getbool( &bee->set, "lcnicks" ) )
705                nick_lc( stripped );
706       
707        if( stripped[0] == '\0' )
708                return FALSE;
709       
710        full_name = g_strdup_printf( "#%s", stripped );
711        if( ( oic = irc_channel_by_name( irc, full_name ) ) )
712        {
713                char *type, *chat_type;
714               
715                type = set_getstr( &oic->set, "type" );
716                chat_type = set_getstr( &oic->set, "chat_type" );
717               
718                if( type && chat_type && oic->data == FALSE &&
719                    strcmp( type, "chat" ) == 0 &&
720                    strcmp( chat_type, "groupchat" ) == 0 )
721                {
722                        /* There's a channel with this name already, but it looks
723                           like it's not in use yet. Most likely the IRC client
724                           rejoined the channel after a reconnect. Remove it so
725                           we can reuse its name. */
726                        irc_channel_free( oic );
727                }
728                else
729                {
730                        g_free( full_name );
731                        return FALSE;
732                }
733        }
734       
735        g_free( ic->name );
736        ic->name = full_name;
737       
738        return TRUE;
739}
740
741static gboolean bee_irc_chat_invite( bee_t *bee, bee_user_t *bu, const char *name, const char *msg )
742{
743        char *channel, *s;
744        irc_t *irc = bee->ui_data;
745        irc_user_t *iu = bu->ui_data;
746        irc_channel_t *chan;
747       
748        if( strchr( CTYPES, name[0] ) )
749                channel = g_strdup( name );
750        else
751                channel = g_strdup_printf( "#%s", name );
752       
753        if( ( s = strchr( channel, '@' ) ) )
754                *s = '\0';
755       
756        if( strlen( channel ) > MAX_NICK_LENGTH )
757        {
758                /* If the channel name is very long (like those insane GTalk
759                   UUID names), try if we can use the inviter's nick. */
760                s = g_strdup_printf( "#%s", iu->nick );
761                if( irc_channel_by_name( irc, s ) == NULL )
762                {
763                        g_free( channel );
764                        channel = s;
765                }
766        }
767       
768        if( ( chan = irc_channel_new( irc, channel ) ) &&
769            set_setstr( &chan->set, "type", "chat" ) &&
770            set_setstr( &chan->set, "chat_type", "room" ) &&
771            set_setstr( &chan->set, "account", bu->ic->acc->tag ) &&
772            set_setstr( &chan->set, "room", (char*) name ) )
773        {
774                /* I'm assuming that if the user didn't "chat add" the room
775                   himself but got invited, it's temporary, so make this a
776                   temporary mapping that is removed as soon as we /PART. */
777                chan->flags |= IRC_CHANNEL_TEMP;
778        }
779        else
780        {
781                irc_channel_free( chan );
782                chan = NULL;
783        }
784        g_free( channel );
785       
786        irc_send_msg_f( iu, "PRIVMSG", irc->user->nick, "<< \002BitlBee\002 - Invitation to chatroom %s >>", name );
787        if( msg )
788                irc_send_msg( iu, "PRIVMSG", irc->user->nick, msg, NULL );
789        if( chan )
790        {
791                irc_send_msg_f( iu, "PRIVMSG", irc->user->nick, "To join the room, just /join %s", chan->name );
792                irc_send_invite( iu, chan );
793        }
794       
795        return TRUE;
796}
797
798/* IRC->IM */
799static gboolean bee_irc_channel_chat_privmsg_cb( gpointer data, gint fd, b_input_condition cond );
800
801static gboolean bee_irc_channel_chat_privmsg( irc_channel_t *ic, const char *msg )
802{
803        struct groupchat *c = ic->data;
804        char *trans = NULL, *s;
805       
806        if( c == NULL )
807                return FALSE;
808       
809        if( set_getbool( &ic->set, "translate_to_nicks" ) )
810        {
811                char nick[MAX_NICK_LENGTH+1];
812                irc_user_t *iu;
813               
814                strncpy( nick, msg, MAX_NICK_LENGTH );
815                nick[MAX_NICK_LENGTH] = '\0';
816                if( ( s = strchr( nick, ':' ) ) || ( s = strchr( nick, ',' ) ) )
817                {
818                        *s = '\0';
819                        if( ( iu = irc_user_by_name( ic->irc, nick ) ) && iu->bu &&
820                            iu->bu->nick && irc_channel_has_user( ic, iu ) )
821                        {
822                                trans = g_strconcat( iu->bu->nick, msg + ( s - nick ), NULL );
823                                msg = trans;
824                        }
825                }
826        }
827       
828        if( set_getbool( &ic->irc->b->set, "paste_buffer" ) )
829        {
830                int delay;
831               
832                if( ic->pastebuf == NULL )
833                        ic->pastebuf = g_string_new( msg );
834                else
835                {
836                        b_event_remove( ic->pastebuf_timer );
837                        g_string_append_printf( ic->pastebuf, "\n%s", msg );
838                }
839               
840                if( ( delay = set_getint( &ic->irc->b->set, "paste_buffer_delay" ) ) <= 5 )
841                        delay *= 1000;
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        }
848        else
849                bee_chat_msg( ic->irc->b, c, msg, 0 );
850       
851        g_free( trans );
852        return TRUE;
853}
854
855static 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        g_string_free( ic->pastebuf, TRUE );
863        ic->pastebuf = 0;
864        ic->pastebuf_timer = 0;
865       
866        return FALSE;
867}
868
869static gboolean bee_irc_channel_chat_join( irc_channel_t *ic )
870{
871        char *acc_s, *room;
872        account_t *acc;
873       
874        if( strcmp( set_getstr( &ic->set, "chat_type" ), "room" ) != 0 )
875                return TRUE;
876       
877        if( ( acc_s = set_getstr( &ic->set, "account" ) ) &&
878            ( room = set_getstr( &ic->set, "room" ) ) &&
879            ( acc = account_get( ic->irc->b, acc_s ) ) &&
880            acc->ic && acc->prpl->chat_join )
881        {
882                char *nick;
883               
884                if( !( nick = set_getstr( &ic->set, "nick" ) ) )
885                        nick = ic->irc->user->nick;
886               
887                ic->flags |= IRC_CHANNEL_CHAT_PICKME;
888                acc->prpl->chat_join( acc->ic, room, nick, NULL, &ic->set );
889                ic->flags &= ~IRC_CHANNEL_CHAT_PICKME;
890               
891                return FALSE;
892        }
893        else
894        {
895                irc_send_num( ic->irc, 403, "%s :Can't join channel, account offline?", ic->name );
896                return FALSE;
897        }
898}
899
900static gboolean bee_irc_channel_chat_part( irc_channel_t *ic, const char *msg )
901{
902        struct groupchat *c = ic->data;
903       
904        if( c && c->ic->acc->prpl->chat_leave )
905                c->ic->acc->prpl->chat_leave( c );
906       
907        ic->data = NULL;
908       
909        return TRUE;
910}
911
912static gboolean bee_irc_channel_chat_topic( irc_channel_t *ic, const char *new )
913{
914        struct groupchat *c = ic->data;
915       
916        if( c == NULL )
917                return FALSE;
918       
919        if( c->ic->acc->prpl->chat_topic == NULL )
920                irc_send_num( ic->irc, 482, "%s :IM network does not support channel topics", ic->name );
921        else
922        {
923                /* TODO: Need more const goodness here, sigh */
924                char *topic = g_strdup( new );
925                c->ic->acc->prpl->chat_topic( c, topic );
926                g_free( topic );
927        }
928               
929        /* Whatever happened, the IM module should ack the topic change. */
930        return FALSE;
931}
932
933static gboolean bee_irc_channel_chat_invite( irc_channel_t *ic, irc_user_t *iu )
934{
935        struct groupchat *c = ic->data;
936        bee_user_t *bu = iu->bu;
937       
938        if( bu == NULL )
939                return FALSE;
940       
941        if( c )
942        {
943                if( iu->bu->ic != c->ic )
944                        irc_send_num( ic->irc, 482, "%s :Can't mix different IM networks in one groupchat", ic->name );
945                else if( c->ic->acc->prpl->chat_invite )
946                        c->ic->acc->prpl->chat_invite( c, iu->bu->handle, NULL );
947                else
948                        irc_send_num( ic->irc, 482, "%s :IM protocol does not support room invitations", ic->name );
949        }
950        else if( bu->ic->acc->prpl->chat_with &&
951                 strcmp( set_getstr( &ic->set, "chat_type" ), "groupchat" ) == 0 )
952        {
953                ic->flags |= IRC_CHANNEL_CHAT_PICKME;
954                iu->bu->ic->acc->prpl->chat_with( bu->ic, bu->handle );
955                ic->flags &= ~IRC_CHANNEL_CHAT_PICKME;
956        }
957        else
958        {
959                irc_send_num( ic->irc, 482, "%s :IM protocol does not support room invitations", ic->name );
960        }
961       
962        return TRUE;
963}
964
965static char *set_eval_room_account( set_t *set, char *value );
966static char *set_eval_chat_type( set_t *set, char *value );
967
968static gboolean bee_irc_channel_init( irc_channel_t *ic )
969{
970        set_add( &ic->set, "account", NULL, set_eval_room_account, ic );
971        set_add( &ic->set, "chat_type", "groupchat", set_eval_chat_type, ic );
972        set_add( &ic->set, "nick", NULL, NULL, ic );
973        set_add( &ic->set, "room", NULL, NULL, ic );
974        set_add( &ic->set, "translate_to_nicks", "true", set_eval_bool, ic );
975       
976        /* chat_type == groupchat */
977        ic->flags |= IRC_CHANNEL_TEMP;
978       
979        return TRUE;
980}
981
982static char *set_eval_room_account( set_t *set, char *value )
983{
984        struct irc_channel *ic = set->data;
985        account_t *acc, *oa;
986       
987        if( !( acc = account_get( ic->irc->b, value ) ) )
988                return SET_INVALID;
989        else if( !acc->prpl->chat_join )
990        {
991                irc_usermsg( ic->irc, "Named chatrooms not supported on that account." );
992                return SET_INVALID;
993        }
994       
995        if( set->value && ( oa = account_get( ic->irc->b, set->value ) ) &&
996            oa->prpl->chat_free_settings )
997                oa->prpl->chat_free_settings( oa, &ic->set );
998       
999        if( acc->prpl->chat_add_settings )
1000                acc->prpl->chat_add_settings( acc, &ic->set );
1001       
1002        return g_strdup( acc->tag );
1003}
1004
1005static char *set_eval_chat_type( set_t *set, char *value )
1006{
1007        struct irc_channel *ic = set->data;
1008       
1009        if( strcmp( value, "groupchat" ) == 0 )
1010                ic->flags |= IRC_CHANNEL_TEMP;
1011        else if( strcmp( value, "room" ) == 0 )
1012                ic->flags &= ~IRC_CHANNEL_TEMP;
1013        else
1014                return NULL;
1015       
1016        return value;
1017}
1018
1019static gboolean bee_irc_channel_free( irc_channel_t *ic )
1020{
1021        struct groupchat *c = ic->data;
1022       
1023        set_del( &ic->set, "account" );
1024        set_del( &ic->set, "chat_type" );
1025        set_del( &ic->set, "nick" );
1026        set_del( &ic->set, "room" );
1027        set_del( &ic->set, "translate_to_nicks" );
1028       
1029        ic->flags &= ~IRC_CHANNEL_TEMP;
1030       
1031        /* That one still points at this channel. Don't. */
1032        if( c )
1033                c->ui_data = NULL;
1034       
1035        return TRUE;
1036}
1037
1038const struct irc_channel_funcs irc_channel_im_chat_funcs = {
1039        bee_irc_channel_chat_privmsg,
1040        bee_irc_channel_chat_join,
1041        bee_irc_channel_chat_part,
1042        bee_irc_channel_chat_topic,
1043        bee_irc_channel_chat_invite,
1044
1045        bee_irc_channel_init,
1046        bee_irc_channel_free,
1047};
1048
1049
1050/* IM->IRC: File transfers */
1051static file_transfer_t *bee_irc_ft_in_start( bee_t *bee, bee_user_t *bu, const char *file_name, size_t file_size )
1052{
1053        return dccs_send_start( bu->ic, (irc_user_t *) bu->ui_data, file_name, file_size );
1054}
1055
1056static gboolean bee_irc_ft_out_start( struct im_connection *ic, file_transfer_t *ft )
1057{
1058        return dccs_recv_start( ft );
1059}
1060
1061static void bee_irc_ft_close( struct im_connection *ic, file_transfer_t *ft )
1062{
1063        return dcc_close( ft );
1064}
1065
1066static void bee_irc_ft_finished( struct im_connection *ic, file_transfer_t *file )
1067{
1068        dcc_file_transfer_t *df = file->priv;
1069
1070        if( file->bytes_transferred >= file->file_size )
1071                dcc_finish( file );
1072        else
1073                df->proto_finished = TRUE;
1074}
1075
1076const struct bee_ui_funcs irc_ui_funcs = {
1077        bee_irc_imc_connected,
1078        bee_irc_imc_disconnected,
1079       
1080        bee_irc_user_new,
1081        bee_irc_user_free,
1082        bee_irc_user_fullname,
1083        bee_irc_user_nick_hint,
1084        bee_irc_user_group,
1085        bee_irc_user_status,
1086        bee_irc_user_msg,
1087        bee_irc_user_typing,
1088        bee_irc_user_action_response,
1089       
1090        bee_irc_chat_new,
1091        bee_irc_chat_free,
1092        bee_irc_chat_log,
1093        bee_irc_chat_msg,
1094        bee_irc_chat_add_user,
1095        bee_irc_chat_remove_user,
1096        bee_irc_chat_topic,
1097        bee_irc_chat_name_hint,
1098        bee_irc_chat_invite,
1099       
1100        bee_irc_ft_in_start,
1101        bee_irc_ft_out_start,
1102        bee_irc_ft_close,
1103        bee_irc_ft_finished,
1104};
Note: See TracBrowser for help on using the repository browser.