Changes in / [a4dc9f7:8e419cb]

Files:

• Makefile (modified) (1 diff)
• bitlbee.c (modified) (12 diffs)
• bitlbee.h (modified) (3 diffs)
• commands.c (added)
• commands.h (modified) (1 diff)
• conf.c (modified) (8 diffs)
• conf.h (modified) (1 diff)
• configure (modified) (5 diffs)
• doc/README (modified) (1 diff)
• ipc.c (deleted)
• ipc.h (deleted)
• irc.c (modified) (17 diffs)
• irc.h (modified) (6 diffs)
• irc_commands.c (deleted)
• log.c (modified) (6 diffs)
• protocols/jabber/jabber.c (modified) (1 diff)
• protocols/msn/msn.c (modified) (2 diffs)
• protocols/msn/sb.c (modified) (2 diffs)
• protocols/oscar/oscar.c (modified) (1 diff)
• protocols/oscar/rxqueue.c (modified) (1 diff)
• protocols/oscar/service.c (modified) (1 diff)
• protocols/ssl_openssl.c (modified) (8 diffs)
• protocols/yahoo/Makefile (modified) (1 diff)
• protocols/yahoo/yahoo.c (modified) (2 diffs)
• protocols/yahoo/yahoo_list.c (added)
• protocols/yahoo/yahoo_list.h (modified) (1 diff)
• root_commands.c (deleted)
• unix.c (modified) (4 diffs)
• url.c (modified) (1 diff)
• user.h (modified) (1 diff)
• utils/bitlbee-ctl.pl (deleted)

Makefile

@@ -10 +10 @@
 
 # Program variables
-objects = account.o bitlbee.o crypting.o help.o ini.o ipc.o irc.o irc_commands.o nick.o query.o root_commands.o set.o storage.o storage_text.o url.o user.o util.o
+objects = account.o bitlbee.o commands.o crypting.o help.o ini.o irc.o nick.o query.o set.o storage.o storage_text.o url.o user.o util.o
 subdirs = protocols
 

bitlbee.c

@@ -29 +29 @@
 #include "protocols/nogaim.h"
 #include "help.h"
-#include "ipc.h"
 #include <signal.h>
 #include <stdio.h>
 #include <errno.h>
 
-gboolean bitlbee_io_new_client( GIOChannel *source, GIOCondition condition, gpointer data );
+gboolean bitlbee_io_new_client( GIOChannel *source, GIOCondition condition, gpointer data )
+{
+        size_t size = sizeof( struct sockaddr_in );
+        struct sockaddr_in conn_info;
+        int new_socket = accept( global.listen_socket, (struct sockaddr *) &conn_info, &size );
+        pid_t client_pid = 0;
+        
+        if( global.conf->runmode == RUNMODE_FORKDAEMON )
+                client_pid = fork();
+        
+        if( client_pid == 0 )
+        {
+                log_message( LOGLVL_INFO, "Creating new connection with fd %d.", new_socket );
+                irc_new( new_socket );
+                
+                if( global.conf->runmode == RUNMODE_FORKDAEMON )
+                {
+                        /* Close the listening socket, we're a client. */
+                        close( global.listen_socket );
+                        g_source_remove( global.listen_watch_source_id );
+                }
+        }
+        else
+        {
+                /* We don't need this one, only the client does. */
+                close( new_socket );
+                
+                /* Or maybe we didn't even get a child process... */
+                if( client_pid == -1 )
+                        log_message( LOGLVL_ERROR, "Failed to fork() subprocess for client: %s", strerror( errno ) );
+        }
+        
+        return TRUE;
+}
+ 
+
 
 int bitlbee_daemon_init()
@@ -45 +79 @@
         int i;
         GIOChannel *ch;
-        FILE *fp;
         
         log_link( LOGLVL_ERROR, LOGOUTPUT_SYSLOG );
@@ -56 +89 @@
                 return( -1 );
         }
-        
-        /* TIME_WAIT (?) sucks.. */
-        i = 1;
-        setsockopt( global.listen_socket, SOL_SOCKET, SO_REUSEADDR, &i, sizeof( i ) );
         
 #ifdef IPV6
@@ -105 +134 @@
                 else if( i != 0 ) 
                         exit( 0 );
-                
+                close( 0 );
+                close( 1 );
+                close( 2 );
                 chdir( "/" );
-                
-                /* Sometimes std* are already closed (for example when we're in a RESTARTed
-                   BitlBee process. So let's only close TTY-fds. */
-                if( isatty( 0 ) ) close( 0 );
-                if( isatty( 0 ) ) close( 1 );
-                if( isatty( 0 ) ) close( 2 );
         }
 #endif
-        
-        if( global.conf->runmode == RUNMODE_FORKDAEMON )
-                ipc_master_load_state();
-
-        if( global.conf->runmode == RUNMODE_DAEMON || 
-                global.conf->runmode == RUNMODE_FORKDAEMON )
-                ipc_master_listen_socket();
-        
-        if( ( fp = fopen( global.conf->pidfile, "w" ) ) )
-        {
-                fprintf( fp, "%d\n", (int) getpid() );
-                fclose( fp );
-        }
-        else
-        {
-                log_message( LOGLVL_WARNING, "Warning: Couldn't write PID to `%s'", global.conf->pidfile );
-        }
         
         return( 0 );
@@ -152 +160 @@
         if( condition & G_IO_ERR || condition & G_IO_HUP )
         {
-                irc_abort( irc, 1, "Read error" );
+                irc_free( irc );
                 return FALSE;
         }
@@ -159 +167 @@
         if( st == 0 )
         {
-                irc_abort( irc, 1, "Connection reset by peer" );
+                irc_free( irc );
                 return FALSE;
         }
@@ -170 +178 @@
                 else
                 {
-                        irc_abort( irc, 1, "Read error: %s", strerror( errno ) );
+                        irc_free( irc );
                         return FALSE;
                 }
@@ -186 +194 @@
         }
         
-        irc_process( irc );
-        
-        /* Normally, irc_process() shouldn't call irc_free() but irc_abort(). Just in case: */
-        if( !g_slist_find( irc_connection_list, irc ) )
-        {
-                log_message( LOGLVL_WARNING, "Abnormal termination of connection with fd %d.", irc->fd );
+        if( !irc_process( irc ) )
+        {
+                log_message( LOGLVL_INFO, "Destroying connection with fd %d.", irc->fd );
+                irc_free( irc );
                 return FALSE;
         } 
@@ -198 +204 @@
         if( irc->readbuffer && ( strlen( irc->readbuffer ) > 1024 ) )
         {
-                irc_abort( irc, 0, "Maximum line length exceeded" );
+                log_message( LOGLVL_ERROR, "Maximum line length exceeded." );
+                irc_free( irc );
                 return FALSE;
         }
@@ -217 +224 @@
         st = write( irc->fd, irc->sendbuffer, size );
         
-        if( st == 0 || ( st < 0 && !sockerr_again() ) )
-        {
-                irc_abort( irc, 1, "Write error: %s", strerror( errno ) );
-                return FALSE;
-        }
-        else if( st < 0 ) /* && sockerr_again() */
-        {
-                return TRUE;
+        if( st <= 0 )
+        {
+                if( sockerr_again() )
+                {
+                        return TRUE;
+                }
+                else
+                {
+                        irc_free( irc );
+                        return FALSE;
+                }
         }
         
@@ -231 +241 @@
                 g_free( irc->sendbuffer );
                 irc->sendbuffer = NULL;
+                
                 irc->w_watch_source_id = 0;
-                
-                if( irc->status == USTATUS_SHUTDOWN )
-                        irc_free( irc );
-                
                 return( FALSE );
         }
@@ -248 +255 @@
 }
 
