source: irc.c @ 85e9644

Last change on this file since 85e9644 was 85e9644, checked in by Wilmer van der Gaast <wilmer@…>, at 2006-06-07T13:36:19Z

Merging Jelmer's storage tree (with LDAP support).

  • Property mode set to 100644
File size: 30.3 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 (irc_t *irc, void *set, char *value) 
36{
37        irc_setpass (irc, value);
38        return (NULL);
39}
40
41irc_t *irc_new( int fd )
42{
43        irc_t *irc;
44        struct hostent *peer;
45        unsigned int i;
46        char buf[128];
47#ifdef IPV6
48        struct sockaddr_in6 sock[1];
49#else
50        struct sockaddr_in sock[1];
51#endif
52       
53        irc = g_new0( irc_t, 1 );
54       
55        irc->fd = fd;
56        sock_make_nonblocking( irc->fd );
57       
58        irc->r_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_READ, bitlbee_io_current_client_read, irc );
59       
60        irc->status = USTATUS_OFFLINE;
61        irc->last_pong = gettime();
62       
63        irc->userhash = g_hash_table_new( g_str_hash, g_str_equal );
64        irc->watches = g_hash_table_new( g_str_hash, g_str_equal );
65       
66        strcpy( irc->umode, UMODE );
67        irc->mynick = g_strdup( ROOT_NICK );
68        irc->channel = g_strdup( ROOT_CHAN );
69       
70        i = sizeof( *sock );
71       
72        if( global.conf->hostname )
73                irc->myhost = g_strdup( global.conf->hostname );
74#ifdef IPV6
75        else if( getsockname( irc->fd, (struct sockaddr*) sock, &i ) == 0 && sock->sin6_family == AF_INETx )
76        {
77                if( ( peer = gethostbyaddr( (char*) &sock->sin6_addr, sizeof( sock->sin6_addr ), AF_INETx ) ) )
78                        irc->myhost = g_strdup( peer->h_name );
79                else if( inet_ntop( AF_INETx, &sock->sin6_addr, buf, sizeof( buf ) - 1 ) != NULL )
80                        irc->myhost = g_strdup( ipv6_unwrap( buf ) );
81        }
82#else
83        else if( getsockname( irc->fd, (struct sockaddr*) sock, &i ) == 0 && sock->sin_family == AF_INETx )
84        {
85                if( ( peer = gethostbyaddr( (char*) &sock->sin_addr, sizeof( sock->sin_addr ), AF_INETx ) ) )
86                        irc->myhost = g_strdup( peer->h_name );
87                else if( inet_ntop( AF_INETx, &sock->sin_addr, buf, sizeof( buf ) - 1 ) != NULL )
88                        irc->myhost = g_strdup( buf );
89        }
90#endif
91       
92        i = sizeof( *sock );
93#ifdef IPV6
94        if( getpeername( irc->fd, (struct sockaddr*) sock, &i ) == 0 && sock->sin6_family == AF_INETx )
95        {
96                if( ( peer = gethostbyaddr( (char*) &sock->sin6_addr, sizeof( sock->sin6_addr ), AF_INETx ) ) )
97                        irc->host = g_strdup( peer->h_name );
98                else if( inet_ntop( AF_INETx, &sock->sin6_addr, buf, sizeof( buf ) - 1 ) != NULL )
99                        irc->host = g_strdup( ipv6_unwrap( buf ) );
100        }
101#else
102        if( getpeername( irc->fd, (struct sockaddr*) sock, &i ) == 0 && sock->sin_family == AF_INETx )
103        {
104                if( ( peer = gethostbyaddr( (char*) &sock->sin_addr, sizeof( sock->sin_addr ), AF_INETx ) ) )
105                        irc->host = g_strdup( peer->h_name );
106                else if( inet_ntop( AF_INETx, &sock->sin_addr, buf, sizeof( buf ) - 1 ) != NULL )
107                        irc->host = g_strdup( buf );
108        }
109#endif
110       
111        /* Rare, but possible. */
112        if( !irc->host ) irc->host = g_strdup( "localhost." );
113        if( !irc->myhost ) irc->myhost = g_strdup( "localhost." );
114
115        if( global.conf->ping_interval > 0 && global.conf->ping_timeout > 0 )
116                irc->ping_source_id = b_timeout_add( global.conf->ping_interval * 1000, irc_userping, irc );
117       
118        irc_write( irc, ":%s NOTICE AUTH :%s", irc->myhost, "BitlBee-IRCd initialized, please go on" );
119
120        irc_connection_list = g_slist_append( irc_connection_list, irc );
121       
122        set_add( irc, "away_devoice", "true",  set_eval_away_devoice );
123        set_add( irc, "auto_connect", "true", set_eval_bool );
124        set_add( irc, "auto_reconnect", "false", set_eval_bool );
125        set_add( irc, "auto_reconnect_delay", "300", set_eval_int );
126        set_add( irc, "buddy_sendbuffer", "false", set_eval_bool );
127        set_add( irc, "buddy_sendbuffer_delay", "200", set_eval_int );
128        set_add( irc, "charset", "iso8859-1", set_eval_charset );
129        set_add( irc, "debug", "false", set_eval_bool );
130        set_add( irc, "default_target", "root", NULL );
131        set_add( irc, "display_namechanges", "false", set_eval_bool );
132        set_add( irc, "handle_unknown", "root", NULL );
133        set_add( irc, "lcnicks", "true", set_eval_bool );
134        set_add( irc, "ops", "both", set_eval_ops );
135        set_add( irc, "private", "true", set_eval_bool );
136        set_add( irc, "query_order", "lifo", NULL );
137        set_add( irc, "save_on_quit", "true", set_eval_bool );
138        set_add( irc, "strip_html", "true", NULL );
139        set_add( irc, "to_char", ": ", set_eval_to_char );
140        set_add( irc, "typing_notice", "false", set_eval_bool );
141        set_add( irc, "password", NULL, passchange);
142       
143        conf_loaddefaults( irc );
144       
145        return( irc );
146}
147
148/* immed=1 makes this function pretty much equal to irc_free(), except that
149   this one will "log". In case the connection is already broken and we
150   shouldn't try to write to it. */
151void irc_abort( irc_t *irc, int immed, char *format, ... )
152{
153        if( format != NULL )
154        {
155                va_list params;
156                char *reason;
157               
158                va_start( params, format );
159                reason = g_strdup_vprintf( format, params );
160                va_end( params );
161               
162                if( !immed )
163                        irc_write( irc, "ERROR :Closing link: %s", reason );
164               
165                ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
166                                   irc->nick ? irc->nick : "(NONE)", irc->host, reason );
167               
168                g_free( reason );
169        }
170        else
171        {
172                if( !immed )
173                        irc_write( irc, "ERROR :Closing link" );
174               
175                ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
176                                   irc->nick ? irc->nick : "(NONE)", irc->host, "No reason given" );
177        }
178       
179        irc->status = USTATUS_SHUTDOWN;
180        if( irc->sendbuffer && !immed )
181        {
182                /* We won't read from this socket anymore. Instead, we'll connect a timer
183                   to it that should shut down the connection in a second, just in case
184                   bitlbee_.._write doesn't do it first. */
185               
186                b_event_remove( irc->r_watch_source_id );
187                irc->r_watch_source_id = b_timeout_add( 1000, (b_event_handler) irc_free, irc );
188        }
189        else
190        {
191                irc_free( irc );
192        }
193}
194
195static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data )
196{
197        g_free( key );
198       
199        return( TRUE );
200}
201
202/* Because we have no garbage collection, this is quite annoying */
203void irc_free(irc_t * irc)
204{
205        account_t *account, *accounttmp;
206        user_t *user, *usertmp;
207        nick_t *nick, *nicktmp;
208        help_t *helpnode, *helpnodetmp;
209        set_t *setnode, *setnodetmp;
210       
211        log_message( LOGLVL_INFO, "Destroying connection with fd %d", irc->fd );
212       
213        if( irc->status >= USTATUS_IDENTIFIED && set_getint( irc, "save_on_quit" ) ) 
214                if( storage_save( irc, TRUE ) != STORAGE_OK )
215                        irc_usermsg( irc, "Error while saving settings!" );
216       
217        closesocket( irc->fd );
218       
219        if( irc->ping_source_id > 0 )
220                b_event_remove( irc->ping_source_id );
221        b_event_remove( irc->r_watch_source_id );
222        if( irc->w_watch_source_id > 0 )
223                b_event_remove( irc->w_watch_source_id );
224       
225        irc_connection_list = g_slist_remove( irc_connection_list, irc );
226       
227        for (account = irc->accounts; account; account = account->next) {
228                if (account->gc) {
229                        account->gc->wants_to_die = TRUE;
230                        signoff(account->gc);
231                } else if (account->reconnect) {
232                        cancel_auto_reconnect(account);
233                }
234        }
235       
236        g_free(irc->sendbuffer);
237        g_free(irc->readbuffer);
238       
239        g_free(irc->nick);
240        g_free(irc->user);
241        g_free(irc->host);
242        g_free(irc->realname);
243        g_free(irc->password);
244       
245        g_free(irc->myhost);
246        g_free(irc->mynick);
247       
248        g_free(irc->channel);
249       
250        while (irc->queries != NULL)
251                query_del(irc, irc->queries);
252       
253        if (irc->accounts != NULL) {
254                account = irc->accounts;
255                while (account != NULL) {
256                        g_free(account->user);
257                        g_free(account->pass);
258                        g_free(account->server);
259                        accounttmp = account;
260                        account = account->next;
261                        g_free(accounttmp);
262                }
263        }
264       
265        if (irc->users != NULL) {
266                user = irc->users;
267                while (user != NULL) {
268                        g_free(user->nick);
269                        g_free(user->away);
270                        g_free(user->handle);
271                        if(user->user!=user->nick) g_free(user->user);
272                        if(user->host!=user->nick) g_free(user->host);
273                        if(user->realname!=user->nick) g_free(user->realname);
274                        b_event_remove(user->sendbuf_timer);
275                                       
276                        usertmp = user;
277                        user = user->next;
278                        g_free(usertmp);
279                }
280        }
281       
282        g_hash_table_foreach_remove(irc->userhash, irc_free_hashkey, NULL);
283        g_hash_table_destroy(irc->userhash);
284       
285        g_hash_table_foreach_remove(irc->watches, irc_free_hashkey, NULL);
286        g_hash_table_destroy(irc->watches);
287       
288        if (irc->nicks != NULL) {
289                nick = irc->nicks;
290                while (nick != NULL) {
291                        g_free(nick->nick);
292                        g_free(nick->handle);
293                                       
294                        nicktmp = nick;
295                        nick = nick->next;
296                        g_free(nicktmp);
297                }
298        }
299        if (irc->help != NULL) {
300                helpnode = irc->help;
301                while (helpnode != NULL) {
302                        g_free(helpnode->string);
303                       
304                        helpnodetmp = helpnode;
305                        helpnode = helpnode->next;
306                        g_free(helpnodetmp);
307                }
308        }
309        if (irc->set != NULL) {
310                setnode = irc->set;
311                while (setnode != NULL) {
312                        g_free(setnode->key);
313                        g_free(setnode->def);
314                        g_free(setnode->value);
315                       
316                        setnodetmp = setnode;
317                        setnode = setnode->next;
318                        g_free(setnodetmp);
319                }
320        }
321        g_free(irc);
322       
323        if( global.conf->runmode == RUNMODE_INETD || global.conf->runmode == RUNMODE_FORKDAEMON )
324                b_main_quit();
325}
326
327/* USE WITH CAUTION!
328   Sets pass without checking */
329void irc_setpass (irc_t *irc, const char *pass) 
330{
331        if (irc->password) g_free (irc->password);
332       
333        if (pass) {
334                irc->password = g_strdup (pass);
335                irc_usermsg (irc, "Password successfully changed");
336        } else {
337                irc->password = NULL;
338        }
339}
340
341void irc_process( irc_t *irc )
342{
343        char **lines, *temp, **cmd, *cs;
344        int i;
345
346        if( irc->readbuffer != NULL )
347        {
348                lines = irc_tokenize( irc->readbuffer );
349               
350                for( i = 0; *lines[i] != '\0'; i ++ )
351                {
352                        char conv[IRC_MAX_LINE+1];
353                       
354                        /* [WvG] Because irc_tokenize splits at every newline, the lines[] list
355                            should end with an empty string. This is why this actually works.
356                            Took me a while to figure out, Maurits. :-P */
357                        if( lines[i+1] == NULL )
358                        {
359                                temp = g_strdup( lines[i] );
360                                g_free( irc->readbuffer );
361                                irc->readbuffer = temp;
362                                i ++;
363                                break;
364                        }
365                       
366                        if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
367                        {
368                                conv[IRC_MAX_LINE] = 0;
369                                if( do_iconv( cs, "UTF-8", lines[i], conv, 0, IRC_MAX_LINE - 2 ) != -1 )
370                                        lines[i] = conv;
371                        }
372                       
373                        if( ( cmd = irc_parse_line( lines[i] ) ) == NULL )
374                                continue;
375                        irc_exec( irc, cmd );
376                       
377                        g_free( cmd );
378                       
379                        /* Shouldn't really happen, but just in case... */
380                        if( !g_slist_find( irc_connection_list, irc ) )
381                        {
382                                g_free( lines );
383                                return;
384                        }
385                }
386               
387                if( lines[i] != NULL )
388                {
389                        g_free( irc->readbuffer );
390                        irc->readbuffer = NULL;
391                }
392               
393                g_free( lines );
394        }
395}
396
397/* Splits a long string into separate lines. The array is NULL-terminated and, unless the string
398   contains an incomplete line at the end, ends with an empty string. */
399char **irc_tokenize( char *buffer )
400{
401        int i, j;
402        char **lines;
403
404        /* Count the number of elements we're gonna need. */
405        for( i = 0, j = 1; buffer[i] != '\0'; i ++ )
406        {
407                if( buffer[i] == '\n' )
408                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
409                                j ++;
410        }
411       
412        /* Allocate j+1 elements. */
413        lines = g_new( char *, j + 1 );
414       
415        /* NULL terminate our list. */ 
416        lines[j] = NULL;
417       
418        lines[0] = buffer;
419       
420        /* Split the buffer in several strings, using \r\n as our seperator, where \r is optional.
421         * Although this is not in the RFC, some braindead ircds (newnet's) use this, so some clients might too.
422         */
423        for( i = 0, j = 0; buffer[i] != '\0'; i ++)
424        {
425                if( buffer[i] == '\n' )
426                {
427                        buffer[i] = '\0';
428                       
429                        if( i > 0 && buffer[i-1] == '\r' )
430                                buffer[i-1] = '\0';
431                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
432                                lines[++j] = buffer + i + 1;
433                }
434        }
435       
436        return( lines );
437}
438
439/* Split an IRC-style line into little parts/arguments. */
440char **irc_parse_line( char *line )
441{
442        int i, j;
443        char **cmd;
444       
445        /* Move the line pointer to the start of the command, skipping spaces and the optional prefix. */
446        if( line[0] == ':' )
447        {
448                for( i = 0; line[i] != ' '; i ++ );
449                line = line + i;
450        }
451        for( i = 0; line[i] == ' '; i ++ );
452        line = line + i;
453       
454        /* If we're already at the end of the line, return. If not, we're going to need at least one element. */
455        if( line[0] == '\0')
456                return NULL;
457       
458        /* Count the number of char **cmd elements we're going to need. */
459        j = 1;
460        for( i = 0; line[i] != '\0'; i ++ )
461        {
462                if( line[i] == ' ' )
463                {
464                        j ++;
465                       
466                        if( line[i+1] == ':' )
467                                break;
468                }
469        }       
470
471        /* Allocate the space we need. */
472        cmd = g_new( char *, j + 1 );
473        cmd[j] = NULL;
474       
475        /* Do the actual line splitting, format is:
476         * Input: "PRIVMSG #bitlbee :foo bar"
477         * Output: cmd[0]=="PRIVMSG", cmd[1]=="#bitlbee", cmd[2]=="foo bar", cmd[3]==NULL
478         */
479
480        cmd[0] = line;
481        for( i = 0, j = 0; line[i] != '\0'; i ++ )
482        {
483                if( line[i] == ' ' )
484                {
485                        line[i] = '\0';
486                        cmd[++j] = line + i + 1;
487                       
488                        if( line[i+1] == ':' )
489                        {
490                                cmd[j] ++;
491                                break;
492                        }
493                }
494        }
495       
496        return cmd;
497}
498
499/* Converts such an array back into a command string. Mainly used for the IPC code right now. */
500char *irc_build_line( char **cmd )
501{
502        int i, len;
503        char *s;
504       
505        if( cmd[0] == NULL )
506                return NULL;
507       
508        len = 1;
509        for( i = 0; cmd[i]; i ++ )
510                len += strlen( cmd[i] ) + 1;
511       
512        if( strchr( cmd[i-1], ' ' ) != NULL )
513                len ++;
514       
515        s = g_new0( char, len + 1 );
516        for( i = 0; cmd[i]; i ++ )
517        {
518                if( cmd[i+1] == NULL && strchr( cmd[i], ' ' ) != NULL )
519                        strcat( s, ":" );
520               
521                strcat( s, cmd[i] );
522               
523                if( cmd[i+1] )
524                        strcat( s, " " );
525        }
526        strcat( s, "\r\n" );
527       
528        return s;
529}
530
531void irc_reply( irc_t *irc, int code, char *format, ... )
532{
533        char text[IRC_MAX_LINE];
534        va_list params;
535       
536        va_start( params, format );
537        g_vsnprintf( text, IRC_MAX_LINE, format, params );
538        va_end( params );
539        irc_write( irc, ":%s %03d %s %s", irc->myhost, code, irc->nick?irc->nick:"*", text );
540       
541        return;
542}
543
544int irc_usermsg( irc_t *irc, char *format, ... )
545{
546        char text[1024];
547        va_list params;
548        char is_private = 0;
549        user_t *u;
550       
551        u = user_find( irc, irc->mynick );
552        is_private = u->is_private;
553       
554        va_start( params, format );
555        g_vsnprintf( text, sizeof( text ), format, params );
556        va_end( params );
557       
558        return( irc_msgfrom( irc, u->nick, text ) );
559}
560
561void irc_write( irc_t *irc, char *format, ... ) 
562{
563        va_list params;
564
565        va_start( params, format );
566        irc_vawrite( irc, format, params );     
567        va_end( params );
568
569        return;
570
571}
572
573void irc_vawrite( irc_t *irc, char *format, va_list params )
574{
575        int size;
576        char line[IRC_MAX_LINE+1], *cs;
577               
578        /* Don't try to write anything new anymore when shutting down. */
579        if( irc->status == USTATUS_SHUTDOWN )
580                return;
581       
582        line[IRC_MAX_LINE] = 0;
583        g_vsnprintf( line, IRC_MAX_LINE - 2, format, params );
584       
585        strip_newlines( line );
586        if( ( cs = set_getstr( irc, "charset" ) ) && ( g_strcasecmp( cs, "utf-8" ) != 0 ) )
587        {
588                char conv[IRC_MAX_LINE+1];
589               
590                conv[IRC_MAX_LINE] = 0;
591                if( do_iconv( "UTF-8", cs, line, conv, 0, IRC_MAX_LINE - 2 ) != -1 )
592                        strcpy( line, conv );
593        }
594        strcat( line, "\r\n" );
595       
596        if( irc->sendbuffer != NULL )
597        {
598                size = strlen( irc->sendbuffer ) + strlen( line );
599                irc->sendbuffer = g_renew ( char, irc->sendbuffer, size + 1 );
600                strcpy( ( irc->sendbuffer + strlen( irc->sendbuffer ) ), line );
601        }
602        else
603        {
604                irc->sendbuffer = g_strdup(line);
605        }
606       
607        if( irc->w_watch_source_id == 0 )
608        {
609                /* If the buffer is empty we can probably write, so call the write event handler
610                   immediately. If it returns TRUE, it should be called again, so add the event to
611                   the queue. If it's FALSE, we emptied the buffer and saved ourselves some work
612                   in the event queue. */
613                if( bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE ) )
614                        irc->w_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_WRITE, bitlbee_io_current_client_write, irc );
615        }
616       
617        return;
618}
619
620void irc_write_all( int now, char *format, ... )
621{
622        va_list params;
623        GSList *temp;   
624       
625        va_start( params, format );
626       
627        temp = irc_connection_list;
628        while( temp != NULL )
629        {
630                irc_t *irc = temp->data;
631               
632                if( now )
633                {
634                        g_free( irc->sendbuffer );
635                        irc->sendbuffer = g_strdup( "\r\n" );
636                }
637                irc_vawrite( temp->data, format, params );
638                if( now )
639                {
640                        bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE );
641                }
642                temp = temp->next;
643        }
644       
645        va_end( params );
646        return;
647} 
648
649void irc_names( irc_t *irc, char *channel )
650{
651        user_t *u = irc->users;
652        char *s;
653        int control = ( g_strcasecmp( channel, irc->channel ) == 0 );
654        struct conversation *c = NULL;
655       
656        if( !control )
657                c = conv_findchannel( channel );
658       
659        /* RFC's say there is no error reply allowed on NAMES, so when the
660           channel is invalid, just give an empty reply. */
661       
662        if( control || c ) while( u )
663        {
664                if( u->online )
665                {
666                        if( u->gc && control )
667                        {
668                                if( set_getint( irc, "away_devoice" ) && !u->away )
669                                        s = "+";
670                                else
671                                        s = "";
672                               
673                                irc_reply( irc, 353, "@ %s :%s%s", channel, s, u->nick );
674                        }
675                        else if( !u->gc )
676                        {
677                                if( strcmp( u->nick, irc->mynick ) == 0 && ( strcmp( set_getstr( irc, "ops" ), "root" ) == 0 || strcmp( set_getstr( irc, "ops" ), "both" ) == 0 ) )
678                                        s = "@";
679                                else if( strcmp( u->nick, irc->nick ) == 0 && ( strcmp( set_getstr( irc, "ops" ), "user" ) == 0 || strcmp( set_getstr( irc, "ops" ), "both" ) == 0 ) )
680                                        s = "@";
681                                else
682                                        s = "";
683                               
684                                irc_reply( irc, 353, "@ %s :%s%s", channel, s, u->nick );
685                        }
686                }
687               
688                u = u->next;
689        }
690       
691        /* For non-controlchannel channels (group conversations) only root and
692           you are listed now. Time to show the channel people: */
693        if( !control && c )
694        {
695                GList *l;
696               
697                for( l = c->in_room; l; l = l->next )
698                        if( ( u = user_findhandle( c->gc, l->data ) ) )
699                                irc_reply( irc, 353, "@ %s :%s%s", channel, "", u->nick );
700        }
701       
702        irc_reply( irc, 366, "%s :End of /NAMES list", channel );
703}
704
705int irc_check_login( irc_t *irc )
706{
707        if( irc->user && irc->nick )
708        {
709                if( global.conf->authmode == AUTHMODE_CLOSED && irc->status < USTATUS_AUTHORIZED )
710                {
711                        irc_reply( irc, 464, ":This server is password-protected." );
712                        return 0;
713                }
714                else
715                {
716                        irc_login( irc );
717                        return 1;
718                }
719        }
720        else
721        {
722                /* More information needed. */
723                return 0;
724        }
725}
726
727void irc_login( irc_t *irc )
728{
729        user_t *u;
730       
731        irc_reply( irc,   1, ":Welcome to the BitlBee gateway, %s", irc->nick );
732        irc_reply( irc,   2, ":Host %s is running BitlBee " BITLBEE_VERSION " " ARCH "/" CPU ".", irc->myhost );
733        irc_reply( irc,   3, ":%s", IRCD_INFO );
734        irc_reply( irc,   4, "%s %s %s %s", irc->myhost, BITLBEE_VERSION, UMODES UMODES_PRIV, CMODES );
735        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 );
736        irc_motd( irc );
737        irc_umode_set( irc, "+" UMODE, 1 );
738
739        u = user_add( irc, irc->mynick );
740        u->host = g_strdup( irc->myhost );
741        u->realname = g_strdup( ROOT_FN );
742        u->online = 1;
743        u->send_handler = root_command_string;
744        u->is_private = 0; /* [SH] The channel is root's personal playground. */
745        irc_spawn( irc, u );
746       
747        u = user_add( irc, NS_NICK );
748        u->host = g_strdup( irc->myhost );
749        u->realname = g_strdup( ROOT_FN );
750        u->online = 0;
751        u->send_handler = root_command_string;
752        u->is_private = 1; /* [SH] NickServ is not in the channel, so should always /query. */
753       
754        u = user_add( irc, irc->nick );
755        u->user = g_strdup( irc->user );
756        u->host = g_strdup( irc->host );
757        u->realname = g_strdup( irc->realname );
758        u->online = 1;
759        irc_spawn( irc, u );
760       
761        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 FAQ's are answered there." );
762       
763        if( global.conf->runmode == RUNMODE_FORKDAEMON || global.conf->runmode == RUNMODE_DAEMON )
764                ipc_to_master_str( "CLIENT %s %s :%s\r\n", irc->host, irc->nick, irc->realname );
765       
766        irc->status = USTATUS_LOGGED_IN;
767}
768
769void irc_motd( irc_t *irc )
770{
771        int fd;
772       
773        fd = open( global.conf->motdfile, O_RDONLY );
774        if( fd == -1 )
775        {
776                irc_reply( irc, 422, ":We don't need MOTDs." );
777        }
778        else
779        {
780                char linebuf[80];       /* Max. line length for MOTD's is 79 chars. It's what most IRC networks seem to do. */
781                char *add, max;
782                int len;
783               
784                linebuf[79] = len = 0;
785                max = sizeof( linebuf ) - 1;
786               
787                irc_reply( irc, 375, ":- %s Message Of The Day - ", irc->myhost );
788                while( read( fd, linebuf + len, 1 ) == 1 )
789                {
790                        if( linebuf[len] == '\n' || len == max )
791                        {
792                                linebuf[len] = 0;
793                                irc_reply( irc, 372, ":- %s", linebuf );
794                                len = 0;
795                        }
796                        else if( linebuf[len] == '%' )
797                        {
798                                read( fd, linebuf + len, 1 );
799                                if( linebuf[len] == 'h' )
800                                        add = irc->myhost;
801                                else if( linebuf[len] == 'v' )
802                                        add = BITLBEE_VERSION;
803                                else if( linebuf[len] == 'n' )
804                                        add = irc->nick;
805                                else
806                                        add = "%";
807                               
808                                strncpy( linebuf + len, add, max - len );
809                                while( linebuf[++len] );
810                        }
811                        else if( len < max )
812                        {
813                                len ++;
814                        }
815                }
816                irc_reply( irc, 376, ":End of MOTD" );
817                close( fd );
818        }
819}
820
821void irc_topic( irc_t *irc, char *channel )
822{
823        if( g_strcasecmp( channel, irc->channel ) == 0 )
824        {
825                irc_reply( irc, 332, "%s :%s", channel, CONTROL_TOPIC );
826        }
827        else
828        {
829                struct conversation *c = conv_findchannel( channel );
830               
831                if( c )
832                        irc_reply( irc, 332, "%s :BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!", channel, c->title );
833                else
834                        irc_reply( irc, 331, "%s :No topic for this channel", channel );
835        }
836}
837
838void irc_umode_set( irc_t *irc, char *s, int allow_priv )
839{
840        /* allow_priv: Set to 0 if s contains user input, 1 if you want
841           to set a "privileged" mode (+o, +R, etc). */
842        char m[256], st = 1, *t;
843        int i;
844       
845        memset( m, 0, sizeof( m ) );
846       
847        for( t = irc->umode; *t; t ++ )
848                m[(int)*t] = 1;
849       
850        for( t = s; *t; t ++ )
851        {
852                if( *t == '+' || *t == '-' )
853                        st = *t == '+';
854                else if( st == 0 || ( strchr( UMODES, *t ) || ( allow_priv && strchr( UMODES_PRIV, *t ) ) ) )
855                        m[(int)*t] = st;
856        }
857       
858        memset( irc->umode, 0, sizeof( irc->umode ) );
859       
860        for( i = 0; i < 256 && strlen( irc->umode ) < ( sizeof( irc->umode ) - 1 ); i ++ )
861                if( m[i] )
862                        irc->umode[strlen(irc->umode)] = i;
863       
864        irc_reply( irc, 221, "+%s", irc->umode );
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[64];
909       
910        if( u->gc && u->gc->flags & OPT_LOGGING_OUT )
911        {
912                if( u->gc->user->proto_opt[0][0] )
913                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
914                                    u->gc->user->proto_opt[0] );
915                else if( ( s = strchr( u->gc->username, '@' ) ) )
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->gc->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 conversation *c = NULL;
945        user_t *u = NULL;
946       
947        if( *nick == '#' || *nick == '&' )
948        {
949                if( !( c = conv_findchannel( 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->gc && u->gc->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->gc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
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->gc && c->gc->prpl )
1036        {
1037                return( bim_chat_msg( c->gc, c->id, s ) );
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        bim_buddy_msg( u->gc, 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->gc ) return;
1066       
1067        if( set_getint( irc, "buddy_sendbuffer" ) && set_getint( irc, "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, "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                bim_buddy_msg( u->gc, 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, "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}
Note: See TracBrowser for help on using the repository browser.