source: irc.c @ 3f9440d

Last change on this file since 3f9440d was 3f9440d, checked in by Wilmer van der Gaast <wilmer@…>, at 2006-06-26T21:50:12Z

/NAMES replies are more efficient now.

  • Property mode set to 100644
File size: 30.8 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;
652        char namelist[385] = "";
653        struct conversation *c = NULL;
654       
655        /* RFCs say there is no error reply allowed on NAMES, so when the
656           channel is invalid, just give an empty reply. */
657       
658        if( g_strcasecmp( channel, irc->channel ) == 0 )
659        {
660                for( u = irc->users; u; u = u->next ) if( u->online )
661                {
662                        if( strlen( namelist ) + strlen( u->nick ) > sizeof( namelist ) - 4 )
663                        {
664                                irc_reply( irc, 353, "= %s :%s", channel, namelist );
665                                *namelist = 0;
666                        }
667                       
668                        if( u->gc && !u->away && set_getint( irc, "away_devoice" ) )
669                                strcat( namelist, "+" );
670                       
671                        strcat( namelist, u->nick );
672                        strcat( namelist, " " );
673                }
674        }
675        else if( ( c = conv_findchannel( channel ) ) )
676        {
677                GList *l;
678                char *ops = set_getstr( irc, "ops" );
679               
680                /* root and the user aren't in the channel userlist but should
681                   show up in /NAMES, so list them first: */
682                sprintf( namelist, "%s%s %s%s ", strcmp( ops, "root" ) == 0 || strcmp( ops, "both" ) ? "@" : "", irc->mynick,
683                                                 strcmp( ops, "user" ) == 0 || strcmp( ops, "both" ) ? "@" : "", irc->nick );
684               
685                for( l = c->in_room; l; l = l->next ) if( ( u = user_findhandle( c->gc, l->data ) ) )
686                {
687                        if( strlen( namelist ) + strlen( u->nick ) > sizeof( namelist ) - 4 )
688                        {
689                                irc_reply( irc, 353, "= %s :%s", channel, namelist );
690                                *namelist = 0;
691                        }
692                       
693                        strcat( namelist, u->nick );
694                        strcat( namelist, " " );
695                }
696        }
697       
698        if( *namelist )
699                irc_reply( irc, 353, "= %s :%s", channel, namelist );
700       
701        irc_reply( irc, 366, "%s :End of /NAMES list", channel );
702}
703
704int irc_check_login( irc_t *irc )
705{
706        if( irc->user && irc->nick )
707        {
708                if( global.conf->authmode == AUTHMODE_CLOSED && !( irc->status & USTATUS_AUTHORIZED ) )
709                {
710                        irc_reply( irc, 464, ":This server is password-protected." );
711                        return 0;
712                }
713                else
714                {
715                        irc_login( irc );
716                        return 1;
717                }
718        }
719        else
720        {
721                /* More information needed. */
722                return 0;
723        }
724}
725
726void irc_login( irc_t *irc )
727{
728        user_t *u;
729       
730        irc_reply( irc,   1, ":Welcome to the BitlBee gateway, %s", irc->nick );
731        irc_reply( irc,   2, ":Host %s is running BitlBee " BITLBEE_VERSION " " ARCH "/" CPU ".", irc->myhost );
732        irc_reply( irc,   3, ":%s", IRCD_INFO );
733        irc_reply( irc,   4, "%s %s %s %s", irc->myhost, BITLBEE_VERSION, UMODES UMODES_PRIV, CMODES );
734        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 );
735        irc_motd( irc );
736        irc->umode[0] = '\0';
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        char changes[512], *p, st2 = 2;
845        char badflag = 0;
846       
847        memset( m, 0, sizeof( m ) );
848       
849        for( t = irc->umode; *t; t ++ )
850                m[(int)*t] = 1;
851
852        p = changes;
853        for( t = s; *t; t ++ )
854        {
855                if( *t == '+' || *t == '-' )
856                        st = *t == '+';
857                else if( st == 0 || ( strchr( UMODES, *t ) || ( allow_priv && strchr( UMODES_PRIV, *t ) ) ) )
858                {
859                        if( m[(int)*t] != st)
860                        {
861                                if( st != st2 )
862                                        st2 = st, *p++ = st ? '+' : '-';
863                                *p++ = *t;
864                        }
865                        m[(int)*t] = st;
866                }
867                else
868                        badflag = 1;
869        }
870        *p = '\0';
871       
872        memset( irc->umode, 0, sizeof( irc->umode ) );
873       
874        for( i = 0; i < 256 && strlen( irc->umode ) < ( sizeof( irc->umode ) - 1 ); i ++ )
875                if( m[i] )
876                        irc->umode[strlen(irc->umode)] = i;
877       
878        if( badflag )
879                irc_reply( irc, 501, ":Unknown MODE flag" );
880        /* Deliberately no !user@host on the prefix here */
881        if( *changes )
882                irc_write( irc, ":%s MODE %s %s", irc->nick, irc->nick, changes );
883}
884
885void irc_spawn( irc_t *irc, user_t *u )
886{
887        irc_join( irc, u, irc->channel );
888}
889
890void irc_join( irc_t *irc, user_t *u, char *channel )
891{
892        char *nick;
893       
894        if( ( g_strcasecmp( channel, irc->channel ) != 0 ) || user_find( irc, irc->nick ) )
895                irc_write( irc, ":%s!%s@%s JOIN :%s", u->nick, u->user, u->host, channel );
896       
897        if( nick_cmp( u->nick, irc->nick ) == 0 )
898        {
899                irc_write( irc, ":%s MODE %s +%s", irc->myhost, channel, CMODE );
900                irc_names( irc, channel );
901                irc_topic( irc, channel );
902        }
903       
904        nick = g_strdup( u->nick );
905        nick_lc( nick );
906        if( g_hash_table_lookup( irc->watches, nick ) )
907        {
908                irc_reply( irc, 600, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged online" );
909        }
910        g_free( nick );
911}
912
913void irc_part( irc_t *irc, user_t *u, char *channel )
914{
915        irc_write( irc, ":%s!%s@%s PART %s :%s", u->nick, u->user, u->host, channel, "" );
916}
917
918void irc_kick( irc_t *irc, user_t *u, char *channel, user_t *kicker )
919{
920        irc_write( irc, ":%s!%s@%s KICK %s %s :%s", kicker->nick, kicker->user, kicker->host, channel, u->nick, "" );
921}
922
923void irc_kill( irc_t *irc, user_t *u )
924{
925        char *nick, *s;
926        char reason[64];
927       
928        if( u->gc && u->gc->flags & OPT_LOGGING_OUT )
929        {
930                if( u->gc->user->proto_opt[0][0] )
931                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
932                                    u->gc->user->proto_opt[0] );
933                else if( ( s = strchr( u->gc->username, '@' ) ) )
934                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
935                                    s + 1 );
936                else
937                        g_snprintf( reason, sizeof( reason ), "%s %s.%s", irc->myhost,
938                                    u->gc->prpl->name, irc->myhost );
939               
940                /* proto_opt might contain garbage after the : */
941                if( ( s = strchr( reason, ':' ) ) )
942                        *s = 0;
943        }
944        else
945        {
946                strcpy( reason, "Leaving..." );
947        }
948       
949        irc_write( irc, ":%s!%s@%s QUIT :%s", u->nick, u->user, u->host, reason );
950       
951        nick = g_strdup( u->nick );
952        nick_lc( nick );
953        if( g_hash_table_lookup( irc->watches, nick ) )
954        {
955                irc_reply( irc, 601, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged offline" );
956        }
957        g_free( nick );
958}
959
960int irc_send( irc_t *irc, char *nick, char *s, int flags )
961{
962        struct conversation *c = NULL;
963        user_t *u = NULL;
964       
965        if( *nick == '#' || *nick == '&' )
966        {
967                if( !( c = conv_findchannel( nick ) ) )
968                {
969                        irc_reply( irc, 403, "%s :Channel does not exist", nick );
970                        return( 0 );
971                }
972        }
973        else
974        {
975                u = user_find( irc, nick );
976               
977                if( !u )
978                {
979                        if( irc->is_private )
980                                irc_reply( irc, 401, "%s :Nick does not exist", nick );
981                        else
982                                irc_usermsg( irc, "Nick `%s' does not exist!", nick );
983                        return( 0 );
984                }
985        }
986       
987        if( *s == 1 && s[strlen(s)-1] == 1 )
988        {
989                if( g_strncasecmp( s + 1, "ACTION", 6 ) == 0 )
990                {
991                        if( s[7] == ' ' ) s ++;
992                        s += 3;
993                        *(s++) = '/';
994                        *(s++) = 'm';
995                        *(s++) = 'e';
996                        *(s++) = ' ';
997                        s -= 4;
998                        s[strlen(s)-1] = 0;
999                }
1000                else if( g_strncasecmp( s + 1, "VERSION", 7 ) == 0 )
1001                {
1002                        u = user_find( irc, irc->mynick );
1003                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", "\001VERSION BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\001" );
1004                        return( 1 );
1005                }
1006                else if( g_strncasecmp( s + 1, "PING", 4 ) == 0 )
1007                {
1008                        u = user_find( irc, irc->mynick );
1009                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", s );
1010                        return( 1 );
1011                }
1012                else if( g_strncasecmp( s + 1, "TYPING", 6 ) == 0 )
1013                {
1014                        if( u && u->gc && u->gc->prpl->send_typing && strlen( s ) >= 10 )
1015                        {
1016                                time_t current_typing_notice = time( NULL );
1017                               
1018                                if( current_typing_notice - u->last_typing_notice >= 5 )
1019                                {
1020                                        u->gc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
1021                                        u->last_typing_notice = current_typing_notice;
1022                                }
1023                        }
1024                        return( 1 );
1025                }
1026                else
1027                {
1028                        irc_usermsg( irc, "Non-ACTION CTCP's aren't supported" );
1029                        return( 0 );
1030                }
1031        }
1032       
1033        if( u )
1034        {
1035                /* For the next message, we probably do have to send new notices... */
1036                u->last_typing_notice = 0;
1037                u->is_private = irc->is_private;
1038               
1039                if( u->is_private )
1040                {
1041                        if( !u->online )
1042                                irc_reply( irc, 301, "%s :%s", u->nick, "User is offline" );
1043                        else if( u->away )
1044                                irc_reply( irc, 301, "%s :%s", u->nick, u->away );
1045                }
1046               
1047                if( u->send_handler )
1048                {
1049                        u->send_handler( irc, u, s, flags );
1050                        return 1;
1051                }
1052        }
1053        else if( c && c->gc && c->gc->prpl )
1054        {
1055                return( bim_chat_msg( c->gc, c->id, s ) );
1056        }
1057       
1058        return( 0 );
1059}
1060
1061static gboolean buddy_send_handler_delayed( gpointer data, gint fd, b_input_condition cond )
1062{
1063        user_t *u = data;
1064       
1065        /* Shouldn't happen, but just to be sure. */
1066        if( u->sendbuf_len < 2 )
1067                return FALSE;
1068       
1069        u->sendbuf[u->sendbuf_len-2] = 0; /* Cut off the last newline */
1070        bim_buddy_msg( u->gc, u->handle, u->sendbuf, u->sendbuf_flags );
1071       
1072        g_free( u->sendbuf );
1073        u->sendbuf = NULL;
1074        u->sendbuf_len = 0;
1075        u->sendbuf_timer = 0;
1076        u->sendbuf_flags = 0;
1077       
1078        return FALSE;
1079}
1080
1081void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags )
1082{
1083        if( !u || !u->gc ) return;
1084       
1085        if( set_getint( irc, "buddy_sendbuffer" ) && set_getint( irc, "buddy_sendbuffer_delay" ) > 0 )
1086        {
1087                int delay;
1088               
1089                if( u->sendbuf_len > 0 && u->sendbuf_flags != flags)
1090                {
1091                        /* Flush the buffer */
1092                        b_event_remove( u->sendbuf_timer );
1093                        buddy_send_handler_delayed( u, -1, 0 );
1094                }
1095
1096                if( u->sendbuf_len == 0 )
1097                {
1098                        u->sendbuf_len = strlen( msg ) + 2;
1099                        u->sendbuf = g_new( char, u->sendbuf_len );
1100                        u->sendbuf[0] = 0;
1101                        u->sendbuf_flags = flags;
1102                }
1103                else
1104                {
1105                        u->sendbuf_len += strlen( msg ) + 1;
1106                        u->sendbuf = g_renew( char, u->sendbuf, u->sendbuf_len );
1107                }
1108               
1109                strcat( u->sendbuf, msg );
1110                strcat( u->sendbuf, "\n" );
1111               
1112                delay = set_getint( irc, "buddy_sendbuffer_delay" );
1113                if( delay <= 5 )
1114                        delay *= 1000;
1115               
1116                if( u->sendbuf_timer > 0 )
1117                        b_event_remove( u->sendbuf_timer );
1118                u->sendbuf_timer = b_timeout_add( delay, buddy_send_handler_delayed, u );
1119        }
1120        else
1121        {
1122                bim_buddy_msg( u->gc, u->handle, msg, flags );
1123        }
1124}
1125
1126int irc_privmsg( irc_t *irc, user_t *u, char *type, char *to, char *prefix, char *msg )
1127{
1128        char last = 0;
1129        char *s = msg, *line = msg;
1130       
1131        /* The almighty linesplitter .. woohoo!! */
1132        while( !last )
1133        {
1134                if( *s == '\r' && *(s+1) == '\n' )
1135                        *(s++) = 0;
1136                if( *s == '\n' )
1137                {
1138                        last = s[1] == 0;
1139                        *s = 0;
1140                }
1141                else
1142                {
1143                        last = s[0] == 0;
1144                }
1145                if( *s == 0 )
1146                {
1147                        if( g_strncasecmp( line, "/me ", 4 ) == 0 && ( !prefix || !*prefix ) && g_strcasecmp( type, "PRIVMSG" ) == 0 )
1148                        {
1149                                irc_write( irc, ":%s!%s@%s %s %s :\001ACTION %s\001", u->nick, u->user, u->host,
1150                                           type, to, line + 4 );
1151                        }
1152                        else
1153                        {
1154                                irc_write( irc, ":%s!%s@%s %s %s :%s%s", u->nick, u->user, u->host,
1155                                           type, to, prefix ? prefix : "", line );
1156                        }
1157                        line = s + 1;
1158                }
1159                s ++;
1160        }
1161       
1162        return( 1 );
1163}
1164
1165int irc_msgfrom( irc_t *irc, char *nick, char *msg )
1166{
1167        user_t *u = user_find( irc, nick );
1168        static char *prefix = NULL;
1169       
1170        if( !u ) return( 0 );
1171        if( prefix && *prefix ) g_free( prefix );
1172       
1173        if( !u->is_private && nick_cmp( u->nick, irc->mynick ) != 0 )
1174        {
1175                int len = strlen( irc->nick) + 3;
1176                prefix = g_new (char, len );
1177                g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( irc, "to_char" ) );
1178                prefix[len-1] = 0;
1179        }
1180        else
1181        {
1182                prefix = "";
1183        }
1184       
1185        return( irc_privmsg( irc, u, "PRIVMSG", u->is_private ? irc->nick : irc->channel, prefix, msg ) );
1186}
1187
1188int irc_noticefrom( irc_t *irc, char *nick, char *msg )
1189{
1190        user_t *u = user_find( irc, nick );
1191       
1192        if( u )
1193                return( irc_privmsg( irc, u, "NOTICE", irc->nick, "", msg ) );
1194        else
1195                return( 0 );
1196}
1197
1198/* Returns 0 if everything seems to be okay, a number >0 when there was a
1199   timeout. The number returned is the number of seconds we received no
1200   pongs from the user. When not connected yet, we don't ping but drop the
1201   connection when the user fails to connect in IRC_LOGIN_TIMEOUT secs. */
1202static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond )
1203{
1204        irc_t *irc = _irc;
1205        int rv = 0;
1206       
1207        if( !( irc->status & USTATUS_LOGGED_IN ) )
1208        {
1209                if( gettime() > ( irc->last_pong + IRC_LOGIN_TIMEOUT ) )
1210                        rv = gettime() - irc->last_pong;
1211        }
1212        else
1213        {
1214                if( ( gettime() > ( irc->last_pong + global.conf->ping_interval ) ) && !irc->pinging )
1215                {
1216                        irc_write( irc, "PING :%s", IRC_PING_STRING );
1217                        irc->pinging = 1;
1218                }
1219                else if( gettime() > ( irc->last_pong + global.conf->ping_timeout ) )
1220                {
1221                        rv = gettime() - irc->last_pong;
1222                }
1223        }
1224       
1225        if( rv > 0 )
1226        {
1227                irc_abort( irc, 0, "Ping Timeout: %d seconds", rv );
1228                return FALSE;
1229        }
1230       
1231        return TRUE;
1232}
Note: See TracBrowser for help on using the repository browser.