source: irc.c @ 07ff8a2

Last change on this file since 07ff8a2 was fc0cf92, checked in by Wilmer van der Gaast <wilmer@…>, at 2008-01-13T00:15:12Z

Different handling of charset mismatches before login time. Ignoring a
USER command because of encoding issues isn't too great, so let's simply
replace them. The information isn't really used anywhere anyway.

  • Property mode set to 100644
File size: 31.4 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 big hairy IRCd part of the project                               */
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#define BITLBEE_CORE
27#include "bitlbee.h"
28#include "crypting.h"
29#include "ipc.h"
30
31static gboolean irc_userping( gpointer _irc, int fd, b_input_condition cond );
32
33GSList *irc_connection_list = NULL;
34
35static char *passchange( set_t *set, char *value )
36{
37        irc_t *irc = set->data;
38       
39        irc_setpass( irc, value );
40        irc_usermsg( irc, "Password successfully changed" );
41        return NULL;
42}
43
44irc_t *irc_new( int fd )
45{
46        irc_t *irc;
47        struct sockaddr_storage sock;
48        socklen_t socklen = sizeof( sock );
49       
50        irc = g_new0( irc_t, 1 );
51       
52        irc->fd = fd;
53        sock_make_nonblocking( irc->fd );
54       
55        irc->r_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_READ, bitlbee_io_current_client_read, irc );
56       
57        irc->status = USTATUS_OFFLINE;
58        irc->last_pong = gettime();
59       
60        irc->userhash = g_hash_table_new( g_str_hash, g_str_equal );
61        irc->watches = g_hash_table_new( g_str_hash, g_str_equal );
62       
63        strcpy( irc->umode, UMODE );
64        irc->mynick = g_strdup( ROOT_NICK );
65        irc->channel = g_strdup( ROOT_CHAN );
66       
67        if( global.conf->hostname )
68        {
69                irc->myhost = g_strdup( global.conf->hostname );
70        }
71        else if( getsockname( irc->fd, (struct sockaddr*) &sock, &socklen ) == 0 ) 
72        {
73                char buf[NI_MAXHOST+1];
74
75                if( getnameinfo( (struct sockaddr *) &sock, socklen, buf,
76                                 NI_MAXHOST, NULL, -1, 0 ) == 0 )
77                {
78                        irc->myhost = g_strdup( ipv6_unwrap( buf ) );
79                }
80        }
81       
82        if( getpeername( irc->fd, (struct sockaddr*) &sock, &socklen ) == 0 )
83        {
84                char buf[NI_MAXHOST+1];
85
86                if( getnameinfo( (struct sockaddr *)&sock, socklen, buf,
87                                 NI_MAXHOST, NULL, -1, 0 ) == 0 )
88                {
89                        irc->host = g_strdup( ipv6_unwrap( buf ) );
90                }
91        }
92       
93        if( irc->host == NULL )
94                irc->host = g_strdup( "localhost.localdomain" );
95        if( irc->myhost == NULL )
96                irc->myhost = g_strdup( "localhost.localdomain" );
97       
98        if( global.conf->ping_interval > 0 && global.conf->ping_timeout > 0 )
99                irc->ping_source_id = b_timeout_add( global.conf->ping_interval * 1000, irc_userping, irc );
100       
101        irc_write( irc, ":%s NOTICE AUTH :%s", irc->myhost, "BitlBee-IRCd initialized, please go on" );
102
103        irc_connection_list = g_slist_append( irc_connection_list, irc );
104       
105        set_add( &irc->set, "away_devoice", "true",  set_eval_away_devoice, irc );
106        set_add( &irc->set, "auto_connect", "true", set_eval_bool, irc );
107        set_add( &irc->set, "auto_reconnect", "false", set_eval_bool, irc );
108        set_add( &irc->set, "auto_reconnect_delay", "300", set_eval_int, irc );
109        set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );
110        set_add( &irc->set, "buddy_sendbuffer_delay", "200", set_eval_int, irc );
111        set_add( &irc->set, "charset", "utf-8", set_eval_charset, irc );
112        set_add( &irc->set, "debug", "false", set_eval_bool, irc );
113        set_add( &irc->set, "default_target", "root", NULL, irc );
114        set_add( &irc->set, "display_namechanges", "false", set_eval_bool, irc );
115        set_add( &irc->set, "handle_unknown", "root", NULL, irc );
116        set_add( &irc->set, "lcnicks", "true", set_eval_bool, irc );
117        set_add( &irc->set, "ops", "both", set_eval_ops, irc );
118        set_add( &irc->set, "password", NULL, passchange, irc );
119        set_add( &irc->set, "private", "true", set_eval_bool, irc );
120        set_add( &irc->set, "query_order", "lifo", NULL, irc );
121        set_add( &irc->set, "save_on_quit", "true", set_eval_bool, irc );
122        set_add( &irc->set, "simulate_netsplit", "true", set_eval_bool, irc );
123        set_add( &irc->set, "strip_html", "true", NULL, irc );
124        set_add( &irc->set, "to_char", ": ", set_eval_to_char, irc );
125        set_add( &irc->set, "typing_notice", "false", set_eval_bool, irc );
126       
127        conf_loaddefaults( irc );
128       
129        return( irc );
130}
131
132/* immed=1 makes this function pretty much equal to irc_free(), except that
133   this one will "log". In case the connection is already broken and we
134   shouldn't try to write to it. */
135void irc_abort( irc_t *irc, int immed, char *format, ... )
136{
137        if( format != NULL )
138        {
139                va_list params;
140                char *reason;
141               
142                va_start( params, format );
143                reason = g_strdup_vprintf( format, params );
144                va_end( params );
145               
146                if( !immed )
147                        irc_write( irc, "ERROR :Closing link: %s", reason );
148               
149                ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
150                                   irc->nick ? irc->nick : "(NONE)", irc->host, reason );
151               
152                g_free( reason );
153        }
154        else
155        {
156                if( !immed )
157                        irc_write( irc, "ERROR :Closing link" );
158               
159                ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
160                                   irc->nick ? irc->nick : "(NONE)", irc->host, "No reason given" );
161        }
162       
163        irc->status |= USTATUS_SHUTDOWN;
164        if( irc->sendbuffer && !immed )
165        {
166                /* We won't read from this socket anymore. Instead, we'll connect a timer
167                   to it that should shut down the connection in a second, just in case
168                   bitlbee_.._write doesn't do it first. */
169               
170                b_event_remove( irc->r_watch_source_id );
171                irc->r_watch_source_id = b_timeout_add( 1000, (b_event_handler) irc_free, irc );
172        }
173        else
174        {
175                irc_free( irc );
176        }
177}
178
179static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data )
180{
181        g_free( key );
182       
183        return( TRUE );
184}
185
186/* Because we have no garbage collection, this is quite annoying */
187void irc_free(irc_t * irc)
188{
189        account_t *account;
190        user_t *user, *usertmp;
191        help_t *helpnode, *helpnodetmp;
192       
193        log_message( LOGLVL_INFO, "Destroying connection with fd %d", irc->fd );
194       
195        if( irc->status & USTATUS_IDENTIFIED && set_getbool( &irc->set, "save_on_quit" ) ) 
196                if( storage_save( irc, TRUE ) != STORAGE_OK )
197                        irc_usermsg( irc, "Error while saving settings!" );
198       
199        closesocket( irc->fd );
200       
201        if( irc->ping_source_id > 0 )
202                b_event_remove( irc->ping_source_id );
203        b_event_remove( irc->r_watch_source_id );
204        if( irc->w_watch_source_id > 0 )
205                b_event_remove( irc->w_watch_source_id );
206       
207        irc_connection_list = g_slist_remove( irc_connection_list, irc );
208       
209        for (account = irc->accounts; account; account = account->next) {
210                if (account->ic) {
211                        imc_logout(account->ic, TRUE);
212                } else if (account->reconnect) {
213                        cancel_auto_reconnect(account);
214                }
215        }
216       
217        g_free(irc->sendbuffer);
218        g_free(irc->readbuffer);
219       
220        g_free(irc->nick);
221        g_free(irc->user);
222        g_free(irc->host);
223        g_free(irc->realname);
224        g_free(irc->password);
225       
226        g_free(irc->myhost);
227        g_free(irc->mynick);
228       
229        g_free(irc->channel);
230       
231        while (irc->queries != NULL)
232                query_del(irc, irc->queries);
233       
234        while (irc->accounts)
235                if (irc->accounts->ic == NULL)
236                        account_del(irc, irc->accounts);
237                else
238                        /* Nasty hack, but account_del() doesn't work in this
239                           case and we don't want infinite loops, do we? ;-) */
240                        irc->accounts = irc->accounts->next;
241       
242        while (irc->set)
243                set_del(&irc->set, irc->set->key);
244       
245        if (irc->users != NULL) {
246                user = irc->users;
247                while (user != NULL) {
248                        g_free(user->nick);
249                        g_free(user->away);
250                        g_free(user->handle);
251                        if(user->user!=user->nick) g_free(user->user);
252                        if(user->host!=user->nick) g_free(user->host);
253                        if(user->realname!=user->nick) g_free(user->realname);
254                        b_event_remove(user->sendbuf_timer);
255                                       
256                        usertmp = user;
257                        user = user->next;
258                        g_free(usertmp);
259                }
260        }
261       
262        g_hash_table_foreach_remove(irc->userhash, irc_free_hashkey, NULL);
263        g_hash_table_destroy(irc->userhash);
264       
265        g_hash_table_foreach_remove(irc->watches, irc_free_hashkey, NULL);
266        g_hash_table_destroy(irc->watches);
267       
268        if (irc->help != NULL) {
269                helpnode = irc->help;
270                while (helpnode != NULL) {
271                        g_free(helpnode->string);
272                       
273                        helpnodetmp = helpnode;
274                        helpnode = helpnode->next;
275                        g_free(helpnodetmp);
276                }
277        }
278        g_free(irc);
279       
280        if( global.conf->runmode == RUNMODE_INETD || global.conf->runmode == RUNMODE_FORKDAEMON )
281                b_main_quit();
282}
283
284/* USE WITH CAUTION!
285   Sets pass without checking */
286void irc_setpass (irc_t *irc, const char *pass) 
287{
288        g_free (irc->password);
289       
290        if (pass) {
291                irc->password = g_strdup (pass);
292        } else {
293                irc->password = NULL;
294        }
295}
296
297void irc_process( irc_t *irc )
298{
299        char **lines, *temp, **cmd, *cs;
300        int i;
301
302        if( irc->readbuffer != NULL )
303        {
304                lines = irc_tokenize( irc->readbuffer );
305               
306                for( i = 0; *lines[i] != '\0'; i ++ )
307                {
308                        char conv[IRC_MAX_LINE+1];
309                       
310                        /* [WvG] Because irc_tokenize splits at every newline, the lines[] list
311                            should end with an empty string. This is why this actually works.
312                            Took me a while to figure out, Maurits. :-P */
313                        if( lines[i+1] == NULL )
314                        {
315                                temp = g_strdup( lines[i] );
316                                g_free( irc->readbuffer );
317                                irc->readbuffer = temp;
318                                i ++;
319                                break;
320                        }
321                       
322                        if( ( cs = set_getstr( &irc->set, "charset" ) ) )
323                        {
324                                conv[IRC_MAX_LINE] = 0;
325                                if( do_iconv( cs, "UTF-8", lines[i], conv, 0, IRC_MAX_LINE - 2 ) == -1 )
326                                {
327                                        /* GLib can do strange things if things are not in the expected charset,
328                                           so let's be a little bit paranoid here: */
329                                        if( irc->status & USTATUS_LOGGED_IN )
330                                        {
331                                                irc_usermsg( irc, "Error: Charset mismatch detected. The charset "
332                                                                  "setting is currently set to %s, so please make "
333                                                                  "sure your IRC client will send and accept text in "
334                                                                  "that charset, or tell BitlBee which charset to "
335                                                                  "expect by changing the charset setting. See "
336                                                                  "`help set charset' for more information. Your "
337                                                                  "message was ignored.", cs );
338                                                *conv = 0;
339                                        }
340                                        else
341                                        {
342                                                irc_write( irc, ":%s NOTICE AUTH :%s", irc->myhost,
343                                                           "Warning: invalid (non-UTF8) characters received at login time." );
344                                               
345                                                strncpy( conv, lines[i], IRC_MAX_LINE );
346                                                for( temp = conv; *temp; temp ++ )
347                                                        if( *temp & 0x80 )
348                                                                *temp = '?';
349                                        }
350                                }
351                                lines[i] = conv;
352                        }
353                       
354                        if( ( cmd = irc_parse_line( lines[i] ) ) == NULL )
355                                continue;
356                        irc_exec( irc, cmd );
357                       
358                        g_free( cmd );
359                       
360                        /* Shouldn't really happen, but just in case... */
361                        if( !g_slist_find( irc_connection_list, irc ) )
362                        {
363                                g_free( lines );
364                                return;
365                        }
366                }
367               
368                if( lines[i] != NULL )
369                {
370                        g_free( irc->readbuffer );
371                        irc->readbuffer = NULL;
372                }
373               
374                g_free( lines );
375        }
376}
377
378/* Splits a long string into separate lines. The array is NULL-terminated and, unless the string
379   contains an incomplete line at the end, ends with an empty string. */
380char **irc_tokenize( char *buffer )
381{
382        int i, j;
383        char **lines;
384
385        /* Count the number of elements we're gonna need. */
386        for( i = 0, j = 1; buffer[i] != '\0'; i ++ )
387        {
388                if( buffer[i] == '\n' )
389                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
390                                j ++;
391        }
392       
393        /* Allocate j+1 elements. */
394        lines = g_new( char *, j + 1 );
395       
396        /* NULL terminate our list. */ 
397        lines[j] = NULL;
398       
399        lines[0] = buffer;
400       
401        /* Split the buffer in several strings, using \r\n as our seperator, where \r is optional.
402         * Although this is not in the RFC, some braindead ircds (newnet's) use this, so some clients might too.
403         */
404        for( i = 0, j = 0; buffer[i] != '\0'; i ++)
405        {
406                if( buffer[i] == '\n' )
407                {
408                        buffer[i] = '\0';
409                       
410                        if( i > 0 && buffer[i-1] == '\r' )
411                                buffer[i-1] = '\0';
412                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
413                                lines[++j] = buffer + i + 1;
414                }
415        }
416       
417        return( lines );
418}
419
420/* Split an IRC-style line into little parts/arguments. */
421char **irc_parse_line( char *line )
422{
423        int i, j;
424        char **cmd;
425       
426        /* Move the line pointer to the start of the command, skipping spaces and the optional prefix. */
427        if( line[0] == ':' )
428        {
429                for( i = 0; line[i] != ' '; i ++ );
430                line = line + i;
431        }
432        for( i = 0; line[i] == ' '; i ++ );
433        line = line + i;
434       
435        /* If we're already at the end of the line, return. If not, we're going to need at least one element. */
436        if( line[0] == '\0')
437                return NULL;
438       
439        /* Count the number of char **cmd elements we're going to need. */
440        j = 1;
441        for( i = 0; line[i] != '\0'; i ++ )
442        {
443                if( line[i] == ' ' )
444                {
445                        j ++;
446                       
447                        if( line[i+1] == ':' )
448                                break;
449                }
450        }       
451
452        /* Allocate the space we need. */
453        cmd = g_new( char *, j + 1 );
454        cmd[j] = NULL;
455       
456        /* Do the actual line splitting, format is:
457         * Input: "PRIVMSG #bitlbee :foo bar"
458         * Output: cmd[0]=="PRIVMSG", cmd[1]=="#bitlbee", cmd[2]=="foo bar", cmd[3]==NULL
459         */
460
461        cmd[0] = line;
462        for( i = 0, j = 0; line[i] != '\0'; i ++ )
463        {
464                if( line[i] == ' ' )
465                {
466                        line[i] = '\0';
467                        cmd[++j] = line + i + 1;
468                       
469                        if( line[i+1] == ':' )
470                        {
471                                cmd[j] ++;
472                                break;
473                        }
474                }
475        }
476       
477        return cmd;
478}
479
480/* Converts such an array back into a command string. Mainly used for the IPC code right now. */
481char *irc_build_line( char **cmd )
482{
483        int i, len;
484        char *s;
485       
486        if( cmd[0] == NULL )
487                return NULL;
488       
489        len = 1;
490        for( i = 0; cmd[i]; i ++ )
491                len += strlen( cmd[i] ) + 1;
492       
493        if( strchr( cmd[i-1], ' ' ) != NULL )
494                len ++;
495       
496        s = g_new0( char, len + 1 );
497        for( i = 0; cmd[i]; i ++ )
498        {
499                if( cmd[i+1] == NULL && strchr( cmd[i], ' ' ) != NULL )
500                        strcat( s, ":" );
501               
502                strcat( s, cmd[i] );
503               
504                if( cmd[i+1] )
505                        strcat( s, " " );
506        }
507        strcat( s, "\r\n" );
508       
509        return s;
510}
511
512void irc_reply( irc_t *irc, int code, char *format, ... )
513{
514        char text[IRC_MAX_LINE];
515        va_list params;
516       
517        va_start( params, format );
518        g_vsnprintf( text, IRC_MAX_LINE, format, params );
519        va_end( params );
520        irc_write( irc, ":%s %03d %s %s", irc->myhost, code, irc->nick?irc->nick:"*", text );
521       
522        return;
523}
524
525int irc_usermsg( irc_t *irc, char *format, ... )
526{
527        char text[1024];
528        va_list params;
529        char is_private = 0;
530        user_t *u;
531       
532        u = user_find( irc, irc->mynick );
533        is_private = u->is_private;
534       
535        va_start( params, format );
536        g_vsnprintf( text, sizeof( text ), format, params );
537        va_end( params );
538       
539        return( irc_msgfrom( irc, u->nick, text ) );
540}
541
542void irc_write( irc_t *irc, char *format, ... ) 
543{
544        va_list params;
545
546        va_start( params, format );
547        irc_vawrite( irc, format, params );     
548        va_end( params );
549
550        return;
551
552}
553
554void irc_vawrite( irc_t *irc, char *format, va_list params )
555{
556        int size;
557        char line[IRC_MAX_LINE+1], *cs;
558               
559        /* Don't try to write anything new anymore when shutting down. */
560        if( irc->status & USTATUS_SHUTDOWN )
561                return;
562       
563        line[IRC_MAX_LINE] = 0;
564        g_vsnprintf( line, IRC_MAX_LINE - 2, format, params );
565       
566        strip_newlines( line );
567        if( ( cs = set_getstr( &irc->set, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
568        {
569                char conv[IRC_MAX_LINE+1];
570               
571                conv[IRC_MAX_LINE] = 0;
572                if( do_iconv( "UTF-8", cs, line, conv, 0, IRC_MAX_LINE - 2 ) != -1 )
573                        strcpy( line, conv );
574        }
575        strcat( line, "\r\n" );
576       
577        if( irc->sendbuffer != NULL )
578        {
579                size = strlen( irc->sendbuffer ) + strlen( line );
580                irc->sendbuffer = g_renew ( char, irc->sendbuffer, size + 1 );
581                strcpy( ( irc->sendbuffer + strlen( irc->sendbuffer ) ), line );
582        }
583        else
584        {
585                irc->sendbuffer = g_strdup(line);
586        }
587       
588        if( irc->w_watch_source_id == 0 )
589        {
590                /* If the buffer is empty we can probably write, so call the write event handler
591                   immediately. If it returns TRUE, it should be called again, so add the event to
592                   the queue. If it's FALSE, we emptied the buffer and saved ourselves some work
593                   in the event queue. */
594                /* Really can't be done as long as the code doesn't do error checking very well:
595                if( bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE ) ) */
596               
597                /* So just always do it via the event handler. */
598                irc->w_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_WRITE, bitlbee_io_current_client_write, irc );
599        }
600       
601        return;
602}
603
604void irc_write_all( int now, char *format, ... )
605{
606        va_list params;
607        GSList *temp;   
608       
609        va_start( params, format );
610       
611        temp = irc_connection_list;
612        while( temp != NULL )
613        {
614                irc_t *irc = temp->data;
615               
616                if( now )
617                {
618                        g_free( irc->sendbuffer );
619                        irc->sendbuffer = g_strdup( "\r\n" );
620                }
621                irc_vawrite( temp->data, format, params );
622                if( now )
623                {
624                        bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE );
625                }
626                temp = temp->next;
627        }
628       
629        va_end( params );
630        return;
631} 
632
633void irc_names( irc_t *irc, char *channel )
634{
635        user_t *u;
636        char namelist[385] = "";
637        struct groupchat *c = NULL;
638        char *ops = set_getstr( &irc->set, "ops" );
639       
640        /* RFCs say there is no error reply allowed on NAMES, so when the
641           channel is invalid, just give an empty reply. */
642       
643        if( g_strcasecmp( channel, irc->channel ) == 0 )
644        {
645                for( u = irc->users; u; u = u->next ) if( u->online )
646                {
647                        if( strlen( namelist ) + strlen( u->nick ) > sizeof( namelist ) - 4 )
648                        {
649                                irc_reply( irc, 353, "= %s :%s", channel, namelist );
650                                *namelist = 0;
651                        }
652                       
653                        if( u->ic && !u->away && set_getbool( &irc->set, "away_devoice" ) )
654                                strcat( namelist, "+" );
655                        else if( ( strcmp( u->nick, irc->mynick ) == 0 && ( strcmp( ops, "root" ) == 0 || strcmp( ops, "both" ) == 0 ) ) ||
656                                 ( strcmp( u->nick, irc->nick ) == 0 && ( strcmp( ops, "user" ) == 0 || strcmp( ops, "both" ) == 0 ) ) )
657                                strcat( namelist, "@" );
658                       
659                        strcat( namelist, u->nick );
660                        strcat( namelist, " " );
661                }
662        }
663        else if( ( c = irc_chat_by_channel( irc, channel ) ) )
664        {
665                GList *l;
666               
667                /* root and the user aren't in the channel userlist but should
668                   show up in /NAMES, so list them first: */
669                sprintf( namelist, "%s%s %s%s ", strcmp( ops, "root" ) == 0 || strcmp( ops, "both" ) ? "@" : "", irc->mynick,
670                                                 strcmp( ops, "user" ) == 0 || strcmp( ops, "both" ) ? "@" : "", irc->nick );
671               
672                for( l = c->in_room; l; l = l->next ) if( ( u = user_findhandle( c->ic, l->data ) ) )
673                {
674                        if( strlen( namelist ) + strlen( u->nick ) > sizeof( namelist ) - 4 )
675                        {
676                                irc_reply( irc, 353, "= %s :%s", channel, namelist );
677                                *namelist = 0;
678                        }
679                       
680                        strcat( namelist, u->nick );
681                        strcat( namelist, " " );
682                }
683        }
684       
685        if( *namelist )
686                irc_reply( irc, 353, "= %s :%s", channel, namelist );
687       
688        irc_reply( irc, 366, "%s :End of /NAMES list", channel );
689}
690
691int irc_check_login( irc_t *irc )
692{
693        if( irc->user && irc->nick )
694        {
695                if( global.conf->authmode == AUTHMODE_CLOSED && !( irc->status & USTATUS_AUTHORIZED ) )
696                {
697                        irc_reply( irc, 464, ":This server is password-protected." );
698                        return 0;
699                }
700                else
701                {
702                        irc_login( irc );
703                        return 1;
704                }
705        }
706        else
707        {
708                /* More information needed. */
709                return 0;
710        }
711}
712
713void irc_login( irc_t *irc )
714{
715        user_t *u;
716       
717        irc_reply( irc,   1, ":Welcome to the BitlBee gateway, %s", irc->nick );
718        irc_reply( irc,   2, ":Host %s is running BitlBee " BITLBEE_VERSION " " ARCH "/" CPU ".", irc->myhost );
719        irc_reply( irc,   3, ":%s", IRCD_INFO );
720        irc_reply( irc,   4, "%s %s %s %s", irc->myhost, BITLBEE_VERSION, UMODES UMODES_PRIV, CMODES );
721        irc_reply( irc,   5, "PREFIX=(ov)@+ CHANTYPES=#& CHANMODES=,,,%s NICKLEN=%d NETWORK=BitlBee CASEMAPPING=rfc1459 MAXTARGETS=1 WATCH=128 :are supported by this server", CMODES, MAX_NICK_LENGTH - 1 );
722        irc_motd( irc );
723        irc->umode[0] = '\0';
724        irc_umode_set( irc, "+" UMODE, 1 );
725
726        u = user_add( irc, irc->mynick );
727        u->host = g_strdup( irc->myhost );
728        u->realname = g_strdup( ROOT_FN );
729        u->online = 1;
730        u->send_handler = root_command_string;
731        u->is_private = 0; /* [SH] The channel is root's personal playground. */
732        irc_spawn( irc, u );
733       
734        u = user_add( irc, NS_NICK );
735        u->host = g_strdup( irc->myhost );
736        u->realname = g_strdup( ROOT_FN );
737        u->online = 0;
738        u->send_handler = root_command_string;
739        u->is_private = 1; /* [SH] NickServ is not in the channel, so should always /query. */
740       
741        u = user_add( irc, irc->nick );
742        u->user = g_strdup( irc->user );
743        u->host = g_strdup( irc->host );
744        u->realname = g_strdup( irc->realname );
745        u->online = 1;
746        irc_spawn( irc, u );
747       
748        irc_usermsg( irc, "Welcome to the BitlBee gateway!\n\nIf you've never used BitlBee before, please do read the help information using the \x02help\x02 command. Lots of FAQs are answered there." );
749       
750        if( global.conf->runmode == RUNMODE_FORKDAEMON || global.conf->runmode == RUNMODE_DAEMON )
751                ipc_to_master_str( "CLIENT %s %s :%s\r\n", irc->host, irc->nick, irc->realname );
752       
753        irc->status |= USTATUS_LOGGED_IN;
754}
755
756void irc_motd( irc_t *irc )
757{
758        int fd;
759       
760        fd = open( global.conf->motdfile, O_RDONLY );
761        if( fd == -1 )
762        {
763                irc_reply( irc, 422, ":We don't need MOTDs." );
764        }
765        else
766        {
767                char linebuf[80];       /* Max. line length for MOTD's is 79 chars. It's what most IRC networks seem to do. */
768                char *add, max;
769                int len;
770               
771                linebuf[79] = len = 0;
772                max = sizeof( linebuf ) - 1;
773               
774                irc_reply( irc, 375, ":- %s Message Of The Day - ", irc->myhost );
775                while( read( fd, linebuf + len, 1 ) == 1 )
776                {
777                        if( linebuf[len] == '\n' || len == max )
778                        {
779                                linebuf[len] = 0;
780                                irc_reply( irc, 372, ":- %s", linebuf );
781                                len = 0;
782                        }
783                        else if( linebuf[len] == '%' )
784                        {
785                                read( fd, linebuf + len, 1 );
786                                if( linebuf[len] == 'h' )
787                                        add = irc->myhost;
788                                else if( linebuf[len] == 'v' )
789                                        add = BITLBEE_VERSION;
790                                else if( linebuf[len] == 'n' )
791                                        add = irc->nick;
792                                else
793                                        add = "%";
794                               
795                                strncpy( linebuf + len, add, max - len );
796                                while( linebuf[++len] );
797                        }
798                        else if( len < max )
799                        {
800                                len ++;
801                        }
802                }
803                irc_reply( irc, 376, ":End of MOTD" );
804                close( fd );
805        }
806}
807
808void irc_topic( irc_t *irc, char *channel )
809{
810        struct groupchat *c = irc_chat_by_channel( irc, channel );
811       
812        if( c && c->topic )
813                irc_reply( irc, 332, "%s :%s", channel, c->topic );
814        else if( g_strcasecmp( channel, irc->channel ) == 0 )
815                irc_reply( irc, 332, "%s :%s", channel, CONTROL_TOPIC );
816        else
817                irc_reply( irc, 331, "%s :No topic for this channel", channel );
818}
819
820void irc_umode_set( irc_t *irc, char *s, int allow_priv )
821{
822        /* allow_priv: Set to 0 if s contains user input, 1 if you want
823           to set a "privileged" mode (+o, +R, etc). */
824        char m[256], st = 1, *t;
825        int i;
826        char changes[512], *p, st2 = 2;
827        char badflag = 0;
828       
829        memset( m, 0, sizeof( m ) );
830       
831        for( t = irc->umode; *t; t ++ )
832                m[(int)*t] = 1;
833
834        p = changes;
835        for( t = s; *t; t ++ )
836        {
837                if( *t == '+' || *t == '-' )
838                        st = *t == '+';
839                else if( st == 0 || ( strchr( UMODES, *t ) || ( allow_priv && strchr( UMODES_PRIV, *t ) ) ) )
840                {
841                        if( m[(int)*t] != st)
842                        {
843                                if( st != st2 )
844                                        st2 = st, *p++ = st ? '+' : '-';
845                                *p++ = *t;
846                        }
847                        m[(int)*t] = st;
848                }
849                else
850                        badflag = 1;
851        }
852        *p = '\0';
853       
854        memset( irc->umode, 0, sizeof( irc->umode ) );
855       
856        for( i = 0; i < 256 && strlen( irc->umode ) < ( sizeof( irc->umode ) - 1 ); i ++ )
857                if( m[i] )
858                        irc->umode[strlen(irc->umode)] = i;
859       
860        if( badflag )
861                irc_reply( irc, 501, ":Unknown MODE flag" );
862        /* Deliberately no !user@host on the prefix here */
863        if( *changes )
864                irc_write( irc, ":%s MODE %s %s", irc->nick, irc->nick, changes );
865}
866
867void irc_spawn( irc_t *irc, user_t *u )
868{
869        irc_join( irc, u, irc->channel );
870}
871
872void irc_join( irc_t *irc, user_t *u, char *channel )
873{
874        char *nick;
875       
876        if( ( g_strcasecmp( channel, irc->channel ) != 0 ) || user_find( irc, irc->nick ) )
877                irc_write( irc, ":%s!%s@%s JOIN :%s", u->nick, u->user, u->host, channel );
878       
879        if( nick_cmp( u->nick, irc->nick ) == 0 )
880        {
881                irc_write( irc, ":%s MODE %s +%s", irc->myhost, channel, CMODE );
882                irc_names( irc, channel );
883                irc_topic( irc, channel );
884        }
885       
886        nick = g_strdup( u->nick );
887        nick_lc( nick );
888        if( g_hash_table_lookup( irc->watches, nick ) )
889        {
890                irc_reply( irc, 600, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged online" );
891        }
892        g_free( nick );
893}
894
895void irc_part( irc_t *irc, user_t *u, char *channel )
896{
897        irc_write( irc, ":%s!%s@%s PART %s :%s", u->nick, u->user, u->host, channel, "" );
898}
899
900void irc_kick( irc_t *irc, user_t *u, char *channel, user_t *kicker )
901{
902        irc_write( irc, ":%s!%s@%s KICK %s %s :%s", kicker->nick, kicker->user, kicker->host, channel, u->nick, "" );
903}
904
905void irc_kill( irc_t *irc, user_t *u )
906{
907        char *nick, *s;
908        char reason[128];
909       
910        if( u->ic && u->ic->flags & OPT_LOGGING_OUT && set_getbool( &irc->set, "simulate_netsplit" ) )
911        {
912                if( u->ic->acc->server )
913                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
914                                    u->ic->acc->server );
915                else if( ( s = strchr( u->ic->acc->user, '@' ) ) )
916                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
917                                    s + 1 );
918                else
919                        g_snprintf( reason, sizeof( reason ), "%s %s.%s", irc->myhost,
920                                    u->ic->acc->prpl->name, irc->myhost );
921               
922                /* proto_opt might contain garbage after the : */
923                if( ( s = strchr( reason, ':' ) ) )
924                        *s = 0;
925        }
926        else
927        {
928                strcpy( reason, "Leaving..." );
929        }
930       
931        irc_write( irc, ":%s!%s@%s QUIT :%s", u->nick, u->user, u->host, reason );
932       
933        nick = g_strdup( u->nick );
934        nick_lc( nick );
935        if( g_hash_table_lookup( irc->watches, nick ) )
936        {
937                irc_reply( irc, 601, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged offline" );
938        }
939        g_free( nick );
940}
941
942int irc_send( irc_t *irc, char *nick, char *s, int flags )
943{
944        struct groupchat *c = NULL;
945        user_t *u = NULL;
946       
947        if( *nick == '#' || *nick == '&' )
948        {
949                if( !( c = irc_chat_by_channel( irc, nick ) ) )
950                {
951                        irc_reply( irc, 403, "%s :Channel does not exist", nick );
952                        return( 0 );
953                }
954        }
955        else
956        {
957                u = user_find( irc, nick );
958               
959                if( !u )
960                {
961                        if( irc->is_private )
962                                irc_reply( irc, 401, "%s :Nick does not exist", nick );
963                        else
964                                irc_usermsg( irc, "Nick `%s' does not exist!", nick );
965                        return( 0 );
966                }
967        }
968       
969        if( *s == 1 && s[strlen(s)-1] == 1 )
970        {
971                if( g_strncasecmp( s + 1, "ACTION", 6 ) == 0 )
972                {
973                        if( s[7] == ' ' ) s ++;
974                        s += 3;
975                        *(s++) = '/';
976                        *(s++) = 'm';
977                        *(s++) = 'e';
978                        *(s++) = ' ';
979                        s -= 4;
980                        s[strlen(s)-1] = 0;
981                }
982                else if( g_strncasecmp( s + 1, "VERSION", 7 ) == 0 )
983                {
984                        u = user_find( irc, irc->mynick );
985                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", "\001VERSION BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\001" );
986                        return( 1 );
987                }
988                else if( g_strncasecmp( s + 1, "PING", 4 ) == 0 )
989                {
990                        u = user_find( irc, irc->mynick );
991                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", s );
992                        return( 1 );
993                }
994                else if( g_strncasecmp( s + 1, "TYPING", 6 ) == 0 )
995                {
996                        if( u && u->ic && u->ic->acc->prpl->send_typing && strlen( s ) >= 10 )
997                        {
998                                time_t current_typing_notice = time( NULL );
999                               
1000                                if( current_typing_notice - u->last_typing_notice >= 5 )
1001                                {
1002                                        u->ic->acc->prpl->send_typing( u->ic, u->handle, ( s[8] - '0' ) << 8 );
1003                                        u->last_typing_notice = current_typing_notice;
1004                                }
1005                        }
1006                        return( 1 );
1007                }
1008                else
1009                {
1010                        irc_usermsg( irc, "Non-ACTION CTCP's aren't supported" );
1011                        return( 0 );
1012                }
1013        }
1014       
1015        if( u )
1016        {
1017                /* For the next message, we probably do have to send new notices... */
1018                u->last_typing_notice = 0;
1019                u->is_private = irc->is_private;
1020               
1021                if( u->is_private )
1022                {
1023                        if( !u->online )
1024                                irc_reply( irc, 301, "%s :%s", u->nick, "User is offline" );
1025                        else if( u->away )
1026                                irc_reply( irc, 301, "%s :%s", u->nick, u->away );
1027                }
1028               
1029                if( u->send_handler )
1030                {
1031                        u->send_handler( irc, u, s, flags );
1032                        return 1;
1033                }
1034        }
1035        else if( c && c->ic && c->ic->acc && c->ic->acc->prpl )
1036        {
1037                return( imc_chat_msg( c, s, 0 ) );
1038        }
1039       
1040        return( 0 );
1041}
1042
1043static gboolean buddy_send_handler_delayed( gpointer data, gint fd, b_input_condition cond )
1044{
1045        user_t *u = data;
1046       
1047        /* Shouldn't happen, but just to be sure. */
1048        if( u->sendbuf_len < 2 )
1049                return FALSE;
1050       
1051        u->sendbuf[u->sendbuf_len-2] = 0; /* Cut off the last newline */
1052        imc_buddy_msg( u->ic, u->handle, u->sendbuf, u->sendbuf_flags );
1053       
1054        g_free( u->sendbuf );
1055        u->sendbuf = NULL;
1056        u->sendbuf_len = 0;
1057        u->sendbuf_timer = 0;
1058        u->sendbuf_flags = 0;
1059       
1060        return FALSE;
1061}
1062
1063void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags )
1064{
1065        if( !u || !u->ic ) return;
1066       
1067        if( set_getbool( &irc->set, "buddy_sendbuffer" ) && set_getint( &irc->set, "buddy_sendbuffer_delay" ) > 0 )
1068        {
1069                int delay;
1070               
1071                if( u->sendbuf_len > 0 && u->sendbuf_flags != flags)
1072                {
1073                        /* Flush the buffer */
1074                        b_event_remove( u->sendbuf_timer );
1075                        buddy_send_handler_delayed( u, -1, 0 );
1076                }
1077
1078                if( u->sendbuf_len == 0 )
1079                {
1080                        u->sendbuf_len = strlen( msg ) + 2;
1081                        u->sendbuf = g_new( char, u->sendbuf_len );
1082                        u->sendbuf[0] = 0;
1083                        u->sendbuf_flags = flags;
1084                }
1085                else
1086                {
1087                        u->sendbuf_len += strlen( msg ) + 1;
1088                        u->sendbuf = g_renew( char, u->sendbuf, u->sendbuf_len );
1089                }
1090               
1091                strcat( u->sendbuf, msg );
1092                strcat( u->sendbuf, "\n" );
1093               
1094                delay = set_getint( &irc->set, "buddy_sendbuffer_delay" );
1095                if( delay <= 5 )
1096                        delay *= 1000;
1097               
1098                if( u->sendbuf_timer > 0 )
1099                        b_event_remove( u->sendbuf_timer );
1100                u->sendbuf_timer = b_timeout_add( delay, buddy_send_handler_delayed, u );
1101        }
1102        else
1103        {
1104                imc_buddy_msg( u->ic, u->handle, msg, flags );
1105        }
1106}
1107
1108int irc_privmsg( irc_t *irc, user_t *u, char *type, char *to, char *prefix, char *msg )
1109{
1110        char last = 0;
1111        char *s = msg, *line = msg;
1112       
1113        /* The almighty linesplitter .. woohoo!! */
1114        while( !last )
1115        {
1116                if( *s == '\r' && *(s+1) == '\n' )
1117                        *(s++) = 0;
1118                if( *s == '\n' )
1119                {
1120                        last = s[1] == 0;
1121                        *s = 0;
1122                }
1123                else
1124                {
1125                        last = s[0] == 0;
1126                }
1127                if( *s == 0 )
1128                {
1129                        if( g_strncasecmp( line, "/me ", 4 ) == 0 && ( !prefix || !*prefix ) && g_strcasecmp( type, "PRIVMSG" ) == 0 )
1130                        {
1131                                irc_write( irc, ":%s!%s@%s %s %s :\001ACTION %s\001", u->nick, u->user, u->host,
1132                                           type, to, line + 4 );
1133                        }
1134                        else
1135                        {
1136                                irc_write( irc, ":%s!%s@%s %s %s :%s%s", u->nick, u->user, u->host,
1137                                           type, to, prefix ? prefix : "", line );
1138                        }
1139                        line = s + 1;
1140                }
1141                s ++;
1142        }
1143       
1144        return( 1 );
1145}
1146
1147int irc_msgfrom( irc_t *irc, char *nick, char *msg )
1148{
1149        user_t *u = user_find( irc, nick );
1150        static char *prefix = NULL;
1151       
1152        if( !u ) return( 0 );
1153        if( prefix && *prefix ) g_free( prefix );
1154       
1155        if( !u->is_private && nick_cmp( u->nick, irc->mynick ) != 0 )
1156        {
1157                int len = strlen( irc->nick) + 3;
1158                prefix = g_new (char, len );
1159                g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( &irc->set, "to_char" ) );
1160                prefix[len-1] = 0;
1161        }
1162        else
1163        {
1164                prefix = "";
1165        }
1166       
1167        return( irc_privmsg( irc, u, "PRIVMSG", u->is_private ? irc->nick : irc->channel, prefix, msg ) );
1168}
1169
1170int irc_noticefrom( irc_t *irc, char *nick, char *msg )
1171{
1172        user_t *u = user_find( irc, nick );
1173       
1174        if( u )
1175                return( irc_privmsg( irc, u, "NOTICE", irc->nick, "", msg ) );
1176        else
1177                return( 0 );
1178}
1179
1180/* Returns 0 if everything seems to be okay, a number >0 when there was a
1181   timeout. The number returned is the number of seconds we received no
1182   pongs from the user. When not connected yet, we don't ping but drop the
1183   connection when the user fails to connect in IRC_LOGIN_TIMEOUT secs. */
1184static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond )
1185{
1186        irc_t *irc = _irc;
1187        int rv = 0;
1188       
1189        if( !( irc->status & USTATUS_LOGGED_IN ) )
1190        {
1191                if( gettime() > ( irc->last_pong + IRC_LOGIN_TIMEOUT ) )
1192                        rv = gettime() - irc->last_pong;
1193        }
1194        else
1195        {
1196                if( ( gettime() > ( irc->last_pong + global.conf->ping_interval ) ) && !irc->pinging )
1197                {
1198                        irc_write( irc, "PING :%s", IRC_PING_STRING );
1199                        irc->pinging = 1;
1200                }
1201                else if( gettime() > ( irc->last_pong + global.conf->ping_timeout ) )
1202                {
1203                        rv = gettime() - irc->last_pong;
1204                }
1205        }
1206       
1207        if( rv > 0 )
1208        {
1209                irc_abort( irc, 0, "Ping Timeout: %d seconds", rv );
1210                return FALSE;
1211        }
1212       
1213        return TRUE;
1214}
1215
1216struct groupchat *irc_chat_by_channel( irc_t *irc, char *channel )
1217{
1218        struct groupchat *c;
1219        account_t *a;
1220       
1221        /* This finds the connection which has a conversation which belongs to this channel */
1222        for( a = irc->accounts; a; a = a->next )
1223        {
1224                if( a->ic == NULL )
1225                        continue;
1226               
1227                c = a->ic->groupchats;
1228                while( c )
1229                {
1230                        if( c->channel && g_strcasecmp( c->channel, channel ) == 0 )
1231                                return c;
1232                       
1233                        c = c->next;
1234                }
1235        }
1236       
1237        return NULL;
1238}
Note: See TracBrowser for help on using the repository browser.