Diff [560d0a0c4cc61e8ed68a80a04491af024254684c:f1cea66ac5fcd860b2702e6b8ab01fcb79179bd4] for / – BitlBee

Makefile

-                      r560d0a0
+                      rf1cea66
 # Program variables
 objects = account.o bitlbee.o chat.o dcc.o help.o ipc.o irc.o irc_commands.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS) user.o
 headers = account.h bitlbee.h commands.h conf.h help.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h user.h lib/events.h lib/ftutil.h lib/http_client.h lib/ini.h lib/md5.h lib/misc.h lib/proxy.h lib/sha1.h lib/ssl_client.h lib/url.h protocols/ft.h protocols/nogaim.h
+objects = bitlbee.o dcc.o help.o ipc.o irc.o irc_im.o irc_channel.o irc_commands.o irc_send.o irc_user.o irc_util.o nick.o query.o root_commands.o set.o storage.o $(STORAGE_OBJS)
+headers = account.h bitlbee.h commands.h conf.h config.h help.h ipc.h irc.h log.h nick.h query.h set.h sock.h storage.h user.h lib/events.h lib/ftutil.h lib/http_client.h lib/ini.h lib/md5.h lib/misc.h lib/proxy.h lib/sha1.h lib/ssl_client.h lib/url.h protocols/ft.h protocols/nogaim.h
 subdirs = lib protocols

bitlbee.h

-                      r560d0a0
+                      rf1cea66
 #define CONF_FILE_DEF ETCDIR "bitlbee.conf"
+#include "bee.h"
 #include "irc.h"
 #include "storage.h"
 …
 gboolean bitlbee_io_current_client_write( gpointer data, gint source, b_input_condition cond );
 void root_command_string( irc_t *irc, user_t *u, char *command, int flags );
+void root_command_string( irc_t *irc, char *command );
 void root_command( irc_t *irc, char *command[] );
 gboolean bitlbee_shutdown( gpointer data, gint fd, b_input_condition cond );

conf.c

r560d0a0	rf1cea66
376	376	if( g_strcasecmp( ini->section, "defaults" ) == 0 )
377	377	{
378		set_t *s = set_find( &irc->set, ini->key );
	378	set_t *s = set_find( &irc->b->set, ini->key );
379	379
380	380	if( s )

configure

-                      r560d0a0
+                      rf1cea66
 yahoo=1
 twitter=1
+twitter=1
 purple=0
 …
 --oscar=0/1     Disable/enable Oscar part (ICQ, AIM)    $oscar
 --yahoo=0/1     Disable/enable Yahoo part               $yahoo
 --twitter=0/1 Disable/enable Twitter part               $twitter
+--twitter=0/1   Disable/enable Twitter part             $twitter
 --purple=0/1    Disable/enable libpurple support        $purple

dcc.c

-                      r560d0a0
+                      rf1cea66
 unsigned int receivedchunks=0, receiveddata=0;
 static void dcc_finish( file_transfer_t *file );
 static void dcc_close( file_transfer_t *file );
+void dcc_finish( file_transfer_t *file );
+void dcc_close( file_transfer_t *file );
 gboolean dccs_send_proto( gpointer data, gint fd, b_input_condition cond );
+int dccs_send_request( struct dcc_file_transfer *df, char *user_nick, struct sockaddr_storage *saddr );
+gboolean dccs_recv_start( file_transfer_t *ft );
+int dccs_send_request( struct dcc_file_transfer *df, irc_user_t *iu, struct sockaddr_storage *saddr );
 gboolean dccs_recv_proto( gpointer data, gint fd, b_input_condition cond);
 gboolean dccs_recv_write_request( file_transfer_t *ft );
 …
 gboolean dcc_abort( dcc_file_transfer_t *df, char *reason, ... );
+/* As defined in ft.h */
+file_transfer_t *imcb_file_send_start( struct im_connection *ic, char *handle, char *file_name, size_t file_size )
+{
+        user_t *u = user_findhandle( ic, handle );
+        /* one could handle this more intelligent like imcb_buddy_msg.
+         * can't call it directly though cause it does some wrapping.
+         * Maybe give imcb_buddy_msg a parameter NO_WRAPPING? */
+        if (!u) return NULL;
+        return dccs_send_start( ic, u->nick, file_name, file_size );
+};
+/* As defined in ft.h */
+void imcb_file_canceled( file_transfer_t *file, char *reason )
+{
+        if( file->canceled )
+                file->canceled( file, reason );
+        dcc_close( file );
+}
+/* As defined in ft.h */
+gboolean imcb_file_recv_start( file_transfer_t *ft )
+{
+        return dccs_recv_start( ft );
+}
+/* As defined in ft.h */
+void imcb_file_finished( file_transfer_t *file )
+{
+        dcc_file_transfer_t *df = file->priv;
+        if( file->bytes_transferred >= file->file_size )
+                dcc_finish( file );
+        else
+                df->proto_finished = TRUE;
+}
+dcc_file_transfer_t *dcc_alloc_transfer( char *file_name, size_t file_size, struct im_connection *ic )
+dcc_file_transfer_t *dcc_alloc_transfer( const char *file_name, size_t file_size, struct im_connection *ic )
+{
         file_transfer_t *file = g_new0( file_transfer_t, 1 );
 …
         file->file_name = g_strdup( file_name );
         file->local_id = local_transfer_id++;
         df->ic = ic;
+        file->ic = df->ic = ic;
         df->ft = file;
 …
 /* This is where the sending magic starts... */
 file_transfer_t *dccs_send_start( struct im_connection *ic, char *user_nick, char *file_name, size_t file_size )
+file_transfer_t *dccs_send_start( struct im_connection *ic, irc_user_t *iu, const char *file_name, size_t file_size )
+{
         file_transfer_t *file;
         dcc_file_transfer_t *df;
+        irc_t *irc = (irc_t *) ic->bee->ui_data;
         struct sockaddr_storage saddr;
         char *errmsg;
 …
         file->status = FT_STATUS_LISTENING;
         if( !dccs_send_request( df, user_nick, &saddr ) )
+        if( !dccs_send_request( df, iu, &saddr ) )
                 return NULL;
 …
         df->watch_in = b_input_add( df->fd, B_EV_IO_READ, dccs_send_proto, df );
         df->ic->irc->file_transfers = g_slist_prepend( df->ic->irc->file_transfers, file );
+        irc->file_transfers = g_slist_prepend( irc->file_transfers, file );
         df->progress_timeout = b_timeout_add( DCC_MAX_STALL * 1000, dcc_progress, df );
 …
                       "Accept the file transfer if you'd like the file. If you don't, "
                       "issue the 'transfers reject' command.",
                       user_nick, file_name, file_size / 1024 );
+                      iu->nick, file_name, file_size / 1024 );
         return file;
 …
 /* Creates the "DCC SEND" line and sends it to the server */
 int dccs_send_request( struct dcc_file_transfer *df, char *user_nick, struct sockaddr_storage *saddr )
+int dccs_send_request( struct dcc_file_transfer *df, irc_user_t *iu, struct sockaddr_storage *saddr )
+{
         char ipaddr[INET6_ADDRSTRLEN];
 …
                                 df->ft->file_name, ipaddr, port, df->ft->file_size );
+        if ( !irc_msgfrom( df->ic->irc, user_nick, cmd ) )
+                return dcc_abort( df, "Couldn't send `DCC SEND' message to %s.", user_nick );
+        irc_send_msg_raw( iu, "PRIVMSG", iu->irc->user->nick, cmd );
         g_free( cmd );
 …
  * Cleans up after a transfer.
  */
 static void dcc_close( file_transfer_t *file )
+void dcc_close( file_transfer_t *file )
+{
         dcc_file_transfer_t *df = file->priv;
+        irc_t *irc = (irc_t *) df->ic->bee->ui_data;
         if( file->free )
 …
                 b_event_remove( df->progress_timeout );
         df->ic->irc->file_transfers = g_slist_remove( df->ic->irc->file_transfers, file );
+        irc->file_transfers = g_slist_remove( irc->file_transfers, file );
         g_free( df );
 …
+ *
  */
+file_transfer_t *dcc_request( struct im_connection *ic, char *line )
+{
+        char *pattern = "SEND"
+                " (([^\"][^ ]*)|\"(([^\"]|\\\")*)\")"
+                " (([0-9]*)|([^ ]*))"
+                " ([0-9]*)"
+                " ([0-9]*)\001";
+        regmatch_t pmatch[10];
+        regex_t re;
+file_transfer_t *dcc_request( struct im_connection *ic, char* const* ctcp )
+{
+        irc_t *irc = (irc_t *) ic->bee->ui_data;
         file_transfer_t *ft;
         dcc_file_transfer_t *df;
+        char errbuf[256];
+        int regerrcode, gret;
+        if( ( regerrcode = regcomp( &re, pattern, REG_EXTENDED ) ) ||
+            ( regerrcode = regexec( &re, line, 10, pmatch, 0 ) ) ) {
+                regerror( regerrcode,&re,errbuf,sizeof( errbuf ) );
+                imcb_log( ic,
+                          "DCC: error parsing 'DCC SEND': %s, line: %s",
+                          errbuf, line );
+                return NULL;
+        }
+        if( ( pmatch[1].rm_so > 0 ) &&
+            ( pmatch[5].rm_so > 0 ) &&
+            ( pmatch[8].rm_so > 0 ) &&
+            ( pmatch[9].rm_so > 0 ) )
+        {
+                char *input = g_strdup( line );
+        int gret;
+        size_t filesize;
+        if( ctcp[5] != NULL &&
+            sscanf( ctcp[4], "%zd", &filesize ) == 1 && /* Just int. validation. */
+            sscanf( ctcp[5], "%zd", &filesize ) == 1 )
+        {
                 char *filename, *host, *port;
-                size_t filesize;
                 struct addrinfo hints, *rp;
+                /* "filename" or filename */
+                if ( pmatch[2].rm_so > 0 )
+                filename = ctcp[2];
+                host = ctcp[3];
+                while( *host && isdigit( *host ) ) host++; /* Just digits? */
+                if( *host == '\0' )
+                {
+                        input[pmatch[2].rm_eo] = '\0';
+                        filename = input + pmatch[2].rm_so;
+                } else
+                {
+                        input[pmatch[3].rm_eo] = '\0';
+                        filename = input + pmatch[3].rm_so;
+                }
+                input[pmatch[5].rm_eo] = '\0';
+                /* number means ipv4, something else means ipv6 */
+                if ( pmatch[6].rm_so > 0 )
+                {
+                        struct in_addr ipaddr = { .s_addr = htonl( strtoul( input + pmatch[5].rm_so, NULL, 10 ) ) };
+                        struct in_addr ipaddr = { .s_addr = htonl( atoll( ctcp[3] ) ) };
                         host = inet_ntoa( ipaddr );
                 } else
+                {
                         /* Contains non-numbers, hopefully an IPV6 address */
                         host = input + pmatch[7].rm_so;
+                        host = ctcp[3];
+                }
+                input[pmatch[8].rm_eo] = '\0';
+                input[pmatch[9].rm_eo] = '\0';
+                port = input + pmatch[8].rm_so;
+                filesize = atoll( input + pmatch[9].rm_so );
+                port = ctcp[4];
+                filesize = atoll( ctcp[5] );
                 memset( &hints, 0, sizeof ( struct addrinfo ) );
 …
                 if ( ( gret = getaddrinfo( host, port, &hints, &rp ) ) )
+                {
-                        g_free( input );
                         imcb_log( ic, "DCC: getaddrinfo() failed with %s "
                                   "when parsing incoming 'DCC SEND': "
 …
                 freeaddrinfo( rp );
+                g_free( input );
+                df->ic->irc->file_transfers = g_slist_prepend( df->ic->irc->file_transfers, ft );
+                irc->file_transfers = g_slist_prepend( irc->file_transfers, ft );
                 return ft;
+        }
         imcb_log( ic, "DCC: couldnt parse 'DCC SEND' line: %s", line );
+        else
+                imcb_log( ic, "DCC: couldnt parse `DCC SEND' line" );
         return NULL;
+}

dcc.h

-                      r560d0a0
+                      rf1cea66
 } dcc_file_transfer_t;
+file_transfer_t *dccs_send_start( struct im_connection *ic, char *user_nick, char *file_name, size_t file_size );
+file_transfer_t *dccs_send_start( struct im_connection *ic, irc_user_t *iu, const char *file_name, size_t file_size );
+void dcc_canceled( file_transfer_t *file, char *reason );
+gboolean dccs_send_write( file_transfer_t *file, char *data, unsigned int data_size );
+file_transfer_t *dcc_request( struct im_connection *ic, char* const* ctcp );
+void dcc_finish( file_transfer_t *file );
+void dcc_close( file_transfer_t *file );
+gboolean dccs_recv_start( file_transfer_t *ft );
-void dcc_canceled( file_transfer_t *file, char *reason );
-gboolean dccs_send_write( file_transfer_t *file, char *data, unsigned int data_size );
-file_transfer_t *dcc_request( struct im_connection *ic, char *line );
 #endif

doc/user-guide/commands.xml

-                      r560d0a0
+                      rf1cea66
         <bitlbee-setting name="handle_unknown" type="string" scope="global">
                 <default>root</default>
+                <default>add_channel</default>
                 <possible-values>root, add, add_private, add_channel, ignore</possible-values>
 …
         <bitlbee-command name="identify">
                 <syntax>identify &lt;password&gt;</syntax>
+                <syntax>identify [-noload|-force] &lt;password&gt;</syntax>
                 <short-description>Identify yourself with your password</short-description>
 …
                         <para>
                                 Once you're registered, you can change your password using <emphasis>set password &lt;password&gt;</emphasis>.
+                        </para>
+                        <para>
+                                The <emphasis>-noload</emphasis> and <emphasis>-force</emphasis> flags can be used to identify when you're logged into some IM accounts already. <emphasis>-force</emphasis> will let you identify yourself and load all saved accounts (and keep the accounts you're logged into already).
+                        </para>
+                        <para>
+                                <emphasis>-noload</emphasis> will log you in but not load any accounts and settings saved under your current nickname. These will be overwritten once you save your settings (i.e. when you disconnect).
                         </para>
                 </description>

doc/user-guide/misc.xml

-                      r560d0a0
+                      rf1cea66
 </sect1>
+<sect1 id="nick_changes">
+<title>Changing your nickname</title>
+<para>
+BitlBee now allows you to change your nickname. So far this was not possible because it made managing saved accounts more complicated.
+</para>
+<para>
+The restriction no longer exists now though. When you change your nick (just using the <emphasis>/nick</emphasis> command), your logged-in status will be reset, which means any changes made to your settings/accounts will not be saved.
+</para>
+<para>
+To restore your logged-in status, you need to either use the <emphasis>register</emphasis> command to create an account under the new nickname, or use <emphasis>identify -noload</emphasis> to re-identify yourself under the new nickname. The <emphasis>-noload</emphasis> flag tells the command to verify your password and log you in, but not load any new settings. See <emphasis>help identify</emphasis> for more information.
+</para>
+</sect1>
 </chapter>

ipc.c

-                      r560d0a0
+                      rf1cea66
         if( strchr( irc->umode, 'w' ) )
                 irc_write( irc, ":%s WALLOPS :%s", irc->myhost, cmd[1] );
+                irc_write( irc, ":%s WALLOPS :%s", irc->root->host, cmd[1] );
+}
 …
         if( strchr( irc->umode, 's' ) )
                 irc_write( irc, ":%s NOTICE %s :%s", irc->myhost, irc->nick, cmd[1] );
+                irc_write( irc, ":%s NOTICE %s :%s", irc->root->host, irc->user->nick, cmd[1] );
+}
 …
         if( strchr( irc->umode, 'o' ) )
                 irc_write( irc, ":%s NOTICE %s :*** OperMsg *** %s", irc->myhost, irc->nick, cmd[1] );
+                irc_write( irc, ":%s NOTICE %s :*** OperMsg *** %s", irc->root->host, irc->user->nick, cmd[1] );
+}
 …
                 return;
         if( nick_cmp( cmd[1], irc->nick ) != 0 )
+        if( nick_cmp( cmd[1], irc->user->nick ) != 0 )
                 return;         /* It's not for us. */
         irc_write( irc, ":%s!%s@%s KILL %s :%s", irc->mynick, irc->mynick, irc->myhost, irc->nick, cmd[2] );
+        irc_write( irc, ":%s!%s@%s KILL %s :%s", irc->root->nick, irc->root->nick, irc->root->host, irc->user->nick, cmd[2] );
         irc_abort( irc, 0, "Killed by operator: %s", cmd[2] );
+}
 …
                 ipc_to_master_str( "HELLO\r\n" );
         else
                 ipc_to_master_str( "HELLO %s %s :%s\r\n", irc->host, irc->nick, irc->realname );
+                ipc_to_master_str( "HELLO %s %s :%s\r\n", irc->user->host, irc->user->nick, irc->user->fullname );
+}

irc.c

-                      r560d0a0
+                      rf1cea66
   \********************************************************************/
 /* The big hairy IRCd part of the project                               */
+/* The IRC-based UI (for now the only one)                              */
 /*
 …
 */
-#define BITLBEE_CORE
 #include "bitlbee.h"
-#include "sock.h"
 #include "ipc.h"
 #include "dcc.h"
+static gboolean irc_userping( gpointer _irc, int fd, b_input_condition cond );
+GSList *irc_connection_list = NULL;
+static char *set_eval_password( set_t *set, char *value )
+{
+        irc_t *irc = set->data;
+        if( irc->status & USTATUS_IDENTIFIED && value )
+        {
+                irc_setpass( irc, value );
+                return NULL;
+        }
+        else
+        {
+                return SET_INVALID;
+        }
+}
+static char *set_eval_charset( set_t *set, char *value )
+{
+        irc_t *irc = set->data;
+        char *test;
+        gsize test_bytes = 0;
+        GIConv ic, oc;
+        if( g_strcasecmp( value, "none" ) == 0 )
+                value = g_strdup( "utf-8" );
+        if( ( oc = g_iconv_open( value, "utf-8" ) ) == (GIConv) -1 )
+        {
+                return NULL;
+        }
+        /* Do a test iconv to see if the user picked an IRC-compatible
+           charset (for example utf-16 goes *horribly* wrong). */
+        if( ( test = g_convert_with_iconv( " ", 1, oc, NULL, &test_bytes, NULL ) ) == NULL ||
+            test_bytes > 1 )
+        {
+                g_free( test );
+                g_iconv_close( oc );
+                irc_usermsg( irc, "Unsupported character set: The IRC protocol "
+                                  "only supports 8-bit character sets." );
+                return NULL;
+        }
+        g_free( test );
+        if( ( ic = g_iconv_open( "utf-8", value ) ) == (GIConv) -1 )
+        {
+                g_iconv_close( oc );
+                return NULL;
+        }
+        if( irc->iconv != (GIConv) -1 )
+                g_iconv_close( irc->iconv );
+        if( irc->oconv != (GIConv) -1 )
+                g_iconv_close( irc->oconv );
+        irc->iconv = ic;
+        irc->oconv = oc;
+        return value;
+}
+static char *set_eval_away_status( set_t *set, char *value )
+{
+        irc_t *irc = set->data;
+        account_t *a;
+        g_free( set->value );
+        set->value = g_strdup( value );
+        for( a = irc->accounts; a; a = a->next )
+        {
+                struct im_connection *ic = a->ic;
+                if( ic && ic->flags & OPT_LOGGED_IN )
+                        imc_away_send_update( ic );
+        }
+        return value;
+}
+GSList *irc_connection_list;
+static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond );
+static char *set_eval_charset( set_t *set, char *value );
+static char *set_eval_password( set_t *set, char *value );
 irc_t *irc_new( int fd )
 …
         struct sockaddr_storage sock;
         socklen_t socklen = sizeof( sock );
+        char *host = NULL, *myhost = NULL;
+        irc_user_t *iu;
         set_t *s;
+        bee_t *b;
         irc = g_new0( irc_t, 1 );
 …
         irc->last_pong = gettime();
         irc->userhash = g_hash_table_new( g_str_hash, g_str_equal );
+        irc->nick_user_hash = g_hash_table_new( g_str_hash, g_str_equal );
         irc->watches = g_hash_table_new( g_str_hash, g_str_equal );
-        strcpy( irc->umode, UMODE );
-        irc->mynick = g_strdup( ROOT_NICK );
-        irc->channel = g_strdup( ROOT_CHAN );
         irc->iconv = (GIConv) -1;
 …
         if( global.conf->hostname )
+        {
                 irc->myhost = g_strdup( global.conf->hostname );
+                myhost = g_strdup( global.conf->hostname );
+        }
         else if( getsockname( irc->fd, (struct sockaddr*) &sock, &socklen ) == 0 )
 …
                                  NI_MAXHOST, NULL, 0, 0 ) == 0 )
+                {
                         irc->myhost = g_strdup( ipv6_unwrap( buf ) );
+                        myhost = g_strdup( ipv6_unwrap( buf ) );
+                }
+        }
 …
                                  NI_MAXHOST, NULL, 0, 0 ) == 0 )
+                {
                         irc->host = g_strdup( ipv6_unwrap( buf ) );
+                }
+        }
         if( irc->host == NULL )
                 irc->host = g_strdup( "localhost.localdomain" );
         if( irc->myhost == NULL )
                 irc->myhost = g_strdup( "localhost.localdomain" );
+                        host = g_strdup( ipv6_unwrap( buf ) );
+                }
+        }
+        if( host == NULL )
+                host = g_strdup( "localhost.localdomain" );
+        if( myhost == NULL )
+                myhost = g_strdup( "localhost.localdomain" );
         if( global.conf->ping_interval > 0 && global.conf->ping_timeout > 0 )
                 irc->ping_source_id = b_timeout_add( global.conf->ping_interval * 1000, irc_userping, irc );
-        irc_write( irc, ":%s NOTICE AUTH :%s", irc->myhost, "BitlBee-IRCd initialized, please go on" );
         irc_connection_list = g_slist_append( irc_connection_list, irc );
+        s = set_add( &irc->set, "away", NULL,  set_eval_away_status, irc );
+        b = irc->b = bee_new();
+        b->ui_data = irc;
+        b->ui = &irc_ui_funcs;
+        s = set_add( &b->set, "away_devoice", "true", set_eval_away_devoice, irc );
+        s = set_add( &b->set, "charset", "utf-8", set_eval_charset, irc );
+        s = set_add( &b->set, "default_target", "root", NULL, irc );
+        s = set_add( &b->set, "display_namechanges", "false", set_eval_bool, irc );
+        s = set_add( &b->set, "display_timestamps", "true", set_eval_bool, irc );
+        s = set_add( &b->set, "handle_unknown", "add_channel", NULL, irc );
+        s = set_add( &b->set, "lcnicks", "true", set_eval_bool, irc );
+        s = set_add( &b->set, "ops", "both", set_eval_irc_channel_ops, irc );
+        s = set_add( &b->set, "paste_buffer", "false", set_eval_bool, irc );
+        s->old_key = g_strdup( "buddy_sendbuffer" );
+        s = set_add( &b->set, "paste_buffer_delay", "200", set_eval_int, irc );
+        s->old_key = g_strdup( "buddy_sendbuffer_delay" );
+        s = set_add( &b->set, "password", NULL, set_eval_password, irc );
         s->flags |= SET_NULL_OK;
