source: irc.c @ fd424c8

Last change on this file since fd424c8 was a758ec1, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-08-21T19:48:41Z

Although the backward compatibility stuff for show_offline and away_devoice
was only meant to ease migration, people are now complaining that
"set show_offline off" doesn't work. Make this work, but at the same time
start hiding these two options to discourage people from using them.

  • Property mode set to 100644
File size: 24.7 KB
Line 
1  /********************************************************************\
2  * BitlBee -- An IRC to other IM-networks gateway                     *
3  *                                                                    *
4  * Copyright 2002-2004 Wilmer van der Gaast and others                *
5  \********************************************************************/
6
7/* The IRC-based UI (for now the only one)                              */
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 "ipc.h"
28#include "dcc.h"
29
30GSList *irc_connection_list;
31
32static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond );
33static char *set_eval_charset( set_t *set, char *value );
34static char *set_eval_password( set_t *set, char *value );
35static char *set_eval_bw_compat( set_t *set, char *value );
36
37irc_t *irc_new( int fd )
38{
39        irc_t *irc;
40        struct sockaddr_storage sock;
41        socklen_t socklen = sizeof( sock );
42        char *host = NULL, *myhost = NULL;
43        irc_user_t *iu;
44        set_t *s;
45        bee_t *b;
46       
47        irc = g_new0( irc_t, 1 );
48       
49        irc->fd = fd;
50        sock_make_nonblocking( irc->fd );
51       
52        irc->r_watch_source_id = b_input_add( irc->fd, B_EV_IO_READ, bitlbee_io_current_client_read, irc );
53       
54        irc->status = USTATUS_OFFLINE;
55        irc->last_pong = gettime();
56       
57        irc->nick_user_hash = g_hash_table_new( g_str_hash, g_str_equal );
58        irc->watches = g_hash_table_new( g_str_hash, g_str_equal );
59       
60        irc->iconv = (GIConv) -1;
61        irc->oconv = (GIConv) -1;
62       
63        if( global.conf->hostname )
64        {
65                myhost = g_strdup( global.conf->hostname );
66        }
67        else if( getsockname( irc->fd, (struct sockaddr*) &sock, &socklen ) == 0 ) 
68        {
69                char buf[NI_MAXHOST+1];
70
71                if( getnameinfo( (struct sockaddr *) &sock, socklen, buf,
72                                 NI_MAXHOST, NULL, 0, 0 ) == 0 )
73                {
74                        myhost = g_strdup( ipv6_unwrap( buf ) );
75                }
76        }
77       
78        if( getpeername( irc->fd, (struct sockaddr*) &sock, &socklen ) == 0 )
79        {
80                char buf[NI_MAXHOST+1];
81
82                if( getnameinfo( (struct sockaddr *)&sock, socklen, buf,
83                                 NI_MAXHOST, NULL, 0, 0 ) == 0 )
84                {
85                        host = g_strdup( ipv6_unwrap( buf ) );
86                }
87        }
88       
89        if( host == NULL )
90                host = g_strdup( "localhost.localdomain" );
91        if( myhost == NULL )
92                myhost = g_strdup( "localhost.localdomain" );
93       
94        if( global.conf->ping_interval > 0 && global.conf->ping_timeout > 0 )
95                irc->ping_source_id = b_timeout_add( global.conf->ping_interval * 1000, irc_userping, irc );
96
97        irc_connection_list = g_slist_append( irc_connection_list, irc );
98       
99        b = irc->b = bee_new();
100        b->ui_data = irc;
101        b->ui = &irc_ui_funcs;
102       
103        s = set_add( &b->set, "allow_takeover", "true", set_eval_bool, irc );
104        s = set_add( &b->set, "away_devoice", "true", set_eval_bw_compat, irc );
105        s->flags |= SET_HIDDEN;
106        s = set_add( &b->set, "away_reply_timeout", "3600", set_eval_int, irc );
107        s = set_add( &b->set, "charset", "utf-8", set_eval_charset, irc );
108        s = set_add( &b->set, "default_target", "root", NULL, irc );
109        s = set_add( &b->set, "display_namechanges", "false", set_eval_bool, irc );
110        s = set_add( &b->set, "display_timestamps", "true", set_eval_bool, irc );
111        s = set_add( &b->set, "handle_unknown", "add_channel", NULL, irc );
112        s = set_add( &b->set, "last_version", NULL, NULL, irc );
113        s->flags |= SET_HIDDEN;
114        s = set_add( &b->set, "lcnicks", "true", set_eval_bool, irc );
115        s = set_add( &b->set, "nick_format", "%-@nick", NULL, irc );
116        s = set_add( &b->set, "offline_user_quits", "true", set_eval_bool, irc );
117        s = set_add( &b->set, "ops", "both", set_eval_irc_channel_ops, irc );
118        s = set_add( &b->set, "paste_buffer", "false", set_eval_bool, irc );
119        s->old_key = g_strdup( "buddy_sendbuffer" );
120        s = set_add( &b->set, "paste_buffer_delay", "200", set_eval_int, irc );
121        s->old_key = g_strdup( "buddy_sendbuffer_delay" );
122        s = set_add( &b->set, "password", NULL, set_eval_password, irc );
123        s->flags |= SET_NULL_OK;
124        s = set_add( &b->set, "private", "true", set_eval_bool, irc );
125        s = set_add( &b->set, "query_order", "lifo", NULL, irc );
126        s = set_add( &b->set, "root_nick", ROOT_NICK, set_eval_root_nick, irc );
127        s->flags |= SET_HIDDEN;
128        s = set_add( &b->set, "show_offline", "false", set_eval_bw_compat, irc );
129        s->flags |= SET_HIDDEN;
130        s = set_add( &b->set, "simulate_netsplit", "true", set_eval_bool, irc );
131        s = set_add( &b->set, "timezone", "local", set_eval_timezone, irc );
132        s = set_add( &b->set, "to_char", ": ", set_eval_to_char, irc );
133        s = set_add( &b->set, "typing_notice", "false", set_eval_bool, irc );
134
135        irc->root = iu = irc_user_new( irc, ROOT_NICK );
136        iu->host = g_strdup( myhost );
137        iu->fullname = g_strdup( ROOT_FN );
138        iu->f = &irc_user_root_funcs;
139       
140        iu = irc_user_new( irc, NS_NICK );
141        iu->host = g_strdup( myhost );
142        iu->fullname = g_strdup( ROOT_FN );
143        iu->f = &irc_user_root_funcs;
144       
145        irc->user = g_new0( irc_user_t, 1 );
146        irc->user->host = g_strdup( host );
147       
148        conf_loaddefaults( irc );
149       
150        /* Evaluator sets the iconv/oconv structures. */
151        set_eval_charset( set_find( &b->set, "charset" ), set_getstr( &b->set, "charset" ) );
152       
153        irc_write( irc, ":%s NOTICE AUTH :%s", irc->root->host, "BitlBee-IRCd initialized, please go on" );
154        if( isatty( irc->fd ) )
155                irc_write( irc, ":%s NOTICE AUTH :%s", irc->root->host,
156                           "If you read this, you most likely accidentally "
157                           "started BitlBee in inetd mode on the command line. "
158                           "You probably want to run it in (Fork)Daemon mode. "
159                           "See doc/README for more information." );
160       
161        g_free( myhost );
162        g_free( host );
163       
164        nogaim_init();
165       
166        return irc;
167}
168
169/* immed=1 makes this function pretty much equal to irc_free(), except that
170   this one will "log". In case the connection is already broken and we
171   shouldn't try to write to it. */
172void irc_abort( irc_t *irc, int immed, char *format, ... )
173{
174        char *reason = NULL;
175       
176        if( format != NULL )
177        {
178                va_list params;
179               
180                va_start( params, format );
181                reason = g_strdup_vprintf( format, params );
182                va_end( params );
183        }
184       
185        irc_write( irc, "ERROR :Closing link: %s", reason ? : "" );
186       
187        ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
188                           irc->user->nick ? irc->user->nick : "(NONE)",
189                           irc->user->host, reason ? : "" );
190       
191        g_free( reason );
192       
193        irc_flush( irc );
194        if( immed )
195        {
196                irc_free( irc );
197        }
198        else
199        {
200                b_event_remove( irc->ping_source_id );
201                irc->ping_source_id = b_timeout_add( 1, (b_event_handler) irc_free, irc );
202        }
203}
204
205static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data );
206
207void irc_free( irc_t * irc )
208{
209        irc->status |= USTATUS_SHUTDOWN;
210       
211        log_message( LOGLVL_INFO, "Destroying connection with fd %d", irc->fd );
212       
213        if( irc->status & USTATUS_IDENTIFIED && set_getbool( &irc->b->set, "save_on_quit" ) ) 
214                if( storage_save( irc, NULL, TRUE ) != STORAGE_OK )
215                        log_message( LOGLVL_WARNING, "Error while saving settings for user %s", irc->user->nick );
216       
217        irc_connection_list = g_slist_remove( irc_connection_list, irc );
218       
219        while( irc->queries != NULL )
220                query_del( irc, irc->queries );
221       
222        /* This is a little bit messy: bee_free() frees all b->users which
223           calls us back to free the corresponding irc->users. So do this
224           before we clear the remaining ones ourselves. */
225        bee_free( irc->b );
226       
227        while( irc->users )
228                irc_user_free( irc, (irc_user_t *) irc->users->data );
229       
230        while( irc->channels )
231                irc_channel_free( irc->channels->data );
232       
233        if( irc->ping_source_id > 0 )
234                b_event_remove( irc->ping_source_id );
235        if( irc->r_watch_source_id > 0 )
236                b_event_remove( irc->r_watch_source_id );
237        if( irc->w_watch_source_id > 0 )
238                b_event_remove( irc->w_watch_source_id );
239       
240        closesocket( irc->fd );
241        irc->fd = -1;
242       
243        g_hash_table_foreach_remove( irc->nick_user_hash, irc_free_hashkey, NULL );
244        g_hash_table_destroy( irc->nick_user_hash );
245       
246        g_hash_table_foreach_remove( irc->watches, irc_free_hashkey, NULL );
247        g_hash_table_destroy( irc->watches );
248       
249        if( irc->iconv != (GIConv) -1 )
250                g_iconv_close( irc->iconv );
251        if( irc->oconv != (GIConv) -1 )
252                g_iconv_close( irc->oconv );
253       
254        g_free( irc->sendbuffer );
255        g_free( irc->readbuffer );
256        g_free( irc->password );
257       
258        g_free( irc );
259       
260        if( global.conf->runmode == RUNMODE_INETD ||
261            global.conf->runmode == RUNMODE_FORKDAEMON ||
262            ( global.conf->runmode == RUNMODE_DAEMON &&
263              global.listen_socket == -1 &&
264              irc_connection_list == NULL ) )
265                b_main_quit();
266}
267
268static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data )
269{
270        g_free( key );
271       
272        return( TRUE );
273}
274
275/* USE WITH CAUTION!
276   Sets pass without checking */
277void irc_setpass (irc_t *irc, const char *pass)
278{
279        g_free (irc->password);
280       
281        if (pass) {
282                irc->password = g_strdup (pass);
283        } else {
284                irc->password = NULL;
285        }
286}
287
288static char *set_eval_password( set_t *set, char *value )
289{
290        irc_t *irc = set->data;
291       
292        if( irc->status & USTATUS_IDENTIFIED && value )
293        {
294                irc_setpass( irc, value );
295                return NULL;
296        }
297        else
298        {
299                return SET_INVALID;
300        }
301}
302
303static char **irc_splitlines( char *buffer );
304
305void irc_process( irc_t *irc )
306{
307        char **lines, *temp, **cmd;
308        int i;
309
310        if( irc->readbuffer != NULL )
311        {
312                lines = irc_splitlines( irc->readbuffer );
313               
314                for( i = 0; *lines[i] != '\0'; i ++ )
315                {
316                        char *conv = NULL;
317                       
318                        /* [WvG] If the last line isn't empty, it's an incomplete line and we
319                           should wait for the rest to come in before processing it. */
320                        if( lines[i+1] == NULL )
321                        {
322                                temp = g_strdup( lines[i] );
323                                g_free( irc->readbuffer );
324                                irc->readbuffer = temp;
325                                i ++;
326                                break;
327                        }
328                       
329                        if( irc->iconv != (GIConv) -1 )
330                        {
331                                gsize bytes_read, bytes_written;
332                               
333                                conv = g_convert_with_iconv( lines[i], -1, irc->iconv,
334                                                             &bytes_read, &bytes_written, NULL );
335                               
336                                if( conv == NULL || bytes_read != strlen( lines[i] ) )
337                                {
338                                        /* GLib can do strange things if things are not in the expected charset,
339                                           so let's be a little bit paranoid here: */
340                                        if( irc->status & USTATUS_LOGGED_IN )
341                                        {
342                                                irc_usermsg( irc, "Error: Charset mismatch detected. The charset "
343                                                                  "setting is currently set to %s, so please make "
344                                                                  "sure your IRC client will send and accept text in "
345                                                                  "that charset, or tell BitlBee which charset to "
346                                                                  "expect by changing the charset setting. See "
347                                                                  "`help set charset' for more information. Your "
348                                                                  "message was ignored.",
349                                                                  set_getstr( &irc->b->set, "charset" ) );
350                                               
351                                                g_free( conv );
352                                                conv = NULL;
353                                        }
354                                        else
355                                        {
356                                                irc_write( irc, ":%s NOTICE AUTH :%s", irc->root->host,
357                                                           "Warning: invalid characters received at login time." );
358                                               
359                                                conv = g_strdup( lines[i] );
360                                                for( temp = conv; *temp; temp ++ )
361                                                        if( *temp & 0x80 )
362                                                                *temp = '?';
363                                        }
364                                }
365                                lines[i] = conv;
366                        }
367                       
368                        if( lines[i] && ( cmd = irc_parse_line( lines[i] ) ) )
369                        {
370                                irc_exec( irc, cmd );
371                                g_free( cmd );
372                        }
373                       
374                        g_free( conv );
375                       
376                        /* Shouldn't really happen, but just in case... */
377                        if( !g_slist_find( irc_connection_list, irc ) )
378                        {
379                                g_free( lines );
380                                return;
381                        }
382                }
383               
384                if( lines[i] != NULL )
385                {
386                        g_free( irc->readbuffer );
387                        irc->readbuffer = NULL;
388                }
389               
390                g_free( lines );
391        }
392}
393
394/* Splits a long string into separate lines. The array is NULL-terminated
395   and, unless the string contains an incomplete line at the end, ends with
396   an empty string. Could use g_strsplit() but this one does it in-place.
397   (So yes, it's destructive.) */
398static char **irc_splitlines( char *buffer )
399{
400        int i, j, n = 3;
401        char **lines;
402
403        /* Allocate n+1 elements. */
404        lines = g_new( char *, n + 1 );
405       
406        lines[0] = buffer;
407       
408        /* Split the buffer in several strings, and accept any kind of line endings,
409         * knowing that ERC on Windows may send something interesting like \r\r\n,
410         * and surely there must be clients that think just \n is enough... */
411        for( i = 0, j = 0; buffer[i] != '\0'; i ++ )
412        {
413                if( buffer[i] == '\r' || buffer[i] == '\n' )
414                {
415                        while( buffer[i] == '\r' || buffer[i] == '\n' )
416                                buffer[i++] = '\0';
417                       
418                        lines[++j] = buffer + i;
419                       
420                        if( j >= n )
421                        {
422                                n *= 2;
423                                lines = g_renew( char *, lines, n + 1 );
424                        }
425
426                        if( buffer[i] == '\0' )
427                                break;
428                }
429        }
430       
431        /* NULL terminate our list. */ 
432        lines[++j] = NULL;
433       
434        return lines;
435}
436
437/* Split an IRC-style line into little parts/arguments. */
438char **irc_parse_line( char *line )
439{
440        int i, j;
441        char **cmd;
442       
443        /* Move the line pointer to the start of the command, skipping spaces and the optional prefix. */
444        if( line[0] == ':' )
445        {
446                for( i = 0; line[i] && line[i] != ' '; i ++ );
447                line = line + i;
448        }
449        for( i = 0; line[i] == ' '; i ++ );
450        line = line + i;
451       
452        /* If we're already at the end of the line, return. If not, we're going to need at least one element. */
453        if( line[0] == '\0')
454                return NULL;
455       
456        /* Count the number of char **cmd elements we're going to need. */
457        j = 1;
458        for( i = 0; line[i] != '\0'; i ++ )
459        {
460                if( line[i] == ' ' )
461                {
462                        j ++;
463                       
464                        if( line[i+1] == ':' )
465                                break;
466                }
467        }       
468
469        /* Allocate the space we need. */
470        cmd = g_new( char *, j + 1 );
471        cmd[j] = NULL;
472       
473        /* Do the actual line splitting, format is:
474         * Input: "PRIVMSG #bitlbee :foo bar"
475         * Output: cmd[0]=="PRIVMSG", cmd[1]=="#bitlbee", cmd[2]=="foo bar", cmd[3]==NULL
476         */
477
478        cmd[0] = line;
479        for( i = 0, j = 0; line[i] != '\0'; i ++ )
480        {
481                if( line[i] == ' ' )
482                {
483                        line[i] = '\0';
484                        cmd[++j] = line + i + 1;
485                       
486                        if( line[i+1] == ':' )
487                        {
488                                cmd[j] ++;
489                                break;
490                        }
491                }
492        }
493       
494        return cmd;
495}
496
497/* Converts such an array back into a command string. Mainly used for the IPC code right now. */
498char *irc_build_line( char **cmd )
499{
500        int i, len;
501        char *s;
502       
503        if( cmd[0] == NULL )
504                return NULL;
505       
506        len = 1;
507        for( i = 0; cmd[i]; i ++ )
508                len += strlen( cmd[i] ) + 1;
509       
510        if( strchr( cmd[i-1], ' ' ) != NULL )
511                len ++;
512       
513        s = g_new0( char, len + 1 );
514        for( i = 0; cmd[i]; i ++ )
515        {
516                if( cmd[i+1] == NULL && strchr( cmd[i], ' ' ) != NULL )
517                        strcat( s, ":" );
518               
519                strcat( s, cmd[i] );
520               
521                if( cmd[i+1] )
522                        strcat( s, " " );
523        }
524        strcat( s, "\r\n" );
525       
526        return s;
527}
528
529void irc_write( irc_t *irc, char *format, ... ) 
530{
531        va_list params;
532
533        va_start( params, format );
534        irc_vawrite( irc, format, params );     
535        va_end( params );
536
537        return;
538}
539
540void irc_write_all( int now, char *format, ... )
541{
542        va_list params;
543        GSList *temp;   
544       
545        va_start( params, format );
546       
547        temp = irc_connection_list;
548        while( temp != NULL )
549        {
550                irc_t *irc = temp->data;
551               
552                if( now )
553                {
554                        g_free( irc->sendbuffer );
555                        irc->sendbuffer = g_strdup( "\r\n" );
556                }
557                irc_vawrite( temp->data, format, params );
558                if( now )
559                {
560                        bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE );
561                }
562                temp = temp->next;
563        }
564       
565        va_end( params );
566        return;
567} 
568
569void irc_vawrite( irc_t *irc, char *format, va_list params )
570{
571        int size;
572        char line[IRC_MAX_LINE+1];
573               
574        /* Don't try to write anything new anymore when shutting down. */
575        if( irc->status & USTATUS_SHUTDOWN )
576                return;
577       
578        memset( line, 0, sizeof( line ) );
579        g_vsnprintf( line, IRC_MAX_LINE - 2, format, params );
580        strip_newlines( line );
581       
582        if( irc->oconv != (GIConv) -1 )
583        {
584                gsize bytes_read, bytes_written;
585                char *conv;
586               
587                conv = g_convert_with_iconv( line, -1, irc->oconv,
588                                             &bytes_read, &bytes_written, NULL );
589
590                if( bytes_read == strlen( line ) )
591                        strncpy( line, conv, IRC_MAX_LINE - 2 );
592               
593                g_free( conv );
594        }
595        g_strlcat( line, "\r\n", IRC_MAX_LINE + 1 );
596       
597        if( irc->sendbuffer != NULL )
598        {
599                size = strlen( irc->sendbuffer ) + strlen( line );
600                irc->sendbuffer = g_renew ( char, irc->sendbuffer, size + 1 );
601                strcpy( ( irc->sendbuffer + strlen( irc->sendbuffer ) ), line );
602        }
603        else
604        {
605                irc->sendbuffer = g_strdup(line);
606        }
607       
608        if( irc->w_watch_source_id == 0 )
609        {
610                /* If the buffer is empty we can probably write, so call the write event handler
611                   immediately. If it returns TRUE, it should be called again, so add the event to
612                   the queue. If it's FALSE, we emptied the buffer and saved ourselves some work
613                   in the event queue. */
614                /* Really can't be done as long as the code doesn't do error checking very well:
615                if( bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE ) ) */
616               
617                /* So just always do it via the event handler. */
618                irc->w_watch_source_id = b_input_add( irc->fd, B_EV_IO_WRITE, bitlbee_io_current_client_write, irc );
619        }
620       
621        return;
622}
623
624/* Flush sendbuffer if you can. If it fails, fail silently and let some
625   I/O event handler clean up. */
626void irc_flush( irc_t *irc )
627{
628        ssize_t n;
629        size_t len;
630       
631        if( irc->sendbuffer == NULL )
632                return;
633       
634        len = strlen( irc->sendbuffer );
635        if( ( n = send( irc->fd, irc->sendbuffer, len, 0 ) ) == len )
636        {
637                g_free( irc->sendbuffer );
638                irc->sendbuffer = NULL;
639               
640                b_event_remove( irc->w_watch_source_id );
641                irc->w_watch_source_id = 0;
642        }
643        else if( n > 0 )
644        {
645                char *s = g_strdup( irc->sendbuffer + n );
646                g_free( irc->sendbuffer );
647                irc->sendbuffer = s;
648        }
649        /* Otherwise something went wrong and we don't currently care
650           what the error was. We may or may not succeed later, we
651           were just trying to flush the buffer immediately. */
652}
653
654/* Meant for takeover functionality. Transfer an IRC connection to a different
655   socket. */
656void irc_switch_fd( irc_t *irc, int fd )
657{
658        irc_write( irc, "ERROR :Transferring session to a new connection" );
659        irc_flush( irc ); /* Write it now or forget about it forever. */
660       
661        if( irc->sendbuffer )
662        {
663                b_event_remove( irc->w_watch_source_id );
664                irc->w_watch_source_id = 0;
665                g_free( irc->sendbuffer );
666                irc->sendbuffer = NULL;
667        }
668       
669        b_event_remove( irc->r_watch_source_id );
670        closesocket( irc->fd );
671        irc->fd = fd;
672        irc->r_watch_source_id = b_input_add( irc->fd, B_EV_IO_READ, bitlbee_io_current_client_read, irc );
673}
674
675void irc_sync( irc_t *irc )
676{
677        GSList *l;
678       
679        irc_write( irc, ":%s!%s@%s MODE %s :+%s", irc->user->nick,
680                   irc->user->user, irc->user->host, irc->user->nick,
681                   irc->umode );
682       
683        for( l = irc->channels; l; l = l->next )
684        {
685                irc_channel_t *ic = l->data;
686                if( ic->flags & IRC_CHANNEL_JOINED )
687                        irc_send_join( ic, irc->user );
688        }
689}
690
691void irc_desync( irc_t *irc )
692{
693        GSList *l;
694       
695        for( l = irc->channels; l; l = l->next )
696                irc_channel_del_user( l->data, irc->user, IRC_CDU_KICK,
697                                      "Switching to old session" );
698       
699        irc_write( irc, ":%s!%s@%s MODE %s :-%s", irc->user->nick,
700                   irc->user->user, irc->user->host, irc->user->nick,
701                   irc->umode );
702}
703
704int irc_check_login( irc_t *irc )
705{
706        if( irc->user->user && irc->user->nick )
707        {
708                if( global.conf->authmode == AUTHMODE_CLOSED && !( irc->status & USTATUS_AUTHORIZED ) )
709                {
710                        irc_send_num( irc, 464, ":This server is password-protected." );
711                        return 0;
712                }
713                else
714                {
715                        irc_channel_t *ic;
716                        irc_user_t *iu = irc->user;
717                       
718                        irc->user = irc_user_new( irc, iu->nick );
719                        irc->user->user = iu->user;
720                        irc->user->host = iu->host;
721                        irc->user->fullname = iu->fullname;
722                        irc->user->f = &irc_user_self_funcs;
723                        g_free( iu->nick );
724                        g_free( iu );
725                       
726                        if( global.conf->runmode == RUNMODE_FORKDAEMON || global.conf->runmode == RUNMODE_DAEMON )
727                                ipc_to_master_str( "CLIENT %s %s :%s\r\n", irc->user->host, irc->user->nick, irc->user->fullname );
728                       
729                        irc->status |= USTATUS_LOGGED_IN;
730                       
731                        irc_send_login( irc );
732                       
733                        irc->umode[0] = '\0';
734                        irc_umode_set( irc, "+" UMODE, TRUE );
735                       
736                        ic = irc->default_channel = irc_channel_new( irc, ROOT_CHAN );
737                        irc_channel_set_topic( ic, CONTROL_TOPIC, irc->root );
738                        set_setstr( &ic->set, "auto_join", "true" );
739                        irc_channel_auto_joins( irc, NULL );
740                       
741                        irc->root->last_channel = irc->default_channel;
742                       
743                        irc_usermsg( irc,
744                                     "Welcome to the BitlBee gateway!\n\n"
745                                     "If you've never used BitlBee before, please do read the help "
746                                     "information using the \x02help\x02 command. Lots of FAQs are "
747                                     "answered there.\n"
748                                     "If you already have an account on this server, just use the "
749                                     "\x02identify\x02 command to identify yourself." );
750                       
751                        /* This is for bug #209 (use PASS to identify to NickServ). */
752                        if( irc->password != NULL )
753                        {
754                                char *send_cmd[] = { "identify", g_strdup( irc->password ), NULL };
755                               
756                                irc_setpass( irc, NULL );
757                                root_command( irc, send_cmd );
758                                g_free( send_cmd[1] );
759                        }
760                       
761                        return 1;
762                }
763        }
764        else
765        {
766                /* More information needed. */
767                return 0;
768        }
769}
770
771/* TODO: This is a mess, but this function is a bit too complicated to be
772   converted to something more generic. */
773void irc_umode_set( irc_t *irc, const char *s, gboolean allow_priv )
774{
775        /* allow_priv: Set to 0 if s contains user input, 1 if you want
776           to set a "privileged" mode (+o, +R, etc). */
777        char m[128], st = 1;
778        const char *t;
779        int i;
780        char changes[512], *p, st2 = 2;
781        char badflag = 0;
782       
783        memset( m, 0, sizeof( m ) );
784       
785        for( t = irc->umode; *t; t ++ )
786                if( *t < sizeof( m ) )
787                        m[(int)*t] = 1;
788       
789        p = changes;
790        for( t = s; *t; t ++ )
791        {
792                if( *t == '+' || *t == '-' )
793                        st = *t == '+';
794                else if( ( st == 0 && ( !strchr( UMODES_KEEP, *t ) || allow_priv ) ) ||
795                         ( st == 1 && strchr( UMODES, *t ) ) ||
796                         ( st == 1 && allow_priv && strchr( UMODES_PRIV, *t ) ) )
797                {
798                        if( m[(int)*t] != st)
799                        {
800                                if( st != st2 )
801                                        st2 = st, *p++ = st ? '+' : '-';
802                                *p++ = *t;
803                        }
804                        m[(int)*t] = st;
805                }
806                else
807                        badflag = 1;
808        }
809        *p = '\0';
810       
811        memset( irc->umode, 0, sizeof( irc->umode ) );
812       
813        for( i = 'A'; i <= 'z' && strlen( irc->umode ) < ( sizeof( irc->umode ) - 1 ); i ++ )
814                if( m[i] )
815                        irc->umode[strlen(irc->umode)] = i;
816       
817        if( badflag )
818                irc_send_num( irc, 501, ":Unknown MODE flag" );
819        if( *changes )
820                irc_write( irc, ":%s!%s@%s MODE %s :%s", irc->user->nick,
821                           irc->user->user, irc->user->host, irc->user->nick,
822                           changes );
823}
824
825/* Returns 0 if everything seems to be okay, a number >0 when there was a
826   timeout. The number returned is the number of seconds we received no
827   pongs from the user. When not connected yet, we don't ping but drop the
828   connection when the user fails to connect in IRC_LOGIN_TIMEOUT secs. */
829static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond )
830{
831        irc_t *irc = _irc;
832        int rv = 0;
833       
834        if( !( irc->status & USTATUS_LOGGED_IN ) )
835        {
836                if( gettime() > ( irc->last_pong + IRC_LOGIN_TIMEOUT ) )
837                        rv = gettime() - irc->last_pong;
838        }
839        else
840        {
841                if( ( gettime() > ( irc->last_pong + global.conf->ping_interval ) ) && !irc->pinging )
842                {
843                        irc_write( irc, "PING :%s", IRC_PING_STRING );
844                        irc->pinging = 1;
845                }
846                else if( gettime() > ( irc->last_pong + global.conf->ping_timeout ) )
847                {
848                        rv = gettime() - irc->last_pong;
849                }
850        }
851       
852        if( rv > 0 )
853        {
854                irc_abort( irc, 0, "Ping Timeout: %d seconds", rv );
855                return FALSE;
856        }
857       
858        return TRUE;
859}
860
861static char *set_eval_charset( set_t *set, char *value )
862{
863        irc_t *irc = (irc_t*) set->data;
864        char *test;
865        gsize test_bytes = 0;
866        GIConv ic, oc;
867
868        if( g_strcasecmp( value, "none" ) == 0 )
869                value = g_strdup( "utf-8" );
870
871        if( ( oc = g_iconv_open( value, "utf-8" ) ) == (GIConv) -1 )
872        {
873                return NULL;
874        }
875       
876        /* Do a test iconv to see if the user picked an IRC-compatible
877           charset (for example utf-16 goes *horribly* wrong). */
878        if( ( test = g_convert_with_iconv( " ", 1, oc, NULL, &test_bytes, NULL ) ) == NULL ||
879            test_bytes > 1 )
880        {
881                g_free( test );
882                g_iconv_close( oc );
883                irc_usermsg( irc, "Unsupported character set: The IRC protocol "
884                                  "only supports 8-bit character sets." );
885                return NULL;
886        }
887        g_free( test );
888       
889        if( ( ic = g_iconv_open( "utf-8", value ) ) == (GIConv) -1 )
890        {
891                g_iconv_close( oc );
892                return NULL;
893        }
894       
895        if( irc->iconv != (GIConv) -1 )
896                g_iconv_close( irc->iconv );
897        if( irc->oconv != (GIConv) -1 )
898                g_iconv_close( irc->oconv );
899       
900        irc->iconv = ic;
901        irc->oconv = oc;
902
903        return value;
904}
905
906/* Mostly meant for upgrades. If one of these is set to the non-default,
907   set show_users of all channels to something with the same effect. */
908static char *set_eval_bw_compat( set_t *set, char *value )
909{
910        irc_t *irc = set->data;
911        char *val;
912        GSList *l;
913       
914        irc_usermsg( irc, "Setting `%s' is obsolete, use the `show_users' "
915                     "channel setting instead.", set->key );
916       
917        if( strcmp( set->key, "away_devoice" ) == 0 && !bool2int( value ) )
918                val = "online,away";
919        else if( strcmp( set->key, "show_offline" ) == 0 && bool2int( value ) )
920                val = "online@,away+,offline";
921        else
922                val = "online+,away";
923       
924        for( l = irc->channels; l; l = l->next )
925        {
926                irc_channel_t *ic = l->data;
927                /* No need to check channel type, if the setting doesn't exist it
928                   will just be ignored. */
929                set_setstr( &ic->set, "show_users", val );
930        }
931       
932        return SET_INVALID;
933}
Note: See TracBrowser for help on using the repository browser.