Changes in / [9299891:46d4230]


Ignore:
Files:
1 added
27 edited

Legend:

Unmodified
Added
Removed
  • account.c

    r9299891 r46d4230  
    182182        account_t *a, *l = NULL;
    183183       
    184         if( acc->ic )
    185                 /* Caller should have checked, accounts still in use can't be deleted. */
    186                 return;
    187        
    188184        for( a = irc->accounts; a; a = (l=a)->next )
    189185                if( a == acc )
    190186                {
     187                        if( a->ic ) return; /* Caller should have checked, accounts still in use can't be deleted. */
     188                       
    191189                        if( l )
     190                        {
    192191                                l->next = a->next;
     192                        }
    193193                        else
     194                        {
    194195                                irc->accounts = a->next;
     196                        }
    195197                       
    196198                        while( a->set )
     
    201203                        g_free( a->user );
    202204                        g_free( a->pass );
    203                         g_free( a->server );
     205                        if( a->server ) g_free( a->server );
    204206                        if( a->reconnect )      /* This prevents any reconnect still queued to happen */
    205207                                cancel_auto_reconnect( a );
  • bitlbee.c

    r9299891 r46d4230  
    5454        ;
    5555
    56         i = getaddrinfo( global.conf->iface_in, global.conf->port, &hints, &addrinfo_bind );
     56        i = getaddrinfo( global.conf->iface, global.conf->port, &hints, &addrinfo_bind );
    5757        if( i )
    5858        {
    5959                log_message( LOGLVL_ERROR, "Couldn't parse address `%s': %s",
    60                                            global.conf->iface_in, gai_strerror(i) );
     60                                           global.conf->iface, gai_strerror(i) );
    6161                return -1;
    6262        }
     
    226226        if( st == size )
    227227        {
     228                g_free( irc->sendbuffer );
     229                irc->sendbuffer = NULL;
     230                irc->w_watch_source_id = 0;
     231               
    228232                if( irc->status & USTATUS_SHUTDOWN )
    229                 {
    230233                        irc_free( irc );
    231                 }
    232                 else
    233                 {
    234                         g_free( irc->sendbuffer );
    235                         irc->sendbuffer = NULL;
    236                         irc->w_watch_source_id = 0;
    237                 }
    238234               
    239235                return FALSE;
  • bitlbee.conf

    r9299891 r46d4230  
    3434# DaemonInterface = 0.0.0.0
    3535# DaemonPort = 6667
    36 
    37 ## ClientInterface:
    38 ##
    39 ## If for any reason, you want BitlBee to use a specific address/interface
    40 ## for outgoing traffic (IM connections, HTTP(S), etc.), set it here.
    41 ##
    42 # ClientInterface = 0.0.0.0
    4336
    4437## AuthMode
  • bitlbee.h

    r9299891 r46d4230  
    160160gboolean bitlbee_shutdown( gpointer data, gint fd, b_input_condition cond );
    161161
    162 char *set_eval_root_nick( set_t *set, char *new_nick );
    163 
    164162extern global_t global;
    165163
  • conf.c

    r9299891 r46d4230  
    4545        conf = g_new0( conf_t, 1 );
    4646       
    47         conf->iface_in = NULL;
    48         conf->iface_out = NULL;
     47        conf->iface = NULL;
    4948        conf->port = g_strdup( "6667" );
    5049        conf->nofork = 0;
     
    8382                if( opt == 'i' )
    8483                {
    85                         conf->iface_in = g_strdup( optarg );
     84                        conf->iface = g_strdup( optarg );
    8685                }
    8786                else if( opt == 'p' )
     
    203202                        else if( g_strcasecmp( ini->key, "daemoninterface" ) == 0 )
    204203                        {
    205                                 g_free( conf->iface_in );
    206                                 conf->iface_in = g_strdup( ini->value );
     204                                g_free( conf->iface );
     205                                conf->iface = g_strdup( ini->value );
    207206                        }
    208207                        else if( g_strcasecmp( ini->key, "daemonport" ) == 0 )
     
    210209                                g_free( conf->port );
    211210                                conf->port = g_strdup( ini->value );
    212                         }
    213                         else if( g_strcasecmp( ini->key, "clientinterface" ) == 0 )
    214                         {
    215                                 g_free( conf->iface_out );
    216                                 conf->iface_out = g_strdup( ini->value );
    217211                        }
    218212                        else if( g_strcasecmp( ini->key, "authmode" ) == 0 )
  • conf.h

    r9299891 r46d4230  
    3232typedef struct conf
    3333{
    34         char *iface_in, *iface_out;
     34        char *iface;
    3535        char *port;
    3636        int nofork;
  • doc/CHANGES

    r9299891 r46d4230  
    1 Version 1.2.1:
    2 - Fixed proxy support.
    3 - Fixed stalling issues while connecting to Jabber when using the OpenSSL
    4   module.
    5 - Fixed problem with GLib and ForkDaemon where processes didn't die when
    6   the client disconnects.
    7 - Fixed handling of "set charset none". (Which pretty much breaks the account
    8   completely in 1.2.)
    9 - You can now automatically identify yourself to BitlBee by setting a server
    10   password in your IRC client.
    11 - Compatible with all crazy kinds of line endings that clients can send.
    12 
    13 Finished ...
    14 
    151Version 1.2:
    162- Added ForkDaemon mode next to the existing Daemon- and inetd modes. With
  • doc/user-guide/commands.xml

    r9299891 r46d4230  
    589589        </bitlbee-setting>
    590590
    591         <bitlbee-setting name="root_nick" type="string" scope="global">
    592                 <default>root</default>
    593 
    594                 <description>
    595                         <para>
    596                                 Normally the "bot" that takes all your BitlBee commands is called "root". If you don't like this name, you can rename it to anything else using the <emphasis>rename</emphasis> command, or by changing this setting.
    597                         </para>
    598                 </description>
    599         </bitlbee-setting>
    600 
    601591        <bitlbee-setting name="save_on_quit" type="boolean" scope="global">
    602592                <default>true</default>
  • irc.c

    r9299891 r46d4230  
    4242}
    4343
    44 static char *set_eval_charset( set_t *set, char *value )
    45 {
    46         irc_t *irc = set->data;
    47         GIConv ic, oc;
    48 
    49         if( g_strcasecmp( value, "none" ) == 0 )
    50                 value = g_strdup( "utf-8" );
    51 
    52         if( ( ic = g_iconv_open( "utf-8", value ) ) == (GIConv) -1 )
    53         {
    54                 return NULL;
    55         }
    56         if( ( oc = g_iconv_open( value, "utf-8" ) ) == (GIConv) -1 )
    57         {
    58                 g_iconv_close( ic );
    59                 return NULL;
    60         }
    61        
    62         if( irc->iconv != (GIConv) -1 )
    63                 g_iconv_close( irc->iconv );
    64         if( irc->oconv != (GIConv) -1 )
    65                 g_iconv_close( irc->oconv );
    66        
    67         irc->iconv = ic;
    68         irc->oconv = oc;
    69 
    70         return value;
    71 }
    72 
    7344irc_t *irc_new( int fd )
    7445{
     
    9364        irc->mynick = g_strdup( ROOT_NICK );
    9465        irc->channel = g_strdup( ROOT_CHAN );
    95        
    96         irc->iconv = (GIConv) -1;
    97         irc->oconv = (GIConv) -1;
    9866       
    9967        if( global.conf->hostname )
     
    151119        set_add( &irc->set, "private", "true", set_eval_bool, irc );
    152120        set_add( &irc->set, "query_order", "lifo", NULL, irc );
    153         set_add( &irc->set, "root_nick", irc->mynick, set_eval_root_nick, irc );
    154121        set_add( &irc->set, "save_on_quit", "true", set_eval_bool, irc );
    155122        set_add( &irc->set, "simulate_netsplit", "true", set_eval_bool, irc );
     
    160127        conf_loaddefaults( irc );
    161128       
    162         /* Evaluator sets the iconv/oconv structures. */
    163         set_eval_charset( set_find( &irc->set, "charset" ), set_getstr( &irc->set, "charset" ) );
    164        
    165129        return( irc );
    166130}
     
    200164        if( irc->sendbuffer && !immed )
    201165        {
    202                 /* Set up a timeout event that should shut down the connection
    203                    in a second, just in case ..._write doesn't do it first. */
     166                /* We won't read from this socket anymore. Instead, we'll connect a timer
     167                   to it that should shut down the connection in a second, just in case
     168                   bitlbee_.._write doesn't do it first. */
    204169               
    205170                b_event_remove( irc->r_watch_source_id );
    206                 irc->r_watch_source_id = 0;
    207                
    208                 b_event_remove( irc->ping_source_id );
    209                 irc->ping_source_id = b_timeout_add( 1000, (b_event_handler) irc_free, irc );
     171                irc->r_watch_source_id = b_timeout_add( 1000, (b_event_handler) irc_free, irc );
    210172        }
    211173        else
     
    223185
    224186/* Because we have no garbage collection, this is quite annoying */
    225 void irc_free( irc_t * irc )
    226 {
     187void irc_free(irc_t * irc)
     188{
     189        account_t *account;
    227190        user_t *user, *usertmp;
    228191       
     
    233196                        irc_usermsg( irc, "Error while saving settings!" );
    234197       
     198        closesocket( irc->fd );
     199       
     200        if( irc->ping_source_id > 0 )
     201                b_event_remove( irc->ping_source_id );
     202        b_event_remove( irc->r_watch_source_id );
     203        if( irc->w_watch_source_id > 0 )
     204                b_event_remove( irc->w_watch_source_id );
     205       
    235206        irc_connection_list = g_slist_remove( irc_connection_list, irc );
    236207       
    237         while( irc->accounts )
    238         {
    239                 if( irc->accounts->ic )
    240                         imc_logout( irc->accounts->ic, FALSE );
    241                 else if( irc->accounts->reconnect )
    242                         cancel_auto_reconnect( irc->accounts );
    243                
    244                 if( irc->accounts->ic == NULL )
    245                         account_del( irc, irc->accounts );
     208        for (account = irc->accounts; account; account = account->next) {
     209                if (account->ic) {
     210                        imc_logout(account->ic, TRUE);
     211                } else if (account->reconnect) {
     212                        cancel_auto_reconnect(account);
     213                }
     214        }
     215       
     216        g_free(irc->sendbuffer);
     217        g_free(irc->readbuffer);
     218       
     219        g_free(irc->nick);
     220        g_free(irc->user);
     221        g_free(irc->host);
     222        g_free(irc->realname);
     223        g_free(irc->password);
     224       
     225        g_free(irc->myhost);
     226        g_free(irc->mynick);
     227       
     228        g_free(irc->channel);
     229       
     230        while (irc->queries != NULL)
     231                query_del(irc, irc->queries);
     232       
     233        while (irc->accounts)
     234                if (irc->accounts->ic == NULL)
     235                        account_del(irc, irc->accounts);
    246236                else
    247237                        /* Nasty hack, but account_del() doesn't work in this
    248238                           case and we don't want infinite loops, do we? ;-) */
    249239                        irc->accounts = irc->accounts->next;
    250         }
    251        
    252         while( irc->queries != NULL )
    253                 query_del( irc, irc->queries );
    254        
    255         while( irc->set )
    256                 set_del( &irc->set, irc->set->key );
    257        
    258         if (irc->users != NULL)
    259         {
     240       
     241        while (irc->set)
     242                set_del(&irc->set, irc->set->key);
     243       
     244        if (irc->users != NULL) {
    260245                user = irc->users;
    261                 while( user != NULL )
    262                 {
    263                         g_free( user->nick );
    264                         g_free( user->away );
    265                         g_free( user->handle );
    266                         if( user->user != user->nick ) g_free( user->user );
    267                         if( user->host != user->nick ) g_free( user->host );
    268                         if( user->realname != user->nick ) g_free( user->realname );
    269                         b_event_remove( user->sendbuf_timer );
     246                while (user != NULL) {
     247                        g_free(user->nick);
     248                        g_free(user->away);
     249                        g_free(user->handle);
     250                        if(user->user!=user->nick) g_free(user->user);
     251                        if(user->host!=user->nick) g_free(user->host);
     252                        if(user->realname!=user->nick) g_free(user->realname);
     253                        b_event_remove(user->sendbuf_timer);
    270254                                       
    271255                        usertmp = user;
    272256                        user = user->next;
    273                         g_free( usertmp );
    274                 }
    275         }
    276        
    277         if( irc->ping_source_id > 0 )
    278                 b_event_remove( irc->ping_source_id );
    279         if( irc->r_watch_source_id > 0 )
    280                 b_event_remove( irc->r_watch_source_id );
    281         if( irc->w_watch_source_id > 0 )
    282                 b_event_remove( irc->w_watch_source_id );
    283        
    284         closesocket( irc->fd );
    285         irc->fd = -1;
    286        
    287         g_hash_table_foreach_remove( irc->userhash, irc_free_hashkey, NULL );
    288         g_hash_table_destroy( irc->userhash );
    289        
    290         g_hash_table_foreach_remove( irc->watches, irc_free_hashkey, NULL );
    291         g_hash_table_destroy( irc->watches );
    292        
    293         if( irc->iconv != (GIConv) -1 )
    294                 g_iconv_close( irc->iconv );
    295         if( irc->oconv != (GIConv) -1 )
    296                 g_iconv_close( irc->oconv );
    297        
    298         g_free( irc->sendbuffer );
    299         g_free( irc->readbuffer );
    300        
    301         g_free( irc->nick );
    302         g_free( irc->user );
    303         g_free( irc->host );
    304         g_free( irc->realname );
    305         g_free( irc->password );
    306        
    307         g_free( irc->myhost );
    308         g_free( irc->mynick );
    309        
    310         g_free( irc->channel );
    311        
    312         g_free( irc->last_target );
    313        
    314         g_free( irc );
     257                        g_free(usertmp);
     258                }
     259        }
     260       
     261        g_hash_table_foreach_remove(irc->userhash, irc_free_hashkey, NULL);
     262        g_hash_table_destroy(irc->userhash);
     263       
     264        g_hash_table_foreach_remove(irc->watches, irc_free_hashkey, NULL);
     265        g_hash_table_destroy(irc->watches);
     266       
     267        g_free(irc);
    315268       
    316269        if( global.conf->runmode == RUNMODE_INETD || global.conf->runmode == RUNMODE_FORKDAEMON )
     
    333286void irc_process( irc_t *irc )
    334287{
    335         char **lines, *temp, **cmd;
     288        char **lines, *temp, **cmd, *cs;
    336289        int i;
    337290
     
    342295                for( i = 0; *lines[i] != '\0'; i ++ )
    343296                {
    344                         char *conv = NULL;
     297                        char conv[IRC_MAX_LINE+1];
    345298                       
    346                         /* [WvG] If the last line isn't empty, it's an incomplete line and we
    347                            should wait for the rest to come in before processing it. */
     299                        /* [WvG] Because irc_tokenize splits at every newline, the lines[] list
     300                            should end with an empty string. This is why this actually works.
     301                            Took me a while to figure out, Maurits. :-P */
    348302                        if( lines[i+1] == NULL )
    349303                        {
     
    355309                        }
    356310                       
    357                         if( irc->iconv != (GIConv) -1 )
     311                        if( ( cs = set_getstr( &irc->set, "charset" ) ) && g_strcasecmp( cs, "none" ) != 0 )
    358312                        {
    359                                 gsize bytes_read, bytes_written;
    360                                
    361                                 conv = g_convert_with_iconv( lines[i], -1, irc->iconv,
    362                                                              &bytes_read, &bytes_written, NULL );
    363                                
    364                                 if( conv == NULL || bytes_read != strlen( lines[i] ) )
     313                                conv[IRC_MAX_LINE] = 0;
     314                                if( do_iconv( cs, "UTF-8", lines[i], conv, 0, IRC_MAX_LINE - 2 ) == -1 )
    365315                                {
    366316                                        /* GLib can do strange things if things are not in the expected charset,
     
    374324                                                                  "expect by changing the charset setting. See "
    375325                                                                  "`help set charset' for more information. Your "
    376                                                                   "message was ignored.",
    377                                                                   set_getstr( &irc->set, "charset" ) );
    378                                                
    379                                                 g_free( conv );
    380                                                 conv = NULL;
     326                                                                  "message was ignored.", cs );
     327                                                *conv = 0;
    381328                                        }
    382329                                        else
     
    385332                                                           "Warning: invalid characters received at login time." );
    386333                                               
    387                                                 conv = g_strdup( lines[i] );
     334                                                strncpy( conv, lines[i], IRC_MAX_LINE );
    388335                                                for( temp = conv; *temp; temp ++ )
    389336                                                        if( *temp & 0x80 )
     
    394341                        }
    395342                       
    396                         if( lines[i] )
    397                         {
    398                                 if( ( cmd = irc_parse_line( lines[i] ) ) == NULL )
    399                                         continue;
    400                                 irc_exec( irc, cmd );
    401                                 g_free( cmd );
    402                         }
     343                        if( ( cmd = irc_parse_line( lines[i] ) ) == NULL )
     344                                continue;
     345                        irc_exec( irc, cmd );
    403346                       
    404                         g_free( conv );
     347                        g_free( cmd );
    405348                       
    406349                        /* Shouldn't really happen, but just in case... */
     
    426369char **irc_tokenize( char *buffer )
    427370{
    428         int i, j, n = 3;
     371        int i, j;
    429372        char **lines;
    430373
    431         /* Allocate n+1 elements. */
    432         lines = g_new( char *, n + 1 );
     374        /* Count the number of elements we're gonna need. */
     375        for( i = 0, j = 1; buffer[i] != '\0'; i ++ )
     376        {
     377                if( buffer[i] == '\n' )
     378                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
     379                                j ++;
     380        }
     381       
     382        /* Allocate j+1 elements. */
     383        lines = g_new( char *, j + 1 );
     384       
     385        /* NULL terminate our list. */
     386        lines[j] = NULL;
    433387       
    434388        lines[0] = buffer;
    435389       
    436         /* Split the buffer in several strings, and accept any kind of line endings,
    437          * knowing that ERC on Windows may send something interesting like \r\r\n,
    438          * and surely there must be clients that think just \n is enough... */
    439         for( i = 0, j = 0; buffer[i] != '\0'; i ++ )
    440         {
    441                 if( buffer[i] == '\r' || buffer[i] == '\n' )
    442                 {
    443                         while( buffer[i] == '\r' || buffer[i] == '\n' )
    444                                 buffer[i++] = '\0';
     390        /* Split the buffer in several strings, using \r\n as our seperator, where \r is optional.
     391         * Although this is not in the RFC, some braindead ircds (newnet's) use this, so some clients might too.
     392         */
     393        for( i = 0, j = 0; buffer[i] != '\0'; i ++)
     394        {
     395                if( buffer[i] == '\n' )
     396                {
     397                        buffer[i] = '\0';
    445398                       
    446                         lines[++j] = buffer + i;
    447                        
    448                         if( j >= n )
    449                         {
    450                                 n *= 2;
    451                                 lines = g_renew( char *, lines, n + 1 );
    452                         }
    453 
    454                         if( buffer[i] == '\0' )
    455                                 break;
    456                 }
    457         }
    458        
    459         /* NULL terminate our list. */
    460         lines[++j] = NULL;
    461        
    462         return lines;
     399                        if( i > 0 && buffer[i-1] == '\r' )
     400                                buffer[i-1] = '\0';
     401                        if( buffer[i+1] != '\r' && buffer[i+1] != '\n' )
     402                                lines[++j] = buffer + i + 1;
     403                }
     404        }
     405       
     406        return( lines );
    463407}
    464408
     
    594538
    595539        return;
     540
    596541}
    597542
     
    599544{
    600545        int size;
    601         char line[IRC_MAX_LINE+1];
     546        char line[IRC_MAX_LINE+1], *cs;
    602547               
    603548        /* Don't try to write anything new anymore when shutting down. */
     
    605550                return;
    606551       
    607         memset( line, 0, sizeof( line ) );
     552        line[IRC_MAX_LINE] = 0;
    608553        g_vsnprintf( line, IRC_MAX_LINE - 2, format, params );
     554       
    609555        strip_newlines( line );
    610        
    611         if( irc->oconv != (GIConv) -1 )
    612         {
    613                 gsize bytes_read, bytes_written;
    614                 char *conv;
    615                
    616                 conv = g_convert_with_iconv( line, -1, irc->oconv,
    617                                              &bytes_read, &bytes_written, NULL );
    618 
    619                 if( bytes_read == strlen( line ) )
    620                         strncpy( line, conv, IRC_MAX_LINE - 2 );
    621                
    622                 g_free( conv );
    623         }
    624         g_strlcat( line, "\r\n", IRC_MAX_LINE + 1 );
     556        if( ( cs = set_getstr( &irc->set, "charset" ) ) &&
     557            g_strcasecmp( cs, "none" ) != 0 && g_strcasecmp( cs, "utf-8" ) != 0 )
     558        {
     559                char conv[IRC_MAX_LINE+1];
     560               
     561                conv[IRC_MAX_LINE] = 0;
     562                if( do_iconv( "UTF-8", cs, line, conv, 0, IRC_MAX_LINE - 2 ) != -1 )
     563                        strcpy( line, conv );
     564        }
     565        strcat( line, "\r\n" );
    625566       
    626567        if( irc->sendbuffer != NULL )
     
    795736        irc_spawn( irc, u );
    796737       
    797         irc_usermsg( irc, "Welcome to the BitlBee gateway!\n\n"
    798                           "If you've never used BitlBee before, please do read the help "
    799                           "information using the \x02help\x02 command. Lots of FAQs are "
    800                           "answered there.\n"
    801                           "If you already have an account on this server, just use the "
    802                           "\x02identify\x02 command to identify yourself." );
     738        irc_usermsg( irc, "Welcome to the BitlBee gateway!\n\nIf you've never used BitlBee before, please do read the help information using the \x02help\x02 command. Lots of FAQs are answered there." );
    803739       
    804740        if( global.conf->runmode == RUNMODE_FORKDAEMON || global.conf->runmode == RUNMODE_DAEMON )
     
    806742       
    807743        irc->status |= USTATUS_LOGGED_IN;
    808        
    809         /* This is for bug #209 (use PASS to identify to NickServ). */
    810         if( irc->password != NULL )
    811         {
    812                 char *send_cmd[] = { "identify", g_strdup( irc->password ), NULL };
    813                
    814                 irc_setpass( irc, NULL );
    815                 root_command( irc, send_cmd );
    816                 g_free( send_cmd[1] );
    817         }
    818744}
    819745
  • irc.h

    r9299891 r46d4230  
    6161        char *sendbuffer;
    6262        char *readbuffer;
    63         GIConv iconv, oconv;
    6463
    6564        int sentbytes;
     
    7069        char *host;
    7170        char *realname;
    72         char *password; /* HACK: Used to save the user's password, but before
    73                            logging in, this may contain a password we should
    74                            send to identify after USER/NICK are received. */
     71        char *password;
    7572
    7673        char umode[8];
  • irc_commands.c

    r9299891 r46d4230  
    3030static void irc_cmd_pass( irc_t *irc, char **cmd )
    3131{
    32         if( irc->status & USTATUS_LOGGED_IN )
    33         {
    34                 char *send_cmd[] = { "identify", cmd[1], NULL };
    35                
    36                 /* We're already logged in, this client seems to send the PASS
    37                    command last. (Possibly it won't send it at all if it turns
    38                    out we don't require it, which will break this feature.)
    39                    Try to identify using the given password. */
    40                 return root_command( irc, send_cmd );
    41         }
    42         /* Handling in pre-logged-in state, first see if this server is
    43            password-protected: */
    44         else if( global.conf->auth_pass &&
     32        if( global.conf->auth_pass &&
    4533            ( strncmp( global.conf->auth_pass, "md5:", 4 ) == 0 ?
    4634                md5_verify_password( cmd[1], global.conf->auth_pass + 4 ) == 0 :
     
    5038                irc_check_login( irc );
    5139        }
    52         else if( global.conf->auth_pass )
     40        else
    5341        {
    5442                irc_reply( irc, 464, ":Incorrect password" );
    55         }
    56         else
    57         {
    58                 /* Remember the password and try to identify after USER/NICK. */
    59                 irc_setpass( irc, cmd[1] );
    60                 irc_check_login( irc );
    6143        }
    6244}
     
    278260                        if( cmd[1] != irc->last_target )
    279261                        {
    280                                 g_free( irc->last_target );
     262                                if( irc->last_target )
     263                                        g_free( irc->last_target );
    281264                                irc->last_target = g_strdup( cmd[1] );
    282265                        }
     
    598581
    599582static const command_t irc_commands[] = {
    600         { "pass",        1, irc_cmd_pass,        0 },
     583        { "pass",        1, irc_cmd_pass,        IRC_CMD_PRE_LOGIN },
    601584        { "user",        4, irc_cmd_user,        IRC_CMD_PRE_LOGIN },
    602585        { "nick",        1, irc_cmd_nick,        0 },
  • lib/arc.h

    r9299891 r46d4230  
    3131};
    3232
    33 #ifndef G_GNUC_MALLOC
    34 #define G_GNUC_MALLOC
    35 #endif
    36 
    3733G_GNUC_MALLOC struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles );
    3834unsigned char arc_getbyte( struct arc_state *st );
  • lib/proxy.c

    r9299891 r46d4230  
    114114{
    115115        struct sockaddr_in *sin;
    116         struct sockaddr_in me;
    117116        int fd = -1;
    118117
     
    128127
    129128        sock_make_nonblocking(fd);
    130        
    131         if( global.conf->iface_out )
    132         {
    133                 me.sin_family = AF_INET;
    134                 me.sin_port = 0;
    135                 me.sin_addr.s_addr = inet_addr( global.conf->iface_out );
    136                
    137                 if( bind( fd, (struct sockaddr *) &me, sizeof( me ) ) != 0 )
    138                         event_debug( "bind( %d, \"%s\" ) failure\n", fd, global.conf->iface_out );
    139         }
    140129       
    141130        event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port, fd);
  • protocols/jabber/jabber_util.c

    r9299891 r46d4230  
    246246};
    247247
    248 static void jabber_buddy_ask_yes( void *data )
    249 {
    250         struct jabber_buddy_ask_data *bla = data;
    251        
     248static void jabber_buddy_ask_yes( gpointer w, struct jabber_buddy_ask_data *bla )
     249{
    252250        presence_send_request( bla->ic, bla->handle, "subscribed" );
    253251       
     
    259257}
    260258
    261 static void jabber_buddy_ask_no( void *data )
    262 {
    263         struct jabber_buddy_ask_data *bla = data;
    264        
     259static void jabber_buddy_ask_no( gpointer w, struct jabber_buddy_ask_data *bla )
     260{
    265261        presence_send_request( bla->ic, bla->handle, "subscribed" );
    266262       
  • protocols/msn/msn.h

    r9299891 r46d4230  
    2929#define GROUPCHAT_SWITCHBOARD_MESSAGE "\r\r\rME WANT TALK TO MANY PEOPLE\r\r\r"
    3030
    31 #ifdef DEBUG_MSN
     31#ifdef DEBUG
    3232#define debug( text... ) imcb_log( ic, text );
    3333#else
  • protocols/msn/msn_util.c

    r9299891 r46d4230  
    9090};
    9191
    92 static void msn_buddy_ask_yes( void *data )
    93 {
    94         struct msn_buddy_ask_data *bla = data;
    95        
     92static void msn_buddy_ask_yes( gpointer w, struct msn_buddy_ask_data *bla )
     93{
    9694        msn_buddy_list_add( bla->ic, "AL", bla->handle, bla->realname );
    9795       
     
    104102}
    105103
    106 static void msn_buddy_ask_no( void *data )
    107 {
    108         struct msn_buddy_ask_data *bla = data;
    109        
     104static void msn_buddy_ask_no( gpointer w, struct msn_buddy_ask_data *bla )
     105{
    110106        msn_buddy_list_add( bla->ic, "BL", bla->handle, bla->realname );
    111107       
  • protocols/msn/ns.c

    r9299891 r46d4230  
    178178                       
    179179                        debug( "Connecting to a new switchboard with key %s", cmd[5] );
    180 
    181                         if( ( sb = msn_sb_create( ic, server, port, cmd[5], MSN_SB_NEW ) ) == NULL )
    182                         {
    183                                 /* Although this isn't strictly fatal for the NS connection, it's
    184                                    definitely something serious (we ran out of file descriptors?). */
    185                                 imcb_error( ic, "Could not create new switchboard" );
    186                                 imc_logout( ic, TRUE );
    187                                 return( 0 );
    188                         }
     180                        sb = msn_sb_create( ic, server, port, cmd[5], MSN_SB_NEW );
    189181                       
    190182                        if( md->msgq )
     
    476468                debug( "Got a call from %s (session %d). Key = %s", cmd[5], session, cmd[4] );
    477469               
    478                 if( ( sb = msn_sb_create( ic, server, port, cmd[4], session ) ) == NULL )
    479                 {
    480                         /* Although this isn't strictly fatal for the NS connection, it's
    481                            definitely something serious (we ran out of file descriptors?). */
    482                         imcb_error( ic, "Could not create new switchboard" );
    483                         imc_logout( ic, TRUE );
    484                         return( 0 );
    485                 }
    486                 else
    487                 {
    488                         sb->who = g_strdup( cmd[5] );
    489                 }
     470                sb = msn_sb_create( ic, server, port, cmd[4], session );
     471                sb->who = g_strdup( cmd[5] );
    490472        }
    491473        else if( strcmp( cmd[0], "ADD" ) == 0 )
  • protocols/nogaim.c

    r9299891 r46d4230  
    343343/* dialogs.c */
    344344
    345 void imcb_ask( struct im_connection *ic, char *msg, void *data,
    346                query_callback doit, query_callback dont )
     345void imcb_ask( struct im_connection *ic, char *msg, void *data, void *doit, void *dont )
    347346{
    348347        query_add( ic->irc, ic, msg, doit, dont, data );
     
    496495};
    497496
    498 void show_got_added_no( void *data )
    499 {
    500         g_free( ((struct show_got_added_data*)data)->handle );
     497void show_got_added_no( gpointer w, struct show_got_added_data *data )
     498{
     499        g_free( data->handle );
    501500        g_free( data );
    502501}
    503502
    504 void show_got_added_yes( void *data )
    505 {
    506         struct show_got_added_data *sga = data;
    507        
    508         sga->ic->acc->prpl->add_buddy( sga->ic, sga->handle, NULL );
    509         /* imcb_add_buddy( sga->ic, NULL, sga->handle, sga->handle ); */
    510        
    511         return show_got_added_no( data );
     503void show_got_added_yes( gpointer w, struct show_got_added_data *data )
     504{
     505        data->ic->acc->prpl->add_buddy( data->ic, data->handle, NULL );
     506        /* imcb_add_buddy( data->ic, NULL, data->handle, data->handle ); */
     507       
     508        return show_got_added_no( w, data );
    512509}
    513510
  • protocols/nogaim.h

    r9299891 r46d4230  
    4242#include "account.h"
    4343#include "proxy.h"
    44 #include "query.h"
    4544#include "md5.h"
    4645
     
    262261 * - 'doit' or 'dont' will be called depending of the answer of the user.
    263262 */
    264 G_MODULE_EXPORT void imcb_ask( struct im_connection *ic, char *msg, void *data, query_callback doit, query_callback dont );
     263G_MODULE_EXPORT void imcb_ask( struct im_connection *ic, char *msg, void *data, void *doit, void *dont );
    265264G_MODULE_EXPORT void imcb_ask_add( struct im_connection *ic, char *handle, const char *realname );
    266265
  • protocols/oscar/oscar.c

    r9299891 r46d4230  
    10841084}
    10851085
    1086 void oscar_accept_chat(void *data);
    1087 void oscar_reject_chat(void *data);
     1086void oscar_accept_chat(gpointer w, struct aim_chat_invitation * inv);
     1087void oscar_reject_chat(gpointer w, struct aim_chat_invitation * inv);
    10881088       
    10891089static int incomingim_chan2(aim_session_t *sess, aim_conn_t *conn, aim_userinfo_t *userinfo, struct aim_incomingim_ch2_args *args) {
     
    11191119}
    11201120
    1121 static void gaim_icq_authgrant(void *data_) {
    1122         struct icq_auth *data = data_;
     1121static void gaim_icq_authgrant(gpointer w, struct icq_auth *data) {
    11231122        char *uin, message;
    11241123        struct oscar_data *od = (struct oscar_data *)data->ic->proto_data;
     
    11351134}
    11361135
    1137 static void gaim_icq_authdeny(void *data_) {
    1138         struct icq_auth *data = data_;
     1136static void gaim_icq_authdeny(gpointer w, struct icq_auth *data) {
    11391137        char *uin, *message;
    11401138        struct oscar_data *od = (struct oscar_data *)data->ic->proto_data;
     
    25902588}
    25912589
    2592 void oscar_accept_chat(void *data)
     2590void oscar_accept_chat(gpointer w, struct aim_chat_invitation * inv)
    25932591{
    2594         struct aim_chat_invitation * inv = data;
    2595        
    25962592        oscar_chat_join(inv->ic, inv->name, NULL, NULL);
    25972593        g_free(inv->name);
     
    25992595}
    26002596
    2601 void oscar_reject_chat(void *data)
     2597void oscar_reject_chat(gpointer w, struct aim_chat_invitation * inv)
    26022598{
    2603         struct aim_chat_invitation * inv = data;
    2604        
    26052599        g_free(inv->name);
    26062600        g_free(inv);
  • protocols/yahoo/yahoo.c

    r9299891 r46d4230  
    797797}
    798798
    799 static void byahoo_accept_conf( void *data )
    800 {
    801         struct byahoo_conf_invitation *inv = data;
    802        
     799static void byahoo_accept_conf( gpointer w, struct byahoo_conf_invitation *inv )
     800{
    803801        yahoo_conference_logon( inv->yid, NULL, inv->members, inv->name );
    804802        imcb_chat_add_buddy( inv->c, inv->ic->acc->user );
     
    807805}
    808806
    809 static void byahoo_reject_conf( void *data )
    810 {
    811         struct byahoo_conf_invitation *inv = data;
    812        
     807static void byahoo_reject_conf( gpointer w, struct byahoo_conf_invitation *inv )
     808{
    813809        yahoo_conference_decline( inv->yid, NULL, inv->members, inv->name, "User rejected groupchat" );
    814810        imcb_chat_free( inv->c );
  • query.c

    r9299891 r46d4230  
    3030static query_t *query_default( irc_t *irc );
    3131
    32 query_t *query_add( irc_t *irc, struct im_connection *ic, char *question,
    33                     query_callback yes, query_callback no, void *data )
     32query_t *query_add( irc_t *irc, struct im_connection *ic, char *question, void *yes, void *no, void *data )
    3433{
    3534        query_t *q = g_new0( query_t, 1 );
     
    145144                else
    146145                        irc_usermsg( irc, "Accepted: %s", q->question );
    147                 q->yes( q->data );
     146                q->yes( NULL, q->data );
    148147        }
    149148        else
     
    153152                else
    154153                        irc_usermsg( irc, "Rejected: %s", q->question );
    155                 q->no( q->data );
     154                q->no( NULL, q->data );
    156155        }
    157156        q->data = NULL;
  • query.h

    r9299891 r46d4230  
    2727#define _QUERY_H
    2828
    29 typedef void (*query_callback) ( void *data );
    30 
    3129typedef struct query
    3230{
    3331        struct im_connection *ic;
    3432        char *question;
    35         query_callback yes, no;
     33        void (* yes) ( gpointer w, void *data );
     34        void (* no) ( gpointer w, void *data );
    3635        void *data;
    3736        struct query *next;
    3837} query_t;
    3938
    40 query_t *query_add( irc_t *irc, struct im_connection *ic, char *question,
    41                     query_callback yes, query_callback no, void *data );
     39query_t *query_add( irc_t *irc, struct im_connection *ic, char *question, void *yes, void *no, void *data );
    4240void query_del( irc_t *irc, query_t *q );
    4341void query_del_by_conn( irc_t *irc, struct im_connection *ic );
  • root_commands.c

    r9299891 r46d4230  
    204204}
    205205
    206 struct cmd_account_del_data
    207 {
    208         account_t *a;
    209         irc_t *irc;
    210 };
    211 
    212 void cmd_account_del_yes( void *data )
    213 {
    214         struct cmd_account_del_data *cad = data;
    215         account_t *a;
    216        
    217         for( a = cad->irc->accounts; a && a != cad->a; a = a->next );
    218        
    219         if( a == NULL )
    220         {
    221                 irc_usermsg( cad->irc, "Account already deleted" );
    222         }
    223         else if( a->ic )
    224         {
    225                 irc_usermsg( cad->irc, "Account is still logged in, can't delete" );
    226         }
    227         else
    228         {
    229                 account_del( cad->irc, a );
    230                 irc_usermsg( cad->irc, "Account deleted" );
    231         }
    232         g_free( data );
    233 }
    234 
    235 void cmd_account_del_no( void *data )
    236 {
    237         g_free( data );
     206void cmd_account_del_yes( gpointer w, void *data )
     207{
     208        account_t *a = data;
     209        irc_t *irc = a->irc;
     210       
     211        if( a->ic )
     212        {
     213                irc_usermsg( irc, "Account is still logged in, can't delete" );
     214        }
     215        else
     216        {
     217                account_del( irc, a );
     218                irc_usermsg( irc, "Account deleted" );
     219        }
     220}
     221
     222void cmd_account_del_no( gpointer w, void *data )
     223{
    238224}
    239225
     
    292278                else
    293279                {
    294                         struct cmd_account_del_data *cad;
    295280                        char *msg;
    296                        
    297                         cad = g_malloc( sizeof( struct cmd_account_del_data ) );
    298                         cad->a = a;
    299                         cad->irc = irc;
    300281                       
    301282                        msg = g_strdup_printf( "If you remove this account (%s(%s)), BitlBee will "
     
    304285                                               "set' command. Are you sure you want to delete this "
    305286                                               "account?", a->prpl->name, a->user );
    306                         query_add( irc, NULL, msg, cmd_account_del_yes, cmd_account_del_no, cad );
     287                        query_add( irc, NULL, msg, cmd_account_del_yes, cmd_account_del_no, a );
    307288                        g_free( msg );
    308289                }
     
    423404                        acc_handle = g_strdup( cmd[2] );
    424405               
    425                 if( !acc_handle )
    426                 {
    427                         irc_usermsg( irc, "Not enough parameters given (need %d)", 3 );
    428                         return;
    429                 }
    430                
    431406                if( ( tmp = strchr( acc_handle, '/' ) ) )
    432407                {
     
    609584                        g_free( irc->mynick );
    610585                        irc->mynick = g_strdup( cmd[2] );
    611                        
    612                         if( strcmp( cmd[0], "set_rename" ) != 0 )
    613                                 set_setstr( &irc->set, "root_nick", cmd[2] );
    614586                }
    615587                else if( u->send_handler == buddy_send_handler )
     
    620592                irc_usermsg( irc, "Nick successfully changed" );
    621593        }
    622 }
    623 
    624 char *set_eval_root_nick( set_t *set, char *new_nick )
    625 {
    626         irc_t *irc = set->data;
    627        
    628         if( strcmp( irc->mynick, new_nick ) != 0 )
    629         {
    630                 char *cmd[] = { "set_rename", irc->mynick, new_nick, NULL };
    631                
    632                 cmd_rename( irc, cmd );
    633         }
    634        
    635         return strcmp( irc->mynick, new_nick ) == 0 ? new_nick : NULL;
    636594}
    637595
  • set.c

    r9299891 r46d4230  
    230230        return value;
    231231}
     232
     233char *set_eval_charset( set_t *set, char *value )
     234{
     235        GIConv cd;
     236
     237        if( g_strcasecmp( value, "none" ) == 0 )
     238                return value;
     239
     240        cd = g_iconv_open( "UTF-8", value );
     241        if( cd == (GIConv) -1 )
     242                return NULL;
     243
     244        g_iconv_close( cd );
     245        return value;
     246}
  • set.h

    r9299891 r46d4230  
    9797char *set_eval_to_char( set_t *set, char *value );
    9898char *set_eval_ops( set_t *set, char *value );
     99char *set_eval_charset( set_t *set, char *value );
    99100
    100101#endif /* __SET_H__ */
  • tests/check_irc.c

    r9299891 r46d4230  
    3737        irc = irc_new(g_io_channel_unix_get_fd(ch1));
    3838
    39         fail_unless(g_io_channel_write_chars(ch2, "NICK bla\r\r\n"
    40                         "USER a a a a\n", -1, NULL, NULL) == G_IO_STATUS_NORMAL);
     39        fail_unless(g_io_channel_write_chars(ch2, "NICK bla\r\n"
     40                        "USER a a a a\r\n", -1, NULL, NULL) == G_IO_STATUS_NORMAL);
    4141        fail_unless(g_io_channel_flush(ch2, NULL) == G_IO_STATUS_NORMAL);
    4242
Note: See TracChangeset for help on using the changeset viewer.