+        s = set_add( &irc->set, "away_devoice", "true",  set_eval_away_devoice, irc );
+        s = set_add( &irc->set, "auto_connect", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "auto_reconnect", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "auto_reconnect_delay", "5*3<900", set_eval_account_reconnect_delay, irc );
+        s = set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );
+        s = set_add( &irc->set, "buddy_sendbuffer_delay", "200", set_eval_int, irc );
+        s = set_add( &irc->set, "charset", "utf-8", set_eval_charset, irc );
+        s = set_add( &irc->set, "control_channel", irc->channel, set_eval_control_channel, irc );
+        s = set_add( &irc->set, "debug", "false", set_eval_bool, irc );
+        s = set_add( &irc->set, "default_target", "root", NULL, irc );
+        s = set_add( &irc->set, "display_namechanges", "false", set_eval_bool, irc );
+        s = set_add( &irc->set, "display_timestamps", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "handle_unknown", "root", NULL, irc );
+        s = set_add( &irc->set, "lcnicks", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "ops", "both", set_eval_ops, irc );
+        s = set_add( &irc->set, "password", NULL, set_eval_password, irc );
+        s->flags |= SET_NULL_OK;
+        s = set_add( &irc->set, "private", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "query_order", "lifo", NULL, irc );
+        s = set_add( &irc->set, "root_nick", irc->mynick, set_eval_root_nick, irc );
+        s = set_add( &irc->set, "save_on_quit", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "show_offline", "false", set_eval_bool, irc );
+        s = set_add( &irc->set, "simulate_netsplit", "true", set_eval_bool, irc );
+        s = set_add( &irc->set, "status", NULL,  set_eval_away_status, irc );
+        s->flags |= SET_NULL_OK;
+        s = set_add( &irc->set, "strip_html", "true", NULL, irc );
+        s = set_add( &irc->set, "timezone", "local", set_eval_timezone, irc );
+        s = set_add( &irc->set, "to_char", ": ", set_eval_to_char, irc );
+        s = set_add( &irc->set, "typing_notice", "false", set_eval_bool, irc );
+        s = set_add( &b->set, "private", "true", set_eval_bool, irc );
+        s = set_add( &b->set, "query_order", "lifo", NULL, irc );
+        s = set_add( &b->set, "root_nick", ROOT_NICK, set_eval_root_nick, irc );
+        s = set_add( &b->set, "simulate_netsplit", "true", set_eval_bool, irc );
+        s = set_add( &b->set, "timezone", "local", set_eval_timezone, irc );
+        s = set_add( &b->set, "to_char", ": ", set_eval_to_char, irc );
+        s = set_add( &b->set, "typing_notice", "false", set_eval_bool, irc );
+        irc->root = iu = irc_user_new( irc, ROOT_NICK );
+        iu->host = g_strdup( myhost );
+        iu->fullname = g_strdup( ROOT_FN );
+        iu->f = &irc_user_root_funcs;
+        iu = irc_user_new( irc, NS_NICK );
+        iu->host = g_strdup( myhost );
+        iu->fullname = g_strdup( ROOT_FN );
+        iu->f = &irc_user_root_funcs;
+        irc->user = g_new0( irc_user_t, 1 );
+        irc->user->host = g_strdup( host );
         conf_loaddefaults( irc );
         /* Evaluator sets the iconv/oconv structures. */
+        set_eval_charset( set_find( &irc->set, "charset" ), set_getstr( &irc->set, "charset" ) );
+        set_eval_charset( set_find( &b->set, "charset" ), set_getstr( &b->set, "charset" ) );
+        irc_write( irc, ":%s NOTICE AUTH :%s", irc->root->host, "BitlBee-IRCd initialized, please go on" );
+        g_free( myhost );
+        g_free( host );
         nogaim_init();
         return( irc );
+        return irc;
+}
 …
                 ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
                                    irc->nick ? irc->nick : "(NONE)", irc->host, reason );
+                                   irc->user->nick ? irc->user->nick : "(NONE)", irc->root->host, reason );
                 g_free( reason );
 …
                 ipc_to_master_str( "OPERMSG :Client exiting: %s@%s [%s]\r\n",
                                    irc->nick ? irc->nick : "(NONE)", irc->host, "No reason given" );
+                                   irc->user->nick ? irc->user->nick : "(NONE)", irc->root->host, "No reason given" );
+        }
 …
+}
+static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data )
+{
+        g_free( key );
+        return( TRUE );
+}
+/* Because we have no garbage collection, this is quite annoying */
+static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data );
 void irc_free( irc_t * irc )
+{
-        user_t *user, *usertmp;
         log_message( LOGLVL_INFO, "Destroying connection with fd %d", irc->fd );
         if( irc->status & USTATUS_IDENTIFIED && set_getbool( &irc->set, "save_on_quit" ) )
+        if( irc->status & USTATUS_IDENTIFIED && set_getbool( &irc->b->set, "save_on_quit" ) )
                 if( storage_save( irc, NULL, TRUE ) != STORAGE_OK )
                         irc_usermsg( irc, "Error while saving settings!" );
+                        log_message( LOGLVL_WARNING, "Error while saving settings for user %s", irc->user->nick );
         irc_connection_list = g_slist_remove( irc_connection_list, irc );
-        while( irc->accounts )
+        {
-                if( irc->accounts->ic )
-                        imc_logout( irc->accounts->ic, FALSE );
-                else if( irc->accounts->reconnect )
-                        cancel_auto_reconnect( irc->accounts );
-                if( irc->accounts->ic == NULL )
-                        account_del( irc, irc->accounts );
-                else
-                        /* Nasty hack, but account_del() doesn't work in this
-                           case and we don't want infinite loops, do we? ;-) */
-                        irc->accounts = irc->accounts->next;
+        }
         while( irc->queries != NULL )
                 query_del( irc, irc->queries );
+        while( irc->set )
+                set_del( &irc->set, irc->set->key );
+        if (irc->users != NULL)
+        {
+                user = irc->users;
+                while( user != NULL )
+                {
+                        g_free( user->nick );
+                        g_free( user->away );
+                        g_free( user->handle );
+                        if( user->user != user->nick ) g_free( user->user );
+                        if( user->host != user->nick ) g_free( user->host );
+                        if( user->realname != user->nick ) g_free( user->realname );
+                        b_event_remove( user->sendbuf_timer );
+                        usertmp = user;
+                        user = user->next;
+                        g_free( usertmp );
+                }
+        }
+        /* This is a little bit messy: bee_free() frees all b->users which
+           calls us back to free the corresponding irc->users. So do this
+           before we clear the remaining ones ourselves. */
+        bee_free( irc->b );
+        while( irc->users )
+                irc_user_free( irc, (irc_user_t *) irc->users->data );
+        while( irc->channels )
+                irc_channel_free( irc->channels->data );
         if( irc->ping_source_id > 0 )
 …
         irc->fd = -1;
         g_hash_table_foreach_remove( irc->userhash, irc_free_hashkey, NULL );
         g_hash_table_destroy( irc->userhash );
+        g_hash_table_foreach_remove( irc->nick_user_hash, irc_free_hashkey, NULL );
+        g_hash_table_destroy( irc->nick_user_hash );
         g_hash_table_foreach_remove( irc->watches, irc_free_hashkey, NULL );
 …
         g_free( irc->sendbuffer );
         g_free( irc->readbuffer );
-        g_free( irc->nick );
-        g_free( irc->user );
-        g_free( irc->host );
-        g_free( irc->realname );
         g_free( irc->password );
+        g_free( irc->myhost );
+        g_free( irc->mynick );
+        g_free( irc->channel );
+        g_free( irc->last_target );
+        g_free( irc->last_root_cmd );
         g_free( irc );
 …
+}
+static gboolean irc_free_hashkey( gpointer key, gpointer value, gpointer data )
+{
+        g_free( key );
+        return( TRUE );
+}
 /* USE WITH CAUTION!
    Sets pass without checking */
 void irc_setpass (irc_t *irc, const char *pass)
+void irc_setpass (irc_t *irc, const char *pass)
+{
         g_free (irc->password);
 …
+}
+static char *set_eval_password( set_t *set, char *value )
+{
+        irc_t *irc = set->data;
+        if( irc->status & USTATUS_IDENTIFIED && value )
+        {
+                irc_setpass( irc, value );
+                return NULL;
+        }
+        else
+        {
+                return SET_INVALID;
+        }
+}
+static char **irc_splitlines( char *buffer );
 void irc_process( irc_t *irc )
+{
 …
         if( irc->readbuffer != NULL )
+        {
                 lines = irc_tokenize( irc->readbuffer );
+                lines = irc_splitlines( irc->readbuffer );
                 for( i = 0; *lines[i] != '\0'; i ++ )
 …
                                                                   "`help set charset' for more information. Your "
                                                                   "message was ignored.",
                                                                   set_getstr( &irc->set, "charset" ) );
+                                                                  set_getstr( &irc->b->set, "charset" ) );
                                                 g_free( conv );
 …
                                         else
+                                        {
                                                 irc_write( irc, ":%s NOTICE AUTH :%s", irc->myhost,
+                                                irc_write( irc, ":%s NOTICE AUTH :%s", irc->root->host,
                                                            "Warning: invalid characters received at login time." );
 …
+}
+/* Splits a long string into separate lines. The array is NULL-terminated and, unless the string
+   contains an incomplete line at the end, ends with an empty string. */
+char **irc_tokenize( char *buffer )
+/* Splits a long string into separate lines. The array is NULL-terminated
+   and, unless the string contains an incomplete line at the end, ends with
+   an empty string. Could use g_strsplit() but this one does it in-place.
+   (So yes, it's destructive.) */
+static char **irc_splitlines( char *buffer )
+{
         int i, j, n = 3;
 …
+}
-void irc_reply( irc_t *irc, int code, char *format, ... )
+{
-        char text[IRC_MAX_LINE];
-        va_list params;
-        va_start( params, format );
-        g_vsnprintf( text, IRC_MAX_LINE, format, params );
-        va_end( params );
-        irc_write( irc, ":%s %03d %s %s", irc->myhost, code, irc->nick?irc->nick:"*", text );
-        return;
+}
-int irc_usermsg( irc_t *irc, char *format, ... )
+{
-        char text[1024];
-        va_list params;
-        char is_private = 0;
-        user_t *u;
-        u = user_find( irc, irc->mynick );
-        is_private = u->is_private;
-        va_start( params, format );
-        g_vsnprintf( text, sizeof( text ), format, params );
-        va_end( params );
-        return( irc_msgfrom( irc, u->nick, text ) );
+}
 void irc_write( irc_t *irc, char *format, ... )
+{
 …
         return;
+}
+void irc_write_all( int now, char *format, ... )
+{
+        va_list params;
+        GSList *temp;
+        va_start( params, format );
+        temp = irc_connection_list;
+        while( temp != NULL )
+        {
+                irc_t *irc = temp->data;
+                if( now )
+                {
+                        g_free( irc->sendbuffer );
+                        irc->sendbuffer = g_strdup( "\r\n" );
+                }
+                irc_vawrite( temp->data, format, params );
+                if( now )
+                {
+                        bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE );
+                }
+                temp = temp->next;
+        }
+        va_end( params );
+        return;
+}
 void irc_vawrite( irc_t *irc, char *format, va_list params )
 …
+}
+void irc_write_all( int now, char *format, ... )
+{
+        va_list params;
+        GSList *temp;
+        va_start( params, format );
+        temp = irc_connection_list;
+        while( temp != NULL )
+        {
+                irc_t *irc = temp->data;
+                if( now )
+                {
+                        g_free( irc->sendbuffer );
+                        irc->sendbuffer = g_strdup( "\r\n" );
+                }
+                irc_vawrite( temp->data, format, params );
+                if( now )
+                {
+                        bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE );
+                }
+                temp = temp->next;
+        }
+        va_end( params );
+        return;
+}
+void irc_names( irc_t *irc, char *channel )
+{
+        user_t *u;
+        char namelist[385] = "";
+        struct groupchat *c = NULL;
+        char *ops = set_getstr( &irc->set, "ops" );
+        /* RFCs say there is no error reply allowed on NAMES, so when the
+           channel is invalid, just give an empty reply. */
+        if( g_strcasecmp( channel, irc->channel ) == 0 )
+        {
+                for( u = irc->users; u; u = u->next ) if( u->online )
+                {
+                        if( strlen( namelist ) + strlen( u->nick ) > sizeof( namelist ) - 4 )
+int irc_check_login( irc_t *irc )
+{
+        if( irc->user->user && irc->user->nick )
+        {
+                if( global.conf->authmode == AUTHMODE_CLOSED && !( irc->status & USTATUS_AUTHORIZED ) )
+                {
+                        irc_send_num( irc, 464, ":This server is password-protected." );
+                        return 0;
+                }
+                else
+                {
+                        irc_channel_t *ic;
+                        irc_user_t *iu = irc->user;
+                        irc->user = irc_user_new( irc, iu->nick );
+                        irc->user->user = iu->user;
+                        irc->user->host = iu->host;
+                        irc->user->fullname = iu->fullname;
+                        irc->user->f = &irc_user_self_funcs;
+                        g_free( iu->nick );
+                        g_free( iu );
+                        if( global.conf->runmode == RUNMODE_FORKDAEMON || global.conf->runmode == RUNMODE_DAEMON )
+                                ipc_to_master_str( "CLIENT %s %s :%s\r\n", irc->user->host, irc->user->nick, irc->user->fullname );
+                        irc->status |= USTATUS_LOGGED_IN;
+                        irc_send_login( irc );
+                        irc->umode[0] = '\0';
+                        irc_umode_set( irc, "+" UMODE, TRUE );
+                        ic = irc->default_channel = irc_channel_new( irc, ROOT_CHAN );
+                        irc_channel_set_topic( ic, CONTROL_TOPIC, irc->root );
+                        irc_channel_add_user( ic, irc->user );
+                        irc->last_root_cmd = g_strdup( ROOT_CHAN );
+                        irc_send_msg( irc->root, "PRIVMSG", ROOT_CHAN,
+                                      "Welcome to the BitlBee gateway!\n\n"
+                                      "If you've never used BitlBee before, please do read the help "
+                                      "information using the \x02help\x02 command. Lots of FAQs are "
+                                      "answered there.\n"
+                                      "If you already have an account on this server, just use the "
+                                      "\x02identify\x02 command to identify yourself.", NULL );
+                        /* This is for bug #209 (use PASS to identify to NickServ). */
+                        if( irc->password != NULL )
+                        {
+                                irc_reply( irc, 353, "= %s :%s", channel, namelist );
+                                *namelist = 0;
+                                char *send_cmd[] = { "identify", g_strdup( irc->password ), NULL };
+                                irc_setpass( irc, NULL );
+                                root_command( irc, send_cmd );
+                                g_free( send_cmd[1] );
+                        }
-                        if( u->ic && !u->away && set_getbool( &irc->set, "away_devoice" ) )
-                                strcat( namelist, "+" );
-                        else if( ( strcmp( u->nick, irc->mynick ) == 0 && ( strcmp( ops, "root" ) == 0 || strcmp( ops, "both" ) == 0 ) ) ||
-                                 ( strcmp( u->nick, irc->nick ) == 0 && ( strcmp( ops, "user" ) == 0 || strcmp( ops, "both" ) == 0 ) ) )
-                                strcat( namelist, "@" );
-                        strcat( namelist, u->nick );
-                        strcat( namelist, " " );
+                }
+        }
-        else if( ( c = irc_chat_by_channel( irc, channel ) ) )
+        {
-                GList *l;
-                /* root and the user aren't in the channel userlist but should
-                   show up in /NAMES, so list them first: */
-                sprintf( namelist, "%s%s %s%s ", strcmp( ops, "root" ) == 0 || strcmp( ops, "both" ) ? "@" : "", irc->mynick,
-                                                 strcmp( ops, "user" ) == 0 || strcmp( ops, "both" ) ? "@" : "", irc->nick );
-                for( l = c->in_room; l; l = l->next ) if( ( u = user_findhandle( c->ic, l->data ) ) )
+                {
-                        if( strlen( namelist ) + strlen( u->nick ) > sizeof( namelist ) - 4 )
+                        {
-                                irc_reply( irc, 353, "= %s :%s", channel, namelist );
-                                *namelist = 0;
+                        }
-                        strcat( namelist, u->nick );
-                        strcat( namelist, " " );
+                }
+        }
-        if( *namelist )
-                irc_reply( irc, 353, "= %s :%s", channel, namelist );
-        irc_reply( irc, 366, "%s :End of /NAMES list", channel );
+}
-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;
+                }
 …
+}
+void irc_login( irc_t *irc )
+{
+        user_t *u;
+        irc_reply( irc,   1, ":Welcome to the BitlBee gateway, %s", irc->nick );
+        irc_reply( irc,   2, ":Host %s is running BitlBee " BITLBEE_VERSION " " ARCH "/" CPU ".", irc->myhost );
+        irc_reply( irc,   3, ":%s", IRCD_INFO );
+        irc_reply( irc,   4, "%s %s %s %s", irc->myhost, BITLBEE_VERSION, UMODES UMODES_PRIV, CMODES );
+        irc_reply( irc,   5, "PREFIX=(ov)@+ CHANTYPES=%s CHANMODES=,,,%s NICKLEN=%d NETWORK=BitlBee "
+                             "CASEMAPPING=rfc1459 MAXTARGETS=1 WATCH=128 :are supported by this server",
+                             CTYPES, CMODES, MAX_NICK_LENGTH - 1 );
+        irc_motd( irc );
+        irc->umode[0] = '\0';
+        irc_umode_set( irc, "+" UMODE, 1 );
+        u = user_add( irc, irc->mynick );
+        u->host = g_strdup( irc->myhost );
+        u->realname = g_strdup( ROOT_FN );
+        u->online = 1;
+        u->send_handler = root_command_string;
+        u->is_private = 0; /* [SH] The channel is root's personal playground. */
+        irc_spawn( irc, u );
+        u = user_add( irc, NS_NICK );
+        u->host = g_strdup( irc->myhost );
+        u->realname = g_strdup( ROOT_FN );
+        u->online = 0;
+        u->send_handler = root_command_string;
+        u->is_private = 1; /* [SH] NickServ is not in the channel, so should always /query. */
+        u = user_add( irc, irc->nick );
+        u->user = g_strdup( irc->user );
+        u->host = g_strdup( irc->host );
+        u->realname = g_strdup( irc->realname );
+        u->online = 1;
+        irc_spawn( irc, u );
+        irc_usermsg( irc, "Welcome to the BitlBee gateway!\n\n"
+                          "If you've never used BitlBee before, please do read the help "
+                          "information using the \x02help\x02 command. Lots of FAQs are "
+                          "answered there.\n"
+                          "If you already have an account on this server, just use the "
+                          "\x02identify\x02 command to identify yourself." );
+        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;
+        /* This is for bug #209 (use PASS to identify to NickServ). */
+        if( irc->password != NULL )
+        {
+                char *send_cmd[] = { "identify", g_strdup( irc->password ), NULL };
+                irc_setpass( irc, NULL );
+                root_command( irc, send_cmd );
+                g_free( send_cmd[1] );
+        }
+}
+void irc_motd( irc_t *irc )
+{
+        int fd;
+        fd = open( global.conf->motdfile, O_RDONLY );
+        if( fd == -1 )
+        {
+                irc_reply( irc, 422, ":We don't need MOTDs." );
+        }
+        else
+        {
+                char linebuf[80];       /* Max. line length for MOTD's is 79 chars. It's what most IRC networks seem to do. */
+                char *add, max;
+                int len;
+                linebuf[79] = len = 0;
+                max = sizeof( linebuf ) - 1;
+                irc_reply( irc, 375, ":- %s Message Of The Day - ", irc->myhost );
+                while( read( fd, linebuf + len, 1 ) == 1 )
+                {
+                        if( linebuf[len] == '\n' || len == max )
+                        {
+                                linebuf[len] = 0;
+                                irc_reply( irc, 372, ":- %s", linebuf );
+                                len = 0;
+                        }
+                        else if( linebuf[len] == '%' )
+                        {
+                                read( fd, linebuf + len, 1 );
+                                if( linebuf[len] == 'h' )
+                                        add = irc->myhost;
+                                else if( linebuf[len] == 'v' )
+                                        add = BITLBEE_VERSION;
+                                else if( linebuf[len] == 'n' )
+                                        add = irc->nick;
+                                else
+                                        add = "%";
+                                strncpy( linebuf + len, add, max - len );
+                                while( linebuf[++len] );
+                        }
+                        else if( len < max )
+                        {
+                                len ++;
+                        }
+                }
+                irc_reply( irc, 376, ":End of MOTD" );
+                close( fd );
+        }
+}
+void irc_topic( irc_t *irc, char *channel )
+{
+        struct groupchat *c = irc_chat_by_channel( irc, channel );
+        if( c && c->topic )
+                irc_reply( irc, 332, "%s :%s", channel, c->topic );
+        else if( g_strcasecmp( channel, irc->channel ) == 0 )
+                irc_reply( irc, 332, "%s :%s", channel, CONTROL_TOPIC );
+        else
+                irc_reply( irc, 331, "%s :No topic for this channel", channel );
+}
+void irc_umode_set( irc_t *irc, char *s, int allow_priv )
+void irc_umode_set( irc_t *irc, const char *s, gboolean allow_priv )
+{
         /* allow_priv: Set to 0 if s contains user input, 1 if you want
            to set a "privileged" mode (+o, +R, etc). */
+        char m[256], st = 1, *t;
+        char m[128], st = 1;
+        const char *t;
         int i;
         char changes[512], *p, st2 = 2;
 …
         for( t = irc->umode; *t; t ++ )
+                m[(int)*t] = 1;
+                if( *t < sizeof( m ) )
+                        m[(int)*t] = 1;
         p = changes;
         for( t = s; *t; t ++ )
 …
                 if( *t == '+' || *t == '-' )
                         st = *t == '+';
+                else if( st == 0 || ( strchr( UMODES, *t ) || ( allow_priv && strchr( UMODES_PRIV, *t ) ) ) )
+                else if( ( st == 0 && ( !strchr( UMODES_KEEP, *t ) || allow_priv ) ) ||
+                         ( st == 1 && strchr( UMODES, *t ) ) ||
+                         ( st == 1 && allow_priv && strchr( UMODES_PRIV, *t ) ) )
+                {
                         if( m[(int)*t] != st)
 …
         memset( irc->umode, 0, sizeof( irc->umode ) );
         for( i = 0; i < 256 && strlen( irc->umode ) < ( sizeof( irc->umode ) - 1 ); i ++ )
+        for( i = 'A'; i <= 'z' && strlen( irc->umode ) < ( sizeof( irc->umode ) - 1 ); i ++ )
                 if( m[i] )
                         irc->umode[strlen(irc->umode)] = i;
         if( badflag )
+                irc_reply( irc, 501, ":Unknown MODE flag" );
+        /* Deliberately no !user@host on the prefix here */
+                irc_send_num( irc, 501, ":Unknown MODE flag" );
         if( *changes )
+                irc_write( irc, ":%s MODE %s %s", irc->nick, irc->nick, changes );
+}
+void irc_spawn( irc_t *irc, user_t *u )
+{
+        irc_join( irc, u, irc->channel );
+}
+void irc_join( irc_t *irc, user_t *u, char *channel )
+{
+        char *nick;
+        if( ( g_strcasecmp( channel, irc->channel ) != 0 ) || user_find( irc, irc->nick ) )
+                irc_write( irc, ":%s!%s@%s JOIN :%s", u->nick, u->user, u->host, channel );
+        if( nick_cmp( u->nick, irc->nick ) == 0 )
+        {
+                irc_write( irc, ":%s MODE %s +%s", irc->myhost, channel, CMODE );
+                irc_names( irc, channel );
+                irc_topic( irc, channel );
+        }
+        nick = g_strdup( u->nick );
+        nick_lc( nick );
+        if( g_hash_table_lookup( irc->watches, nick ) )
+        {
+                irc_reply( irc, 600, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged online" );
+        }
+        g_free( nick );
+}
+void irc_part( irc_t *irc, user_t *u, char *channel )
+{
+        irc_write( irc, ":%s!%s@%s PART %s :%s", u->nick, u->user, u->host, channel, "" );
+}
+void irc_kick( irc_t *irc, user_t *u, char *channel, user_t *kicker )
+{
+        irc_write( irc, ":%s!%s@%s KICK %s %s :%s", kicker->nick, kicker->user, kicker->host, channel, u->nick, "" );
+}
+void irc_kill( irc_t *irc, user_t *u )
+{
+        char *nick, *s;
+        char reason[128];
+        if( u->ic && u->ic->flags & OPT_LOGGING_OUT && set_getbool( &irc->set, "simulate_netsplit" ) )
+        {
+                if( u->ic->acc->server )
+                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
+                                    u->ic->acc->server );
+                else if( ( s = strchr( u->ic->acc->user, '@' ) ) )
+                        g_snprintf( reason, sizeof( reason ), "%s %s", irc->myhost,
+                                    s + 1 );
+                else
+                        g_snprintf( reason, sizeof( reason ), "%s %s.%s", irc->myhost,
+                                    u->ic->acc->prpl->name, irc->myhost );
+                /* proto_opt might contain garbage after the : */
+                if( ( s = strchr( reason, ':' ) ) )
+                        *s = 0;
+        }
+        else
+        {
+                strcpy( reason, "Leaving..." );
+        }
+        irc_write( irc, ":%s!%s@%s QUIT :%s", u->nick, u->user, u->host, reason );
+        nick = g_strdup( u->nick );
+        nick_lc( nick );
+        if( g_hash_table_lookup( irc->watches, nick ) )
+        {
+                irc_reply( irc, 601, "%s %s %s %d :%s", u->nick, u->user, u->host, (int) time( NULL ), "logged offline" );
+        }
+        g_free( nick );
+}
+int irc_send( irc_t *irc, char *nick, char *s, int flags )
+{
+        struct groupchat *c = NULL;
+        user_t *u = NULL;
+        if( strchr( CTYPES, *nick ) )
+        {
+                if( !( c = irc_chat_by_channel( irc, nick ) ) )
+                {
+                        irc_reply( irc, 403, "%s :Channel does not exist", nick );
+                        return( 0 );
+                }
+        }
+        else
+        {
+                u = user_find( irc, nick );
+                if( !u )
+                {
+                        if( irc->is_private )
+                                irc_reply( irc, 401, "%s :Nick does not exist", nick );
+                        else
+                                irc_usermsg( irc, "Nick `%s' does not exist!", nick );
+                        return( 0 );
+                }
+        }
+        if( *s == 1 && s[strlen(s)-1] == 1 )
+        {
+                if( g_strncasecmp( s + 1, "ACTION", 6 ) == 0 )
+                {
+                        if( s[7] == ' ' ) s ++;
+                        s += 3;
+                        *(s++) = '/';
+                        *(s++) = 'm';
+                        *(s++) = 'e';
+                        *(s++) = ' ';
+                        s -= 4;
+                        s[strlen(s)-1] = 0;
+                }
+                else if( g_strncasecmp( s + 1, "VERSION", 7 ) == 0 )
+                {
+                        u = user_find( irc, irc->mynick );
+                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", "\001VERSION BitlBee " BITLBEE_VERSION " " ARCH "/" CPU "\001" );
+                        return( 1 );
+                }
+                else if( g_strncasecmp( s + 1, "PING", 4 ) == 0 )
+                {
+                        u = user_find( irc, irc->mynick );
+                        irc_privmsg( irc, u, "NOTICE", irc->nick, "", s );
+                        return( 1 );
+                }
+                else if( g_strncasecmp( s + 1, "TYPING", 6 ) == 0 )
+                {
+                        if( u && u->ic && u->ic->acc->prpl->send_typing && strlen( s ) >= 10 )
+                        {
+                                time_t current_typing_notice = time( NULL );
+                                if( current_typing_notice - u->last_typing_notice >= 5 )
+                                {
+                                        u->ic->acc->prpl->send_typing( u->ic, u->handle, ( s[8] - '0' ) << 8 );
+                                        u->last_typing_notice = current_typing_notice;
+                                }
+                        }
+                        return( 1 );
+                }
+                else if( g_strncasecmp( s + 1, "DCC", 3 ) == 0 )
+                {
+                        if( u && u->ic && u->ic->acc->prpl->transfer_request )
+                        {
+                                file_transfer_t *ft = dcc_request( u->ic, s + 5 );
+                                if ( ft )
+                                        u->ic->acc->prpl->transfer_request( u->ic, ft, u->handle );
+                        }
+                        return( 1 );
+                }
+                else
+                {
+                        irc_usermsg( irc, "Supported CTCPs are ACTION, VERSION, PING, TYPING, DCC" );
+                        return( 0 );
+                }
+        }
+        if( u )
+        {
+                /* For the next message, we probably do have to send new notices... */
+                u->last_typing_notice = 0;
+                u->is_private = irc->is_private;
+                if( u->is_private )
+                {
+                        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 );
+                }
+                if( u->send_handler )
+                {
+                        u->send_handler( irc, u, s, flags );
+                        return 1;
+                }
+        }
+        else if( c && c->ic && c->ic->acc && c->ic->acc->prpl )
+        {
+                return( imc_chat_msg( c, s, 0 ) );
+        }
+        return( 0 );
+}
+static gboolean buddy_send_handler_delayed( gpointer data, gint fd, b_input_condition cond )
+{
+        user_t *u = data;
+        /* Shouldn't happen, but just to be sure. */
+        if( u->sendbuf_len < 2 )
+                return FALSE;
+        u->sendbuf[u->sendbuf_len-2] = 0; /* Cut off the last newline */
+        imc_buddy_msg( u->ic, u->handle, u->sendbuf, u->sendbuf_flags );
+        g_free( u->sendbuf );
+        u->sendbuf = NULL;
+        u->sendbuf_len = 0;
+        u->sendbuf_timer = 0;
+        u->sendbuf_flags = 0;
+        return FALSE;
+}
+void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags )
+{
+        if( !u || !u->ic ) return;
+        if( set_getbool( &irc->set, "buddy_sendbuffer" ) && set_getint( &irc->set, "buddy_sendbuffer_delay" ) > 0 )
+        {
+                int delay;
+                if( u->sendbuf_len > 0 && u->sendbuf_flags != flags)
+                {
+                        /* Flush the buffer */
+                        b_event_remove( u->sendbuf_timer );
+                        buddy_send_handler_delayed( u, -1, 0 );
+                }
+                if( u->sendbuf_len == 0 )
+                {
+                        u->sendbuf_len = strlen( msg ) + 2;
+                        u->sendbuf = g_new( char, u->sendbuf_len );
+                        u->sendbuf[0] = 0;
+                        u->sendbuf_flags = flags;
+                }
+                else
+                {
+                        u->sendbuf_len += strlen( msg ) + 1;
+                        u->sendbuf = g_renew( char, u->sendbuf, u->sendbuf_len );
+                }
+                strcat( u->sendbuf, msg );
+                strcat( u->sendbuf, "\n" );
+                delay = set_getint( &irc->set, "buddy_sendbuffer_delay" );
+                if( delay <= 5 )
+                        delay *= 1000;
+                if( u->sendbuf_timer > 0 )
+                        b_event_remove( u->sendbuf_timer );
+                u->sendbuf_timer = b_timeout_add( delay, buddy_send_handler_delayed, u );
+        }
+        else
+        {
+                imc_buddy_msg( u->ic, u->handle, msg, flags );
+        }
+}
+int irc_privmsg( irc_t *irc, user_t *u, char *type, char *to, char *prefix, char *msg )
+{
+        char last = 0;
+        char *s = msg, *line = msg;
+        /* The almighty linesplitter .. woohoo!! */
+        while( !last )
+        {
+                if( *s == '\r' && *(s+1) == '\n' )
+                        *(s++) = 0;
+                if( *s == '\n' )
+                {
+                        last = s[1] == 0;
+                        *s = 0;
+                }
+                else
+                {
+                        last = s[0] == 0;
+                }
+                if( *s == 0 )
+                {
+                        if( g_strncasecmp( line, "/me ", 4 ) == 0 && ( !prefix || !*prefix ) && g_strcasecmp( type, "PRIVMSG" ) == 0 )
+                        {
+                                irc_write( irc, ":%s!%s@%s %s %s :\001ACTION %s\001", u->nick, u->user, u->host,
+                                           type, to, line + 4 );
+                        }
+                        else
+                        {
+                                irc_write( irc, ":%s!%s@%s %s %s :%s%s", u->nick, u->user, u->host,
+                                           type, to, prefix ? prefix : "", line );
+                        }
+                        line = s + 1;
+                }
+                s ++;
+        }
+        return( 1 );
+}
+int irc_msgfrom( irc_t *irc, char *nick, char *msg )
+{
+        user_t *u = user_find( irc, nick );
+        static char *prefix = NULL;
+        if( !u ) return( 0 );
+        if( prefix && *prefix ) g_free( prefix );
+        if( !u->is_private && nick_cmp( u->nick, irc->mynick ) != 0 )
+        {
+                int len = strlen( irc->nick) + 3;
+                prefix = g_new (char, len );
+                g_snprintf( prefix, len, "%s%s", irc->nick, set_getstr( &irc->set, "to_char" ) );
+                prefix[len-1] = 0;
+        }
+        else
+        {
+                prefix = "";
+        }
+        return( irc_privmsg( irc, u, "PRIVMSG", u->is_private ? irc->nick : irc->channel, prefix, msg ) );
+}
+int irc_noticefrom( irc_t *irc, char *nick, char *msg )
+{
+        user_t *u = user_find( irc, nick );
+        if( u )
+                return( irc_privmsg( irc, u, "NOTICE", irc->nick, "", msg ) );
+        else
+                return( 0 );
+                irc_write( irc, ":%s!%s@%s MODE %s :%s", irc->user->nick,
+                           irc->user->user, irc->user->host, irc->user->nick,
+                           changes );
+}
 …