-gboolean bitlbee_io_new_client( GIOChannel *source, GIOCondition condition, gpointer data )
-{
-        size_t size = sizeof( struct sockaddr_in );
-        struct sockaddr_in conn_info;
-        int new_socket = accept( global.listen_socket, (struct sockaddr *) &conn_info, &size );
-        pid_t client_pid = 0;
-        
-        if( new_socket == -1 )
-        {
-                log_message( LOGLVL_WARNING, "Could not accept new connection: %s", strerror( errno ) );
-                return TRUE;
-        }
-        
-        if( global.conf->runmode == RUNMODE_FORKDAEMON )
-        {
-                int fds[2];
-                
-                if( socketpair( AF_UNIX, SOCK_STREAM, 0, fds ) == -1 )
-                {
-                        log_message( LOGLVL_WARNING, "Could not create IPC socket for client: %s", strerror( errno ) );
-                        fds[0] = fds[1] = -1;
-                }
-                
-                sock_make_nonblocking( fds[0] );
-                sock_make_nonblocking( fds[1] );
-                
-                client_pid = fork();
-                
-                if( client_pid > 0 && fds[0] != -1 )
-                {
-                        struct bitlbee_child *child;
-                        
-                        child = g_new0( struct bitlbee_child, 1 );
-                        child->pid = client_pid;
-                        child->ipc_fd = fds[0];
-                        child->ipc_inpa = gaim_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
-                        child_list = g_slist_append( child_list, child );
-                        
-                        log_message( LOGLVL_INFO, "Creating new subprocess with pid %d.", client_pid );
-                        
-                        /* Close some things we don't need in the parent process. */
-                        close( new_socket );
-                        close( fds[1] );
-                }
-                else if( client_pid == 0 )
-                {
-                        irc_t *irc;
-                        
-                        /* Close the listening socket, we're a client. */
-                        close( global.listen_socket );
-                        g_source_remove( global.listen_watch_source_id );
-                        
-                        /* Make the connection. */
-                        irc = irc_new( new_socket );
-                        
-                        /* We can store the IPC fd there now. */
-                        global.listen_socket = fds[1];
-                        global.listen_watch_source_id = gaim_input_add( fds[1], GAIM_INPUT_READ, ipc_child_read, irc );
-                        
-                        close( fds[0] );
-                        
-                        ipc_master_free_all();
-                }
-        }
-        else
-        {
-                log_message( LOGLVL_INFO, "Creating new connection with fd %d.", new_socket );
-                irc_new( new_socket );
-        }
-        
-        return TRUE;
-}
-
 void bitlbee_shutdown( gpointer data )
 {

bitlbee.h

@@ -109 +109 @@
 #include "sock.h"
 
-typedef struct global {
-        /* In forked mode, child processes store the fd of the IPC socket here. */
+typedef struct global_t {
         int listen_socket;
         gint listen_watch_source_id;
@@ -118 +117 @@
         char *helpfile;
         GMainLoop *loop;
-        int restart;
 } global_t;
 
@@ -127 +125 @@
 gboolean bitlbee_io_current_client_write( GIOChannel *source, GIOCondition condition, gpointer data );
 
-void root_command_string( irc_t *irc, user_t *u, char *command, int flags );
-void root_command( irc_t *irc, char *command[] );
+int root_command_string( irc_t *irc, user_t *u, char *command, int flags );
+int root_command( irc_t *irc, char *command[] );
 void bitlbee_shutdown( gpointer data );
 double gettime( void );

commands.h

@@ -29 +29 @@
 #include "bitlbee.h"
 
-typedef struct command
+typedef struct command_t
 {
         char *command;
         int required_parameters;
-        void (*execute)(irc_t *, char **args);
-        int flags;
+        int (*execute)(irc_t *, char **args);
 } command_t;
+
+int cmd_account( irc_t *irc, char **cmd );
+int cmd_help( irc_t *irc, char **args);
+int cmd_info( irc_t *irc, char **args);
+int cmd_add( irc_t *irc, char **args) ;
+int cmd_rename( irc_t *irc, char **args );
+int cmd_remove( irc_t *irc, char **args );
+int cmd_block( irc_t *irc, char **args );
+int cmd_allow( irc_t *irc, char **args );
+int cmd_save( irc_t *irc, char **args );
+int cmd_set( irc_t *irc, char **args );
+int cmd_yesno( irc_t *irc, char **args );
+int cmd_identify( irc_t *irc, char **args );
+int cmd_register( irc_t *irc, char **args );
+int cmd_drop( irc_t *irc, char **args );
+int cmd_blist( irc_t *irc, char **cmd );
+int cmd_nick( irc_t *irc, char **cmd );
+int cmd_qlist( irc_t *irc, char **cmd );
+int cmd_import_buddies( irc_t *irc, char **cmd );
+int cmd_dump( irc_t *irc, char **cmd );
 
 extern const command_t commands[];
 
-#define IRC_CMD_PRE_LOGIN       1
-#define IRC_CMD_LOGGED_IN       2
-#define IRC_CMD_OPER_ONLY       4
-#define IRC_CMD_TO_MASTER       8
-
-#define IPC_CMD_TO_CHILDREN     1
-
 #endif

conf.c

@@ -32 +32 @@
 #include "ini.h"
 #include "url.h"
-#include "ipc.h"
 
 #include "protocols/proxy.h"
@@ -62 +61 @@
         conf->configdir = g_strdup( CONFIG );
         conf->plugindir = g_strdup( PLUGINDIR );
-        conf->pidfile = g_strdup( "/var/run/bitlbee.pid" );
         conf->motdfile = g_strdup( ETCDIR "/motd.txt" );
         conf->ping_interval = 180;
         conf->ping_timeout = 300;
-        proxytype = 0;
         
         i = conf_loadini( conf, CONF_FILE );
@@ -79 +76 @@
         }
         
-        while( argc > 0 && ( opt = getopt( argc, argv, "i:p:P:nvIDFc:d:hR:" ) ) >= 0 )
-        /*     ^^^^ Just to make sure we skip this step from the REHASH handler. */
+        while( ( opt = getopt( argc, argv, "i:p:nvIDFc:d:h" ) ) >= 0 )
         {
                 if( opt == 'i' )
@@ -95 +91 @@
                         conf->port = i;
                 }
-                else if( opt == 'p' )
-                {
-                        g_free( conf->pidfile );
-                        conf->pidfile = g_strdup( optarg );
-                }
                 else if( opt == 'n' )
-                        conf->nofork = 1;
+                        conf->nofork=1;
                 else if( opt == 'v' )
-                        conf->verbose = 1;
+                        conf->verbose=1;
                 else if( opt == 'I' )
-                        conf->runmode = RUNMODE_INETD;
+                        conf->runmode=RUNMODE_INETD;
                 else if( opt == 'D' )
-                        conf->runmode = RUNMODE_DAEMON;
+                        conf->runmode=RUNMODE_DAEMON;
                 else if( opt == 'F' )
-                        conf->runmode = RUNMODE_FORKDAEMON;
+                        conf->runmode=RUNMODE_FORKDAEMON;
                 else if( opt == 'c' )
                 {
@@ -117 +108 @@
                                 CONF_FILE = g_strdup( optarg );
                                 g_free( conf );
-                                /* Re-evaluate arguments. Don't use this option twice, 
-                                   you'll end up in an infinite loop! Hope this trick
-                                   works with all libcs BTW.. */
-                                optind = 1;
                                 return( conf_load( argc, argv ) );
                         }
@@ -139 +126 @@
                                 "  -D  Daemon mode. (Still EXPERIMENTAL!)\n"
                                 "  -F  Forking daemon. (one process per client)\n"
-                                "  -P  Specify PID-file (not for inetd mode)\n"
                                 "  -i  Specify the interface (by IP address) to listen on.\n"
                                 "      (Default: 0.0.0.0 (any interface))\n"
@@ -150 +136 @@
                         return( NULL );
                 }
-                else if( opt == 'R' )
-                {
-                        /* We can't load the statefile yet (and should make very sure we do this
-                           only once), so set the filename here and load the state information
-                           when initializing ForkDaemon. (This option only makes sense in that
-                           mode anyway!) */
-                        ipc_master_set_statefile( optarg );
-                }
         }
         
@@ -191 +169 @@
                                 else
                                         conf->runmode = RUNMODE_INETD;
-                        }
-                        else if( g_strcasecmp( ini->key, "pidfile" ) == 0 )
-                        {
-                                g_free( conf->pidfile );
-                                conf->pidfile = g_strdup( ini->value );
                         }
                         else if( g_strcasecmp( ini->key, "daemoninterface" ) == 0 )

conf.h

@@ -43 +43 @@
         char *configdir;
         char *plugindir;
-        char *pidfile;
         char *motdfile;
         char *primary_storage;

configure

@@ -14 +14 @@
 datadir='$prefix/share/bitlbee/'
 config='/var/lib/bitlbee/'
-pidfile='/var/run/bitlbee.pid'
-ipcsocket='/var/run/bitlbee'
 plugindir='$prefix/lib/bitlbee'
 
@@ -48 +46 @@
 --datadir=...                                           $datadir
 --plugindir=...                                         $plugindir
---pidfile=...                                           $pidfile
 --config=...                                            $config
---ipcsocket=...                                         $ipcsocket
 
 --msn=0/1       Disable/enable MSN part                 $msn
@@ -78 +74 @@
 config=`eval echo "$config/" | sed 's/\/\{1,\}/\//g'`
 plugindir=`eval echo "$plugindir/" | sed 's/\/\{1,\}/\//g'`
-pidfile=`eval echo "$pidfile" | sed 's/\/\{1,\}/\//g'`
-ipcsocket=`eval echo "$ipcsocket" | sed 's/\/\{1,\}/\//g'`
 
 cat<<EOF>Makefile.settings
@@ -90 +84 @@
 PLUGINDIR=$plugindir
 CONFIG=$config
-IPCSOCKET=$ipcsocket
 
 ARCH=$arch
@@ -111 +104 @@
 #define VARDIR "$datadir"
 #define PLUGINDIR "$plugindir"
-#define PIDFILE "$pidfile"
-#define IPCSOCKET "$ipcsocket"
 #define ARCH "$arch"
 #define CPU "$cpu"

doc/README

@@ -50 +50 @@
 
 These days, MSN Messenger clients have to connect to the MS Passport servers
-through HTTPS. BitlBee can use several SSL libraries for this: GnuTLS, NSS
+through HTTPS. BitlBee can use serveral SSL libraries for this: GnuTLS, NSS
 (which comes with Mozilla) and OpenSSL. OpenSSL is not GPL-compatible in some
 situations, so using GnuTLS or NSS is preferred. However, especially on *BSD,

irc.c

@@ -27 +27 @@
 #include "bitlbee.h"
 #include "crypting.h"
-#include "ipc.h"
 
 static gboolean irc_userping( gpointer _irc );
@@ -152 +151 @@
 }
 
