source: irc.c @ 85cf37f

Last change on this file since 85cf37f was 0356ae3, checked in by Wilmer van der Gaast <wilmer@…>, at 2006-05-13T22:30:51Z

irc_vawrite() now first attempts to write() immediately (because that's
usually not a problem) and only touches the event queue when the write()
doesn't write everything. And got rid of a quit element in the irc_t
structure that actually wasn't even used.

  • Property mode set to 100644
File size: 29.6 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        if( u ) 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" );
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, 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;
908       
909        irc_write( irc, ":%s!%s@%s QUIT :%s", u->nick, u->user, u->host, "Leaving..." );
910       
911        nick = g_strdup( u->nick );
912        nick_lc( nick );
913        if( g_hash_table_lookup( irc->watches, nick ) )
914        {
915                irc_reply( irc, 601, "%s %s %s %d :%s", u->nick, u->user, u->host, time( NULL ), "logged offline" );
916        }
917        g_free( nick );
918}
919
920int irc_send( irc_t *irc, char *nick, char *s, int flags )
921{
922        struct conversation *c = NULL;
923        user_t *u = NULL;
924       
925        if( *nick == '#' || *nick == '&' )
926        {
927                if( !( c = conv_findchannel( nick ) ) )
928                {
929                        irc_reply( irc, 403, "%s :Channel does not exist", nick );
930                        return( 0 );
931                }
932        }
933        else
934        {
935                u = user_find( irc, nick );
936               
937                if( !u )
938                {
939                        if( irc->is_private )
940                                irc_reply( irc, 401, "%s :Nick does not exist", nick );
941                        else
942                                irc_usermsg( irc, "Nick `%s' does not exist!", nick );
943                        return( 0 );
944                }
945        }
946       
947        if( *s == 1 && s[strlen(s)-1] == 1 )
948        {
949                if( g_strncasecmp( s + 1, "ACTION", 6 ) == 0 )
950                {
951                        if( s[7] == ' ' ) s ++;
952                        s += 3;
953                        *(s++) = '/';
954                        *(s++) = 'm';
955                        *(s++) = 'e';
956                        *(s++) = ' ';
957                        s -= 4;
958                        s[strlen(s)-1] = 0;
959                }
960                else if( g_strncasecmp( s + 1, "VERSION", 7 ) == 0 )
961                {
962                        u = user_find( irc, irc->mynick );
963                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", "\001VERSION BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\001" );
964                        return( 1 );
965                }
966                else if( g_strncasecmp( s + 1, "PING", 4 ) == 0 )
967                {
968                        u = user_find( irc, irc->mynick );
969                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", s );
970                        return( 1 );
971                }
972                else if( g_strncasecmp( s + 1, "TYPING", 6 ) == 0 )
973                {
974                        if( u && u->gc && u->gc->prpl->send_typing && strlen( s ) >= 10 )
975                        {
976                                time_t current_typing_notice = time( NULL );
977                               
978                                if( current_typing_notice - u->last_typing_notice >= 5 )
979                                {
980                                        u->gc->prpl->send_typing( u->gc, u->handle, s[8] == '1' );
981                                        u->last_typing_notice = current_typing_notice;
982                                }
983                        }
984                        return( 1 );
985                }
986                else
987                {
988                        irc_usermsg( irc, "Non-ACTION CTCP's aren't supported" );
989                        return( 0 );
990                }
991        }
992       
993        if( u )
994        {
995                /* For the next message, we probably do have to send new notices... */
996                u->last_typing_notice = 0;
997                u->is_private = irc->is_private;
998               
999                if( u->is_private )
1000                {
1001                        if( !u->online )
1002                                irc_reply( irc, 301, "%s :%s", u->nick, "User is offline" );
1003                        else if( u->away )
1004                                irc_reply( irc, 301, "%s :%s", u->nick, u->away );
1005                }
1006               
1007                if( u->send_handler )
1008                {
1009                        u->send_handler( irc, u, s, flags );
1010                        return 1;
1011                }
1012        }
1013        else if( c && c->gc && c->gc->prpl )
1014        {
1015                return( serv_send_chat( irc, c->gc, c->id, s ) );
1016        }
1017       
1018        return( 0 );
1019}
1020
1021static gboolean buddy_send_handler_delayed( gpointer data, gint fd, b_input_condition cond )
1022{
1023        user_t *u = data;
1024       
1025        u->sendbuf[u->sendbuf_len-2] = 0; /* Cut off the last newline */
1026        serv_send_im( u->gc->irc, u, u->sendbuf, u->sendbuf_flags );
1027       
1028        g_free( u->sendbuf );
1029        u->sendbuf = NULL;
1030        u->sendbuf_len = 0;
1031        u->sendbuf_timer = 0;
1032        u->sendbuf_flags = 0;
1033       
1034        return FALSE;
1035}
1036
1037void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags )
1038{
1039        if( !u || !u->gc ) return;
1040       
1041        if( set_getint( irc, "buddy_sendbuffer" ) && set_getint( irc, "buddy_sendbuffer_delay" ) > 0 )
1042        {
1043                int delay;
1044               
1045                if( u->sendbuf_len > 0 && u->sendbuf_flags != flags)
1046                {
1047                        //Flush the buffer
1048                        b_event_remove( u->sendbuf_timer );
1049                        buddy_send_handler_delayed( u, -1, 0 );
1050                }
1051
1052                if( u->sendbuf_len == 0 )
1053                {
1054                        u->sendbuf_len = strlen( msg ) + 2;
1055                        u->sendbuf = g_new (char, u->sendbuf_len );
1056                        u->sendbuf[0] = 0;
1057                        u->sendbuf_flags = flags;
1058                }
1059                else
1060                {
1061                        u->sendbuf_len += strlen( msg ) + 1;
1062                        u->sendbuf = g_renew ( char, u->sendbuf, u->sendbuf_len );
1063                }
1064               
1065                strcat( u->sendbuf, msg );
1066                strcat( u->sendbuf, "\n" );
1067               
1068                delay = set_getint( irc, "buddy_sendbuffer_delay" );
1069                if( delay <= 5 )
1070                        delay *= 1000;
1071               
1072                if( u->sendbuf_timer > 0 )
1073                        b_event_remove( u->sendbuf_timer );
1074                u->sendbuf_timer = b_timeout_add( delay, buddy_send_handler_delayed, u );
1075        }
1076        else
1077        {
1078                serv_send_im( irc, u, msg, flags );
1079        }
1080}
1081
1082int irc_privmsg( irc_t *irc, user_t *u, char *type, char *to, char *prefix, char *msg )
1083{
1084        char last = 0;
1085        char *s = msg, *line = msg;
1086       
1087        /* The almighty linesplitter .. woohoo!! */
1088        while( !last )
1089        {
1090                if( *s == '\r' && *(s+1) == '\n' )
1091                        *(s++) = 0;
1092                if( *s == '\n' )
1093                {
1094                        last = s[1] == 0;
1095                        *s = 0;
1096                }
1097                else
1098                {
1099                        last = s[0] == 0;
1100                }
1101                if( *s == 0 )
1102                {
1103                        if( g_strncasecmp( line, "/me ", 4 ) == 0 && ( !prefix || !*prefix ) && g_strcasecmp( type, "PRIVMSG" ) == 0 )
1104                        {
1105                                irc_write( irc, ":%s!%s@%s %s %s :\001ACTION %s\001", u->nick, u->user, u->host,
1106                                           type, to, line + 4 );
1107                        }
1108                        else
1109                        {
1110                                irc_write( irc, ":%s!%s@%s %s %s :%s%s", u->nick, u->user, u->host,
1111                                           type, to, prefix ? prefix : "", line );
1112                        }
1113                        line = s + 1;
1114                }
1115                s ++;
1116        }
1117       
1118        return( 1 );
1119}
1120
1121int irc_msgfrom( irc_t *irc, char *nick, char *msg )
1122{
1123        user_t *u = user_find( irc, nick );
1124        static char *prefix = NULL;
1125       
1126        if( !u ) return( 0 );
1127        if( prefix && *prefix ) g_free( prefix );
1128       
1129        if( !u->is_private && nick_cmp( u->nick, irc->mynick ) != 0 )
1130        {
1131                int len = strlen( irc->nick) + 3;
1132                prefix = g_new (char, len );
1133                g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( irc, "to_char" ) );
1134                prefix[len-1] = 0;
1135        }
1136        else
1137        {
1138                prefix = "";
1139        }
1140       
1141        return( irc_privmsg( irc, u, "PRIVMSG", u->is_private ? irc->nick : irc->channel, prefix, msg ) );
1142}
1143
1144int irc_noticefrom( irc_t *irc, char *nick, char *msg )
1145{
1146        user_t *u = user_find( irc, nick );
1147       
1148        if( u )
1149                return( irc_privmsg( irc, u, "NOTICE", irc->nick, "", msg ) );
1150        else
1151                return( 0 );
1152}
1153
1154/* Returns 0 if everything seems to be okay, a number >0 when there was a
1155   timeout. The number returned is the number of seconds we received no
1156   pongs from the user. When not connected yet, we don't ping but drop the
1157   connection when the user fails to connect in IRC_LOGIN_TIMEOUT secs. */
1158static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond )
1159{
1160        irc_t *irc = _irc;
1161        int rv = 0;
1162       
1163        if( irc->status < USTATUS_LOGGED_IN )
1164        {
1165                if( gettime() > ( irc->last_pong + IRC_LOGIN_TIMEOUT ) )
1166                        rv = gettime() - irc->last_pong;
1167        }
1168        else
1169        {
1170                if( ( gettime() > ( irc->last_pong + global.conf->ping_interval ) ) && !irc->pinging )
1171                {
1172                        irc_write( irc, "PING :%s", IRC_PING_STRING );
1173                        irc->pinging = 1;
1174                }
1175                else if( gettime() > ( irc->last_pong + global.conf->ping_timeout ) )
1176                {
1177                        rv = gettime() - irc->last_pong;
1178                }
1179        }
1180       
1181        if( rv > 0 )
1182        {
1183                irc_abort( irc, 0, "Ping Timeout: %d seconds", rv );
1184                return FALSE;
1185        }
1186       
1187        return TRUE;
1188}
Note: See TracBrowser for help on using the repository browser.