+}
+struct groupchat *irc_chat_by_channel( irc_t *irc, char *channel )
+{
+        struct groupchat *c;
+        account_t *a;
+        /* This finds the connection which has a conversation which belongs to this channel */
+        for( a = irc->accounts; a; a = a->next )
+        {
+                if( a->ic == NULL )
+                        continue;
+                c = a->ic->groupchats;
+                while( c )
+                {
+                        if( c->channel && g_strcasecmp( c->channel, channel ) == 0 )
+                                return c;
+                        c = c->next;
+                }
+        }
+        return NULL;
+}
+static char *set_eval_charset( set_t *set, char *value )
+{
+        irc_t *irc = (irc_t*) set->data;
+        char *test;
+        gsize test_bytes = 0;
+        GIConv ic, oc;
+        if( g_strcasecmp( value, "none" ) == 0 )
+                value = g_strdup( "utf-8" );
+        if( ( oc = g_iconv_open( value, "utf-8" ) ) == (GIConv) -1 )
+        {
+                return NULL;
+        }
+        /* Do a test iconv to see if the user picked an IRC-compatible
+           charset (for example utf-16 goes *horribly* wrong). */
+        if( ( test = g_convert_with_iconv( " ", 1, oc, NULL, &test_bytes, NULL ) ) == NULL ||
+            test_bytes > 1 )
+        {
+                g_free( test );
+                g_iconv_close( oc );
+                irc_usermsg( irc, "Unsupported character set: The IRC protocol "
+                                  "only supports 8-bit character sets." );
+                return NULL;
+        }
+        g_free( test );
+        if( ( ic = g_iconv_open( "utf-8", value ) ) == (GIConv) -1 )
+        {
+                g_iconv_close( oc );
+                return NULL;
+        }
+        if( irc->iconv != (GIConv) -1 )
+                g_iconv_close( irc->iconv );
+        if( irc->oconv != (GIConv) -1 )
+                g_iconv_close( irc->oconv );
+        irc->iconv = ic;
+        irc->oconv = oc;
+        return value;
+}
+char *set_eval_away_devoice( set_t *set, char *value )
+{
+        irc_t *irc = set->data;
+        if( !is_bool( value ) )
+                return SET_INVALID;
+        /* The usual problem: The setting isn't actually changed at this
+           point and we need it to be, so do it by hand. */
+        g_free( set->value );
+        set->value = g_strdup( value );
+        bee_irc_channel_update( irc, NULL, NULL );
+        return value;
+}

irc.h

-                      r560d0a0
+                      rf1cea66
   \********************************************************************/
 /* The big hairy IRCd part of the project                               */
+/* The IRC-based UI (for now the only one)                              */
 /*
 …
 #define IRC_PING_STRING "PinglBee"
+#define UMODES "abisw"
+#define UMODES_PRIV "Ro"
+#define CMODES "nt"
+#define CMODE "t"
+#define UMODE "s"
+#define CTYPES "&#"
+#define UMODES "abisw"     /* Allowed umodes (although they mostly do nothing) */
+#define UMODES_PRIV "Ro"   /* Allowed, but not by user directly */
+#define UMODES_KEEP "R"    /* Don't allow unsetting using /MODE */
+#define CMODES "nt"        /* Allowed modes */
+#define CMODE "t"          /* Default mode */
+#define UMODE "s"          /* Default mode */
+#define CTYPES "&#"        /* Valid channel name prefixes */
 typedef enum
 …
         USTATUS_SHUTDOWN = 8
 } irc_status_t;
+struct irc_user;
 typedef struct irc
 …
         GIConv iconv, oconv;
+        int sentbytes;
+        time_t oldtime;
+        struct irc_user *root;
+        struct irc_user *user;
+        char *last_root_cmd;
+        char *password; /* HACK: Used to save the user's password, but before
+                           logging in, this may contain a password we should
+                           send to identify after USER/NICK are received. */
+        char umode[8];
+        struct query *queries;
+        GSList *file_transfers;
+        GSList *users, *channels;
+        struct irc_channel *default_channel;
+        GHashTable *nick_user_hash;
+        GHashTable *watches;
+        gint r_watch_source_id;
+        gint w_watch_source_id;
+        gint ping_source_id;
+        struct bee *b;
+} irc_t;
+typedef enum
+{
+        IRC_USER_PRIVATE = 1,
+        IRC_USER_AWAY = 2,
+} irc_user_flags_t;
+typedef struct irc_user
+{
+        irc_t *irc;
         char *nick;
         char *user;
         char *host;
+        char *realname;
+        char *password; /* HACK: Used to save the user's password, but before
+                           logging in, this may contain a password we should
+                           send to identify after USER/NICK are received. */
+        char umode[8];
+        char *myhost;
+        char *mynick;
+        char *channel;
+        int c_id;
+        char is_private;                /* Not too nice... */
+        char *last_target;
+        struct query *queries;
+        struct account *accounts;
+        GSList *file_transfers;
+        struct chat *chatrooms;
+        struct __USER *users;
+        GHashTable *userhash;
+        GHashTable *watches;
+        struct __NICK *nicks;
+        char *fullname;
+        /* Nickname in lowercase for case sensitive searches */
+        char *key;
+        irc_user_flags_t flags;
+        GString *pastebuf;
+        guint pastebuf_timer;
+        struct bee_user *bu;
+        const struct irc_user_funcs *f;
+} irc_user_t;
+struct irc_user_funcs
+{
+        gboolean (*privmsg)( irc_user_t *iu, const char *msg );
+        gboolean (*ctcp)( irc_user_t *iu, char * const* ctcp );
+};
+extern const struct irc_user_funcs irc_user_root_funcs;
+extern const struct irc_user_funcs irc_user_self_funcs;
+typedef enum
+{
+        IRC_CHANNEL_JOINED = 1,
+        /* Hack: Set this flag right before jumping into IM when we expect
+           a call to imcb_chat_new(). */
+        IRC_CHANNEL_CHAT_PICKME = 0x10000,
+} irc_channel_flags_t;
+typedef struct irc_channel
+{
+        irc_t *irc;
+        char *name;
+        char mode[8];
+        int flags;
+        char *topic;
+        char *topic_who;
+        time_t topic_time;
+        GSList *users;
         struct set *set;
+        gint r_watch_source_id;
+        gint w_watch_source_id;
+        gint ping_source_id;
+} irc_t;
+#include "user.h"
+        GString *pastebuf;
+        guint pastebuf_timer;
+        const struct irc_channel_funcs *f;
+        void *data;
+} irc_channel_t;
+struct irc_channel_funcs
+{
+        gboolean (*privmsg)( irc_channel_t *ic, const char *msg );
+        gboolean (*join)( irc_channel_t *ic );
+        gboolean (*part)( irc_channel_t *ic, const char *msg );
+        gboolean (*topic)( irc_channel_t *ic, const char *new );
+        gboolean (*invite)( irc_channel_t *ic, irc_user_t *iu );
+        gboolean (*_init)( irc_channel_t *ic );
+        gboolean (*_free)( irc_channel_t *ic );
+};
+typedef enum
+{
+        IRC_CHANNEL_USER_OP = 1,
+        IRC_CHANNEL_USER_HALFOP = 2,
+        IRC_CHANNEL_USER_VOICE = 4,
+} irc_channel_user_flags_t;
+typedef struct irc_channel_user
+{
+        irc_user_t *iu;
+        int flags;
+} irc_channel_user_t;
+typedef enum
+{
+        IRC_CC_TYPE_DEFAULT,
+        IRC_CC_TYPE_REST,
+        IRC_CC_TYPE_GROUP,
+        IRC_CC_TYPE_ACCOUNT,
+} irc_control_channel_type_t;
+struct irc_control_channel
+{
+        irc_control_channel_type_t type;
+        struct bee_group *group;
+        struct account *account;
+};
+extern const struct bee_ui_funcs irc_ui_funcs;
+/* irc.c */
 extern GSList *irc_connection_list;
 …
 void irc_abort( irc_t *irc, int immed, char *format, ... ) G_GNUC_PRINTF( 3, 4 );
 void irc_free( irc_t *irc );
+void irc_exec( irc_t *irc, char **cmd );
+void irc_setpass (irc_t *irc, const char *pass);
 void irc_process( irc_t *irc );
 char **irc_parse_line( char *line );
 char *irc_build_line( char **cmd );