-/* immed=1 makes this function pretty much equal to irc_free(), except that
-   this one will "log". In case the connection is already broken and we
-   shouldn't try to write to it. */
-void irc_abort( irc_t *irc, int immed, char *format, ... )
-{
-        if( format != NULL )
-        {
-                va_list params;
-                char *reason;
-                
-                va_start( params, format );
-                reason = g_strdup_vprintf( format, params );
-                va_end( params );
-                
-                if( !immed )
-                        irc_write( irc, "ERROR :Closing link: %s", reason );
-                
-                ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
-                                   irc->nick ? irc->nick : "(NONE)", irc->host, reason );
-                
-                g_free( reason );
-        }
-        else
-        {
-                if( !immed )
-                        irc_write( irc, "ERROR :Closing link" );
-                
-                ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
-                                   irc->nick ? irc->nick : "(NONE)", irc->host, "No reason given" );
-        }
-        
-        irc->status = USTATUS_SHUTDOWN;
-        if( irc->sendbuffer && !immed )
-        {
-                /* We won't read from this socket anymore. Instead, we'll connect a timer
-                   to it that should shut down the connection in a second, just in case
-                   bitlbee_.._write doesn't do it first. */
-                
-                g_source_remove( irc->r_watch_source_id );
-                irc->r_watch_source_id = g_timeout_add_full( G_PRIORITY_HIGH, 1000, (GSourceFunc) irc_free, irc, NULL );
-        }
-        else
-        {
-                irc_free( irc );
-        }
-}
-
 static gboolean irc_free_userhash( gpointer key, gpointer value, gpointer data )
 {
@@ -220 +172 @@
                 if( storage_save( irc, TRUE ) != STORAGE_OK )
                         irc_usermsg( irc, "Error while saving settings!" );
-        
-        closesocket( irc->fd );
         
         if( irc->ping_source_id > 0 )
@@ -341 +291 @@
 }
 
-void irc_process( irc_t *irc )
-{
-        char **lines, *temp, **cmd;
+int irc_process( irc_t *irc )
+{
+        char **lines, *temp;    
         int i;
 
-        if( irc->readbuffer != NULL )
-        {
-                lines = irc_tokenize( irc->readbuffer );
-                
-                for( i = 0; *lines[i] != '\0'; i ++ )
-                {
-                        if( lines[i+1] == NULL )
-                        {
+        if( irc->readbuffer != NULL ) {
+                lines = irc_tokenize(irc->readbuffer );
+                for( i = 0; *lines[i] != '\0'; i++ ) {
+                        if( lines[i+1] == NULL ) {
                                 temp = g_strdup( lines[i] );
                                 g_free( irc->readbuffer );
                                 irc->readbuffer = temp;
-                                i ++;
+                                i++;
                                 break;
                         }                       
-                        
-                        if( ( cmd = irc_parse_line( lines[i] ) ) == NULL )
-                                continue;
-                        irc_exec( irc, cmd );
-                        
-                        g_free( cmd );
-                        
-                        /* Shouldn't really happen, but just in case... */
-                        if( !g_slist_find( irc_connection_list, irc ) )
-                        {
+                        if (!irc_process_line(irc, lines[i])) {
                                 g_free( lines );
-                                return;
-                        }
-                }
-                
-                if( lines[i] != NULL )
-                {
-                        g_free( irc->readbuffer );
-                        irc->readbuffer = NULL;
-                }
-                
+                                return 0;
+                        }
+                }
+                if(lines[i]!=NULL) {
+                        g_free(irc->readbuffer);
+                        irc->readbuffer=NULL;   
+                }
                 g_free( lines );
         }
+        return 1;       
 }
 
@@ -391 +326 @@
 
         /* Count the number of elements we're gonna need. */
-        for( i = 0, j = 1; buffer[i] != '\0'; i ++ )
-        {
-                if( buffer[i] == '\n' )
-                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
-                                j ++;
+        for(i=0, j=1; buffer[i]!='\0'; i++ ) {
+                if(buffer[i]=='\n' )
+                        if(buffer[i+1]!='\r' && buffer[i+1]!='\n')
+                                j++;
         }
         
         /* Allocate j+1 elements. */
-        lines = g_new( char *, j + 1 );
+        lines=g_new (char *, j+1);
         
         /* NULL terminate our list. */ 
-        lines[j] = NULL;
-        
-        lines[0] = buffer;
+        lines[j]=NULL;
+        
+        lines[0]=buffer;
         
         /* Split the buffer in several strings, using \r\n as our seperator, where \r is optional.
          * Although this is not in the RFC, some braindead ircds (newnet's) use this, so some clients might too. 
          */
-        for( i = 0, j = 0; buffer[i] != '\0'; i ++)
-        {
-                if( buffer[i] == '\n' )
-                {
-                        buffer[i] = '\0';
-                        
-                        if( i > 0 && buffer[i-1] == '\r' )
-                                buffer[i-1] = '\0';
-                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
-                                lines[++j] = buffer + i + 1;
-                }
-        }
-        
-        return( lines );
-}
-
-char **irc_parse_line( char *line )
+        for( i=0, j=0; buffer[i]!='\0'; i++) {
+                if(buffer[i]=='\n') {
+                        buffer[i]='\0';
+
+                        /* We dont want to read 1 byte before our buffer
+                         * and (in rare cases) generate a SIGSEGV.
+                         */
+                        if(i!=0)
+                                if(buffer[i-1]=='\r')
+                                        buffer[i-1]='\0';
+                        if(buffer[i+1]!='\r'&&buffer[i+1]!='\n')
+                                lines[++j]=buffer+i+1;
+                }
+        }
+
+        return(lines);
+}
+
+int irc_process_line( irc_t *irc, char *line )
 {
         int i, j;
@@ -431 +367 @@
         
         /* Move the line pointer to the start of the command, skipping spaces and the optional prefix. */
-        if( line[0] == ':' )
-        {
-                for( i = 0; line[i] != ' '; i ++ );
-                line = line + i;
-        }
-        for( i = 0; line[i] == ' '; i ++ );
-        line = line + i;
-        
+        if(line[0]==':') {
+                for(i=0; line[i]!=32; i++);
+                line=line+i;
+        }
+        for(i=0; line[i]==32; i++);
+        line=line+i;
+
         /* If we're already at the end of the line, return. If not, we're going to need at least one element. */
-        if( line[0] == '\0')
-                return NULL;
-        
-        /* Count the number of char **cmd elements we're going to need. */
-        j = 1;
-        for( i = 0; line[i] != '\0'; i ++ )
-        {
-                if( line[i] == ' ' )
-                {
-                        j ++;
+        if(line[0]=='\0')
+                return 1;
+        else
+                j=1;    
+        
+        /* Count the number of char **cmd elements we're going to need. */      
+        for(i=0; line[i]!='\0'; i++) {
+                if((line[i]==32) && (line[i+1]!=32) && (line[i+1]!='\0') && (line[i+1]!=':'))           
+                        j++;
+                else if((line[i]==':') && (line[i+1]!='\0') && (line[i-1]==32)) {
+                        j++;
+                        break;
+                }
                         
-                        if( line[i+1] == ':' )
-                                break;
-                }
         }       
 
         /* Allocate the space we need. */
-        cmd = g_new( char *, j + 1 );
-        cmd[j] = NULL;
+        cmd=g_new(char *, j+1);
+        cmd[j]=NULL;
         
         /* Do the actual line splitting, format is:
@@ -465 +400 @@
          */
 
-        cmd[0] = line;
-        for( i = 0, j = 0; line[i] != '\0'; i ++ )
-        {
-                if( line[i] == ' ' )
-                {
-                        line[i] = '\0';
-                        cmd[++j] = line + i + 1;
+        cmd[0]=line;
+        for(i=0, j=0; line[i]!='\0'; i++) {
+                if((line[i]==32)) {
+                        line[i]='\0';
+                        if((line[i+1]!=32) && (line[i+1]!='\0') && (line[i+1]!=':'))            
+                                cmd[++j]=line+i+1;
+                }
+                else if((line[i]==':') && (line[i+1]!='\0') && (line[i-1]=='\0')) {
+                        cmd[++j]=line+i+1;
+                        break;
+                }
+        }
+        
+        i=irc_exec(irc, cmd);
+        g_free(cmd);
+
+        return(i);      
+}
+
+int irc_exec( irc_t *irc, char **cmd )
+{       
+        int i;
+
+        if( (global.conf)->authmode == AUTHMODE_CLOSED && irc->status < USTATUS_AUTHORIZED )
+        {
+                if( g_strcasecmp( cmd[0], "PASS" ) == 0 )
+                {
+                        if( !cmd[1] )
+                        {
+                                irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                        }
+                        else if( strcmp( cmd[1], (global.conf)->auth_pass ) == 0 )
+                        {
+                                irc->status = USTATUS_AUTHORIZED;
+                        }
+                        else
+                        {
+                                irc_reply( irc, 464, ":Nope, maybe you should try it again..." );
+                        }
+                }
+                else
+                {
+                        irc_reply( irc, 464, ":Uhh, fine, but I want the password first." );
+                }
+                
+                return( 1 );
+        }
+        
+        if( g_strcasecmp( cmd[0], "USER" ) == 0 )
+        {
+                if( !( cmd[1] && cmd[2] && cmd[3] && cmd[4] ) )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+                else if( irc->user )
+                {
+                        irc_reply( irc, 462, ":You can't change your nick/userinfo" );
+                }
+                else
+                {
+                        irc->user = g_strdup( cmd[1] );
+                        irc->realname = g_strdup( cmd[4] );
+                        if( irc->nick ) irc_login( irc );
+                }
+                return( 1 );
+        }
+        else if( g_strcasecmp( cmd[0], "NICK" ) == 0 )
+        {
+                if( !cmd[1] )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+                else if( irc->nick )
+                {
+                        irc_reply( irc, 438, ":The hand of the deity is upon thee, thy nick may not change" );
+                }
+                /* This is not clean, but for now it'll have to be like this... */
+                else if( ( nick_cmp( cmd[1], irc->mynick ) == 0 ) || ( nick_cmp( cmd[1], NS_NICK ) == 0 ) )
+                {
+                        irc_reply( irc, 433, ":This nick is already in use" );
+                }
+                else if( !nick_ok( cmd[1] ) )
+                {
+                        /* [SH] Invalid characters. */
+                        irc_reply( irc, 432, ":This nick contains invalid characters" );
+                }
+                else
+                {
+                        irc->nick = g_strdup( cmd[1] );
+                        if( irc->user ) irc_login( irc );
+                }
+                return( 1 );
+        }
+        else if( g_strcasecmp( cmd[0], "QUIT" ) == 0 )
+        {
+                irc_write( irc, "ERROR :%s%s", cmd[1]?"Quit: ":"", cmd[1]?cmd[1]:"Client Quit" );
+                g_io_channel_close( irc->io_channel );
+                return( 0 );
+        }
+        
+        if( !irc->user || !irc->nick )
+        {
+                irc_reply( irc, 451, ":Register first" );
+                return( 1 );
+        }
+        
+        if( g_strcasecmp( cmd[0], "PING" ) == 0 )
+        {
+                irc_write( irc, ":%s PONG %s :%s", irc->myhost, irc->myhost, cmd[1]?cmd[1]:irc->myhost );
+        }
+        else if( g_strcasecmp( cmd[0], "OPER" ) == 0 )
+        {
+                if( !cmd[2] )
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                else if( strcmp( cmd[2], global.conf->oper_pass ) == 0 )
+                        irc_umode_set( irc, "+o", 1 );
+                // else
+                        /* FIXME/TODO: Find out which reply to send now. */
+        }
+        else if( g_strcasecmp( cmd[0], "MODE" ) == 0 )
+        {
+                if( !cmd[1] )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+                else if( *cmd[1] == '#' || *cmd[1] == '&' )
+                {
+                        if( cmd[2] )
+                        {
+                                if( *cmd[2] == '+' || *cmd[2] == '-' )
+                                        irc_reply( irc, 477, "%s :Can't change channel modes", cmd[1] );
+                                else if( *cmd[2] == 'b' )
+                                        irc_reply( irc, 368, "%s :No bans possible", cmd[1] );
+                        }
+                        else
+                                irc_reply( irc, 324, "%s +%s", cmd[1], CMODE );
+                }
+                else
+                {
+                        if( nick_cmp( cmd[1], irc->nick ) == 0 )
+                        {
+                                if( cmd[2] )
+                                        irc_umode_set( irc, cmd[2], 0 );
+                        }
+                        else
+                                irc_reply( irc, 502, ":Don't touch their modes" );
+                }
+        }
+        else if( g_strcasecmp( cmd[0], "NAMES" ) == 0 )
+        {
+                irc_names( irc, cmd[1]?cmd[1]:irc->channel );
+        }
+        else if( g_strcasecmp( cmd[0], "PART" ) == 0 )
+        {
+                struct conversation *c;
+                
+                if( !cmd[1] )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+                else if( g_strcasecmp( cmd[1], irc->channel ) == 0 )
+                {
+                        user_t *u = user_find( irc, irc->nick );
                         
-                        if( line[i+1] == ':' )
-                        {
-                                cmd[j] ++;
+                        /* Not allowed to leave control channel */
+                        irc_part( irc, u, irc->channel );
+                        irc_join( irc, u, irc->channel );
+                }
+                else if( ( c = conv_findchannel( cmd[1] ) ) )
+                {
+                        user_t *u = user_find( irc, irc->nick );
+                        
+                        irc_part( irc, u, c->channel );
+                        
+                        if( c->gc && c->gc->prpl )
+                        {
+                                c->joined = 0;
+                                c->gc->prpl->chat_leave( c->gc, c->id );
+                        }
+                }
+                else
+                {
+                        irc_reply( irc, 403, "%s :No such channel", cmd[1] );
+                }
+        }
+        else if( g_strcasecmp( cmd[0], "JOIN" ) == 0 )
+        {
+                if( !cmd[1] )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+                else if( g_strcasecmp( cmd[1], irc->channel ) == 0 )
+                        ; /* Dude, you're already there...
+                             RFC doesn't have any reply for that though? */
+                else if( cmd[1] )
+                {
+                        if( ( cmd[1][0] == '#' || cmd[1][0] == '&' ) && cmd[1][1] )
+                        {
+                                user_t *u = user_find( irc, cmd[1] + 1 );
+                                
+                                if( u && u->gc && u->gc->prpl && u->gc->prpl->chat_open )
+                                {
+                                        irc_reply( irc, 403, "%s :Initializing groupchat in a different channel", cmd[1] );
+                                        
+                                        if( !u->gc->prpl->chat_open( u->gc, u->handle ) )
+                                        {
+                                                irc_usermsg( irc, "Could not open a groupchat with %s, maybe you don't have a connection to him/her yet?", u->nick );
+                                        }
+                                }
+                                else
+                                {
+                                        irc_reply( irc, 403, "%s :Groupchats are not possible with %s", cmd[1], cmd[1]+1 );
+                                }
+                        }
+                        else
+                        {
+                                irc_reply( irc, 403, "%s :No such channel", cmd[1] );
+                        }
+                }
+        }
+        else if( g_strcasecmp( cmd[0], "INVITE" ) == 0 )
+        {
+                if( cmd[1] && cmd[2] )
+                        irc_invite( irc, cmd[1], cmd[2] );
+                else
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+        }
+        else if( g_strcasecmp( cmd[0], "PRIVMSG" ) == 0 || g_strcasecmp( cmd[0], "NOTICE" ) == 0 )
+        {
+                if( !cmd[1] )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                } 
+                else if ( !cmd[2] ) 
+                {
+                        irc_reply( irc, 412, ":No text to send" );
+                }
+                else if ( irc->nick && g_strcasecmp( cmd[1], irc->nick ) == 0 ) 
+                {
+                        irc_write( irc, ":%s!%s@%s %s %s :%s", irc->nick, irc->user, irc->host, cmd[0], cmd[1], cmd[2] ); 
+                }
+                else 
+                {
+                        if( g_strcasecmp( cmd[1], irc->channel ) == 0 )
+                        {
+                                unsigned int i;
+                                char *t = set_getstr( irc, "default_target" );
+                                
+                                if( g_strcasecmp( t, "last" ) == 0 && irc->last_target )
+                                        cmd[1] = irc->last_target;
+                                else if( g_strcasecmp( t, "root" ) == 0 )
+                                        cmd[1] = irc->mynick;
+                                
+                                for( i = 0; i < strlen( cmd[2] ); i ++ )
+                                {
+                                        if( cmd[2][i] == ' ' ) break;
+                                        if( cmd[2][i] == ':' || cmd[2][i] == ',' )
+                                        {
+                                                cmd[1] = cmd[2];
+                                                cmd[2] += i;
+                                                *cmd[2] = 0;
+                                                while( *(++cmd[2]) == ' ' );
+                                                break;
+                                        }
+                                }
+                                
+                                irc->is_private = 0;
+                                
+                                if( cmd[1] != irc->last_target )
+                                {
+                                        if( irc->last_target )
+                                                g_free( irc->last_target );
+                                        irc->last_target = g_strdup( cmd[1] );
+                                }
+                        }
+                        else
+                        {
+                                irc->is_private = 1;
+                        }
+                        irc_send( irc, cmd[1], cmd[2], ( g_strcasecmp( cmd[0], "NOTICE" ) == 0 ) ? IM_FLAG_AWAY : 0 );
+                }
+        }
+        else if( g_strcasecmp( cmd[0], "WHO" ) == 0 )
+        {
+                irc_who( irc, cmd[1] );
+        }
+        else if( g_strcasecmp( cmd[0], "USERHOST" ) == 0 )
+        {
+                user_t *u;
+                
+                if( !cmd[1] )
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+                /* [TV] Usable USERHOST-implementation according to
+                        RFC1459. Without this, mIRC shows an error
+                        while connecting, and the used way of rejecting
+                        breaks standards.
+                */
+                
+                for( i = 1; cmd[i]; i ++ )
+                        if( ( u = user_find( irc, cmd[i] ) ) )
+                        {
+                                if( u->online && u->away )
+                                        irc_reply( irc, 302, ":%s=-%s@%s", u->nick, u->user, u->host );
+                                else
+                                        irc_reply( irc, 302, ":%s=+%s@%s", u->nick, u->user, u->host );
+                        }
+        }
+        else if( g_strcasecmp( cmd[0], "ISON" ) == 0 )
+        {
+                user_t *u;
+                char buff[IRC_MAX_LINE];
+                int lenleft;
+                
+                buff[0] = '\0';
+                
+                /* [SH] Leave room for : and \0 */
+                lenleft = IRC_MAX_LINE - 2;
+                
+                for( i = 1; cmd[i]; i ++ )
+                {
+                        if( ( u = user_find( irc, cmd[i] ) ) && u->online )
+                        {
+                                /* [SH] Make sure we don't use too much buffer space. */
+                                lenleft -= strlen( u->nick ) + 1;
+                                
+                                if( lenleft < 0 )
+                                {
+                                        break;
+                                }
+                                
+                                /* [SH] Add the nick to the buffer. Note
+                                 * that an extra space is always added. Even
+                                 * if it's the last nick in the list. Who
+                                 * cares?
+                                 */
+                                
+                                strcat( buff, u->nick );
+                                strcat( buff, " " );
+                        }
+                }
+                
+                /* [WvG] Well, maybe someone cares, so why not remove it? */
+                if( strlen( buff ) > 0 )
+                        buff[strlen(buff)-1] = '\0';
+                
+                /* [SH] By the way, that really *was* WvG talking. */
+                /* [WvG] Really? */
+                /* [SH] Yeah... But *this* is WvG talking too. ;-P */
+                /* [WvG] *sigh* */
+                
+                irc_reply( irc, 303, ":%s", buff );
+        }
+        else if( g_strcasecmp( cmd[0], "WATCH" ) == 0 )
+        {
+                /* Obviously we could also mark a user structure as being
+                   watched, but what if the WATCH command is sent right
+                   after connecting? The user won't exist yet then... */
+                for( i = 1; cmd[i]; i ++ )
+                {
+                        char *nick;
+                        user_t *u;
+                        
+                        if( !cmd[i][0] || !cmd[i][1] )
                                 break;
-                        }
-                }
-        }
-        
-        return cmd;
-}
-
-char *irc_build_line( char **cmd )
-{
-        int i, len;
-        char *s;
-        
-        if( cmd[0] == NULL )
-                return NULL;
-        
-        len = 1;
-        for( i = 0; cmd[i]; i ++ )
-                len += strlen( cmd[i] ) + 1;
-        
-        if( strchr( cmd[i-1], ' ' ) != NULL )
-                len ++;
-        
-        s = g_new0( char, len + 1 );
-        for( i = 0; cmd[i]; i ++ )
-        {
-                if( cmd[i+1] == NULL && strchr( cmd[i], ' ' ) != NULL )
-                        strcat( s, ":" );
-                
-                strcat( s, cmd[i] );
-                
-                if( cmd[i+1] )
-                        strcat( s, " " );
-        }
-        strcat( s, "\r\n" );
-        
-        return s;
+                        
+                        nick = g_strdup( cmd[i] + 1 );
+                        nick_lc( nick );
+                        
+                        u = user_find( irc, nick );
+                        
+                        if( cmd[i][0] == '+' )
+                        {
+                                if( !g_hash_table_lookup( irc->watches, nick ) )
+                                        g_hash_table_insert( irc->watches, nick, nick );
+                                
+                                if( u && u->online )
+                                        irc_reply( irc, 604, "%s %s %s %d :%s", u->nick, u->user, u->host, time( NULL ), "is online" );
+                                else
+                                        irc_reply( irc, 605, "%s %s %s %d :%s", nick, "*", "*", time( NULL ), "is offline" );
+                        }
+                        else if( cmd[i][0] == '-' )
+                        {
+                                gpointer okey, ovalue;
+                                
+                                if( g_hash_table_lookup_extended( irc->watches, nick, &okey, &ovalue ) )
+                                {
+                                        g_free( okey );
+                                        g_hash_table_remove( irc->watches, okey );
+                                        
+                                        irc_reply( irc, 602, "%s %s %s %d :%s", nick, "*", "*", 0, "Stopped watching" );
+                                }
+                        }
+                }
+        }
+        else if( g_strcasecmp( cmd[0], "TOPIC" ) == 0 )
+        {
+                if( cmd[1] && cmd[2] )
+                        irc_reply( irc, 482, "%s :Cannot change topic", cmd[1] );
+                else if( cmd[1] )
+                        irc_topic( irc, cmd[1] );
+                else
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+        }
+        else if( g_strcasecmp( cmd[0], "AWAY" ) == 0 )
+        {
+                irc_away( irc, cmd[1] );
+        }
+        else if( g_strcasecmp( cmd[0], "WHOIS" ) == 0 )
+        {
+                if( cmd[1] )
+                {
+                        irc_whois( irc, cmd[1] );
+                }
+                else
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+        }
+        else if( g_strcasecmp( cmd[0], "WHOWAS" ) == 0 )
+        {
+                /* For some reason irssi tries a whowas when whois fails. We can
+                   ignore this, but then the user never gets a "user not found"
+                   message from irssi which is a bit annoying. So just respond
+                   with not-found and irssi users will get better error messages */
+                
+                if( cmd[1] )
+                {
+                        irc_reply( irc, 406, "%s :Nick does not exist", cmd[1] );
+                        irc_reply( irc, 369, "%s :End of WHOWAS", cmd[1] );
+                }
+                else
+                {
+                        irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                }
+        }
+        else if( ( g_strcasecmp( cmd[0], "NICKSERV" ) == 0 ) || ( g_strcasecmp( cmd[0], "NS" ) == 0 ) )
+        {
+                /* [SH] This aliases the NickServ command to PRIVMSG root */
+                /* [TV] This aliases the NS command to PRIVMSG root as well */
+                root_command( irc, cmd + 1 );
+        }
+        else if( g_strcasecmp( cmd[0], "MOTD" ) == 0 )
+        {
+                irc_motd( irc );
+        }
+        else if( g_strcasecmp( cmd[0], "PONG" ) == 0 )
+        {
+                /* We could check the value we get back from the user, but in
+                   fact we don't care, we're just happy he's still alive. */
+                irc->last_pong = gettime();
+                irc->pinging = 0;
+        }
+        else if( g_strcasecmp( cmd[0], "COMPLETIONS" ) == 0 )
+        {
+                user_t *u = user_find( irc, irc->mynick );
+                help_t *h;
+                set_t *s;
+                int i;
+                
+                irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS ", "OK" );
+                
+                for( i = 0; commands[i].command; i ++ )
+                        irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS ", commands[i].command );
+                
+                for( h = global.help; h; h = h->next )
+                        irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS help ", h->string );
+                
+                for( s = irc->set; s; s = s->next )
+                        irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS set ", s->key );
+                
+                irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS ", "END" );
+        }
+        else if( set_getint( irc, "debug" ) )
+        {
+                irc_usermsg( irc, "\002--- Unknown command:" );
+                for( i = 0; cmd[i]; i ++ ) irc_usermsg( irc, "%s", cmd[i] );
+                irc_usermsg( irc, "\002--------------------" );
+        }
+        
+        return( 1 );
 }
 
@@ -671 +1040 @@
 }
 
-int irc_check_login( irc_t *irc )
-{
-        if( irc->user && irc->nick )
-        {
-                if( global.conf->authmode == AUTHMODE_CLOSED && irc->status < USTATUS_AUTHORIZED )
-                {
-                        irc_reply( irc, 464, ":This server is password-protected." );
-                        return 0;
-                }
-                else
-                {
-                        irc_login( irc );
-                        return 1;
-                }
-        }
-        else
-        {
-                /* More information needed. */
-                return 0;
-        }
+void irc_who( irc_t *irc, char *channel )
+{
+        user_t *u = irc->users;
+        struct conversation *c;
+        GList *l;
+        
+        if( !channel || *channel == '0' || *channel == '*' || !*channel )
+                while( u )
+                {
+                        irc_reply( irc, 352, "%s %s %s %s %s %c :0 %s", u->online ? irc->channel : "*", u->user, u->host, irc->myhost, u->nick, u->online ? ( u->away ? 'G' : 'H' ) : 'G', u->realname );
+                        u = u->next;
+                }
+        else if( g_strcasecmp( channel, irc->channel ) == 0 )
+                while( u )
+                {
+                        if( u->online )
+                                irc_reply( irc, 352, "%s %s %s %s %s %c :0 %s", channel, u->user, u->host, irc->myhost, u->nick, u->away ? 'G' : 'H', u->realname );
+                        u = u->next;
+                }
+        else if( ( c = conv_findchannel( channel ) ) )
+                for( l = c->in_room; l; l = l->next )
+                {
+                        if( ( u = user_findhandle( c->gc, l->data ) ) )
+                                irc_reply( irc, 352, "%s %s %s %s %s %c :0 %s", channel, u->user, u->host, irc->myhost, u->nick, u->away ? 'G' : 'H', u->realname );
+                }
+        else if( ( u = user_find( irc, channel ) ) )
+                irc_reply( irc, 352, "%s %s %s %s %s %c :0 %s", channel, u->user, u->host, irc->myhost, u->nick, u->online ? ( u->away ? 'G' : 'H' ) : 'G', u->realname );
+        
+        irc_reply( irc, 315, "%s :End of /WHO list.", channel?channel:"**" );
 }
 
@@ -725 +1103 @@
         u->realname = g_strdup( irc->realname );
         u->online = 1;
+//      u->send_handler = msg_echo;
         irc_spawn( irc, u );
         
         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." );
-        
-        if( global.conf->runmode == RUNMODE_FORKDAEMON || global.conf->runmode == RUNMODE_DAEMON )
-                ipc_to_master_str( "CLIENT %s %s :%s\r\n", irc->host, irc->nick, irc->realname );
         
         irc->status = USTATUS_LOGGED_IN;
@@ -783 +1159 @@
                 }
                 irc_reply( irc, 376, ":End of MOTD" );
-                close( fd );
+                closesocket( fd );
         }
 }
@@ -804 +1180 @@
 }
 
+void irc_whois( irc_t *irc, char *nick )
+{
+        user_t *u = user_find( irc, nick );
+        
+        if( u )
+        {
+                irc_reply( irc, 311, "%s %s %s * :%s", u->nick, u->user, u->host, u->realname );
+                
+                if( u->gc )
+                        irc_reply( irc, 312, "%s %s.%s :%s network", u->nick, u->gc->user->username,
+                                   *u->gc->user->proto_opt[0] ? u->gc->user->proto_opt[0] : "", u->gc->prpl->name );
+                else
+                        irc_reply( irc, 312, "%s %s :%s", u->nick, irc->myhost, IRCD_INFO );
+                
+                if( !u->online )
+                        irc_reply( irc, 301, "%s :%s", u->nick, "User is offline" );
+                else if( u->away )
+                        irc_reply( irc, 301, "%s :%s", u->nick, u->away );
+                
+                irc_reply( irc, 318, "%s :End of /WHOIS list", nick );
+        }
+        else
+        {
+                irc_reply( irc, 401, "%s :Nick does not exist", nick );
+        }
+}
+
+
 void irc_umode_set( irc_t *irc, char *s, int allow_priv )
 {
@@ -833 +1237 @@
 }
 
+int irc_away( irc_t *irc, char *away )
+{
+        user_t *u = user_find( irc, irc->nick );
+        GSList *c = get_connections();
+        
+        if( !u ) return( 0 );
+        
+        if( away && *away )
+        {
+                int i, j;
+                
+                /* Copy away string, but skip control chars. Mainly because
+                   Jabber really doesn't like them. */
+                u->away = g_malloc( strlen( away ) + 1 );
+                for( i = j = 0; away[i]; i ++ )
+                        if( ( u->away[j] = away[i] ) >= ' ' )
+                                j ++;
+                u->away[j] = 0;
+                
+                irc_reply( irc, 306, ":You're now away: %s", u->away );
+                /* irc_umode_set( irc, irc->myhost, "+a" ); */
+        }
+        else
+        {
+                if( u->away ) g_free( u->away );
+                u->away = NULL;
+                /* irc_umode_set( irc, irc->myhost, "-a" ); */
+                irc_reply( irc, 305, ":Welcome back" );
+        }
+        
+        while( c )
+        {
+                if( ((struct gaim_connection *)c->data)->flags & OPT_LOGGED_IN )
+                        proto_away( c->data, u->away );
+                
+                c = c->next;
+        }
+        
+        return( 1 );
+}
+
 void irc_spawn( irc_t *irc, user_t *u )
 {
@@ -884 +1329 @@
         }
         g_free( nick );
+}
+
+void irc_invite( irc_t *irc, char *nick, char *channel )
+{
+        struct conversation *c = conv_findchannel( channel );
+        user_t *u = user_find( irc, nick );
+        
+        if( u && c && ( u->gc == c->gc ) )
+                if( c->gc && c->gc->prpl && c->gc->prpl->chat_invite )
+                {
+                        c->gc->prpl->chat_invite( c->gc, c->id, "", u->handle );
+                        irc_reply( irc, 341, "%s %s", nick, channel );
+                        return;
+                }
+        
+        irc_reply( irc, 482, "%s :Invite impossible; User/Channel non-existent or incompatible", channel );
 }
 
@@ -974 +1435 @@
                 
                 if( u->send_handler )
-                {
-                        u->send_handler( irc, u, s, flags );
-                        return 1;
-                }
+                        return( u->send_handler( irc, u, s, flags ) );
         }
         else if( c && c->gc && c->gc->prpl )
@@ -1003 +1461 @@
 }
 
-void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags )
-{
-        if( !u || !u->gc ) return;
+int buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags )
+{
+        if( !u || !u->gc ) return( 0 );
         
         if( set_getint( irc, "buddy_sendbuffer" ) && set_getint( irc, "buddy_sendbuffer_delay" ) > 0 )
@@ -1041 +1499 @@
                         g_source_remove( u->sendbuf_timer );
                 u->sendbuf_timer = g_timeout_add( delay, buddy_send_handler_delayed, u );
+                
+                return( 1 );
         }
         else
         {
-                serv_send_im( irc, u, msg, flags );
+                return( serv_send_im( irc, u, msg, flags ) );
         }
 }
@@ -1149 +1609 @@
         if( rv > 0 )
         {
-                irc_abort( irc, 0, "Ping Timeout: %d seconds", rv );
+                irc_write( irc, "ERROR :Closing Link: Ping Timeout: %d seconds", rv );
+                irc_free( irc );
                 return FALSE;
         }

irc.h

@@ -33 +33 @@
 #define IRC_PING_STRING "PinglBee"
 
-#define UMODES "iasw"
+#define UMODES "ias"
 #define UMODES_PRIV "Ro"
 #define CMODES "nt"
@@ -41 +41 @@
 typedef enum
 {
-        USTATUS_OFFLINE = 0,
+        USTATUS_OFFLINE,
         USTATUS_AUTHORIZED,
         USTATUS_LOGGED_IN,
-        USTATUS_IDENTIFIED,
-        USTATUS_SHUTDOWN = -1
+        USTATUS_IDENTIFIED
 } irc_status_t;
 
@@ -105 +104 @@
 
 irc_t *irc_new( int fd );
-void irc_abort( irc_t *irc, int immed, char *format, ... );
 void irc_free( irc_t *irc );
 
-void irc_exec( irc_t *irc, char **cmd );
-void irc_process( irc_t *irc );
-char **irc_parse_line( char *line );
-char *irc_build_line( char **cmd );
+int irc_exec( irc_t *irc, char **cmd );
+int irc_process( irc_t *irc );
+int irc_process_line( irc_t *irc, char *line );
 
 void irc_vawrite( irc_t *irc, char *format, va_list params );
@@ -121 +118 @@
 
 void irc_login( irc_t *irc );
-int irc_check_login( irc_t *irc );
 void irc_motd( irc_t *irc );
 void irc_names( irc_t *irc, char *channel );
@@ -134 +130 @@
 void irc_invite( irc_t *irc, char *nick, char *channel );
 void irc_whois( irc_t *irc, char *nick );
+int irc_away( irc_t *irc, char *away );
 void irc_setpass( irc_t *irc, const char *pass ); /* USE WITH CAUTION! */
 
@@ -141 +138 @@
 int irc_noticefrom( irc_t *irc, char *nick, char *msg );
 
-void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags );
+int buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags );
 
 #endif

log.c

@@ -38 +38 @@
         openlog("bitlbee", LOG_PID, LOG_DAEMON);        
 
-        logoutput.informational = &log_null;
-        logoutput.warning = &log_null;
-        logoutput.error = &log_null;
+        logoutput.informational=&log_null;
+        logoutput.warning=&log_null;
+        logoutput.error=&log_null;
 #ifdef DEBUG
-        logoutput.debug = &log_null;
+        logoutput.debug=&log_null;
 #endif
 
@@ -51 +51 @@
         /* I know it's ugly, but it works and I didn't feel like messing with pointer to function pointers */
 
-        if(level == LOGLVL_INFO) {
-                if(output == LOGOUTPUT_NULL)
-                        logoutput.informational = &log_null;    
-                else if(output == LOGOUTPUT_IRC)
-                        logoutput.informational = &log_irc;     
-                else if(output == LOGOUTPUT_SYSLOG)
-                        logoutput.informational = &log_syslog;  
-                else if(output == LOGOUTPUT_CONSOLE) 
-                        logoutput.informational = &log_console; 
+        if(level==LOGLVL_INFO) {
+                if(output==LOGOUTPUT_NULL)
+                        logoutput.informational=&log_null;      
+                else if(output==LOGOUTPUT_IRC)
+                        logoutput.informational=&log_irc;       
+                else if(output==LOGOUTPUT_SYSLOG)
+                        logoutput.informational=&log_syslog;    
+                else if(output==LOGOUTPUT_CONSOLE) 
+                        logoutput.informational=&log_console;   
         }
-        else if(level == LOGLVL_WARNING) {
-                if(output == LOGOUTPUT_NULL)
-                        logoutput.warning = &log_null;
-                else if(output == LOGOUTPUT_IRC)
-                        logoutput.warning = &log_irc;
-                else if(output == LOGOUTPUT_SYSLOG)
-                        logoutput.warning = &log_syslog;
-                else if(output == LOGOUTPUT_CONSOLE)
-                        logoutput.warning = &log_console;
+        else if(level==LOGLVL_WARNING) {
+                if(output==LOGOUTPUT_NULL)
+                        logoutput.warning=&log_null;
+                else if(output==LOGOUTPUT_IRC)
+                        logoutput.warning=&log_irc;
+                else if(output==LOGOUTPUT_SYSLOG)
+                        logoutput.warning=&log_syslog;
+                else if(output==LOGOUTPUT_CONSOLE)
+                        logoutput.warning=&log_console;
         }
-        else if(level == LOGLVL_ERROR) {
-                if(output == LOGOUTPUT_NULL)
-                        logoutput.error = &log_null;
-                else if(output == LOGOUTPUT_IRC)
-                        logoutput.error = &log_irc;
-                else if(output == LOGOUTPUT_SYSLOG)
-                        logoutput.error = &log_syslog;
-                else if(output == LOGOUTPUT_CONSOLE)
-                        logoutput.error = &log_console;
+        else if(level==LOGLVL_ERROR) {
+                if(output==LOGOUTPUT_NULL)
+                        logoutput.error=&log_null;
+                else if(output==LOGOUTPUT_IRC)
+                        logoutput.error=&log_irc;
+                else if(output==LOGOUTPUT_SYSLOG)
+                        logoutput.error=&log_syslog;
+                else if(output==LOGOUTPUT_CONSOLE)
+                        logoutput.error=&log_console;
         }
 #ifdef DEBUG
-        else if(level == LOGLVL_DEBUG) {
-                if(output == LOGOUTPUT_NULL)
-                        logoutput.debug = &log_null;
-                else if(output == LOGOUTPUT_IRC)
-                        logoutput.debug = &log_irc;
-                else if(output == LOGOUTPUT_SYSLOG)
-                        logoutput.debug = &log_syslog;
-                else if(output == LOGOUTPUT_CONSOLE)
-                        logoutput.debug = &log_console;
+        else if(level==LOGLVL_DEBUG) {
+                if(output==LOGOUTPUT_NULL)
+                        logoutput.debug=&log_null;
+                else if(output==LOGOUTPUT_IRC)
+                        logoutput.debug=&log_irc;
+                else if(output==LOGOUTPUT_SYSLOG)
+                        logoutput.debug=&log_syslog;
+                else if(output==LOGOUTPUT_CONSOLE)
+                        logoutput.debug=&log_console;
         }
 #endif
@@ -106 +106 @@
         va_end(ap);
 
-        if(level == LOGLVL_INFO)
+        if(level==LOGLVL_INFO)
                 (*(logoutput.informational))(level, msgstring);
-        if(level == LOGLVL_WARNING) 
+        if(level==LOGLVL_WARNING) 
                 (*(logoutput.warning))(level, msgstring);
-        if(level == LOGLVL_ERROR)
+        if(level==LOGLVL_ERROR)
                 (*(logoutput.error))(level, msgstring);
 #ifdef DEBUG
-        if(level == LOGLVL_DEBUG)
+        if(level==LOGLVL_DEBUG)
                 (*(logoutput.debug))(level, msgstring);
 #endif
@@ -133 +133 @@
 
 static void log_irc(int level, char *message) {
-        if(level == LOGLVL_ERROR)
+        if(level==LOGLVL_ERROR)
                 irc_write_all(1, "ERROR :Error: %s", message);
-        if(level == LOGLVL_WARNING)
+        if(level==LOGLVL_WARNING)
                 irc_write_all(0, "ERROR :Warning: %s", message);
-        if(level == LOGLVL_INFO)
+        if(level==LOGLVL_INFO)
                 irc_write_all(0, "ERROR :Informational: %s", message);  
 #ifdef DEBUG
-        if(level == LOGLVL_DEBUG)
+        if(level==LOGLVL_DEBUG)
                 irc_write_all(0, "ERROR :Debug: %s", message);  
 #endif  
@@ -148 +148 @@
 
 static void log_syslog(int level, char *message) {
-        if(level == LOGLVL_ERROR)
+        if(level==LOGLVL_ERROR)
                 syslog(LOG_ERR, "%s", message);
-        if(level == LOGLVL_WARNING)
+        if(level==LOGLVL_WARNING)
                 syslog(LOG_WARNING, "%s", message);
-        if(level == LOGLVL_INFO)
+        if(level==LOGLVL_INFO)
                 syslog(LOG_INFO, "%s", message);
 #ifdef DEBUG
-        if(level == LOGLVL_DEBUG)
+        if(level==LOGLVL_DEBUG)
                 syslog(LOG_DEBUG, "%s", message);
 #endif
@@ -162 +162 @@
 
 static void log_console(int level, char *message) {
-        if(level == LOGLVL_ERROR)
+        if(level==LOGLVL_ERROR)
                 fprintf(stderr, "Error: %s\n", message);
-        if(level == LOGLVL_WARNING)
+        if(level==LOGLVL_WARNING)
                 fprintf(stderr, "Warning: %s\n", message);
-        if(level == LOGLVL_INFO)
+        if(level==LOGLVL_INFO)
                 fprintf(stdout, "Informational: %s\n", message);
 #ifdef DEBUG
-        if(level == LOGLVL_DEBUG)
+        if(level==LOGLVL_DEBUG)
                 fprintf(stdout, "Debug: %s\n", message);
 #endif

protocols/jabber/jabber.c

@@ -413 +413 @@
                 if (jd->die)
                         signoff(GJ_GC(gjc));
-        } else if (len == 0 || (len < 0 && (!sockerr_again() || gjc->ssl))) {
+        } else if (len < 0 || errno != EAGAIN) {
                 STATE_EVT(JCONN_STATE_OFF)
         }

protocols/msn/msn.c

@@ -84 +84 @@
                 {
                         m = l->data;
-                
-                        serv_got_crap( gc, "Warning: Closing down MSN connection with unsent message to %s, you'll have to resend it.", m->who );
                         g_free( m->who );
                         g_free( m->text );
@@ -91 +89 @@
                 }
                 g_slist_free( md->msgq );
+                
+                serv_got_crap( gc, "Warning: Closing down MSN connection with unsent message(s), you'll have to resend them." );
         }
         

protocols/msn/sb.c

@@ -213 +213 @@
                 {
                         m = l->data;
-
                         g_free( m->who );
                         g_free( m->text );
@@ -220 +219 @@
                 g_slist_free( sb->msgq );
                 
-                serv_got_crap( gc, "Warning: Closing down MSN switchboard connection with "
-                                   "unsent message to %s, you'll have to resend it.",
-                                   m->who ? m->who : "(unknown)" );
+                serv_got_crap( gc, "Warning: Closing down MSN switchboard connection with unsent message(s), you'll have to resend them." );
         }
         

protocols/oscar/oscar.c

@@ -608 +608 @@
                 return;
         }
-        /* [WvG] Wheeeee! Who needs error checking anyway? ;-) */
         read(pos->fd, m, 16);
         m[16] = '\0';

protocols/oscar/rxqueue.c

@@ -353 +353 @@
                 return -1; /* its a aim_conn_close()'d connection */
 
-        /* KIDS, THIS IS WHAT HAPPENS IF YOU USE CODE WRITTEN FOR GUIS IN A DAEMON!
-           
-           And wouldn't it make sense to return something that prevents this function
-           from being called again IMMEDIATELY (and making the program suck up all
-           CPU time)?...
-           
-        if (conn->fd < 3)
+        if (conn->fd < 3)  /* can happen when people abuse the interface */
                 return 0;
-        */
 
         if (conn->status & AIM_CONN_STATUS_INPROGRESS)

protocols/oscar/service.c

@@ -736 +736 @@
 
         tlvlen = aim_addtlvtochain32(&tl, 0x0006, data);
+
+        printf("%d\n", tlvlen);
 
         if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 8)))

protocols/ssl_openssl.c

@@ -5 +5 @@
   \********************************************************************/
 
-/* SSL module - OpenTLS version                                          */
+/* SSL module - GnuTLS version                                          */
 
 /*
@@ -41 +41 @@
 struct scd
 {
-        SslInputFunction func;
+        ssl_input_function func;
         gpointer data;
         int fd;
         gboolean established;
         
+        int inpa;
+        int lasterr;            /* Necessary for SSL_get_error */
         SSL *ssl;
         SSL_CTX *ssl_ctx;
@@ -54 +56 @@
 
 
-void *ssl_connect( char *host, int port, SslInputFunction func, gpointer data )
+void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data )
 {
         struct scd *conn = g_new0( struct scd, 1 );
@@ -93 +95 @@
 }
 