-void irc_vawrite( irc_t *irc, char *format, va_list params );
 void irc_write( irc_t *irc, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
 void irc_write_all( int now, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
+void irc_reply( irc_t *irc, int code, char *format, ... ) G_GNUC_PRINTF( 3, 4 );
+G_MODULE_EXPORT int irc_usermsg( irc_t *irc, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
+char **irc_tokenize( char *buffer );
+void irc_login( irc_t *irc );
+void irc_vawrite( irc_t *irc, char *format, va_list params );
 int irc_check_login( irc_t *irc );
+void irc_motd( irc_t *irc );
+void irc_names( irc_t *irc, char *channel );
+void irc_topic( irc_t *irc, char *channel );
+void irc_umode_set( irc_t *irc, char *s, int allow_priv );
+void irc_who( irc_t *irc, char *channel );
+void irc_spawn( irc_t *irc, user_t *u );
+void irc_join( irc_t *irc, user_t *u, char *channel );
+void irc_part( irc_t *irc, user_t *u, char *channel );
+void irc_kick( irc_t *irc, user_t *u, char *channel, user_t *kicker );
+void irc_kill( irc_t *irc, user_t *u );
+void irc_invite( irc_t *irc, char *nick, char *channel );
+void irc_whois( irc_t *irc, char *nick );
+void irc_setpass( irc_t *irc, const char *pass ); /* USE WITH CAUTION! */
+int irc_send( irc_t *irc, char *nick, char *s, int flags );
+int irc_privmsg( irc_t *irc, user_t *u, char *type, char *to, char *prefix, char *msg );
+int irc_msgfrom( irc_t *irc, char *nick, char *msg );
+int irc_noticefrom( irc_t *irc, char *nick, char *msg );
+void buddy_send_handler( irc_t *irc, user_t *u, char *msg, int flags );
+struct groupchat *irc_chat_by_channel( irc_t *irc, char *channel );
+void irc_umode_set( irc_t *irc, const char *s, gboolean allow_priv );
+/* irc_channel.c */
+irc_channel_t *irc_channel_new( irc_t *irc, const char *name );
+irc_channel_t *irc_channel_by_name( irc_t *irc, const char *name );
+irc_channel_t *irc_channel_get( irc_t *irc, char *id );
+int irc_channel_free( irc_channel_t *ic );
+int irc_channel_add_user( irc_channel_t *ic, irc_user_t *iu );
+int irc_channel_del_user( irc_channel_t *ic, irc_user_t *iu, gboolean silent, const char *msg );
+irc_channel_user_t *irc_channel_has_user( irc_channel_t *ic, irc_user_t *iu );
+int irc_channel_set_topic( irc_channel_t *ic, const char *topic, const irc_user_t *who );
+void irc_channel_user_set_mode( irc_channel_t *ic, irc_user_t *iu, irc_channel_user_flags_t flags );
+void irc_channel_printf( irc_channel_t *ic, char *format, ... );
+gboolean irc_channel_name_ok( const char *name );
+void irc_channel_update_ops( irc_channel_t *ic, char *value );
+char *set_eval_irc_channel_ops( struct set *set, char *value );
+/* irc_commands.c */
+void irc_exec( irc_t *irc, char **cmd );
+/* irc_send.c */
+void irc_send_num( irc_t *irc, int code, char *format, ... ) G_GNUC_PRINTF( 3, 4 );
+void irc_send_login( irc_t *irc );
+void irc_send_motd( irc_t *irc );
+void irc_usermsg( irc_t *irc, char *format, ... );
+void irc_send_join( irc_channel_t *ic, irc_user_t *iu );
+void irc_send_part( irc_channel_t *ic, irc_user_t *iu, const char *reason );
+void irc_send_quit( irc_user_t *iu, const char *reason );
+void irc_send_names( irc_channel_t *ic );
+void irc_send_topic( irc_channel_t *ic, gboolean topic_change );
+void irc_send_whois( irc_user_t *iu );
+void irc_send_who( irc_t *irc, GSList *l, const char *channel );
+void irc_send_msg( irc_user_t *iu, const char *type, const char *dst, const char *msg, const char *prefix );
+void irc_send_msg_raw( irc_user_t *iu, const char *type, const char *dst, const char *msg );
+void irc_send_msg_f( irc_user_t *iu, const char *type, const char *dst, const char *format, ... ) G_GNUC_PRINTF( 4, 5 );
+void irc_send_nick( irc_user_t *iu, const char *new );
+void irc_send_channel_user_mode_diff( irc_channel_t *ic, irc_user_t *iu,
+                                      irc_channel_user_flags_t old, irc_channel_user_flags_t new );
+/* irc_user.c */
+irc_user_t *irc_user_new( irc_t *irc, const char *nick );
+int irc_user_free( irc_t *irc, irc_user_t *iu );
+irc_user_t *irc_user_by_name( irc_t *irc, const char *nick );
+int irc_user_set_nick( irc_user_t *iu, const char *new );
+gint irc_user_cmp( gconstpointer a_, gconstpointer b_ );
+const char *irc_user_get_away( irc_user_t *iu );
+/* irc_util.c */
+char *set_eval_timezone( struct set *set, char *value );
+char *irc_format_timestamp( irc_t *irc, time_t msg_ts );
+/* irc_im.c */
+void bee_irc_channel_update( irc_t *irc, irc_channel_t *ic, irc_user_t *iu );
 #endif

irc_commands.c

-                      r560d0a0
+                      rf1cea66
   * BitlBee -- An IRC to other IM-networks gateway                     *
   *                                                                    *
   * Copyright 2002-2006 Wilmer van der Gaast and others                *
+  * Copyright 2002-2010 Wilmer van der Gaast and others                *
   \********************************************************************/
 …
         else if( global.conf->auth_pass )
+        {
                 irc_reply( irc, 464, ":Incorrect password" );
+                irc_send_num( irc, 464, ":Incorrect password" );
+        }
         else
 …
 static void irc_cmd_user( irc_t *irc, char **cmd )
+{
         irc->user = g_strdup( cmd[1] );
         irc->realname = g_strdup( cmd[4] );
+        irc->user->user = g_strdup( cmd[1] );
+        irc->user->fullname = g_strdup( cmd[4] );
         irc_check_login( irc );
 …
 static void irc_cmd_nick( irc_t *irc, char **cmd )
+{
+        if( irc->status & USTATUS_IDENTIFIED && irc->nick )
+        {
+                irc_reply( irc, 438, "%s %s :You can only change your nick if you're not "
+                           "logged in (i.e. pre-identify)", irc->nick, cmd[1] );
+        }
+        /* 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 ) || ( user_find( irc, cmd[1] ) != NULL ) )
+        {
+                irc_reply( irc, 433, "%s :This nick is already in use", cmd[1] );
+        if( irc_user_by_name( irc, cmd[1] ) )
+        {
+                irc_send_num( irc, 433, ":This nick is already in use" );
+        }
         else if( !nick_ok( cmd[1] ) )
+        {
                 /* [SH] Invalid characters. */
+                irc_reply( irc, 432, "%s :This nick contains invalid characters", cmd[1] );
+        }
+        else if(irc->nick)
+        {
+                if( user_find( irc, irc->nick ) )
+                        user_rename(irc, irc->nick, cmd[1]);
+                irc_write( irc, ":%s!%s@%s NICK %s", irc->nick, irc->user, irc->host, cmd[1] );
+                g_free(irc->nick);
+                irc->nick = g_strdup( cmd[1] );
+        }
+        else
+        {
+                irc->nick = g_strdup( cmd[1] );
+                irc_send_num( irc, 432, ":This nick contains invalid characters" );
+        }
+        else if( irc->user->nick )
+        {
+                if( irc->status & USTATUS_IDENTIFIED )
+                {
+                        irc_setpass( irc, NULL );
+                        irc->status &= ~USTATUS_IDENTIFIED;
+                        irc_umode_set( irc, "-R", 1 );
+                        irc_usermsg( irc, "Changing nicks resets your identify status. "
+                                     "Re-identify or register a new account if you want "
+                                     "your configuration to be saved. See \x02help "
+                                     "nick_changes\x02." );
+                }
+                irc_user_set_nick( irc->user, cmd[1] );
+        }
+        else
+        {
+                irc->user->nick = g_strdup( cmd[1] );
                 irc_check_login( irc );
 …
 static void irc_cmd_ping( irc_t *irc, char **cmd )
+{
+        irc_write( irc, ":%s PONG %s :%s", irc->myhost, irc->myhost, cmd[1]?cmd[1]:irc->myhost );
+}
+static void irc_cmd_oper( irc_t *irc, char **cmd )
+{
+        if( global.conf->oper_pass &&
+            ( strncmp( global.conf->oper_pass, "md5:", 4 ) == 0 ?
+                md5_verify_password( cmd[2], global.conf->oper_pass + 4 ) == 0 :
+                strcmp( cmd[2], global.conf->oper_pass ) == 0 ) )
+        {
+                irc_umode_set( irc, "+o", 1 );
+                irc_reply( irc, 381, ":Password accepted" );
+        }
+        else
+        {
+                irc_reply( irc, 432, ":Incorrect password" );
+        }
+        irc_write( irc, ":%s PONG %s :%s", irc->root->host,
+                   irc->root->host, cmd[1]?cmd[1]:irc->root->host );
+}
+static void irc_cmd_pong( irc_t *irc, char **cmd )
+{
+        /* We could check the value we get back from the user, but in
+           fact we don't care, we're just happy s/he's still alive. */
+        irc->last_pong = gettime();
+        irc->pinging = 0;
+}
+static void irc_cmd_join( irc_t *irc, char **cmd )
+{
+        irc_channel_t *ic;
+        if( ( ic = irc_channel_by_name( irc, cmd[1] ) ) == NULL )
+                ic = irc_channel_new( irc, cmd[1] );
+        if( ic == NULL )
+        {
+                irc_send_num( irc, 479, "%s :Invalid channel name", cmd[1] );
+                return;
+        }
+        if( ic->flags & IRC_CHANNEL_JOINED )
+                return; /* Dude, you're already there...
+                           RFC doesn't have any reply for that though? */
+        if( ic->f->join && !ic->f->join( ic ) )
+                /* The story is: FALSE either means the handler showed an error
+                   message, or is doing some work before the join should be
+                   confirmed. (In the latter case, the caller should take care
+                   of that confirmation.)
+                   TRUE means all's good, let the user join the channel right away. */
+                return;
+        irc_channel_add_user( ic, irc->user );
+}
+static void irc_cmd_names( irc_t *irc, char **cmd )
+{
+        irc_channel_t *ic;
+        if( cmd[1] && ( ic = irc_channel_by_name( irc, cmd[1] ) ) )
+                irc_send_names( ic );
+        /* With no args, we should show /names of all chans. Make the code
+           below work well if necessary.
+        else
+        {
+                GSList *l;
+                for( l = irc->channels; l; l = l->next )
+                        irc_send_names( l->data );
+        }
+        */
+}
+static void irc_cmd_part( irc_t *irc, char **cmd )
+{
+        irc_channel_t *ic;
+        if( ( ic = irc_channel_by_name( irc, cmd[1] ) ) == NULL )
+        {
+                irc_send_num( irc, 403, "%s :No such channel", cmd[1] );
+        }
+        else if( irc_channel_del_user( ic, irc->user, FALSE, cmd[2] ) )
+        {
+                if( ic->f->part )
+                        ic->f->part( ic, NULL );
+        }
+        else
+        {
+                irc_send_num( irc, 442, "%s :You're not on that channel", cmd[1] );
+        }
+}
+static void irc_cmd_whois( irc_t *irc, char **cmd )
+{
+        char *nick = cmd[1];
+        irc_user_t *iu = irc_user_by_name( irc, nick );
+        if( iu )
+                irc_send_whois( iu );
+        else
+                irc_send_num( irc, 401, "%s :Nick does not exist", nick );
+}
+static void irc_cmd_whowas( irc_t *irc, char **cmd )
+{
+        /* 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 */
+        irc_send_num( irc, 406, "%s :Nick does not exist", cmd[1] );
+        irc_send_num( irc, 369, "%s :End of WHOWAS", cmd[1] );
+}
+static void irc_cmd_motd( irc_t *irc, char **cmd )
+{
+        irc_send_motd( irc );
+}
 static void irc_cmd_mode( irc_t *irc, char **cmd )
+{
+        if( strchr( CTYPES, *cmd[1] ) )
+        {
+                if( cmd[2] )
+        if( irc_channel_name_ok( cmd[1] ) )
+        {
+                irc_channel_t *ic;
+                if( ( ic = irc_channel_by_name( irc, cmd[1] ) ) == NULL )
+                        irc_send_num( irc, 403, "%s :No such channel", cmd[1] );
+                else if( cmd[2] )
+                {
                         if( *cmd[2] == '+' || *cmd[2] == '-' )
                                 irc_reply( irc, 477, "%s :Can't change channel modes", cmd[1] );
+                                irc_send_num( 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] );
+                                irc_send_num( 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 )
+                        irc_send_num( irc, 324, "%s +%s", cmd[1], ic->mode );
+        }
+        else
+        {
+                if( nick_cmp( cmd[1], irc->user->nick ) == 0 )
+                {
                         if( cmd[2] )
                                 irc_umode_set( irc, cmd[2], 0 );
                         else
                                 irc_reply( irc, 221, "+%s", irc->umode );
+                                irc_send_num( irc, 221, "+%s", irc->umode );
+                }
                 else
+                        irc_reply( irc, 502, ":Don't touch their modes" );
+        }
+}
+static void irc_cmd_names( irc_t *irc, char **cmd )
+{
+        irc_names( irc, cmd[1]?cmd[1]:irc->channel );
+}
+static void irc_cmd_part( irc_t *irc, char **cmd )
+{
+        struct groupchat *c;
+        if( g_strcasecmp( cmd[1], irc->channel ) == 0 )
+        {
+                user_t *u = user_find( irc, irc->nick );
+                /* Not allowed to leave control channel */
+                irc_part( irc, u, irc->channel );
+                irc_join( irc, u, irc->channel );
+        }
+        else if( ( c = irc_chat_by_channel( irc, cmd[1] ) ) )
+        {
+                user_t *u = user_find( irc, irc->nick );
+                irc_part( irc, u, c->channel );
+                if( c->ic )
+                {
+                        c->joined = 0;
+                        c->ic->acc->prpl->chat_leave( c );
+                }
+        }
+        else
+        {
+                irc_reply( irc, 403, "%s :No such channel", cmd[1] );
+        }
+}
+static void irc_cmd_join( irc_t *irc, char **cmd )
+{
+        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] )
+        {
+                struct chat *c;
+                if( strchr( CTYPES, cmd[1][0] ) == NULL || cmd[1][1] == 0 )
+                        irc_reply( irc, 479, "%s :Invalid channel name", cmd[1] );
+                else if( ( c = chat_bychannel( irc, cmd[1] ) ) && c->acc && c->acc->ic )
+                        chat_join( irc, c, cmd[2] );
+                else
+                        irc_reply( irc, 403, "%s :No such channel", cmd[1] );
+        }
+}
+static void irc_cmd_invite( irc_t *irc, char **cmd )
+{
+        char *nick = cmd[1], *channel = cmd[2];
+        struct groupchat *c = irc_chat_by_channel( irc, channel );
+        user_t *u = user_find( irc, nick );
+        if( u && c && ( u->ic == c->ic ) )
+                if( c->ic && c->ic->acc->prpl->chat_invite )
+                {
+                        c->ic->acc->prpl->chat_invite( c, u->handle, NULL );
+                        irc_reply( irc, 341, "%s %s", nick, channel );
+                        return;
+                }
+        irc_reply( irc, 482, "%s :Invite impossible; User/Channel non-existent or incompatible", channel );
+                        irc_send_num( irc, 502, ":Don't touch their modes" );
+        }
+}
+static void irc_cmd_who( irc_t *irc, char **cmd )
+{
+        char *channel = cmd[1];
+        irc_channel_t *ic;
+        if( !channel || *channel == '0' || *channel == '*' || !*channel )
+                irc_send_who( irc, irc->users, "**" );
+        else if( ( ic = irc_channel_by_name( irc, channel ) ) )
+                irc_send_who( irc, ic->users, channel );
+        else
+                irc_send_num( irc, 403, "%s :No such channel", channel );
+}
 static void irc_cmd_privmsg( irc_t *irc, char **cmd )
+{
+        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] );
+        irc_channel_t *ic;
+        irc_user_t *iu;
+        if( !cmd[2] )
+        {
+                irc_send_num( irc, 412, ":No text to send" );
+                return;
+        }
+        /* Don't treat CTCP actions as real CTCPs, just convert them right now. */
+        if( g_strncasecmp( cmd[2], "\001ACTION", 7 ) == 0 )
+        {
+                cmd[2] += 4;
+                strcpy( cmd[2], "/me" );
+                if( cmd[2][strlen(cmd[2])-1] == '\001' )
+                        cmd[2][strlen(cmd[2])-1] = '\0';
+        }
+        if( irc_channel_name_ok( cmd[1] ) &&
+            ( ic = irc_channel_by_name( irc, cmd[1] ) ) )
+        {
+                if( ic->f->privmsg )
+                        ic->f->privmsg( ic, cmd[2] );
+        }
+        else if( ( iu = irc_user_by_name( irc, cmd[1] ) ) )
+        {
+                if( cmd[2][0] == '\001' )
+                {
+                        char **ctcp;
+                        if( iu->f->ctcp == NULL )
+                                return;
+                        if( cmd[2][strlen(cmd[2])-1] == '\001' )
+                                cmd[2][strlen(cmd[2])-1] = '\0';
+                        ctcp = split_command_parts( cmd[2] + 1 );
+                        iu->f->ctcp( iu, ctcp );
+                }
+                else if( iu->f->privmsg )
+                {
+                        iu->flags |= IRC_USER_PRIVATE;
+                        iu->f->privmsg( iu, cmd[2] );
+                }
+        }
+        else
+        {
+                irc_send_num( irc, 401, "%s :No such nick/channel", cmd[1] );
+        }
+#if 0
+        else if( irc->nick && g_strcasecmp( cmd[1], irc->nick ) == 0 )
+        {
+        }
         else
 …
                 irc_send( irc, cmd[1], cmd[2], ( g_strcasecmp( cmd[0], "NOTICE" ) == 0 ) ? OPT_AWAY : 0 );
+        }
+}
+static void irc_cmd_who( irc_t *irc, char **cmd )
+{
+        char *channel = cmd[1];
+        user_t *u = irc->users;
+        struct groupchat *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 = irc_chat_by_channel( irc, channel ) ) )
+                for( l = c->in_room; l; l = l->next )
+                {
+                        if( ( u = user_findhandle( c->ic, 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:"**" );
+#endif
+}
+static void irc_cmd_nickserv( irc_t *irc, char **cmd )
+{
+        /* [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 );
+}
+static void irc_cmd_oper( irc_t *irc, char **cmd )
+{
+        if( global.conf->oper_pass &&
+            ( strncmp( global.conf->oper_pass, "md5:", 4 ) == 0 ?
+                md5_verify_password( cmd[2], global.conf->oper_pass + 4 ) == 0 :
+                strcmp( cmd[2], global.conf->oper_pass ) == 0 ) )
+        {
+                irc_umode_set( irc, "+o", 1 );
+                irc_send_num( irc, 381, ":Password accepted" );
+        }
+        else
+        {
+                irc_send_num( irc, 432, ":Incorrect password" );
+        }
+}
+static void irc_cmd_invite( irc_t *irc, char **cmd )
+{
+        irc_channel_t *ic;
+        irc_user_t *iu;
+        if( ( iu = irc_user_by_name( irc, cmd[1] ) ) == NULL )
+        {
+                irc_send_num( irc, 401, "%s :No such nick", cmd[1] );
+                return;
+        }
+        else if( ( ic = irc_channel_by_name( irc, cmd[2] ) ) == NULL )
+        {
+                irc_send_num( irc, 403, "%s :No such channel", cmd[2] );
+                return;
+        }
+        if( !ic->f->invite || !ic->f->invite( ic, iu ) )
+                irc_send_num( irc, 482, "%s :Can't invite people here", cmd[2] );
+}
 static void irc_cmd_userhost( irc_t *irc, char **cmd )
+{
-        user_t *u;
         int i;
 …
         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 );
+                }
+        {
+                irc_user_t *iu = irc_user_by_name( irc, cmd[i] );
+                if( iu )
+                        irc_send_num( irc, 302, ":%s=%c%s@%s", iu->nick,
+                                      irc_user_get_away( iu ) ? '-' : '+',
+                                      iu->user, iu->host );
+        }
+}
 static void irc_cmd_ison( irc_t *irc, char **cmd )
+{
-        user_t *u;
         char buff[IRC_MAX_LINE];
         int lenleft, i;
 …
                 while( *this )
+                {
+                        irc_user_t *iu;
                         if( ( next = strchr( this, ' ' ) ) )
                                 *next = 0;
+                        if( ( u = user_find( irc, this ) ) && u->online )
+                        {
+                                lenleft -= strlen( u->nick ) + 1;
+                        if( ( iu = irc_user_by_name( irc, this ) ) &&
+                            iu->bu && iu->bu->flags & BEE_USER_ONLINE )
+                        {
+                                lenleft -= strlen( iu->nick ) + 1;
                                 if( lenleft < 0 )
                                         break;
                                 strcat( buff, u->nick );
+                                strcat( buff, iu->nick );
                                 strcat( buff, " " );
+                        }
 …
                 buff[strlen(buff)-1] = '\0';
         irc_reply( irc, 303, ":%s", buff );
+        irc_send_num( irc, 303, ":%s", buff );
+}
 …
+        {
                 char *nick;
                 user_t *u;
+                irc_user_t *iu;
                 if( !cmd[i][0] || !cmd[i][1] )
 …
                 nick_lc( nick );
                 u = user_find( irc, nick );
+                iu = irc_user_by_name( irc, nick );
                 if( cmd[i][0] == '+' )
 …
                                 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, (int) time( NULL ), "is online" );
+                        if( iu && iu->bu && iu->bu->flags & BEE_USER_ONLINE )
+                                irc_send_num( irc, 604, "%s %s %s %d :%s", iu->nick, iu->user,
+                                              iu->host, (int) time( NULL ), "is online" );
                         else
+                                irc_reply( irc, 605, "%s %s %s %d :%s", nick, "*", "*", (int) time( NULL ), "is offline" );
+                                irc_send_num( irc, 605, "%s %s %s %d :%s", nick, "*", "*",
+                                              (int) time( NULL ), "is offline" );
+                }
                 else if( cmd[i][0] == '-' )
 …
                                 g_free( okey );
                                 irc_reply( irc, 602, "%s %s %s %d :%s", nick, "*", "*", 0, "Stopped watching" );
+                                irc_send_num( irc, 602, "%s %s %s %d :%s", nick, "*", "*", 0, "Stopped watching" );
+                        }
+                }
 …
 static void irc_cmd_topic( irc_t *irc, char **cmd )
+{
+        char *channel = cmd[1];
+        char *topic = cmd[2];
+        if( topic )
+        {
+                /* Send the topic */
+                struct groupchat *c = irc_chat_by_channel( irc, channel );
+                if( c && c->ic && c->ic->acc->prpl->chat_topic )
+                        c->ic->acc->prpl->chat_topic( c, topic );
+        }
+        else
+        {
+                /* Get the topic */
+                irc_topic( irc, channel );
+        irc_channel_t *ic = irc_channel_by_name( irc, cmd[1] );
+        const char *new = cmd[2];
+        if( ic == NULL )
+        {
+                irc_send_num( irc, 403, "%s :No such channel", cmd[1] );
+        }
+        else if( new )
+        {
+                if( ic->f->topic == NULL )
+                        irc_send_num( irc, 482, "%s :Can't change this channel's topic", ic->name );
+                else if( ic->f->topic( ic, new ) )
+                        irc_send_topic( ic, TRUE );
+        }
+        else
+        {
+                irc_send_topic( ic, FALSE );
+        }
+}
 …
 static void irc_cmd_away( irc_t *irc, char **cmd )
+{
+        user_t *u = user_find( irc, irc->nick );
+        char *away = cmd[1];
+        if( !u ) return;
+        if( away && *away )
+        {
+        if( cmd[1] && *cmd[1] )
+        {
+                char away[strlen(cmd[1])+1];
                 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] ) >= ' ' )
+                for( i = j = 0; cmd[1][i]; i ++ )
+                        if( ( away[j] = cmd[1][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" );
+        }
+        set_setstr( &irc->set, "away", u->away );
+}
+static void irc_cmd_whois( irc_t *irc, char **cmd )
+{
+        char *nick = cmd[1];
+        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->ic )
+                        irc_reply( irc, 312, "%s %s.%s :%s network", u->nick, u->ic->acc->user,
+                                   u->ic->acc->server && *u->ic->acc->server ? u->ic->acc->server : "",
+                                   u->ic->acc->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 );
+                if( u->status_msg )
+                        irc_reply( irc, 320, "%s :%s", u->nick, u->status_msg );
+                irc_reply( irc, 318, "%s :End of /WHOIS list", nick );
+        }
+        else
+        {
+                irc_reply( irc, 401, "%s :Nick does not exist", nick );
+        }
+}
+static void irc_cmd_whowas( irc_t *irc, char **cmd )
+{
+        /* 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 */
+        irc_reply( irc, 406, "%s :Nick does not exist", cmd[1] );
+        irc_reply( irc, 369, "%s :End of WHOWAS", cmd[1] );
+}
+static void irc_cmd_nickserv( irc_t *irc, char **cmd )
+{
+        /* [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 );
+}
+static void irc_cmd_motd( irc_t *irc, char **cmd )
+{
+        irc_motd( irc );
+}
+static void irc_cmd_pong( irc_t *irc, char **cmd )
+{
+        /* 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;
+                away[j] = '\0';
+                irc_send_num( irc, 306, ":You're now away: %s", away );
+                set_setstr( &irc->b->set, "away", away );
+        }
+        else
+        {
+                irc_send_num( irc, 305, ":Welcome back" );
+                set_setstr( &irc->b->set, "away", NULL );
+        }
+}
 static void irc_cmd_version( irc_t *irc, char **cmd )
+{
+        irc_reply( irc, 351, "bitlbee-%s. %s :%s/%s ", BITLBEE_VERSION, irc->myhost, ARCH, CPU );
+        irc_send_num( irc, 351, "bitlbee-%s. %s :%s/%s ",
+                      BITLBEE_VERSION, irc->root->host, ARCH, CPU );
+}
 static void irc_cmd_completions( irc_t *irc, char **cmd )
+{
-        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" );
+        irc_send_msg_raw( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS OK" );
         for( i = 0; commands[i].command; i ++ )
                 irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS ", commands[i].command );
+                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS %s", commands[i].command );
         for( h = global.help; h; h = h->next )
                 irc_privmsg( irc, u, "NOTICE", irc->nick, "COMPLETIONS help ", h->title );
         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" );
+                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS help %s", h->title );
+        for( s = irc->b->set; s; s = s->next )
+                irc_send_msg_f( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS set %s", s->key );
+        irc_send_msg_raw( irc->root, "NOTICE", irc->user->nick, "COMPLETIONS END" );
+}
 …
                 ipc_to_master( cmd );
         irc_reply( irc, 382, "%s :Rehashing", global.conf_file );
+        irc_send_num( irc, 382, "%s :Rehashing", global.conf_file );
+}
 …
         { "quit",        0, irc_cmd_quit,        0 },
         { "ping",        0, irc_cmd_ping,        0 },
+        { "oper",        2, irc_cmd_oper,        IRC_CMD_LOGGED_IN },
+        { "pong",        0, irc_cmd_pong,        IRC_CMD_LOGGED_IN },
+        { "join",        1, irc_cmd_join,        IRC_CMD_LOGGED_IN },
+        { "names",       1, irc_cmd_names,       IRC_CMD_LOGGED_IN },
+        { "part",        1, irc_cmd_part,        IRC_CMD_LOGGED_IN },
+        { "whois",       1, irc_cmd_whois,       IRC_CMD_LOGGED_IN },
+        { "whowas",      1, irc_cmd_whowas,      IRC_CMD_LOGGED_IN },
+        { "motd",        0, irc_cmd_motd,        IRC_CMD_LOGGED_IN },
         { "mode",        1, irc_cmd_mode,        IRC_CMD_LOGGED_IN },
+        { "names",       0, irc_cmd_names,       IRC_CMD_LOGGED_IN },
+        { "part",        1, irc_cmd_part,        IRC_CMD_LOGGED_IN },
+        { "join",        1, irc_cmd_join,        IRC_CMD_LOGGED_IN },
+        { "invite",      2, irc_cmd_invite,      IRC_CMD_LOGGED_IN },
+        { "who",         0, irc_cmd_who,         IRC_CMD_LOGGED_IN },
         { "privmsg",     1, irc_cmd_privmsg,     IRC_CMD_LOGGED_IN },
+        { "notice",      1, irc_cmd_privmsg,     IRC_CMD_LOGGED_IN },
+        { "who",         0, irc_cmd_who,         IRC_CMD_LOGGED_IN },
+        { "nickserv",    1, irc_cmd_nickserv,    IRC_CMD_LOGGED_IN },
+        { "ns",          1, irc_cmd_nickserv,    IRC_CMD_LOGGED_IN },
+        { "away",        0, irc_cmd_away,        IRC_CMD_LOGGED_IN },
+        { "version",     0, irc_cmd_version,     IRC_CMD_LOGGED_IN },
+        { "completions", 0, irc_cmd_completions, IRC_CMD_LOGGED_IN },
         { "userhost",    1, irc_cmd_userhost,    IRC_CMD_LOGGED_IN },
         { "ison",        1, irc_cmd_ison,        IRC_CMD_LOGGED_IN },
         { "watch",       1, irc_cmd_watch,       IRC_CMD_LOGGED_IN },
+        { "invite",      2, irc_cmd_invite,      IRC_CMD_LOGGED_IN },
+#if 0
+        { "notice",      1, irc_cmd_privmsg,     IRC_CMD_LOGGED_IN },
+#endif
         { "topic",       1, irc_cmd_topic,       IRC_CMD_LOGGED_IN },
+        { "away",        0, irc_cmd_away,        IRC_CMD_LOGGED_IN },
+        { "whois",       1, irc_cmd_whois,       IRC_CMD_LOGGED_IN },
+        { "whowas",      1, irc_cmd_whowas,      IRC_CMD_LOGGED_IN },
+        { "nickserv",    1, irc_cmd_nickserv,    IRC_CMD_LOGGED_IN },
+        { "ns",          1, irc_cmd_nickserv,    IRC_CMD_LOGGED_IN },
+        { "motd",        0, irc_cmd_motd,        IRC_CMD_LOGGED_IN },
+        { "pong",        0, irc_cmd_pong,        IRC_CMD_LOGGED_IN },
+        { "version",     0, irc_cmd_version,     IRC_CMD_LOGGED_IN },
+        { "completions", 0, irc_cmd_completions, IRC_CMD_LOGGED_IN },
+        { "oper",        2, irc_cmd_oper,        IRC_CMD_LOGGED_IN },
         { "die",         0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
         { "deaf",        0, NULL,                IRC_CMD_OPER_ONLY | IRC_CMD_TO_MASTER },
 …
                         if( irc_commands[i].flags & IRC_CMD_PRE_LOGIN && irc->status & USTATUS_LOGGED_IN )
+                        {
                                 irc_reply( irc, 462, ":Only allowed before logging in" );
+                                irc_send_num( irc, 462, ":Only allowed before logging in" );
+                        }
                         else if( irc_commands[i].flags & IRC_CMD_LOGGED_IN && !( irc->status & USTATUS_LOGGED_IN ) )
+                        {
                                 irc_reply( irc, 451, ":Register first" );
+                                irc_send_num( irc, 451, ":Register first" );
+                        }
                         else if( irc_commands[i].flags & IRC_CMD_OPER_ONLY && !strchr( irc->umode, 'o' ) )
+                        {
                                 irc_reply( irc, 481, ":Permission denied - You're not an IRC operator" );
+                                irc_send_num( irc, 481, ":Permission denied - You're not an IRC operator" );
+                        }
                         else if( n_arg < irc_commands[i].required_parameters )
+                        {
                                 irc_reply( irc, 461, "%s :Need more parameters", cmd[0] );
+                                irc_send_num( irc, 461, "%s :Need more parameters", cmd[0] );
+                        }
                         else if( irc_commands[i].flags & IRC_CMD_TO_MASTER )
 …
         if( irc->status >= USTATUS_LOGGED_IN )
                 irc_reply( irc, 421, "%s :Unknown command", cmd[0] );
+}
+                irc_send_num( irc, 421, "%s :Unknown command", cmd[0] );
+}

lib/misc.c

-                      r560d0a0
+                      rf1cea66
         return ret;
+}
+char **split_command_parts( char *command )
+{
+        static char *cmd[IRC_MAX_ARGS+1];
+        char *s, q = 0;
+        int k;
+        memset( cmd, 0, sizeof( cmd ) );
+        cmd[0] = command;
+        k = 1;
+        for( s = command; *s && k < IRC_MAX_ARGS; s ++ )
+                if( *s == ' ' && !q )
+                {
+                        *s = 0;
+                        while( *++s == ' ' );
+                        if( *s == '"' || *s == '\'' )
+                        {
+                                q = *s;
+                                s ++;
+                        }
+                        if( *s )
+                        {
+                                cmd[k++] = s;
+                                s --;
+                        }
+                        else
+                        {
+                                break;
+                        }
+                }
+                else if( *s == '\\' && ( ( !q && s[1] ) || ( q && q == s[1] ) ) )
+                {
+                        char *cpy;
+                        for( cpy = s; *cpy; cpy ++ )
+                                cpy[0] = cpy[1];
+                }
+                else if( *s == q )
+                {
+                        q = *s = 0;
+                }
+        /* Full zero-padding for easier argc checking. */
+        while( k <= IRC_MAX_ARGS )
+                cmd[k++] = NULL;
+        return cmd;
+}

lib/misc.h

r560d0a0	rf1cea66
69	69	G_MODULE_EXPORT int md5_verify_password( char password, char hash );
70	70
	71	G_MODULE_EXPORT char *split_command_parts( char command );
	72
71	73	#endif

nick.c

-                      r560d0a0
+                      rf1cea66
                 nick_strip( nick );
                 if( set_getbool( &acc->irc->set, "lcnicks" ) )
+                if( set_getbool( &acc->bee->set, "lcnicks" ) )
                         nick_lc( nick );
+        }
 …
 void nick_dedupe( account_t *acc, const char *handle, char nick[MAX_NICK_LENGTH+1] )