+static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond );
+
 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond )
 {
@@ -98 +102 @@
         
         if( source == -1 )
-                goto ssl_connected_failure;
-        
+                return ssl_handshake( data, -1, cond );
+        
+        /* Make it non-blocking at least during the handshake... */
+        sock_make_nonblocking( conn->fd );
         SSL_set_fd( conn->ssl, conn->fd );
         
-        if( SSL_connect( conn->ssl ) < 0 )
-                goto ssl_connected_failure;
+        return ssl_handshake( data, source, cond );
+}       
+
+static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond )
+{
+        struct scd *conn = data;
+        int st;
+        
+        if( conn->inpa != -1 )
+        {
+                gaim_input_remove( conn->inpa );
+                conn->inpa = -1;
+        }
+        
+        if( ( st = SSL_connect( conn->ssl ) ) < 0 )
+        {
+                conn->lasterr = SSL_get_error( conn->ssl, st );
+                if( conn->lasterr != SSL_ERROR_WANT_READ && conn->lasterr != SSL_ERROR_WANT_WRITE )
+                        goto ssl_connected_failure;
+                
+                conn->inpa = gaim_input_add( conn->fd, ssl_getdirection( conn ), ssl_handshake, data );
+                return;
+        }
         
         conn->established = TRUE;
+        sock_make_blocking( conn->fd );         /* For now... */
         conn->func( conn->data, conn, cond );
         return;
@@ -127 +155 @@
 int ssl_read( void *conn, char *buf, int len )
 {
+        int st;
+        
         if( !((struct scd*)conn)->established )
-                return( 0 );
-        
-        return( SSL_read( ((struct scd*)conn)->ssl, buf, len ) );
+        {
+                ssl_errno = SSL_NOHANDSHAKE;
+                return -1;
+        }
+        
+        st = SSL_read( ((struct scd*)conn)->ssl, buf, len );
+        
+        ssl_errno = SSL_OK;
+        if( st <= 0 )
+        {
+                ((struct scd*)conn)->lasterr = SSL_get_error( ((struct scd*)conn)->ssl, st );
+                if( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_READ || ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE )
+                        ssl_errno = SSL_AGAIN;
+        }
+        
+        return st;
 }
 
 int ssl_write( void *conn, const char *buf, int len )
 {
+        int st;
+        
         if( !((struct scd*)conn)->established )
-                return( 0 );
-        
-        return( SSL_write( ((struct scd*)conn)->ssl, buf, len ) );
+        {
+                ssl_errno = SSL_NOHANDSHAKE;
+                return -1;
+        }
+        
+        st = SSL_write( ((struct scd*)conn)->ssl, buf, len );
+        
+        ssl_errno = SSL_OK;
+        if( st <= 0 )
+        {
+                ((struct scd*)conn)->lasterr = SSL_get_error( ((struct scd*)conn)->ssl, st );
+                if( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_READ || ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE )
+                        ssl_errno = SSL_AGAIN;
+        }
+        
+        return st;
 }
 
@@ -144 +202 @@
 {
         struct scd *conn = conn_;
+        
+        if( conn->inpa != -1 )
+                gaim_input_remove( conn->inpa );
         
         if( conn->established )
@@ -159 +220 @@
         return( ((struct scd*)conn)->fd );
 }
+
+GaimInputCondition ssl_getdirection( void *conn )
+{
+        return( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE ? GAIM_INPUT_WRITE : GAIM_INPUT_READ );
+}

protocols/yahoo/Makefile

@@ -10 +10 @@
 
 # [SH] Program variables
-objects = yahoo.o crypt.o libyahoo2.o yahoo_fn.o yahoo_httplib.o yahoo_util.o
+objects = yahoo.o crypt.o libyahoo2.o yahoo_fn.o yahoo_httplib.o yahoo_list.o yahoo_util.o
 
 CFLAGS += -Wall -DSTDC_HEADERS -DHAVE_STRING_H -DHAVE_STRCHR -DHAVE_MEMCPY -DHAVE_GLIB

protocols/yahoo/yahoo.c

@@ -189 +189 @@
 {
         struct byahoo_data *yd = (struct byahoo_data *) gc->proto_data;
-        
+
         gc->away = NULL;
-        
-        if( msg )
+
+        if (msg)
         {
                 yd->current_status = YAHOO_STATUS_CUSTOM;
                 gc->away = "";
         }
-        if( state )
+        else if (state)
         {
                 gc->away = "";
-                if( g_strcasecmp( state, "Available" ) == 0 )
+                if( g_strcasecmp(state, "Available" ) == 0 )
                 {
                         yd->current_status = YAHOO_STATUS_AVAILABLE;
@@ -235 +235 @@
                 }
         }
-        else if( gc->is_idle )
+        else if ( gc->is_idle )
                 yd->current_status = YAHOO_STATUS_IDLE;
         else
                 yd->current_status = YAHOO_STATUS_AVAILABLE;
         
-        if( yd->current_status == YAHOO_STATUS_INVISIBLE )
-                yahoo_set_away( yd->y2_id, yd->current_status, NULL, gc->away != NULL );
-        else
-                yahoo_set_away( yd->y2_id, yd->current_status, msg, gc->away != NULL );
+        yahoo_set_away( yd->y2_id, yd->current_status, msg, gc->away != NULL );
 }
 

protocols/yahoo/yahoo_list.h

@@ -21 +21 @@
  */
 
+/*
+ * This is a replacement for the GList.  It only provides functions that 
+ * we use in Ayttm.  Thanks to Meredyyd from everybuddy dev for doing 
+ * most of it.
+ */
+
 #ifndef __YLIST_H__
 #define __YLIST_H__
 
-/* GLib has linked list already, so I don't see why libyahoo2 has to copy this... */
+#ifdef __cplusplus
+extern "C" {
+#endif
 
-typedef GList YList;
+typedef struct _YList {
+        struct _YList *next;
+        struct _YList *prev;
+        void *data;
+} YList;
 
-#define y_list_append g_list_append
-#define y_list_concat g_list_concat
-#define y_list_copy g_list_copy
-#define y_list_empty g_list_empty
-#define y_list_find g_list_find
-#define y_list_find_custom g_list_find_custom
-#define y_list_foreach g_list_foreach
-#define y_list_free g_list_free
-#define y_list_free_1 g_list_free_1
-#define y_list_insert_sorted g_list_insert_sorted
-#define y_list_length g_list_length
-#define y_list_next g_list_next
-#define y_list_nth g_list_nth
-#define y_list_prepend g_list_prepend
-#define y_list_remove g_list_remove
-#define y_list_remove_link g_list_remove_link
-#define y_list_singleton g_list_singleton
+typedef int (*YListCompFunc) (const void *, const void *);
+typedef void (*YListFunc) (void *, void *);
 
+YList *y_list_append(YList * list, void *data);
+YList *y_list_prepend(YList * list, void *data);
+YList *y_list_remove_link(YList * list, const YList * link);
+YList *y_list_remove(YList * list, void *data);
+
+YList *y_list_insert_sorted(YList * list, void * data, YListCompFunc comp);
+
+YList *y_list_copy(YList * list);
+
+YList *y_list_concat(YList * list, YList * add);
+
+YList *y_list_find(YList * list, const void *data);
+YList *y_list_find_custom(YList * list, const void *data, YListCompFunc comp);
+
+YList *y_list_nth(YList * list, int n);
+
+void y_list_foreach(YList * list, YListFunc fn, void *user_data);
+
+void y_list_free_1(YList * list);
+void y_list_free(YList * list);
+int  y_list_length(const YList * list);
+int  y_list_empty(const YList * list);
+int  y_list_singleton(const YList * list);
+
+#define y_list_next(list)       list->next
+
+#ifdef __cplusplus
+}
 #endif
+#endif

unix.c

@@ -29 +29 @@
 #include "protocols/nogaim.h"
 #include "help.h"
-#include "ipc.h"
 #include <signal.h>
 #include <unistd.h>
@@ -39 +38 @@
 static void sighandler( int signal );
 
-int main( int argc, char *argv[], char **envp )
+int main( int argc, char *argv[] )
 {
         int i = 0;
-        char *old_cwd = NULL;
         struct sigaction sig, old;
         
@@ -81 +79 @@
         else if( global.conf->runmode == RUNMODE_FORKDAEMON )
         {
-                /* In case the operator requests a restart, we need this. */
-                old_cwd = g_malloc( 256 );
-                if( getcwd( old_cwd, 255 ) == NULL )
-                {
-                        log_message( LOGLVL_WARNING, "Could not save current directory: %s", strerror( errno ) );
-                        g_free( old_cwd );
-                        old_cwd = NULL;
-                }
-                
                 i = bitlbee_daemon_init();
                 log_message( LOGLVL_INFO, "Bitlbee %s starting in forking daemon mode.", BITLBEE_VERSION );
@@ -124 +113 @@
         
         g_main_run( global.loop );
-        
-        if( global.restart )
-        {
-                char *fn = ipc_master_save_state();
-                char **args;
-                int n, i;
-                
-                chdir( old_cwd );
-                
-                n = 0;
-                args = g_new0( char *, argc + 3 );
-                args[n++] = argv[0];
-                if( fn )
-                {
-                        args[n++] = "-R";
-                        args[n++] = fn;
-                }
-                for( i = 1; argv[i] && i < argc; i ++ )
-                {
-                        if( strcmp( argv[i], "-R" ) == 0 )
-                                i += 2;
-                        
-                        args[n++] = argv[i];
-                }
-                
-                close( global.listen_socket );
-                
-                execve( args[0], args, envp );
-        }
         
         return( 0 );

url.c

@@ -40 +40 @@
         else
         {
-                if( g_strncasecmp( set_url, "http", i - set_url ) == 0 )
+                if( g_strncasecmp( set_url, "https", i - set_url ) == 0 )
+                        url->proto = PROTO_HTTPS;
+                else if( g_strncasecmp( set_url, "http", i - set_url ) == 0 )
                         url->proto = PROTO_HTTP;
-                else if( g_strncasecmp( set_url, "https", i - set_url ) == 0 )
-                        url->proto = PROTO_HTTPS;
                 else if( g_strncasecmp( set_url, "socks4", i - set_url ) == 0 )
                         url->proto = PROTO_SOCKS4;

user.h

@@ -45 +45 @@
         int sendbuf_flags;
         
-        void (*send_handler) ( irc_t *irc, struct __USER *u, char *msg, int flags );
+        int (*send_handler) ( irc_t *irc, struct __USER *u, char *msg, int flags );
         
         struct __USER *next;