+{
+        irc_t *irc = (irc_t*) acc->bee->ui_data;
         int inf_protection = 256;
         /* Now, find out if the nick is already in use at the moment, and make
            subtle changes to make it unique. */
         while( !nick_ok( nick ) || user_find( acc->irc, nick ) )
+        while( !nick_ok( nick ) || irc_user_by_name( irc, nick ) )
+        {
                 if( strlen( nick ) < ( MAX_NICK_LENGTH - 1 ) )
 …
                         int i;
                         irc_usermsg( acc->irc, "Warning: Almost had an infinite loop in nick_get()! "
                                                "This used to be a fatal BitlBee bug, but we tried to fix it. "
                                                "This message should *never* appear anymore. "
                                                "If it does, please *do* send us a bug report! "
                                                "Please send all the following lines in your report:" );
                         irc_usermsg( acc->irc, "Trying to get a sane nick for handle %s", handle );
+                        irc_usermsg( irc, "Warning: Almost had an infinite loop in nick_get()! "
+                                          "This used to be a fatal BitlBee bug, but we tried to fix it. "
+                                          "This message should *never* appear anymore. "
+                                          "If it does, please *do* send us a bug report! "
+                                          "Please send all the following lines in your report:" );
+                        irc_usermsg( irc, "Trying to get a sane nick for handle %s", handle );
                         for( i = 0; i < MAX_NICK_LENGTH; i ++ )
                                 irc_usermsg( acc->irc, "Char %d: %c/%d", i, nick[i], nick[i] );
                         irc_usermsg( acc->irc, "FAILED. Returning an insane nick now. Things might break. "
                                                "Good luck, and please don't forget to paste the lines up here "
                                                "in #bitlbee on OFTC or in a mail to wilmer@gaast.net" );
+                                irc_usermsg( irc, "Char %d: %c/%d", i, nick[i], nick[i] );
+                        irc_usermsg( irc, "FAILED. Returning an insane nick now. Things might break. "
+                                          "Good luck, and please don't forget to paste the lines up here "
+                                          "in #bitlbee on OFTC or in a mail to wilmer@gaast.net" );
                         g_snprintf( nick, MAX_NICK_LENGTH + 1, "xx%x", rand() );

protocols/Makefile

-                      r560d0a0
+                      rf1cea66
 # [SH] Program variables
+objects = nogaim.o
+objects = account.o bee.o bee_chat.o bee_ft.o bee_user.o nogaim.o
 # [SH] The next two lines should contain the directory name (in $(subdirs))

protocols/ft.h

-                      r560d0a0
+                      rf1cea66
          */
         gpointer data;
+        struct im_connection *ic;
         /*
 …
  * the canceled() and free() callbacks given in file will be called by this function.
  */
 void imcb_file_canceled( file_transfer_t *file, char *reason );
+void imcb_file_canceled( struct im_connection *ic, file_transfer_t *file, char *reason );
 gboolean imcb_file_recv_start( file_transfer_t *ft );
+gboolean imcb_file_recv_start( struct im_connection *ic, file_transfer_t *ft );
 void imcb_file_finished( file_transfer_t *file );
+void imcb_file_finished( struct im_connection *ic, file_transfer_t *file );
 #endif

protocols/jabber/conference.c

-                      r560d0a0
+                      rf1cea66
+{
         char *normalized = jabber_normalize( name );
+        GSList *l;
         struct groupchat *ret;
         struct jabber_chat *jc;
+        for( ret = ic->groupchats; ret; ret = ret->next )
+        {
+        for( l = ic->groupchats; l; l = l->next )
+        {
+                ret = l->data;
                 jc = ret->data;
                 if( strcmp( normalized, jc->name ) == 0 )
 …
         g_free( normalized );
         return ret;
+        return l ? ret : NULL;
+}

protocols/jabber/iq.c

-                      r560d0a0
+                      rf1cea66
         while( ( c = xt_find_node( c, "item" ) ) )
+        {
                 struct xt_node *group = xt_find_node( node->children, "group" );
+                struct xt_node *group = xt_find_node( c->children, "group" );
                 char *jid = xt_find_attr( c, "jid" );
                 char *name = xt_find_attr( c, "name" );
 …
                         if( ( strcmp( sub, "both" ) == 0 || strcmp( sub, "to" ) == 0 ) )
+                        {
+                                if( initial || imcb_find_buddy( ic, jid ) == NULL )
+                                        imcb_add_buddy( ic, jid, ( group && group->text_len ) ?
+                                                                   group->text : NULL );
+                                imcb_add_buddy( ic, jid, ( group && group->text_len ) ?
+                                                           group->text : NULL );
                                 if( name )
 …
             strcmp( s, "result" ) == 0 )
+        {
                 if( imcb_find_buddy( ic, jid ) == NULL )
+                if( bee_user_by_handle( ic->bee, ic, jid ) == NULL )
                         imcb_add_buddy( ic, jid, NULL );
+        }

protocols/jabber/jabber.c

-                      r560d0a0
+                      rf1cea66
         while( jd->filetransfers )
                 imcb_file_canceled( ( ( struct jabber_transfer *) jd->filetransfers->data )->ft, "Logging out" );
+                imcb_file_canceled( ic, ( ( struct jabber_transfer *) jd->filetransfers->data )->ft, "Logging out" );
         while( jd->streamhosts )
 …
         while( ic->groupchats )
                 jabber_chat_free( ic->groupchats );
+                jabber_chat_free( ic->groupchats->data );
         if( jd->r_inpa >= 0 )

protocols/jabber/jabber_util.c

-                      r560d0a0
+                      rf1cea66
         presence_send_request( bla->ic, bla->handle, "subscribed" );
+        if( imcb_find_buddy( bla->ic, bla->handle ) == NULL )
+                imcb_ask_add( bla->ic, bla->handle, NULL );
+        imcb_ask_add( bla->ic, bla->handle, NULL );
         g_free( bla->handle );
 …
                 if( bud == NULL && ( flags & GET_BUDDY_CREAT ) &&
                     ( bare_exists || imcb_find_buddy( ic, jid ) ) )
+                    ( bare_exists || bee_user_by_handle( ic->bee, ic, jid ) ) )
+                {
                         *s = '/';
 …
                 if( bud == NULL )
                         /* No match. Create it now? */
+                        return ( ( flags & GET_BUDDY_CREAT ) && imcb_find_buddy( ic, jid_ ) ) ?
+                        return ( ( flags & GET_BUDDY_CREAT ) &&
+                                 bee_user_by_handle( ic->bee, ic, jid_ ) ) ?
                                    jabber_buddy_add( ic, jid_ ) : NULL;
                 else if( bud->resource && ( flags & GET_BUDDY_EXACT ) )

protocols/jabber/presence.c

-                      r560d0a0
+                      rf1cea66
         struct jabber_data *jd = ic->proto_data;
         struct xt_node *node, *cap;
         struct groupchat *c;
+        GSList *l;
         int st;
 …
         /* Have to send this update to all groupchats too, the server won't
            do this automatically. */
+        for( c = ic->groupchats; c && st; c = c->next )
+        {
+        for( l = ic->groupchats; l && st; l = l->next )
+        {
+                struct groupchat *c = l->data;
                 struct jabber_chat *jc = c->data;

protocols/jabber/s5bytestream.c

-                      r560d0a0
+                      rf1cea66
         xt_free_node( reply );
         imcb_file_canceled( tf->ft, "couldn't connect to any streamhosts" );
+        imcb_file_canceled( tf->ic, tf->ft, "couldn't connect to any streamhosts" );
         bt->tf->watch_in = 0;
 …
         if( !jabber_write_packet( tf->ic, reply ) )
                 imcb_file_canceled( tf->ft, "Error transmitting bytestream response" );
+                imcb_file_canceled( tf->ic, tf->ft, "Error transmitting bytestream response" );
         xt_free_node( reply );
+}
 …
         if( tf->bytesread >= tf->ft->file_size )
                 imcb_file_finished( tf->ft );
+                imcb_file_finished( tf->ic, tf->ft );
         tf->ft->write( tf->ft, tf->ft->buffer, ret );
 …
         if( tf->watch_in )
+        {
                 imcb_file_canceled( ft, "BUG in jabber file transfer: write_request called when already watching for input" );
+                imcb_file_canceled( tf->ic, ft, "BUG in jabber file transfer: write_request called when already watching for input" );
                 return FALSE;
+        }
 …
         if( tf->byteswritten >= ft->file_size )
                 imcb_file_finished( ft );
+                imcb_file_finished( tf->ic, ft );
         else
                 bt->tf->watch_out = b_input_add( tf->fd, B_EV_IO_WRITE, jabber_bs_send_can_write, bt );
 …
         if( !jabber_write_packet( tf->ic, iq ) )
                 imcb_file_canceled( tf->ft, "Error transmitting bytestream request" );
+                imcb_file_canceled( tf->ic, tf->ft, "Error transmitting bytestream request" );
         return TRUE;
+}
 …
         if( jd->streamhosts==NULL ) /* we're done here unless we have a proxy to try */
                 imcb_file_canceled( tf->ft, error );
+                imcb_file_canceled( tf->ic, tf->ft, error );
         /* MUST always return FALSE! */

protocols/jabber/si.c

-                      r560d0a0
+                      rf1cea66
         if( !foundft )
                 imcb_file_canceled( tf->ft, "Buddy's client doesn't feature file transfers" );
+                imcb_file_canceled( tf->ic, tf->ft, "Buddy's client doesn't feature file transfers" );
         else if( !foundbt )
                 imcb_file_canceled( tf->ft, "Buddy's client doesn't feature byte streams (required)" );
+                imcb_file_canceled( tf->ic, tf->ft, "Buddy's client doesn't feature byte streams (required)" );
         else if( !foundsi )
                 imcb_file_canceled( tf->ft, "Buddy's client doesn't feature stream initiation (required)" );
+                imcb_file_canceled( tf->ic, tf->ft, "Buddy's client doesn't feature stream initiation (required)" );
         return foundft && foundbt && foundsi;
 …
         /* and start the receive logic */
         imcb_file_recv_start( tf->ft );
+        imcb_file_recv_start( tf->ic, tf->ft );
+}
 …
         if( bud == NULL )
+        {
                 imcb_file_canceled( ft, "Couldn't find buddy (BUG?)" );
+                imcb_file_canceled( ic, ft, "Couldn't find buddy (BUG?)" );
                 return;
+        }

protocols/msn/Makefile

r560d0a0	rf1cea66
13	13
14	14	# [SH] Program variables
15		objects = ~~invitation.o~~ msn.o msn_util.o ns.o passport.o sb.o tables.o
	15	objects = msn.o msn_util.o ns.o passport.o sb.o tables.o
16	16
17	17	CFLAGS += -Wall

protocols/msn/msn.c

-                      r560d0a0
+                      rf1cea66
         if( md )
+        {
+                /** Disabling MSN ft support for now.
                 while( md->filetransfers ) {
                         imcb_file_canceled( md->filetransfers->data, "Closing connection" );
+                }
+                */
                 if( md->fd >= 0 )
 …
+{
         struct msn_switchboard *sb;
+        struct groupchat *c = imcb_chat_new( ic, who );
         if( ( sb = msn_sb_by_handle( ic, who ) ) )
 …
                 msn_sb_write_msg( ic, m );
+                return NULL;
+        }
+        return NULL;
+                return c;
+        }
+}
 …
         ret->send_typing = msn_send_typing;
         ret->handle_cmp = g_strcasecmp;
         ret->transfer_request = msn_ftp_transfer_request;
+        //ret->transfer_request = msn_ftp_transfer_request;
         register_protocol(ret);

protocols/msn/msn_util.c

-                      r560d0a0
+                      rf1cea66
         msn_buddy_list_add( bla->ic, "AL", bla->handle, bla->realname );
+        if( imcb_find_buddy( bla->ic, bla->handle ) == NULL )
+                imcb_ask_add( bla->ic, bla->handle, NULL );
+        imcb_ask_add( bla->ic, bla->handle, NULL );
         g_free( bla->handle );

protocols/msn/sb.c

-                      r560d0a0
+                      rf1cea66
                         i = g_snprintf( buf, i, MSN_TYPING_HEADERS, sb->ic->acc->user );
+                }
+                else if( strcmp( text, SB_KEEPALIVE_MESSAGE ) == 0 )
+                {
+                        buf = g_strdup( SB_KEEPALIVE_HEADERS );
+                        i = strlen( buf );
+                }
                 else if( strncmp( text, MSN_INVITE_HEADERS, sizeof( MSN_INVITE_HEADERS ) - 1 ) == 0 )
+                {
                         buf = g_strdup( text );
-                        i = strlen( buf );
+                }
-                else if( strcmp( text, SB_KEEPALIVE_MESSAGE ) == 0 )
+                {
-                        buf = g_strdup( SB_KEEPALIVE_HEADERS );
                         i = strlen( buf );
+                }
 …
+{
         struct im_connection *ic = sb->ic;
+        struct groupchat *c = NULL;
         char buf[1024];
         /* Create the groupchat structure. */
         g_snprintf( buf, sizeof( buf ), "MSN groupchat session %d", sb->session );
+        sb->chat = imcb_chat_new( ic, buf );
+        if( sb->who )
+                c = bee_chat_by_title( ic->bee, ic, sb->who );
+        if( c && !msn_sb_by_chat( c ) )
+                sb->chat = c;
+        else
+                sb->chat = imcb_chat_new( ic, buf );
         /* Populate the channel. */
 …
+                        }
+                }
+#if 0
+                // Disable MSN ft support for now.
                 else if( g_strncasecmp( ct, "text/x-msmsgsinvite", 19 ) == 0 )
+                {
 …
                         g_free( command );
+                }
+#endif
                 else if( g_strncasecmp( ct, "application/x-msnmsgrp2p", 24 ) == 0 )
+                {
 …
 void msn_sb_start_keepalives( struct msn_switchboard *sb, gboolean initial )
+{
         struct buddy *b;
+        bee_user_t *bu;
         if( sb && sb->who && sb->keepalive == 0 &&
+            ( b = imcb_find_buddy( sb->ic, sb->who ) ) && !b->present &&
+            ( bu = bee_user_by_handle( sb->ic->bee, sb->ic, sb->who ) ) &&
+            !( bu->flags & BEE_USER_ONLINE ) &&
             set_getbool( &sb->ic->acc->set, "switchboard_keepalives" ) )
+        {

protocols/nogaim.c

-                      r560d0a0
+                      rf1cea66
 #include "chat.h"
-static int remove_chat_buddy_silent( struct groupchat *b, const char *handle );
-static char *format_timestamp( irc_t *irc, time_t msg_ts );
 GSList *connections;
 …
+}
 #endif
-/* nogaim.c */
 GList *protocols = NULL;
 …
+}
-/* nogaim.c */
 void nogaim_init()
+{
 …
         twitter_initmodule();
 #endif
 #ifdef WITH_PURPLE
         purple_initmodule();
 …
 GSList *get_connections() { return connections; }
-/* multi.c */
 struct im_connection *imcb_new( account_t *acc )
+{
 …
         ic = g_new0( struct im_connection, 1 );
         ic->irc = acc->irc;
+        ic->bee = acc->bee;
         ic->acc = acc;
         acc->ic = ic;
 …
         /* Destroy the pointer to this connection from the account list */
         for( a = ic->irc->accounts; a; a = a->next )
+        for( a = ic->bee->accounts; a; a = a->next )
                 if( a->ic == ic )
+                {
 …
         va_end( params );
         if( ( g_strcasecmp( set_getstr( &ic->irc->set, "strip_html" ), "always" ) == 0 ) ||
             ( ( ic->flags & OPT_DOES_HTML ) && set_getbool( &ic->irc->set, "strip_html" ) ) )
+        if( ( g_strcasecmp( set_getstr( &ic->bee->set, "strip_html" ), "always" ) == 0 ) ||
+            ( ( ic->flags & OPT_DOES_HTML ) && set_getbool( &ic->bee->set, "strip_html" ) ) )
                 strip_html( text );
         /* Try to find a different connection on the same protocol. */
         for( a = ic->irc->accounts; a; a = a->next )
+        for( a = ic->bee->accounts; a; a = a->next )
                 if( a->prpl == ic->acc->prpl && a->ic != ic )
                         break;
 …
         /* If we found one, include the screenname in the message. */
         if( a )
+                irc_usermsg( ic->irc, "%s(%s) - %s", ic->acc->prpl->name, ic->acc->user, text );
+                /* FIXME(wilmer): ui_log callback or so */
+                irc_usermsg( ic->bee->ui_data, "%s(%s) - %s", ic->acc->prpl->name, ic->acc->user, text );
         else
                 irc_usermsg( ic->irc, "%s - %s", ic->acc->prpl->name, text );
+                irc_usermsg( ic->bee->ui_data, "%s - %s", ic->acc->prpl->name, text );
         g_free( text );
 …
 void imcb_connected( struct im_connection *ic )
+{
-        irc_t *irc = ic->irc;
-        struct chat *c;
-        user_t *u;
         /* MSN servers sometimes redirect you to a different server and do
            the whole login sequence again, so these "late" calls to this
 …
                 return;
-        u = user_find( ic->irc, ic->irc->nick );
         imcb_log( ic, "Logged in" );
 …
         ic->acc->auto_reconnect_delay = 0;
+        /*
         for( c = irc->chatrooms; c; c = c->next )
+        {
 …
                         chat_join( irc, c, NULL );
+        }
+        */
+}
 …
         a->reconnect = 0;
         account_on( a->irc, a );
+        account_on( a->bee, a );
         return( FALSE );        /* Only have to run the timeout once */
 …
 void imc_logout( struct im_connection *ic, int allow_reconnect )
+{
+        irc_t *irc = ic->irc;
+        user_t *t, *u;
+        bee_t *bee = ic->bee;
         account_t *a;
+        GSList *l;
         int delay;
 …
         ic->away = NULL;
+        u = irc->users;
+        while( u )
+        {
+                if( u->ic == ic )
+                {
+                        t = u->next;
+                        user_del( irc, u->nick );
+                        u = t;
+                }
+                else
+                        u = u->next;
+        }
+        query_del_by_conn( ic->irc, ic );
+        for( a = irc->accounts; a; a = a->next )
+        for( l = bee->users; l; )
+        {
+                bee_user_t *bu = l->data;
+                GSList *next = l->next;
+                if( bu->ic == ic )
+                        bee_user_free( bee, bu );
+                l = next;
+        }
+        query_del_by_conn( (irc_t*) ic->bee->ui_data, ic );
+        for( a = bee->accounts; a; a = a->next )
                 if( a->ic == ic )
                         break;
 …
                 /* Uhm... This is very sick. */
+        }
         else if( allow_reconnect && set_getbool( &irc->set, "auto_reconnect" ) &&
+        else if( allow_reconnect && set_getbool( &bee->set, "auto_reconnect" ) &&
                  set_getbool( &a->set, "auto_reconnect" ) &&
                  ( delay = account_reconnect_delay( a ) ) > 0 )
 …
+}
-/* dialogs.c */
 void imcb_ask( struct im_connection *ic, char *msg, void *data,
                query_callback doit, query_callback dont )
+{
+        query_add( ic->irc, ic, msg, doit, dont, data );
+}
+/* list.c */
+        query_add( (irc_t *) ic->bee->ui_data, ic, msg, doit, dont, data );
+}
 void imcb_add_buddy( struct im_connection *ic, const char *handle, const char *group )
+{
+        user_t *u;
+        char nick[MAX_NICK_LENGTH+1], *s;
+        irc_t *irc = ic->irc;
+        if( user_findhandle( ic, handle ) )
+        {
+                if( set_getbool( &irc->set, "debug" ) )
+                        imcb_log( ic, "User already exists, ignoring add request: %s", handle );
+        bee_user_t *bu;
+        bee_t *bee = ic->bee;
+        if( !( bu = bee_user_by_handle( bee, ic, handle ) ) )
+                bu = bee_user_new( bee, ic, handle, 0 );
+        bu->group = bee_group_by_name( bee, group, TRUE );
+        if( bee->ui->user_group )
+                bee->ui->user_group( bee, bu );
+}
+void imcb_rename_buddy( struct im_connection *ic, const char *handle, const char *fullname )
+{
+        bee_t *bee = ic->bee;
+        bee_user_t *bu = bee_user_by_handle( bee, ic, handle );
+        if( !bu || !fullname ) return;
+        if( !bu->fullname || strcmp( bu->fullname, fullname ) != 0 )
+        {
+                g_free( bu->fullname );
+                bu->fullname = g_strdup( fullname );
+                return;
+                /* Buddy seems to exist already. Let's ignore this request then...
+                   Eventually subsequent calls to this function *should* be possible
+                   when a buddy is in multiple groups. But for now BitlBee doesn't
+                   even support groups so let's silently ignore this for now. */
+        }
+        memset( nick, 0, MAX_NICK_LENGTH + 1 );
+        strcpy( nick, nick_get( ic->acc, handle ) );
+        u = user_add( ic->irc, nick );
+//      if( !realname || !*realname ) realname = nick;
+//      u->realname = g_strdup( realname );
+        if( ( s = strchr( handle, '@' ) ) )
+        {
+                u->host = g_strdup( s + 1 );
+                u->user = g_strndup( handle, s - handle );
+        }
+        else if( ic->acc->server )
+        {
+                u->host = g_strdup( ic->acc->server );
+                u->user = g_strdup( handle );
+                /* s/ /_/ ... important for AOL screennames */
+                for( s = u->user; *s; s ++ )
+                        if( *s == ' ' )
+                                *s = '_';
+        }
+        else
+        {
+                u->host = g_strdup( ic->acc->prpl->name );
+                u->user = g_strdup( handle );
+        }
+        u->ic = ic;
+        u->handle = g_strdup( handle );
+        if( group ) u->group = g_strdup( group );
+        u->send_handler = buddy_send_handler;
+        u->last_typing_notice = 0;
+}
+struct buddy *imcb_find_buddy( struct im_connection *ic, char *handle )
+{
+        static struct buddy b[1];
+        user_t *u;
+        u = user_findhandle( ic, handle );
+        if( !u )
+                return( NULL );
+        memset( b, 0, sizeof( b ) );
+        strncpy( b->name, handle, 80 );
+        strncpy( b->show, u->realname, BUDDY_ALIAS_MAXLEN );
+        b->present = u->online;
+        b->ic = u->ic;
+        return( b );
+}
+void imcb_rename_buddy( struct im_connection *ic, const char *handle, const char *realname )
+{
+        user_t *u = user_findhandle( ic, handle );
+        char *set;
+        if( !u || !realname ) return;
+        if( g_strcasecmp( u->realname, realname ) != 0 )
+        {
+                if( u->realname != u->nick ) g_free( u->realname );
+                u->realname = g_strdup( realname );
+                if( ( ic->flags & OPT_LOGGED_IN ) && set_getbool( &ic->irc->set, "display_namechanges" ) )
+                        imcb_log( ic, "User `%s' changed name to `%s'", u->nick, u->realname );
+        }
+        set = set_getstr( &ic->acc->set, "nick_source" );
+        if( strcmp( set, "handle" ) != 0 )
+        {
+                char *name = g_strdup( realname );
+                if( strcmp( set, "first_name" ) == 0 )
+                {
+                        int i;
+                        for( i = 0; name[i] && !isspace( name[i] ); i ++ ) {}
+                        name[i] = '\0';
+                }
+                imcb_buddy_nick_hint( ic, handle, name );
+                g_free( name );
+                if( bee->ui->user_fullname )
+                        bee->ui->user_fullname( bee, bu );
+        }
+}
 …
 void imcb_remove_buddy( struct im_connection *ic, const char *handle, char *group )
+{
+        user_t *u;
+        if( ( u = user_findhandle( ic, handle ) ) )
+                user_del( ic->irc, u->nick );
+        bee_user_free( ic->bee, bee_user_by_handle( ic->bee, ic, handle ) );
+}
 …
 void imcb_buddy_nick_hint( struct im_connection *ic, const char *handle, const char *nick )
+{
+        user_t *u = user_findhandle( ic, handle );
+        char newnick[MAX_NICK_LENGTH+1], *orig_nick;
+        if( u && !u->online && !nick_saved( ic->acc, handle ) )
+        {
+                /* Only do this if the person isn't online yet (which should
+                   be the case if we just added it) and if the user hasn't
+                   assigned a nickname to this buddy already. */
+                strncpy( newnick, nick, MAX_NICK_LENGTH );
+                newnick[MAX_NICK_LENGTH] = 0;
+                /* Some processing to make sure this string is a valid IRC nickname. */
+                nick_strip( newnick );
+                if( set_getbool( &ic->irc->set, "lcnicks" ) )
+                        nick_lc( newnick );
+                if( strcmp( u->nick, newnick ) != 0 )
+                {
+                        /* Only do this if newnick is different from the current one.
+                           If rejoining a channel, maybe we got this nick already
+                           (and dedupe would only add an underscore. */
+                        nick_dedupe( ic->acc, handle, newnick );
+                        /* u->nick will be freed halfway the process, so it can't be
+                           passed as an argument. */
+                        orig_nick = g_strdup( u->nick );
+                        user_rename( ic->irc, orig_nick, newnick );
+                        g_free( orig_nick );
+                }
+        }
+        bee_t *bee = ic->bee;
+        bee_user_t *bu = bee_user_by_handle( bee, ic, handle );
+        if( !bu || !nick ) return;
+        if( bee->ui->user_nick_hint )
+                bee->ui->user_nick_hint( bee, bu, nick );
+}
 …
         data->ic = ic;
         data->handle = g_strdup( handle );
+        query_add( ic->irc, ic, s, imcb_ask_auth_cb_yes, imcb_ask_auth_cb_no, data );
+        query_add( (irc_t *) ic->bee->ui_data, ic, s,
+                   imcb_ask_auth_cb_yes, imcb_ask_auth_cb_no, data );
+}
 …
         /* TODO: Make a setting for this! */
         if( user_findhandle( ic, handle ) != NULL )
+        if( bee_user_by_handle( ic->bee, ic, handle ) != NULL )
                 return;
 …
         data->ic = ic;
         data->handle = g_strdup( handle );
+        query_add( ic->irc, ic, s, imcb_ask_add_cb_yes, imcb_ask_add_cb_no, data );
+}
+/* server.c */
+void imcb_buddy_status( struct im_connection *ic, const char *handle, int flags, const char *state, const char *message )
+{
+        user_t *u;
+        int oa, oo;
+        u = user_findhandle( ic, (char*) handle );
+        if( !u )
+        {
+                if( g_strcasecmp( set_getstr( &ic->irc->set, "handle_unknown" ), "add" ) == 0 )
+                {
+                        imcb_add_buddy( ic, (char*) handle, NULL );
+                        u = user_findhandle( ic, (char*) handle );
+                }
+                else
+                {
+                        if( set_getbool( &ic->irc->set, "debug" ) || g_strcasecmp( set_getstr( &ic->irc->set, "handle_unknown" ), "ignore" ) != 0 )
+                        {
+                                imcb_log( ic, "imcb_buddy_status() for unknown handle %s:", handle );
+                                imcb_log( ic, "flags = %d, state = %s, message = %s", flags,
+                                          state ? state : "NULL", message ? message : "NULL" );
+                        }
+                        return;
+                }
+        }
+        oa = u->away != NULL;
+        oo = u->online;
+        g_free( u->away );
+        g_free( u->status_msg );
+        u->away = u->status_msg = NULL;
+        if( set_getbool( &ic->irc->set, "show_offline" ) && !u->online )
+        {
+                /* always set users as online */
+                irc_spawn( ic->irc, u );
+                u->online = 1;
+                if( !( flags & OPT_LOGGED_IN ) )
+                {
+                        /* set away message if user isn't really online */
+                        u->away = g_strdup( "User is offline" );
+                }
+        }
+        else if( ( flags & OPT_LOGGED_IN ) && !u->online )
+        {
+                irc_spawn( ic->irc, u );
+                u->online = 1;
+        }
+        else if( !( flags & OPT_LOGGED_IN ) && u->online )
+        {
+                struct groupchat *c;
+                if( set_getbool( &ic->irc->set, "show_offline" ) )
+                {
+                        /* keep offline users in channel and set away message to "offline" */
+                        u->away = g_strdup( "User is offline" );
+                        /* Keep showing him/her in the control channel but not in groupchats. */
+                        for( c = ic->groupchats; c; c = c->next )
+                        {
+                                if( remove_chat_buddy_silent( c, handle ) && c->joined )
+                                        irc_part( c->ic->irc, u, c->channel );
+                        }
+                }
+                else
+                {
+                        /* kill offline users */
+                        irc_kill( ic->irc, u );
+                        u->online = 0;
+                        /* Remove him/her from the groupchats to prevent PART messages after he/she QUIT already */
+                        for( c = ic->groupchats; c; c = c->next )
+                                remove_chat_buddy_silent( c, handle );
+                }
+        }
+        if( flags & OPT_AWAY )
+        {
+                if( state && message )
+                {
+                        u->away = g_strdup_printf( "%s (%s)", state, message );
+                }
+                else if( state )
+                {
+                        u->away = g_strdup( state );
+                }
+                else if( message )
+                {
+                        u->away = g_strdup( message );
+                }
+                else
+                {
+                        u->away = g_strdup( "Away" );
+                }
+        }
+        else
+        {
+                u->status_msg = g_strdup( message );
+        }
+        /* early if-clause for show_offline even if there is some redundant code here because this isn't LISP but C ;) */
+        if( set_getbool( &ic->irc->set, "show_offline" ) && set_getbool( &ic->irc->set, "away_devoice" ) )
+        {
+                char *from;
+                if( set_getbool( &ic->irc->set, "simulate_netsplit" ) )
+                {
+                        from = g_strdup( ic->irc->myhost );
+                }
+                else
+                {
+                        from = g_strdup_printf( "%s!%s@%s", ic->irc->mynick, ic->irc->mynick,
+                                                            ic->irc->myhost );
+                }
+                /* if we use show_offline, we op online users, voice away users, and devoice/deop offline users */
+                if( flags & OPT_LOGGED_IN )
+                {
+                        /* user is "online" (either really online or away) */
+                        irc_write( ic->irc, ":%s MODE %s %cv%co %s %s", from, ic->irc->channel,
+                                                                  u->away?'+':'-', u->away?'-':'+', u->nick, u->nick );
+                }
+                else
+                {
+                        /* user is offline */
+                        irc_write( ic->irc, ":%s MODE %s -vo %s %s", from, ic->irc->channel, u->nick, u->nick );
+                }
+        }
+        else
+        {
+                /* LISPy... */
+                if( ( set_getbool( &ic->irc->set, "away_devoice" ) ) &&         /* Don't do a thing when user doesn't want it */
+                    ( u->online ) &&                                            /* Don't touch offline people */
+                    ( ( ( u->online != oo ) && !u->away ) ||                    /* Voice joining people */
+                      ( ( u->online == oo ) && ( oa == !u->away ) ) ) )         /* (De)voice people changing state */
+                {
+                        char *from;
+                        if( set_getbool( &ic->irc->set, "simulate_netsplit" ) )
+                        {
+                                from = g_strdup( ic->irc->myhost );
+                        }
+                        else
+                        {
+                                from = g_strdup_printf( "%s!%s@%s", ic->irc->mynick, ic->irc->mynick,
+                                                                    ic->irc->myhost );
+                        }
+                        irc_write( ic->irc, ":%s MODE %s %cv %s", from, ic->irc->channel,
+                                                                  u->away?'-':'+', u->nick );
+                        g_free( from );
+                }
+        }
+}
+void imcb_buddy_msg( struct im_connection *ic, const char *handle, char *msg, uint32_t flags, time_t sent_at )
+{
+        irc_t *irc = ic->irc;
+        char *wrapped, *ts = NULL;
+        user_t *u;
+        u = user_findhandle( ic, handle );
+        if( !u )
+        {
+                char *h = set_getstr( &irc->set, "handle_unknown" );
+                if( g_strcasecmp( h, "ignore" ) == 0 )
+                {
+                        if( set_getbool( &irc->set, "debug" ) )
+                                imcb_log( ic, "Ignoring message from unknown handle %s", handle );
+                        return;
+                }
+                else if( g_strncasecmp( h, "add", 3 ) == 0 )
+                {
+                        int private = set_getbool( &irc->set, "private" );
+                        if( h[3] )
+                        {
+                                if( g_strcasecmp( h + 3, "_private" ) == 0 )
+                                        private = 1;
+                                else if( g_strcasecmp( h + 3, "_channel" ) == 0 )
+                                        private = 0;
+                        }
+                        imcb_add_buddy( ic, handle, NULL );
+                        u = user_findhandle( ic, handle );
+                        u->is_private = private;
+                }
+                else
+                {
+                        imcb_log( ic, "Message from unknown handle %s:", handle );
+                        u = user_find( irc, irc->mynick );
+                }
+        }
+        if( ( g_strcasecmp( set_getstr( &ic->irc->set, "strip_html" ), "always" ) == 0 ) ||
+            ( ( ic->flags & OPT_DOES_HTML ) && set_getbool( &ic->irc->set, "strip_html" ) ) )
+                strip_html( msg );
+        if( set_getbool( &ic->irc->set, "display_timestamps" ) &&
+            ( ts = format_timestamp( irc, sent_at ) ) )
+        {
+                char *new = g_strconcat( ts, msg, NULL );
+                g_free( ts );
+                ts = msg = new;
+        }
+        wrapped = word_wrap( msg, 425 );
+        irc_msgfrom( irc, u->nick, wrapped );
+        g_free( wrapped );
+        g_free( ts );
+}
+void imcb_buddy_typing( struct im_connection *ic, char *handle, uint32_t flags )
+{
+        user_t *u;
+        if( !set_getbool( &ic->irc->set, "typing_notice" ) )
+                return;
+        if( ( u = user_findhandle( ic, handle ) ) )
+        {
+                char buf[256];
+                g_snprintf( buf, 256, "\1TYPING %d\1", ( flags >> 8 ) & 3 );
+                irc_privmsg( ic->irc, u, "PRIVMSG", ic->irc->nick, NULL, buf );
+        }
+}
+struct groupchat *imcb_chat_new( struct im_connection *ic, const char *handle )
+{
+        struct groupchat *c;
+        /* This one just creates the conversation structure, user won't see anything yet */
+        if( ic->groupchats )
+        {
+                for( c = ic->groupchats; c->next; c = c->next );
+                c = c->next = g_new0( struct groupchat, 1 );
+        }
+        else
+                ic->groupchats = c = g_new0( struct groupchat, 1 );
+        c->ic = ic;
+        c->title = g_strdup( handle );
+        c->channel = g_strdup_printf( "&chat_%03d", ic->irc->c_id++ );
+        c->topic = g_strdup_printf( "BitlBee groupchat: \"%s\". Please keep in mind that root-commands won't work here. Have fun!", c->title );
+        if( set_getbool( &ic->irc->set, "debug" ) )
+                imcb_log( ic, "Creating new conversation: (id=%p,handle=%s)", c, handle );
+        return c;
+}
+void imcb_chat_name_hint( struct groupchat *c, const char *name )
+{
+        if( !c->joined )
+        {
+                struct im_connection *ic = c->ic;
+                char stripped[MAX_NICK_LENGTH+1], *full_name;
+                strncpy( stripped, name, MAX_NICK_LENGTH );
+                stripped[MAX_NICK_LENGTH] = '\0';
+                nick_strip( stripped );
+                if( set_getbool( &ic->irc->set, "lcnicks" ) )
+                        nick_lc( stripped );
+                full_name = g_strdup_printf( "&%s", stripped );
+                if( stripped[0] &&
+                    nick_cmp( stripped, ic->irc->channel + 1 ) != 0 &&
+                    irc_chat_by_channel( ic->irc, full_name ) == NULL )
+                {
+                        g_free( c->channel );
+                        c->channel = full_name;
+                }
+                else
+                {
+                        g_free( full_name );
+                }
+        }
+}
+void imcb_chat_free( struct groupchat *c )
+{
+        struct im_connection *ic = c->ic;
+        struct groupchat *l;
+        GList *ir;
+        if( set_getbool( &ic->irc->set, "debug" ) )
+                imcb_log( ic, "You were removed from conversation %p", c );
+        if( c )
+        {
+                if( c->joined )
+                {
+                        user_t *u, *r;
+                        r = user_find( ic->irc, ic->irc->mynick );
+                        irc_privmsg( ic->irc, r, "PRIVMSG", c->channel, "", "Cleaning up channel, bye!" );
+                        u = user_find( ic->irc, ic->irc->nick );
+                        irc_kick( ic->irc, u, c->channel, r );
+                        /* irc_part( ic->irc, u, c->channel ); */
+                }
+                /* Find the previous chat in the linked list. */
+                for( l = ic->groupchats; l && l->next != c; l = l->next );
+                if( l )
+                        l->next = c->next;
+                else
+                        ic->groupchats = c->next;
+                for( ir = c->in_room; ir; ir = ir->next )
+                        g_free( ir->data );
+                g_list_free( c->in_room );
+                g_free( c->channel );
+                g_free( c->title );
+                g_free( c->topic );
+                g_free( c );
+        }
+}
+void imcb_chat_msg( struct groupchat *c, const char *who, char *msg, uint32_t flags, time_t sent_at )
+{
+        struct im_connection *ic = c->ic;
+        char *wrapped;
+        user_t *u;
+        /* Gaim sends own messages through this too. IRC doesn't want this, so kill them */
+        if( g_strcasecmp( who, ic->acc->user ) == 0 )
+                return;
+        u = user_findhandle( ic, who );
+        if( ( g_strcasecmp( set_getstr( &ic->irc->set, "strip_html" ), "always" ) == 0 ) ||
+            ( ( ic->flags & OPT_DOES_HTML ) && set_getbool( &ic->irc->set, "strip_html" ) ) )
+                strip_html( msg );
+        wrapped = word_wrap( msg, 425 );
+        if( c && u )
+        {
+                char *ts = NULL;
+                if( set_getbool( &ic->irc->set, "display_timestamps" ) )
+                        ts = format_timestamp( ic->irc, sent_at );
+                irc_privmsg( ic->irc, u, "PRIVMSG", c->channel, ts ? : "", wrapped );
+                g_free( ts );
+        }
+        else
+        {
+                imcb_log( ic, "Message from/to conversation %s@%p (unknown conv/user): %s", who, c, wrapped );
+        }
+        g_free( wrapped );
+}
+void imcb_chat_log( struct groupchat *c, char *format, ... )
+{
+        irc_t *irc = c->ic->irc;
+        va_list params;
+        char *text;
+        user_t *u;
+        va_start( params, format );
+        text = g_strdup_vprintf( format, params );
+        va_end( params );
+        u = user_find( irc, irc->mynick );
+        irc_privmsg( irc, u, "PRIVMSG", c->channel, "System message: ", text );
+        g_free( text );
+}
+void imcb_chat_topic( struct groupchat *c, char *who, char *topic, time_t set_at )
+{
+        struct im_connection *ic = c->ic;
+        user_t *u = NULL;
+        if( who == NULL)
+                u = user_find( ic->irc, ic->irc->mynick );
+        else if( g_strcasecmp( who, ic->acc->user ) == 0 )
+                u = user_find( ic->irc, ic->irc->nick );
+        else
+                u = user_findhandle( ic, who );
+        if( ( g_strcasecmp( set_getstr( &ic->irc->set, "strip_html" ), "always" ) == 0 ) ||
+            ( ( ic->flags & OPT_DOES_HTML ) && set_getbool( &ic->irc->set, "strip_html" ) ) )
+                strip_html( topic );
+        g_free( c->topic );
+        c->topic = g_strdup( topic );
+        if( c->joined && u )
+                irc_write( ic->irc, ":%s!%s@%s TOPIC %s :%s", u->nick, u->user, u->host, c->channel, topic );
+}
+/* buddy_chat.c */
+void imcb_chat_add_buddy( struct groupchat *b, const char *handle )
+{
+        user_t *u = user_findhandle( b->ic, handle );
+        int me = 0;
+        if( set_getbool( &b->ic->irc->set, "debug" ) )
+                imcb_log( b->ic, "User %s added to conversation %p", handle, b );
+        /* It might be yourself! */
+        if( b->ic->acc->prpl->handle_cmp( handle, b->ic->acc->user ) == 0 )
+        {
+                u = user_find( b->ic->irc, b->ic->irc->nick );
+                if( !b->joined )
+                        irc_join( b->ic->irc, u, b->channel );
+                b->joined = me = 1;
+        }
+        /* Most protocols allow people to join, even when they're not in
+           your contact list. Try to handle that here */
+        if( !u )
+        {
+                imcb_add_buddy( b->ic, handle, NULL );
+                u = user_findhandle( b->ic, handle );
+        }
+        /* Add the handle to the room userlist, if it's not 'me' */
+        if( !me )
+        {
+                if( b->joined )
+                        irc_join( b->ic->irc, u, b->channel );
+                b->in_room = g_list_append( b->in_room, g_strdup( handle ) );
+        }
+}
+/* This function is one BIG hack... :-( EREWRITE */
+void imcb_chat_remove_buddy( struct groupchat *b, const char *handle, const char *reason )
+{
+        user_t *u;
+        int me = 0;
+        if( set_getbool( &b->ic->irc->set, "debug" ) )
+                imcb_log( b->ic, "User %s removed from conversation %p (%s)", handle, b, reason ? reason : "" );
+        /* It might be yourself! */
+        if( g_strcasecmp( handle, b->ic->acc->user ) == 0 )
+        {
+                if( b->joined == 0 )
+                        return;
+                u = user_find( b->ic->irc, b->ic->irc->nick );
+                b->joined = 0;
+                me = 1;
+        }
+        else
+        {
+                u = user_findhandle( b->ic, handle );
+        }
+        if( me || ( remove_chat_buddy_silent( b, handle ) && b->joined && u ) )
+                irc_part( b->ic->irc, u, b->channel );
+}
+static int remove_chat_buddy_silent( struct groupchat *b, const char *handle )
+{
+        GList *i;
+        /* Find the handle in the room userlist and shoot it */
+        i = b->in_room;
+        while( i )
+        {
+                if( g_strcasecmp( handle, i->data ) == 0 )
+                {
+                        g_free( i->data );
+                        b->in_room = g_list_remove( b->in_room, i->data );
+                        return( 1 );
+                }
+                i = i->next;
+        }
+        return( 0 );
+}
+/* Misc. BitlBee stuff which shouldn't really be here */
+char *set_eval_away_devoice( set_t *set, char *value )
+{
+        irc_t *irc = set->data;
+        int st;
+        if( !is_bool( value ) )
+                return SET_INVALID;
+        st = bool2int( value );
+        /* Horror.... */
+        if( st != set_getbool( &irc->set, "away_devoice" ) )
+        {
+                char list[80] = "";
+                user_t *u = irc->users;
+                int i = 0, count = 0;
+                char pm;
+                char v[80];
+                if( st )
+                        pm = '+';
+                else
+                        pm = '-';
+                while( u )
+                {
+                        if( u->ic && u->online && !u->away )
+                        {
+                                if( ( strlen( list ) + strlen( u->nick ) ) >= 79 )
+                                {
+                                        for( i = 0; i < count; v[i++] = 'v' ); v[i] = 0;
+                                        irc_write( irc, ":%s MODE %s %c%s%s",
+                                                   irc->myhost,
+                                                   irc->channel, pm, v, list );
+                                        *list = 0;
+                                        count = 0;
+                                }
+                                sprintf( list + strlen( list ), " %s", u->nick );
+                                count ++;
+                        }
+                        u = u->next;
+                }
+                /* $v = 'v' x $i */
+                for( i = 0; i < count; v[i++] = 'v' ); v[i] = 0;
+                irc_write( irc, ":%s MODE %s %c%s%s", irc->myhost,
+                                                            irc->channel, pm, v, list );
+        }
+        return value;
+}
+char *set_eval_timezone( set_t *set, char *value )
+{
+        char *s;
+        if( strcmp( value, "local" ) == 0 ||
+            strcmp( value, "gmt" ) == 0 || strcmp( value, "utc" ) == 0 )
+                return value;
+        /* Otherwise: +/- at the beginning optional, then one or more numbers,
+           possibly followed by a colon and more numbers. Don't bother bound-
+           checking them since users are free to shoot themselves in the foot. */
+        s = value;
+        if( *s == '+' || *s == '-' )
+                s ++;
+        /* \d+ */
+        if( !isdigit( *s ) )
+                return SET_INVALID;
+        while( *s && isdigit( *s ) ) s ++;
+        /* EOS? */
+        if( *s == '\0' )
+                return value;
+        /* Otherwise, colon */
+        if( *s != ':' )
+                return SET_INVALID;
+        s ++;
+        /* \d+ */
+        if( !isdigit( *s ) )
+                return SET_INVALID;
+        while( *s && isdigit( *s ) ) s ++;
+        /* EOS */
+        return *s == '\0' ? value : SET_INVALID;
+}
+static char *format_timestamp( irc_t *irc, time_t msg_ts )
+{
+        time_t now_ts = time( NULL );
+        struct tm now, msg;
+        char *set;
+        /* If the timestamp is <= 0 or less than a minute ago, discard it as
+           it doesn't seem to add to much useful info and/or might be noise. */
+        if( msg_ts <= 0 || msg_ts > now_ts - 60 )
+                return NULL;
+        set = set_getstr( &irc->set, "timezone" );
+        if( strcmp( set, "local" ) == 0 )
+        {
+                localtime_r( &now_ts, &now );
+                localtime_r( &msg_ts, &msg );
+        }
+        else
+        {
+                int hr, min = 0, sign = 60;
+                if( set[0] == '-' )
+                {
+                        sign *= -1;
+                        set ++;
+                }
+                else if( set[0] == '+' )
+                {
+                        set ++;
+                }
+                if( sscanf( set, "%d:%d", &hr, &min ) >= 1 )
+                {
+                        msg_ts += sign * ( hr * 60 + min );
+                        now_ts += sign * ( hr * 60 + min );
+                }
+                gmtime_r( &now_ts, &now );
+                gmtime_r( &msg_ts, &msg );
+        }
+        if( msg.tm_year == now.tm_year && msg.tm_yday == now.tm_yday )
+                return g_strdup_printf( "\x02[\x02\x02\x02%02d:%02d:%02d\x02]\x02 ",
+                                        msg.tm_hour, msg.tm_min, msg.tm_sec );
+        else
+                return g_strdup_printf( "\x02[\x02\x02\x02%04d-%02d-%02d "
+                                        "%02d:%02d:%02d\x02]\x02 ",
+                                        msg.tm_year + 1900, msg.tm_mon + 1, msg.tm_mday,
+                                        msg.tm_hour, msg.tm_min, msg.tm_sec );
+        query_add( (irc_t *) ic->bee->ui_data, ic, s,
+                   imcb_ask_add_cb_yes, imcb_ask_add_cb_no, data );
+}
+struct bee_user *imcb_buddy_by_handle( struct im_connection *ic, const char *handle )
+{
+        return bee_user_by_handle( ic->bee, ic, handle );
+}
 /* The plan is to not allow straight calls to prpl functions anymore, but do
    them all from some wrappers. We'll start to define some down here: */
-int imc_buddy_msg( struct im_connection *ic, char *handle, char *msg, int flags )
+{
-        char *buf = NULL;
-        int st;
-        if( ( ic->flags & OPT_DOES_HTML ) && ( g_strncasecmp( msg, "<html>", 6 ) != 0 ) )
+        {
-                buf = escape_html( msg );
-                msg = buf;
+        }
-        st = ic->acc->prpl->buddy_msg( ic, handle, msg, flags );
-        g_free( buf );
-        return st;
+}
 int imc_chat_msg( struct groupchat *c, char *msg, int flags )
 …
         away = set_getstr( &ic->acc->set, "away" ) ?
              : set_getstr( &ic->irc->set, "away" );
+             : set_getstr( &ic->bee->set, "away" );
         if( away && *away )
+        {
 …
                 away = NULL;
                 msg = set_getstr( &ic->acc->set, "status" ) ?
                     : set_getstr( &ic->irc->set, "status" );
+                    : set_getstr( &ic->bee->set, "status" );
+        }

protocols/nogaim.h

-                      r560d0a0
+                      rf1cea66
   * BitlBee -- An IRC to other IM-networks gateway                     *
   *                                                                    *
   * Copyright 2002-2004 Wilmer van der Gaast and others                *
+  * Copyright 2002-2010 Wilmer van der Gaast and others                *
   \********************************************************************/
 …
         /* BitlBee */
         irc_t *irc;
         struct groupchat *groupchats;
+        bee_t *bee;
+        GSList *groupchats;
 };
 …
          * already, for example to avoid adding somebody two times. */
         GList *in_room;
+        GList *ignored;
+        struct groupchat *next;
+        char *channel;
+        //GList *ignored;
+        //struct groupchat *next;
         /* The title variable contains the ID you gave when you created the
          * chat using imcb_chat_new(). */
 …
          * structure for your protocol's needs. */
         void *data;
+        void *ui_data;
 };
 …
 G_MODULE_EXPORT void imcb_buddy_nick_hint( struct im_connection *ic, const char *handle, const char *nick );
-/* Buddy activity */
-/* To manipulate the status of a handle.
- * - flags can be |='d with OPT_* constants. You will need at least:
- *   OPT_LOGGED_IN and OPT_AWAY.
- * - 'state' and 'message' can be NULL */
-G_MODULE_EXPORT void imcb_buddy_status( struct im_connection *ic, const char *handle, int flags, const char *state, const char *message );
-/* Not implemented yet! */ G_MODULE_EXPORT void imcb_buddy_times( struct im_connection *ic, const char *handle, time_t login, time_t idle );
-/* Call when a handle says something. 'flags' and 'sent_at may be just 0. */
-G_MODULE_EXPORT void imcb_buddy_msg( struct im_connection *ic, const char *handle, char *msg, uint32_t flags, time_t sent_at );
 G_MODULE_EXPORT void imcb_buddy_typing( struct im_connection *ic, char *handle, uint32_t flags );
+G_MODULE_EXPORT struct bee_user *imcb_buddy_by_handle( struct im_connection *ic, const char *handle );
 G_MODULE_EXPORT void imcb_clean_handle( struct im_connection *ic, char *handle );
 …
 /* Actions, or whatever. */
 int imc_away_send_update( struct im_connection *ic );
-int imc_buddy_msg( struct im_connection *ic, char *handle, char *msg, int flags );
 int imc_chat_msg( struct groupchat *c, char *msg, int flags );

protocols/oscar/oscar.c

-                      r560d0a0
+                      rf1cea66
         u = t = g_strdup(s);
-        strcpy(t, s);
         g_strdown(t);
 …
         struct im_connection *ic = sess->aux_data;
         struct chat_connection *chatcon;
+        struct groupchat *c = NULL;
         static int id = 1;
 …
         chatcon = find_oscar_chat_by_conn(ic, fr->conn);
         chatcon->id = id;
+        chatcon->cnv = imcb_chat_new(ic, chatcon->show);
+        c = bee_chat_by_title(ic->bee, ic, chatcon->show);
+        if (c && !c->data)
+                chatcon->cnv = c;
+        else
+                chatcon->cnv = imcb_chat_new(ic, chatcon->show);
         chatcon->cnv->data = chatcon;
 …
         tmp = normalize(info->sn);
         imcb_buddy_status(ic, tmp, flags, state_string, NULL);
         /* imcb_buddy_times(ic, tmp, signon, time_idle); */
+        imcb_buddy_times(ic, tmp, signon, time_idle);
 …
         aim_ssi_auth_reply(od->sess, od->conn, uin, 1, "");
         // aim_send_im_ch4(od->sess, uin, AIM_ICQMSG_AUTHGRANTED, &message);
+        if(imcb_find_buddy(data->ic, uin) == NULL)
+                imcb_ask_add(data->ic, uin, NULL);
+        imcb_ask_add(data->ic, uin, NULL);
         g_free(uin);
 …
         struct oscar_data *odata = (struct oscar_data *)g->proto_data;
         if (odata->icq) {
+                /** FIXME(wilmer): Hmm, lost the ability to get away msgs here, do we care to get that back?
                 struct buddy *budlight = imcb_find_buddy(g, who);
                 if (budlight)
 …
                                 if (budlight->caps & AIM_CAPS_ICQSERVERRELAY)
                                         aim_send_im_ch2_geticqmessage(odata->sess, who, (budlight->uc & 0xff80) >> 7);
+                */
         } else
                 aim_getinfo(odata->sess, odata->conn, who, AIM_GETINFO_AWAYMESSAGE);
 …
 static int gaim_ssi_parselist(aim_session_t *sess, aim_frame_t *fr, ...) {
         struct im_connection *ic = sess->aux_data;
         struct aim_ssi_item *curitem;
+        struct aim_ssi_item *curitem, *curgroup;
         int tmp;
         char *nrm;
 …
                 switch (curitem->type) {
                         case 0x0000: /* Buddy */
                                 if ((curitem->name) && (!imcb_find_buddy(ic, nrm))) {
+                                if ((curitem->name) && (!imcb_buddy_by_handle(ic, nrm))) {
                                         char *realname = NULL;
                                         if (curitem->data && aim_gettlv(curitem->data, 0x0131, 1))
                                                     realname = aim_gettlv_str(curitem->data, 0x0131, 1);
                                         imcb_add_buddy(ic, nrm, NULL);
+                                        imcb_add_buddy(ic, nrm, curgroup->gid == curitem->gid ? curgroup->name : NULL);
                                         if (realname) {
 …
+                                        }
+                                }
+                                break;
+                        case 0x0001: /* Group */
+                                curgroup = curitem;
                                 break;
 …
         static int chat_id = 0;
         char * chatname;
+        struct groupchat *c;
         chatname = g_strdup_printf("%s%s_%d", isdigit(*ic->acc->user) ? "icq_" : "",
                                    ic->acc->user, chat_id++);
+        c = imcb_chat_new(ic, chatname);
         ret = oscar_chat_join(ic, chatname, NULL, NULL);
         aim_chat_invite(od->sess, od->conn, who, "", 4, chatname, 0x0);

protocols/purple/ft.c

r560d0a0	rf1cea66
75	75	px->fn = mktemp( g_strdup( "/tmp/bitlbee-purple-ft.XXXXXX" ) );
76	76	px->fd = -1;
	77	px->ic = purple_ic_by_pa( xfer->account );
77	78
78	79	purple_xfer_set_local_filename( xfer, px->fn );
…	…
143	144	{
144	145	purple_xfer_cancel_local( px->xfer );
145		imcb_file_canceled( ft, "Read error" );
	146	imcb_file_canceled( px->ic, ft, "Read error" );
146	147	}
147	148	}
…	…
150	151	{
151	152	/purple_xfer_end( px->xfer );/
152		imcb_file_finished( ft );
	153	imcb_file_finished( px->ic, ft );
153	154	}
154	155
…	…
230	231
231	232	if( px->ft )
232		imcb_file_canceled( px->ft, "Canceled by remote end" );
	233	imcb_file_canceled( px->ic, px->ft, "Canceled by remote end" );
233	234	else
234	235	/* px->ft == NULL for sends, because of the two stages. :-/ */
…	…
301	302	{
302	303	file_transfer_t *ft = data;
	304	struct prpl_xfer_data *px = ft->data;
303	305
304	306	if( ft->write == NULL )
305	307	{
306	308	ft->write = prpl_xfer_write;
307		imcb_file_recv_start( ft );
	309	imcb_file_recv_start( px->ic, ft );
308	310	}
309	311
…	…
319	321	if( write( px->fd, buffer, len ) != len )
320	322	{
321		imcb_file_canceled( ft, "Error while writing temporary file" );
	323	imcb_file_canceled( px->ic, ft, "Error while writing temporary file" );
322	324	return FALSE;
323	325	}
…	…
329	331
330	332	purple_transfer_forward( ft );
331		imcb_file_finished( ft );
	333	imcb_file_finished( px->ic, ft );
332	334	px->ft = NULL;
333	335	}

protocols/purple/purple.c

-                      r560d0a0
+                      rf1cea66
    any context so this is the only way to get that. Don't want to support
    libpurple in daemon mode anyway. */
 static irc_t *local_irc;
+static bee_t *local_bee;
 static char *set_eval_display_name( set_t *set, char *value );
 …
                 default:
+                        /** No way to talk to the user right now, invent one when
+                        this becomes important.
                         irc_usermsg( acc->irc, "Setting with unknown type: %s (%d) Expect stuff to break..\n",
                                      name, purple_account_option_get_type( o ) );
+                        */
                         name = NULL;
+                }
 …
         PurpleAccount *pa;
+        if( local_irc != NULL && local_irc != acc->irc )
+        {
+                irc_usermsg( acc->irc, "Daemon mode detected. Do *not* try to use libpurple in daemon mode! "
+                                       "Please use inetd or ForkDaemon mode instead." );
+        if( local_bee != NULL && local_bee != acc->bee )
+        {
+                imcb_error( ic,  "Daemon mode detected. Do *not* try to use libpurple in daemon mode! "
+                                 "Please use inetd or ForkDaemon mode instead." );
+                imc_logout( ic, FALSE );
                 return;
+        }
         local_irc = acc->irc;
+        local_bee = acc->bee;
         /* For now this is needed in the _connected() handlers if using
 …
                 imcb_buddy_status( ic, bud->name, flags, purple_status_get_name( as ),
                                    purple_status_get_attr_string( as, "message" ) );
+                imcb_buddy_times( ic, bud->name,
+                                  purple_presence_get_login_time( bud->presence ),
+                                  purple_presence_get_idle_time( bud->presence ) );
+        }
+}
 …
         pqad->user_data = user_data;
+        /* TODO: IRC stuff here :-( */
         q = g_strdup_printf( "Request: %s\n\n%s\n\n%s", title, primary, secondary );
         pqad->bee_data = query_add( local_irc, purple_ic_by_pa( account ), q,
+        pqad->bee_data = query_add( local_bee->ui_data, purple_ic_by_pa( account ), q,
                 prplcb_request_action_yes, prplcb_request_action_no, pqad );

protocols/twitter/twitter_lib.c

r560d0a0	rf1cea66
103	103
104	104	// Check if the buddy is allready in the buddy list.
105		if (!~~imcb_find_buddy(~~ ic, name ))
	105	if (!bee_user_by_handle( ic->bee, ic, name ))
106	106	{
107	107	char *mode = set_getstr(&ic->acc->set, "mode");

protocols/yahoo/yahoo.c

-                      r560d0a0
+                      rf1cea66
         while( ic->groupchats )
                 imcb_chat_free( ic->groupchats );
+                imcb_chat_free( ic->groupchats->data );
         for( l = yd->buddygroups; l; l = l->next )
 …
         imcb_buddy_status( ic, who, flags, state_string, msg );
-        /* Not implemented yet...
         if( stat == YAHOO_STATUS_IDLE )
+                imcb_buddy_times( ic, who, 0, away );
+        */
+                imcb_buddy_times( ic, who, 0, idle );
+}
 …
         struct byahoo_conf_invitation *inv = data;
         struct groupchat *b;
+        for( b = inv->ic->groupchats; b; b = b->next )
+        GSList *l;
+        for( l = inv->ic->groupchats; l; l = l->next )
+        {
+                b = l->data;
                 if( b == inv->c )
                         break;
+        }
         if( b != NULL )
 …
+{
         struct im_connection *ic = byahoo_get_ic_by_id( id );
+        struct groupchat *c;
+        for( c = ic->groupchats; c && strcmp( c->title, room ) != 0; c = c->next );
+        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
         if( c )
 …
+{
         struct im_connection *ic = byahoo_get_ic_by_id( id );
+        struct groupchat *c;
+        for( c = ic->groupchats; c && strcmp( c->title, room ) != 0; c = c->next );
+        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
         if( c )
 …
         struct im_connection *ic = byahoo_get_ic_by_id( id );
         char *m = byahoo_strip( msg );
+        struct groupchat *c;
+        for( c = ic->groupchats; c && strcmp( c->title, room ) != 0; c = c->next );
+        struct groupchat *c = bee_chat_by_title( ic->bee, ic, room );
         if( c )

query.c

-                      r560d0a0
+                      rf1cea66
+        }
         if( g_strcasecmp( set_getstr( &irc->set, "query_order" ), "lifo" ) == 0 || irc->queries == q )
+        if( g_strcasecmp( set_getstr( &irc->b->set, "query_order" ), "lifo" ) == 0 || irc->queries == q )
                 query_display( irc, q );
 …
         query_t *q;
         if( g_strcasecmp( set_getstr( &irc->set, "query_order" ), "fifo" ) == 0 )
+        if( g_strcasecmp( set_getstr( &irc->b->set, "query_order" ), "fifo" ) == 0 )
                 q = irc->queries;
         else

root_commands.c

-                      r560d0a0
+                      rf1cea66
 #include <string.h>
+void root_command_string( irc_t *irc, user_t *u, char *command, int flags )
+{
+        char *cmd[IRC_MAX_ARGS];
+        char *s;
+        int k;
+        char q = 0;
+        memset( cmd, 0, sizeof( cmd ) );
+        cmd[0] = command;
+        k = 1;
+        for( s = command; *s && k < ( IRC_MAX_ARGS - 1 ); s ++ )
+                if( *s == ' ' && !q )
+                {
+                        *s = 0;
+                        while( *++s == ' ' );
+                        if( *s == '"' || *s == '\'' )
+                        {
+                                q = *s;
+                                s ++;
+                        }
+                        if( *s )
+                        {
+                                cmd[k++] = s;
+                                s --;
+                        }
+                        else
+                        {
+                                break;
+                        }
+                }
+                else if( *s == '\\' && ( ( !q && s[1] ) || ( q && q == s[1] ) ) )
+                {
+                        char *cpy;
+                        for( cpy = s; *cpy; cpy ++ )
+                                cpy[0] = cpy[1];
+                }
+                else if( *s == q )
+                {
+                        q = *s = 0;
+                }
+        cmd[k] = NULL;
+        root_command( irc, cmd );
+void root_command_string( irc_t *irc, char *command )
+{
+        root_command( irc, split_command_parts( command ) );
+}
 …
 void root_command( irc_t *irc, char *cmd[] )
+{
         int i;
+        int i, len;
         if( !cmd[0] )
                 return;
+        len = strlen( cmd[0] );
         for( i = 0; commands[i].command; i++ )
+                if( g_strcasecmp( commands[i].command, cmd[0] ) == 0 )
+                {
+                if( g_strncasecmp( commands[i].command, cmd[0], len ) == 0 )
+                {
+                        if( commands[i+1].command &&
+                            g_strncasecmp( commands[i+1].command, cmd[0], len ) == 0 )
+                                /* Only match on the first letters if the match is unique. */
+                                break;
                         MIN_ARGS( commands[i].required_parameters );
 …
 static void cmd_identify( irc_t *irc, char **cmd )
+{
         storage_status_t status = storage_load( irc, cmd[1] );
+        storage_status_t status;
         char *account_on[] = { "account", "on", NULL };
+        if( strchr( irc->umode, 'R' ) != NULL )
+        gboolean load = TRUE;
+        char *password = cmd[1];
+        if( irc->status & USTATUS_IDENTIFIED )
+        {
                 irc_usermsg( irc, "You're already logged in." );
                 return;
+        }
+        if( strncmp( cmd[1], "-no", 3 ) == 0 )
+        {
+                load = FALSE;
+                password = cmd[2];
+        }
+        else if( strncmp( cmd[1], "-force", 6 ) == 0 )
+        {
+                password = cmd[2];
+        }
+        else if( irc->b->accounts != NULL )
+        {
+                irc_usermsg( irc,
+                             "You're trying to identify yourself, but already have "
+                             "at least one IM account set up. "
+                             "Use \x02identify -noload\x02 or \x02identify -force\x02 "
+                             "instead (see \x02help identify\x02)." );
+                return;
+        }
+        if( password == NULL )
+        {
+                MIN_ARGS( 2 );
+        }
+        if( load )
+                status = storage_load( irc, password );
+        else
+                status = storage_check_pass( irc->user->nick, password );
         switch (status) {
 …
                 break;
         case STORAGE_OK:
+                irc_usermsg( irc, "Password accepted, settings and accounts loaded" );
+                irc_setpass( irc, cmd[1] );
+                irc_usermsg( irc, "Password accepted%s",
+                             load ? ", settings and accounts loaded" : "" );
+                irc_setpass( irc, password );
                 irc->status |= USTATUS_IDENTIFIED;
                 irc_umode_set( irc, "+R", 1 );
                 if( set_getbool( &irc->set, "auto_connect" ) )
+                if( load && set_getbool( &irc->b->set, "auto_connect" ) )
                         cmd_account( irc, account_on );
                 break;
 …
         storage_status_t status;
         status = storage_remove (irc->nick, cmd[1]);
+        status = storage_remove (irc->user->nick, cmd[1]);
         switch (status) {
         case STORAGE_NO_SUCH_USER:
 …
                 irc->status &= ~USTATUS_IDENTIFIED;
                 irc_umode_set( irc, "-R", 1 );
                 irc_usermsg( irc, "Account `%s' removed", irc->nick );
+                irc_usermsg( irc, "Account `%s' removed", irc->user->nick );
                 break;
         default:
 …
+}
+struct cmd_account_del_data
+{
+        account_t *a;
+        irc_t *irc;
+};
+void cmd_account_del_yes( void *data )
+{
+        struct cmd_account_del_data *cad = data;
+        account_t *a;
+        for( a = cad->irc->accounts; a && a != cad->a; a = a->next );
+        if( a == NULL )
+        {
+                irc_usermsg( cad->irc, "Account already deleted" );
+        }
+        else if( a->ic )
+        {
+                irc_usermsg( cad->irc, "Account is still logged in, can't delete" );
+        }
+        else
+        {
+                account_del( cad->irc, a );
+                irc_usermsg( cad->irc, "Account deleted" );
+        }
+        g_free( data );
+}
+void cmd_account_del_no( void *data )
+{
+        g_free( data );
+static void cmd_save( irc_t *irc, char **cmd )
+{
+        if( ( irc->status & USTATUS_IDENTIFIED ) == 0 )
+                irc_usermsg( irc, "Please create an account first" );
+        else if( storage_save( irc, NULL, TRUE ) == STORAGE_OK )
+                irc_usermsg( irc, "Configuration saved" );
+        else
+                irc_usermsg( irc, "Configuration could not be saved!" );
+}
 …
                 set_name = set_full;
                 head = &irc->set;
+                head = &irc->b->set;
+        }
         else
 …
         account_t *a;
         if( ( a = account_get( irc, id ) ) )
+        if( ( a = account_get( irc->b, id ) ) )
                 return &a->set;
         else
 …
+                }
                 a = account_add( irc, prpl, cmd[3], cmd[4] );
+                a = account_add( irc->b, prpl, cmd[3], cmd[4] );
                 if( cmd[5] )
+                {
 …
                 MIN_ARGS( 2 );
                 if( !( a = account_get( irc, cmd[2] ) ) )
+                if( !( a = account_get( irc->b, cmd[2] ) ) )
+                {
                         irc_usermsg( irc, "Invalid account" );
 …
                 else
+                {
+                        struct cmd_account_del_data *cad;
+                        char *msg;
+                        cad = g_malloc( sizeof( struct cmd_account_del_data ) );
+                        cad->a = a;
+                        cad->irc = irc;
+                        msg = g_strdup_printf( "If you remove this account (%s(%s)), BitlBee will "
+                                               "also forget all your saved nicknames. If you want "
+                                               "to change your username/password, use the `account "
+                                               "set' command. Are you sure you want to delete this "
+                                               "account?", a->prpl->name, a->user );
+                        query_add( irc, NULL, msg, cmd_account_del_yes, cmd_account_del_no, cad );
+                        g_free( msg );
+                        account_del( irc->b, a );
+                        irc_usermsg( irc, "Account deleted" );
+                }
+        }
 …
                         irc_usermsg( irc, "Account list:" );
                 for( a = irc->accounts; a; a = a->next )
+                for( a = irc->b->accounts; a; a = a->next )
+                {
                         char *con;
 …
                 if( cmd[2] )
+                {
                         if( ( a = account_get( irc, cmd[2] ) ) )
+                        if( ( a = account_get( irc->b, cmd[2] ) ) )
+                        {
                                 if( a->ic )
 …
                                 else
+                                {
                                         account_on( irc, a );
+                                        account_on( irc->b, a );
+                                }
+                        }
 …
                 else
+                {
+                        if ( irc->accounts ) {
+                        if ( irc->b->accounts )
+                        {
                                 irc_usermsg( irc, "Trying to get all accounts connected..." );
                                 for( a = irc->accounts; a; a = a->next )
+                                for( a = irc->b->accounts; a; a = a->next )
                                         if( !a->ic && a->auto_connect )
                                                 account_on( irc, a );
+                                                account_on( irc->b, a );
+                        }
                         else
 …
                         irc_usermsg( irc, "Deactivating all active (re)connections..." );
                         for( a = irc->accounts; a; a = a->next )
+                        for( a = irc->b->accounts; a; a = a->next )
+                        {
                                 if( a->ic )
                                         account_off( irc, a );
+                                        account_off( irc->b, a );
                                 else if( a->reconnect )
                                         cancel_auto_reconnect( a );
+                        }
+                }
                 else if( ( a = account_get( irc, cmd[2] ) ) )
+                else if( ( a = account_get( irc->b, cmd[2] ) ) )
+                {
                         if( a->ic )
+                        {
                                 account_off( irc, a );
+                                account_off( irc->b, a );
+                        }
                         else if( a->reconnect )
 …
+}
+static set_t **cmd_channel_set_findhead( irc_t *irc, char *id )
+{
+        irc_channel_t *ic;
+        if( ( ic = irc_channel_get( irc, id ) ) )
+                return &ic->set;
+        else
+                return NULL;
+}
+static void cmd_channel( irc_t *irc, char **cmd )
+{
+        if( g_strcasecmp( cmd[1], "set" ) == 0 )
+        {
+                MIN_ARGS( 2 );
+                cmd_set_real( irc, cmd + 1, cmd_channel_set_findhead, NULL );
+        }
+        else if( g_strcasecmp( cmd[1], "list" ) == 0 )
+        {
+                GSList *l;
+                int i = 0;
+                if( strchr( irc->umode, 'b' ) )
+                        irc_usermsg( irc, "Channel list:" );
+                for( l = irc->channels; l; l = l->next )
+                {
+                        irc_channel_t *ic = l->data;
+                        irc_usermsg( irc, "%2d. %s, %s channel%s", i, ic->name,
+                                     set_getstr( &ic->set, "type" ),
+                                     ic->flags & IRC_CHANNEL_JOINED ? " (joined)" : "" );
+                        i ++;
+                }
+                irc_usermsg( irc, "End of channel list" );
+        }
+        else if( g_strcasecmp( cmd[1], "del" ) == 0 )
+        {
+                irc_channel_t *ic;
+                MIN_ARGS( 2 );
+                if( ( ic = irc_channel_get( irc, cmd[2] ) ) &&
+                   !( ic->flags & IRC_CHANNEL_JOINED ) &&
+                    ic != ic->irc->default_channel )
+                {
+                        irc_usermsg( irc, "Channel %s deleted.", ic->name );
+                        irc_channel_free( ic );
+                }
+                else
+                        irc_usermsg( irc, "Couldn't remove channel (main channel %s or "
+                                          "channels you're still in cannot be deleted).",
+                                          ic->irc->default_channel->name );
+        }
+        else
+        {
+                irc_usermsg( irc, "Unknown command: %s %s. Please use \x02help commands\x02 to get a list of available commands.", "channel", cmd[1] );
+        }
+}
 static void cmd_add( irc_t *irc, char **cmd )
+{
 …
+        }
         if( !( a = account_get( irc, cmd[1] ) ) )
+        if( !( a = account_get( irc->b, cmd[1] ) ) )
+        {
                 irc_usermsg( irc, "Invalid account" );
 …
                         return;
+                }
                 else if( user_find( irc, cmd[3] ) )
+                else if( irc_user_by_name( irc, cmd[3] ) )
+                {
                         irc_usermsg( irc, "The requested nick `%s' already exists", cmd[3] );
 …
                 a->ic->acc->prpl->add_buddy( a->ic, cmd[2], NULL );
         else
+                /* Yeah, officially this is a call-*back*... So if we just
+                   called add_buddy, we'll wait for the IM server to respond
+                   before we do this. */
+                imcb_add_buddy( a->ic, cmd[2], NULL );
+                /* Only for add -tmp. For regular adds, this callback will
+                   be called once the IM server confirms. */
+                bee_user_new( irc->b, a->ic, cmd[2], BEE_USER_LOCAL );
         irc_usermsg( irc, "Adding `%s' to your contact list", cmd[2]  );
+}
+static void cmd_remove( irc_t *irc, char **cmd )
+{
+        irc_user_t *iu;
+        bee_user_t *bu;
+        char *s;
+        if( !( iu = irc_user_by_name( irc, cmd[1] ) ) || !( bu = iu->bu ) )
+        {
+                irc_usermsg( irc, "Buddy `%s' not found", cmd[1] );
+                return;
+        }
+        s = g_strdup( bu->handle );
+        bu->ic->acc->prpl->remove_buddy( bu->ic, bu->handle, NULL );
+        nick_del( bu->ic->acc, bu->handle );
+        //TODO(wilmer): bee_user_free() and/or let the IM mod do it? irc_user_free( irc, cmd[1] );
+        irc_usermsg( irc, "Buddy `%s' (nick %s) removed from contact list", s, cmd[1] );
+        g_free( s );
+        return;
+}
 …
         if( !cmd[2] )
+        {
                 user_t *u = user_find( irc, cmd[1] );
                 if( !u || !u->ic )
+                irc_user_t *iu = irc_user_by_name( irc, cmd[1] );
+                if( !iu || !iu->bu )
+                {
                         irc_usermsg( irc, "Nick `%s' does not exist", cmd[1] );
                         return;
+                }
                 ic = u->ic;
                 cmd[2] = u->handle;
+        }
         else if( !( a = account_get( irc, cmd[1] ) ) )
+                ic = iu->bu->ic;
+                cmd[2] = iu->bu->handle;
+        }
+        else if( !( a = account_get( irc->b, cmd[1] ) ) )
+        {
                 irc_usermsg( irc, "Invalid account" );
 …
 static void cmd_rename( irc_t *irc, char **cmd )
+{
+        user_t *u;
+        if( g_strcasecmp( cmd[1], irc->nick ) == 0 )
+        irc_user_t *iu;
+        iu = irc_user_by_name( irc, cmd[1] );
+        if( iu == NULL )
+        {
+                irc_usermsg( irc, "Nick `%s' does not exist", cmd[1] );
+        }
+        else if( iu == irc->user )
+        {
                 irc_usermsg( irc, "Nick `%s' can't be changed", cmd[1] );
+        }
+        else if( g_strcasecmp( cmd[1], irc->channel ) == 0 )
+        {
+                if( strchr( CTYPES, cmd[2][0] ) && nick_ok( cmd[2] + 1 ) )
+                {
+                        u = user_find( irc, irc->nick );
+                        irc_part( irc, u, irc->channel );
+                        g_free( irc->channel );
+                        irc->channel = g_strdup( cmd[2] );
+                        irc_join( irc, u, irc->channel );
+                        if( strcmp( cmd[0], "set_rename" ) != 0 )
+                                set_setstr( &irc->set, "control_channel", cmd[2] );
+                }
+        }
+        else if( user_find( irc, cmd[2] ) && ( nick_cmp( cmd[1], cmd[2] ) != 0 ) )
+        else if( !nick_ok( cmd[2] ) )
+        {
+                irc_usermsg( irc, "Nick `%s' is invalid", cmd[2] );
+        }
+        else if( irc_user_by_name( irc, cmd[2] ) )
+        {
                 irc_usermsg( irc, "Nick `%s' already exists", cmd[2] );
+        }
+        else if( !nick_ok( cmd[2] ) )
+        {
+                irc_usermsg( irc, "Nick `%s' is invalid", cmd[2] );
+        }
+        else if( !( u = user_find( irc, cmd[1] ) ) )
+        {
+                irc_usermsg( irc, "Nick `%s' does not exist", cmd[1] );
+        }
+        else
+        {
+                user_rename( irc, cmd[1], cmd[2] );
+                irc_write( irc, ":%s!%s@%s NICK %s", cmd[1], u->user, u->host, cmd[2] );
+                if( g_strcasecmp( cmd[1], irc->mynick ) == 0 )
+                {
+                        g_free( irc->mynick );
+                        irc->mynick = g_strdup( cmd[2] );
+        else
+        {
+                if( !irc_user_set_nick( iu, cmd[2] ) )
+                {
+                        irc_usermsg( irc, "Error while changing nick" );
+                        return;
+                }
+                if( iu == irc->root )
+                {
                         /* If we're called internally (user did "set root_nick"),
                            let's not go O(INF). :-) */
                         if( strcmp( cmd[0], "set_rename" ) != 0 )
                                 set_setstr( &irc->set, "root_nick", cmd[2] );
+                }
                 else if( u->send_handler == buddy_send_handler )
+                {
                         nick_set( u->ic->acc, u->handle, cmd[2] );
+                                set_setstr( &irc->b->set, "root_nick", cmd[2] );
+                }
+                else if( iu->bu )
+                {
+                        nick_set( iu->bu->ic->acc, iu->bu->handle, cmd[2] );
+                }
 …
         irc_t *irc = set->data;
         if( strcmp( irc->mynick, new_nick ) != 0 )
+        {
                 char *cmd[] = { "set_rename", irc->mynick, new_nick, NULL };
+        if( strcmp( irc->root->nick, new_nick ) != 0 )
+        {
+                char *cmd[] = { "set_rename", irc->root->nick, new_nick, NULL };
                 cmd_rename( irc, cmd );
+        }
+        return strcmp( irc->mynick, new_nick ) == 0 ? new_nick : SET_INVALID;
+}
+char *set_eval_control_channel( set_t *set, char *new_name )
+{
+        irc_t *irc = set->data;
+        if( strcmp( irc->channel, new_name ) != 0 )
+        {
+                char *cmd[] = { "set_rename", irc->channel, new_name, NULL };
+                cmd_rename( irc, cmd );
+        }
+        return strcmp( irc->channel, new_name ) == 0 ? new_name : SET_INVALID;
+}
+static void cmd_remove( irc_t *irc, char **cmd )
+{
+        user_t *u;
+        char *s;
+        if( !( u = user_find( irc, cmd[1] ) ) || !u->ic )
+        {
+                irc_usermsg( irc, "Buddy `%s' not found", cmd[1] );
+                return;
+        }
+        s = g_strdup( u->handle );
+        u->ic->acc->prpl->remove_buddy( u->ic, u->handle, NULL );
+        nick_del( u->ic->acc, u->handle );
+        user_del( irc, cmd[1] );
+        irc_usermsg( irc, "Buddy `%s' (nick %s) removed from contact list", s, cmd[1] );
+        g_free( s );
+        return;
+        return strcmp( irc->root->nick, new_nick ) == 0 ? new_nick : SET_INVALID;
+}
 …
         account_t *a;
         if( !cmd[2] && ( a = account_get( irc, cmd[1] ) ) && a->ic )
+        if( !cmd[2] && ( a = account_get( irc->b, cmd[1] ) ) && a->ic )
+        {
                 char *format;
 …
                 for( l = a->ic->deny; l; l = l->next )
+                {
+                        user_t *u = user_findhandle( a->ic, l->data );
+                        irc_usermsg( irc, format, l->data, u ? u->nick : "(none)" );
+                        bee_user_t *bu = bee_user_by_handle( irc->b, a->ic, l->data );
+                        irc_user_t *iu = bu ? bu->ui_data : NULL;
+                        irc_usermsg( irc, format, l->data, iu ? iu->nick : "(none)" );
+                }
                 irc_usermsg( irc, "End of list." );
 …
         else if( !cmd[2] )
+        {
                 user_t *u = user_find( irc, cmd[1] );
                 if( !u || !u->ic )
+                irc_user_t *iu = irc_user_by_name( irc, cmd[1] );
+                if( !iu || !iu->bu )
+                {
                         irc_usermsg( irc, "Nick `%s' does not exist", cmd[1] );
                         return;
+                }
                 ic = u->ic;
                 cmd[2] = u->handle;
+        }
         else if( !( a = account_get( irc, cmd[1] ) ) )
+                ic = iu->bu->ic;
+                cmd[2] = iu->bu->handle;
+        }
+        else if( !( a = account_get( irc->b, cmd[1] ) ) )
+        {
                 irc_usermsg( irc, "Invalid account" );
 …
         account_t *a;
         if( !cmd[2] && ( a = account_get( irc, cmd[1] ) ) && a->ic )
+        if( !cmd[2] && ( a = account_get( irc->b, cmd[1] ) ) && a->ic )
+        {
                 char *format;
 …
                 for( l = a->ic->permit; l; l = l->next )
+                {
+                        user_t *u = user_findhandle( a->ic, l->data );
+                        irc_usermsg( irc, format, l->data, u ? u->nick : "(none)" );
+                        bee_user_t *bu = bee_user_by_handle( irc->b, a->ic, l->data );
+                        irc_user_t *iu = bu ? bu->ui_data : NULL;
+                        irc_usermsg( irc, format, l->data, iu ? iu->nick : "(none)" );
+                }
                 irc_usermsg( irc, "End of list." );
 …
         else if( !cmd[2] )
+        {
                 user_t *u = user_find( irc, cmd[1] );
                 if( !u || !u->ic )
+                irc_user_t *iu = irc_user_by_name( irc, cmd[1] );
+                if( !iu || !iu->bu )
+                {
                         irc_usermsg( irc, "Nick `%s' does not exist", cmd[1] );
                         return;
+                }
                 ic = u->ic;
                 cmd[2] = u->handle;
+        }
         else if( !( a = account_get( irc, cmd[1] ) ) )
+                ic = iu->bu->ic;
+                cmd[2] = iu->bu->handle;
+        }
+        else if( !( a = account_get( irc->b, cmd[1] ) ) )
+        {
                 irc_usermsg( irc, "Invalid account" );
 …
+}
-static void cmd_save( irc_t *irc, char **cmd )
+{
-        if( ( irc->status & USTATUS_IDENTIFIED ) == 0 )
-                irc_usermsg( irc, "Please create an account first" );
-        else if( storage_save( irc, NULL, TRUE ) == STORAGE_OK )
-                irc_usermsg( irc, "Configuration saved" );
-        else
-                irc_usermsg( irc, "Configuration could not be saved!" );
+}
 static void cmd_blist( irc_t *irc, char **cmd )
+{
         int online = 0, away = 0, offline = 0;
         user_t *u;
+        GSList *l;
         char s[256];
         char *format;
 …
                 format = "%-16.16s  %-40.40s  %s";
+        irc_usermsg( irc, format, "Nick", "User/Host/Network", "Status" );
+        for( u = irc->users; u; u = u->next ) if( u->ic && u->online && !u->away )
+        {
+        irc_usermsg( irc, format, "Nick", "Handle/Account", "Status" );
+        for( l = irc->users; l; l = l->next )
+        {
+                irc_user_t *iu = l->data;
+                bee_user_t *bu = iu->bu;
+                if( !bu || ( bu->flags & ( BEE_USER_ONLINE | BEE_USER_AWAY ) ) != BEE_USER_ONLINE )
+                        continue;
                 if( online == 1 )
+                {
                         char st[256] = "Online";
                         if( u->status_msg )
                                 g_snprintf( st, sizeof( st ) - 1, "Online (%s)", u->status_msg );
+                        if( bu->status_msg )
+                                g_snprintf( st, sizeof( st ) - 1, "Online (%s)", bu->status_msg );
                         g_snprintf( s, sizeof( s ) - 1, "%s@%s %s(%s)", u->user, u->host, u->ic->acc->prpl->name, u->ic->acc->user );
                         irc_usermsg( irc, format, u->nick, s, st );
+                        g_snprintf( s, sizeof( s ) - 1, "%s %s(%s)", bu->handle, bu->ic->acc->prpl->name, bu->ic->acc->user );
+                        irc_usermsg( irc, format, iu->nick, s, st );
+                }
 …
+        }
+        for( u = irc->users; u; u = u->next ) if( u->ic && u->online && u->away )
+        {
+        for( l = irc->users; l; l = l->next )
+        {
+                irc_user_t *iu = l->data;
+                bee_user_t *bu = iu->bu;
+                if( !bu || !( bu->flags & BEE_USER_ONLINE ) || !( bu->flags & BEE_USER_AWAY ) )
+                        continue;
                 if( away == 1 )
+                {
                         g_snprintf( s, sizeof( s ) - 1, "%s@%s %s(%s)", u->user, u->host, u->ic->acc->prpl->name, u->ic->acc->user );
                         irc_usermsg( irc, format, u->nick, s, u->away );
+                        g_snprintf( s, sizeof( s ) - 1, "%s %s(%s)", bu->handle, bu->ic->acc->prpl->name, bu->ic->acc->user );
+                        irc_usermsg( irc, format, iu->nick, s, irc_user_get_away( iu ) );
+                }
                 n_away ++;
+        }
+        for( u = irc->users; u; u = u->next ) if( u->ic && !u->online )
+        {
+        for( l = irc->users; l; l = l->next )
+        {
+                irc_user_t *iu = l->data;
+                bee_user_t *bu = iu->bu;
+                if( !bu || bu->flags & BEE_USER_ONLINE )
+                        continue;
                 if( offline == 1 )
+                {
                         g_snprintf( s, sizeof( s ) - 1, "%s@%s %s(%s)", u->user, u->host, u->ic->acc->prpl->name, u->ic->acc->user );
                         irc_usermsg( irc, format, u->nick, s, "Offline" );
+                        g_snprintf( s, sizeof( s ) - 1, "%s %s(%s)", bu->handle, bu->ic->acc->prpl->name, bu->ic->acc->user );
+                        irc_usermsg( irc, format, iu->nick, s, "Offline" );
+                }
                 n_offline ++;
 …
         irc_usermsg( irc, "%d buddies (%d available, %d away, %d offline)", n_online + n_away + n_offline, n_online, n_away, n_offline );
+}
-static void cmd_nick( irc_t *irc, char **cmd )
+{
-        account_t *a;
-        if( !cmd[1] || !( a = account_get( irc, cmd[1] ) ) )
+        {
-                irc_usermsg( irc, "Invalid account");
+        }
-        else if( !( a->ic && ( a->ic->flags & OPT_LOGGED_IN ) ) )
+        {
-                irc_usermsg( irc, "That account is not on-line" );
+        }
-        else if ( !cmd[2] )
+        {
-                irc_usermsg( irc, "Your name is `%s'" , a->ic->displayname ? a->ic->displayname : "NULL" );
+        }
-        else if ( !a->prpl->set_my_name )
+        {
-                irc_usermsg( irc, "Command `%s' not supported by this protocol", cmd[0] );
+        }
-        else
+        {
-                irc_usermsg( irc, "Setting your name to `%s'", cmd[2] );
-                a->prpl->set_my_name( a->ic, cmd[2] );
+        }
+}
 …
+}
-static void cmd_join_chat( irc_t *irc, char **cmd )
+{
-        irc_usermsg( irc, "This command is now obsolete. "
-                          "Please try the `chat' command instead." );
+}
-static set_t **cmd_chat_set_findhead( irc_t *irc, char *id )
+{
-        struct chat *c;
-        if( ( c = chat_get( irc, id ) ) )
-                return &c->set;
-        else
-                return NULL;
+}
 static void cmd_chat( irc_t *irc, char **cmd )
+{
         account_t *acc;
-        struct chat *c;
         if( g_strcasecmp( cmd[1], "add" ) == 0 )
+        {
                 char *channel, *s;
+                struct irc_channel *ic;
                 MIN_ARGS( 3 );
                 if( !( acc = account_get( irc, cmd[2] ) ) )
+                if( !( acc = account_get( irc->b, cmd[2] ) ) )
+                {
                         irc_usermsg( irc, "Invalid account" );
+                        return;
+                }
+                else if( !acc->prpl->chat_join )
+                {
+                        irc_usermsg( irc, "Named chatrooms not supported on that account." );
                         return;
+                }
 …
                 if( strchr( CTYPES, channel[0] ) == NULL )
+                {
                         s = g_strdup_printf( "%c%s", CTYPES[0], channel );
+                        s = g_strdup_printf( "#%s", channel );
                         g_free( channel );
                         channel = s;
+                }
+                if( ( c = chat_add( irc, acc, cmd[3], channel ) ) )
+                        irc_usermsg( irc, "Chatroom added successfully." );
+                else
+                if( ( ic = irc_channel_new( irc, channel ) ) &&
+                    set_setstr( &ic->set, "chat_type", "room" ) &&
+                    set_setstr( &ic->set, "account", cmd[2] ) &&
+                    set_setstr( &ic->set, "room", cmd[3] ) )
+                {
+                        irc_usermsg( irc, "Chatroom successfully added." );
+                }
+                else
+                {
+                        if( ic )
+                                irc_channel_free( ic );
                         irc_usermsg( irc, "Could not add chatroom." );
+                g_free( channel );
+        }
+        else if( g_strcasecmp( cmd[1], "list" ) == 0 )
+        {
+                int i = 0;
+                if( strchr( irc->umode, 'b' ) )
+                        irc_usermsg( irc, "Chatroom list:" );
+                for( c = irc->chatrooms; c; c = c->next )
+                {
+                        irc_usermsg( irc, "%2d. %s(%s) %s, %s", i, c->acc->prpl->name,
+                                          c->acc->user, c->handle, c->channel );
+                        i ++;
+                }
+                irc_usermsg( irc, "End of chatroom list" );
+        }
+        else if( g_strcasecmp( cmd[1], "set" ) == 0 )
+        {
+                }
+        }
+        else if( g_strcasecmp( cmd[1], "with" ) == 0 )
+        {
+                irc_user_t *iu;
                 MIN_ARGS( 2 );
+                cmd_set_real( irc, cmd + 1, cmd_chat_set_findhead, NULL );
+        }
+        else if( g_strcasecmp( cmd[1], "del" ) == 0 )
+        {
+                MIN_ARGS( 2 );
+                if( ( c = chat_get( irc, cmd[2] ) ) )
+                {
+                        chat_del( irc, c );
+                }
+                else
+                {
+                        irc_usermsg( irc, "Could not remove chat." );
+                }
+        }
+        else if( g_strcasecmp( cmd[1], "with" ) == 0 )
+        {
+                user_t *u;
+                MIN_ARGS( 2 );
+                if( ( u = user_find( irc, cmd[2] ) ) && u->ic && u->ic->acc->prpl->chat_with )
+                {
+                        if( !u->ic->acc->prpl->chat_with( u->ic, u->handle ) )
+                if( ( iu = irc_user_by_name( irc, cmd[2] ) ) &&
+                    iu->bu && iu->bu->ic->acc->prpl->chat_with )
+                {
+                        if( !iu->bu->ic->acc->prpl->chat_with( iu->bu->ic, iu->bu->handle ) )
+                        {
                                 irc_usermsg( irc, "(Possible) failure while trying to open "
                                                   "a groupchat with %s.", u->nick );
+                                                  "a groupchat with %s.", iu->nick );
+                        }
+                }
 …
+                        {
                                 irc_usermsg( irc, "Rejecting file transfer for %s", file->file_name );
                                 imcb_file_canceled( file, "Denied by user" );
+                                imcb_file_canceled( file->ic, file, "Denied by user" );
+                        }
                         break;
 …
+                        {
                                 irc_usermsg( irc, "Canceling file transfer for %s", file->file_name );
                                 imcb_file_canceled( file, "Canceled by user" );
+                                imcb_file_canceled( file->ic, file, "Canceled by user" );
+                        }
                         break;
 …
+}
+/* IMPORTANT: Keep this list sorted! The short command logic needs that. */
 const command_t commands[] = {
+        { "account",        1, cmd_account,        0 },
+        { "add",            2, cmd_add,            0 },
+        { "allow",          1, cmd_allow,          0 },
+        { "blist",          0, cmd_blist,          0 },
+        { "block",          1, cmd_block,          0 },
+        { "channel",        1, cmd_channel,        0 },
+        { "chat",           1, cmd_chat,           0 },
+        { "drop",           1, cmd_drop,           0 },
+        { "ft",             0, cmd_transfer,       0 },
         { "help",           0, cmd_help,           0 },
         { "identify",       1, cmd_identify,       0 },
+        { "info",           1, cmd_info,           0 },
+        { "no",             0, cmd_yesno,          0 },
+        { "qlist",          0, cmd_qlist,          0 },
         { "register",       1, cmd_register,       0 },
+        { "drop",           1, cmd_drop,           0 },
+        { "account",        1, cmd_account,        0 },
+        { "add",            2, cmd_add,            0 },
+        { "info",           1, cmd_info,           0 },
+        { "remove",         1, cmd_remove,         0 },
         { "rename",         2, cmd_rename,         0 },
-        { "remove",         1, cmd_remove,         0 },
-        { "block",          1, cmd_block,          0 },
-        { "allow",          1, cmd_allow,          0 },
         { "save",           0, cmd_save,           0 },
         { "set",            0, cmd_set,            0 },
+        { "transfer",       0, cmd_transfer,       0 },
         { "yes",            0, cmd_yesno,          0 },
-        { "no",             0, cmd_yesno,          0 },
-        { "blist",          0, cmd_blist,          0 },
-        { "nick",           1, cmd_nick,           0 },
-        { "qlist",          0, cmd_qlist,          0 },
-        { "join_chat",      2, cmd_join_chat,      0 },
-        { "chat",           1, cmd_chat,           0 },
-        { "transfer",       0, cmd_transfer,       0 },
         { NULL }
 };

set.c

-                      r560d0a0
+                      rf1cea66
         while( s )
+        {
+                if( g_strcasecmp( s->key, key ) == 0 )
+                if( g_strcasecmp( s->key, key ) == 0 ||
+                    ( s->old_key && g_strcasecmp( s->old_key, key ) == 0 ) )
                         break;
                 s = s->next;
 …
                 g_free( s->key );
+                if( s->value ) g_free( s->value );
+                if( s->def ) g_free( s->def );
+                g_free( s->old_key );
+                g_free( s->value );
+                g_free( s->def );
                 g_free( s );
+        }
 …
+}
+/*
 char *set_eval_ops( set_t *set, char *value )
+{
 …
         return value;
+}
+*/

set.h

r560d0a0	rf1cea66
54	54
55	55	char *key;
	56	char old_key; / Previously known as; for smooth upgrades. */
56	57	char *value;
57	58	char def; / Default value. If the set_setstr() function

storage_xml.c

-                      r560d0a0
+                      rf1cea66
                                          arc_decode( pass_cr, pass_len, &password, xd->given_pass ) )
+                {
                         xd->current_account = account_add( irc, prpl, handle, password );
+                        xd->current_account = account_add( irc->b, prpl, handle, password );
                         if( server )
                                 set_setstr( &xd->current_account->set, "server", server );
 …
                                 xd->current_set_head = &xd->current_account->set;
                         else
                                 xd->current_set_head = &xd->irc->set;
+                                xd->current_set_head = &xd->irc->b->set;
                         xd->current_setting = g_strdup( setting );
 …
                 if( xd->current_account && handle && channel )
+                {
                         xd->current_chat = chat_add( xd->irc, xd->current_account, handle, channel );
+                        //xd->current_chat = chat_add( xd->irc, xd->current_account, handle, channel );
+                }
                 else
 …
 static storage_status_t xml_load( irc_t *irc, const char *password )
+{
         return xml_load_real( irc, irc->nick, password, XML_PASS_UNKNOWN );
+        return xml_load_real( irc, irc->user->nick, password, XML_PASS_UNKNOWN );
+}
 …
         md5_state_t md5_state;
         path2 = g_strdup( irc->nick );
+        path2 = g_strdup( irc->user->nick );
         nick_lc( path2 );
         g_snprintf( path, sizeof( path ) - 2, "%s%s%s", global.conf->configdir, path2, ".xml" );
 …
         pass_buf = base64_encode( pass_md5, 21 );
         if( !xml_printf( fd, 0, "<user nick=\"%s\" password=\"%s\" version=\"%d\">\n", irc->nick, pass_buf, XML_FORMAT_VERSION ) )
+        if( !xml_printf( fd, 0, "<user nick=\"%s\" password=\"%s\" version=\"%d\">\n", irc->user->nick, pass_buf, XML_FORMAT_VERSION ) )
                 goto write_error;
         g_free( pass_buf );
         for( set = irc->set; set; set = set->next )
+        for( set = irc->b->set; set; set = set->next )
                 if( set->value )
                         if( !xml_printf( fd, 1, "<setting name=\"%s\">%s</setting>\n", set->key, set->value ) )
                                 goto write_error;
         for( acc = irc->accounts; acc; acc = acc->next )
+        for( acc = irc->b->accounts; acc; acc = acc->next )
+        {
                 unsigned char *pass_cr;
 …
                         goto write_error;
+#if 0
                 for( c = irc->chatrooms; c; c = c->next )
+                {
 …
                                 goto write_error;
+                }
+#endif
                 if( !xml_printf( fd, 1, "</account>\n" ) )

Context Navigation

Changes in / [560d0a0:f1cea66]

Legend:

Download in other formats: