Changes in / [881fd4e:41ca004]


Ignore:
Files:
3 added
27 edited

Legend:

Unmodified
Added
Removed
  • bitlbee.c

    r881fd4e r41ca004  
    3434#include <errno.h>
    3535
    36 gboolean bitlbee_io_new_client( GIOChannel *source, GIOCondition condition, gpointer data );
     36static gboolean bitlbee_io_new_client( gpointer data, gint fd, b_input_condition condition );
    3737
    3838int bitlbee_daemon_init()
     
    4444#endif
    4545        int i;
    46         GIOChannel *ch;
    4746        FILE *fp;
    4847       
     
    9190        }
    9291       
    93         ch = g_io_channel_unix_new( global.listen_socket );
    94         global.listen_watch_source_id = g_io_add_watch( ch, G_IO_IN, bitlbee_io_new_client, NULL );
     92        global.listen_watch_source_id = b_input_add( global.listen_socket, GAIM_INPUT_READ, bitlbee_io_new_client, NULL );
    9593       
    9694#ifndef _WIN32
     
    147145}
    148146
    149 gboolean bitlbee_io_current_client_read( GIOChannel *source, GIOCondition condition, gpointer data )
     147gboolean bitlbee_io_current_client_read( gpointer data, gint fd, b_input_condition cond )
    150148{
    151149        irc_t *irc = data;
     
    153151        int st;
    154152       
    155         if( condition & G_IO_ERR || condition & G_IO_HUP )
    156         {
    157                 irc_abort( irc, 1, "Read error" );
    158                 return FALSE;
    159         }
    160        
    161153        st = read( irc->fd, line, sizeof( line ) - 1 );
    162154        if( st == 0 )
     
    194186        if( !g_slist_find( irc_connection_list, irc ) )
    195187        {
    196                 log_message( LOGLVL_WARNING, "Abnormal termination of connection with fd %d.", irc->fd );
     188                log_message( LOGLVL_WARNING, "Abnormal termination of connection with fd %d.", fd );
    197189                return FALSE;
    198190        }
     
    208200}
    209201
    210 gboolean bitlbee_io_current_client_write( GIOChannel *source, GIOCondition condition, gpointer data )
     202gboolean bitlbee_io_current_client_write( gpointer data, gint fd, b_input_condition cond )
    211203{
    212204        irc_t *irc = data;
     
    215207
    216208        if( irc->sendbuffer == NULL )
    217                 return( FALSE );
     209                return FALSE;
    218210       
    219211        size = strlen( irc->sendbuffer );
     
    239231                        irc_free( irc );
    240232               
    241                 return( FALSE );
     233                return FALSE;
    242234        }
    243235        else
     
    247239                irc->sendbuffer = temp;
    248240               
    249                 return( TRUE );
    250         }
    251 }
    252 
    253 gboolean bitlbee_io_new_client( GIOChannel *source, GIOCondition condition, gpointer data )
    254 {
    255         size_t size = sizeof( struct sockaddr_in );
     241                return TRUE;
     242        }
     243}
     244
     245static gboolean bitlbee_io_new_client( gpointer data, gint fd, b_input_condition condition )
     246{
     247        socklen_t size = sizeof( struct sockaddr_in );
    256248        struct sockaddr_in conn_info;
    257249        int new_socket = accept( global.listen_socket, (struct sockaddr *) &conn_info, &size );
     
    286278                        child->pid = client_pid;
    287279                        child->ipc_fd = fds[0];
    288                         child->ipc_inpa = gaim_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
     280                        child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
    289281                        child_list = g_slist_append( child_list, child );
    290282                       
     
    301293                        /* Close the listening socket, we're a client. */
    302294                        close( global.listen_socket );
    303                         g_source_remove( global.listen_watch_source_id );
     295                        b_event_remove( global.listen_watch_source_id );
    304296                       
    305297                        /* Make the connection. */
     
    308300                        /* We can store the IPC fd there now. */
    309301                        global.listen_socket = fds[1];
    310                         global.listen_watch_source_id = gaim_input_add( fds[1], GAIM_INPUT_READ, ipc_child_read, irc );
     302                        global.listen_watch_source_id = b_input_add( fds[1], GAIM_INPUT_READ, ipc_child_read, irc );
    311303                       
    312304                        close( fds[0] );
     
    324316}
    325317
    326 void bitlbee_shutdown( gpointer data )
     318gboolean bitlbee_shutdown( gpointer data, gint fd, b_input_condition cond )
    327319{
    328320        /* Try to save data for all active connections (if desired). */
     
    331323       
    332324        /* We'll only reach this point when not running in inetd mode: */
    333         g_main_quit( global.loop );
    334 }
     325        b_main_quit();
     326       
     327        return FALSE;
     328}
  • bitlbee.h

    r881fd4e r41ca004  
    5858/* The following functions should not be used if we want to maintain Windows compatibility... */
    5959#undef free
    60 #define free            __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM_INSTEAD__
     60#define free            __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM__
    6161#undef malloc
    62 #define malloc          __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM_INSTEAD__
     62#define malloc          __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM__
    6363#undef calloc
    64 #define calloc          __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM_INSTEAD__
     64#define calloc          __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM__
    6565#undef realloc
    66 #define realloc         __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM_INSTEAD__
     66#define realloc         __PLEASE_USE_THE_GLIB_MEMORY_ALLOCATION_SYSTEM__
    6767#undef strdup
    68 #define strdup          __PLEASE_USE_THE_GLIB_STRDUP_FUNCTIONS_SYSTEM_INSTEAD__
     68#define strdup          __PLEASE_USE_THE_GLIB_STRDUP_FUNCTIONS_SYSTEM__
    6969#undef strndup
    70 #define strndup         __PLEASE_USE_THE_GLIB_STRDUP_FUNCTIONS_SYSTEM_INSTEAD__
     70#define strndup         __PLEASE_USE_THE_GLIB_STRDUP_FUNCTIONS_SYSTEM__
    7171#undef snprintf
    72 #define snprintf        __PLEASE_USE_G_SNPRINTF_INSTEAD__
     72#define snprintf        __PLEASE_USE_G_SNPRINTF__
    7373#undef strcasecmp
    74 #define strcasecmp      __PLEASE_USE_G_STRCASECMP_INSTEAD__
     74#define strcasecmp      __PLEASE_USE_G_STRCASECMP__
    7575#undef strncasecmp
    76 #define strncasecmp     __PLEASE_USE_G_STRNCASECMP_INSTEAD__
     76#define strncasecmp     __PLEASE_USE_G_STRNCASECMP__
     77
     78/* And the following functions shouldn't be used anymore to keep compatibility
     79   with other event handling libs than GLib. */
     80#undef g_timeout_add
     81#define g_timeout_add           __PLEASE_USE_B_TIMEOUT_ADD__
     82#undef g_timeout_add_full
     83#define g_timeout_add_full      __PLEASE_USE_B_TIMEOUT_ADD__
     84#undef g_io_add_watch
     85#define g_io_add_watch          __PLEASE_USE_B_INPUT_ADD__
     86#undef g_io_add_watch_full
     87#define g_io_add_watch_full     __PLEASE_USE_B_INPUT_ADD__
     88#undef g_source_remove
     89#define g_source_remove         __PLEASE_USE_B_EVENT_REMOVE__
     90#undef g_source_remove_by_user_data
     91#define g_source_remove_by_user_data    __PLEASE_USE_B_SOURCE_REMOVE_BY_USER_DATA__
     92#undef g_main_run
     93#define g_main_run              __PLEASE_USE_B_MAIN_RUN__
     94#undef g_main_quit
     95#define g_main_quit             __PLEASE_USE_B_MAIN_QUIT__
    7796
    7897#ifndef F_OK
     
    112131#include "sock.h"
    113132#include "util.h"
     133#include "proxy.h"
    114134
    115135typedef struct global {
     
    121141        GList *storage; /* The first backend in the list will be used for saving */
    122142        char *helpfile;
    123         GMainLoop *loop;
    124143        int restart;
    125144} global_t;
     
    128147int bitlbee_inetd_init( void );
    129148
    130 gboolean bitlbee_io_current_client_read( GIOChannel *source, GIOCondition condition, gpointer data );
    131 gboolean bitlbee_io_current_client_write( GIOChannel *source, GIOCondition condition, gpointer data );
     149gboolean bitlbee_io_current_client_read( gpointer data, gint source, b_input_condition cond );
     150gboolean bitlbee_io_current_client_write( gpointer data, gint source, b_input_condition cond );
    132151
    133152void root_command_string( irc_t *irc, user_t *u, char *command, int flags );
    134153void root_command( irc_t *irc, char *command[] );
    135 void bitlbee_shutdown( gpointer data );
     154gboolean bitlbee_shutdown( gpointer data, gint fd, b_input_condition cond );
    136155
    137156extern global_t global;
  • configure

    r881fd4e r41ca004  
    1414datadir='$prefix/share/bitlbee/'
    1515config='/var/lib/bitlbee/'
     16plugindir='$prefix/lib/bitlbee/'
     17includedir='$prefix/include/bitlbee/'
     18libevent='/usr/'
    1619pidfile='/var/run/bitlbee.pid'
    1720ipcsocket='/var/run/bitlbee'
    18 plugindir='$prefix/lib/bitlbee'
    1921pcdir='$prefix/lib/pkgconfig'
    20 includedir='$prefix/include/bitlbee'
    2122
    2223msn=1
     
    2829strip=1
    2930ipv6=1
     31
     32events=glib
    3033ssl=auto
    3134
     
    6467--ipv6=0/1      IPv6 socket support                     $ipv6
    6568
     69--events=...    Event handler (glib, libevent)          $events
    6670--ssl=...       SSL library to use (gnutls, nss, openssl, bogus, auto)
    6771                                                        $ssl
     
    8084config=`eval echo "$config/" | sed 's/\/\{1,\}/\//g'`
    8185plugindir=`eval echo "$plugindir/" | sed 's/\/\{1,\}/\//g'`
     86includedir=`eval echo "$includedir"/ | sed 's/\/\{1,\}/\//g'`
     87libevent=`eval echo "$libevent"/ | sed 's/\/\{1,\}/\//g'`
     88
    8289pidfile=`eval echo "$pidfile" | sed 's/\/\{1,\}/\//g'`
    8390ipcsocket=`eval echo "$ipcsocket" | sed 's/\/\{1,\}/\//g'`
    84 includedir=`eval echo "$includedir" | sed 's/\/\{1,\}/\//g'`
    8591pcdir=`eval echo "$pcdir" | sed 's/\/\{1,\}/\//g'`
    8692
     
    183189        :;
    184190elif [ -r /usr/local/include/iconv.h ]; then
    185         echo CFLAGS+=-I/usr/local/include >> Makefile.settings;
     191        echo CFLAGS+=-I/usr/local/include >> Makefile.settings
    186192else
    187193        echo
    188194        echo 'Warning: Could not find iconv.h, you might have to install it and/or modify'
    189         echo 'Makefile.settings to tell where this file is.';
    190 fi
     195        echo 'Makefile.settings to tell where this file is.'
     196fi
     197
     198
     199if [ "$events" = "libevent" ]; then
     200        if ! [ -e "${libevent}include/event.h" ]; then
     201                echo
     202                echo 'Warning: Could not find event.h, you might have to install it and/or specify'
     203                echo 'its location using the --libevent= argument. (Example: If event.h is in'
     204                echo '/usr/local/include and binaries are in /usr/local/lib: --libevent=/usr/local)'
     205        fi
     206       
     207        echo '#define EVENTS_LIBEVENT' >> config.h
     208        cat <<EOF>>Makefile.settings
     209EFLAGS+=-levent -L${libevent}lib
     210CFLAGS+=-I${libevent}include
     211EOF
     212elif [ "$events" = "glib" ]; then
     213        ## We already use glib anyway, so this is all we need (and in fact not even this, but just to be sure...):
     214        echo '#define EVENTS_GLIB' >> config.h
     215else
     216        echo
     217        echo 'ERROR: Unknown event handler specified.'
     218        exit 1
     219fi
     220echo 'EVENT_HANDLER=events_'$events'.o' >> Makefile.settings
    191221
    192222
     
    422452fi
    423453
    424 if [ "$msn" = "1" ]; then
    425         echo '  Using SSL library: '$ssl;
    426 fi
     454echo '  Using event handler: '$events;
     455echo '  Using SSL library: '$ssl;
    427456
    428457#if [ "$flood" = "0" ]; then
  • ipc.c

    r881fd4e r41ca004  
    6060                ipc_to_children_str( "DIE\r\n" );
    6161       
    62         bitlbee_shutdown( NULL );
     62        bitlbee_shutdown( NULL, -1, 0 );
    6363}
    6464
     
    9191       
    9292        global.restart = -1;
    93         bitlbee_shutdown( NULL );
     93        bitlbee_shutdown( NULL, -1, 0 );
    9494}
    9595
     
    246246}
    247247
    248 void ipc_master_read( gpointer data, gint source, GaimInputCondition cond )
     248gboolean ipc_master_read( gpointer data, gint source, b_input_condition cond )
    249249{
    250250        char *buf, **cmd;
     
    272272                }
    273273        }
    274 }
    275 
    276 void ipc_child_read( gpointer data, gint source, GaimInputCondition cond )
     274       
     275        return TRUE;
     276}
     277
     278gboolean ipc_child_read( gpointer data, gint source, b_input_condition cond )
    277279{
    278280        char *buf, **cmd;
     
    286288        else
    287289        {
    288                 gaim_input_remove( global.listen_watch_source_id );
     290                b_event_remove( global.listen_watch_source_id );
    289291                close( global.listen_socket );
    290292               
    291293                global.listen_socket = -1;
    292294        }
     295       
     296        return TRUE;
    293297}
    294298
     
    397401void ipc_master_free_one( struct bitlbee_child *c )
    398402{
    399         gaim_input_remove( c->ipc_inpa );
     403        b_event_remove( c->ipc_inpa );
    400404        closesocket( c->ipc_fd );
    401405       
     
    463467
    464468
    465 static gboolean new_ipc_client (GIOChannel *gio, GIOCondition cond, gpointer data)
     469static gboolean new_ipc_client( gpointer data, gint serversock, b_input_condition cond )
    466470{
    467471        struct bitlbee_child *child = g_new0( struct bitlbee_child, 1 );
    468         int serversock;
    469 
    470         serversock = g_io_channel_unix_get_fd(gio);
    471 
    472         child->ipc_fd = accept(serversock, NULL, 0);
    473 
    474         if (child->ipc_fd == -1) {
     472       
     473        child->ipc_fd = accept( serversock, NULL, 0 );
     474       
     475        if( child->ipc_fd == -1 )
     476        {
    475477                log_message( LOGLVL_WARNING, "Unable to accept connection on UNIX domain socket: %s", strerror(errno) );
    476478                return TRUE;
    477479        }
    478480               
    479         child->ipc_inpa = gaim_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
    480                
     481        child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
     482       
    481483        child_list = g_slist_append( child_list, child );
    482 
     484       
    483485        return TRUE;
    484486}
     
    489491        struct sockaddr_un un_addr;
    490492        int serversock;
    491         GIOChannel *gio;
    492493
    493494        /* Clean up old socket files that were hanging around.. */
     
    517518        }
    518519       
    519         gio = g_io_channel_unix_new(serversock);
    520        
    521         if (gio == NULL) {
    522                 log_message( LOGLVL_WARNING, "Unable to create IO channel for unix socket" );
    523                 return 0;
    524         }
    525 
    526         g_io_add_watch(gio, G_IO_IN, new_ipc_client, NULL);
     520        b_input_add( serversock, GAIM_INPUT_READ, new_ipc_client, NULL );
     521       
    527522        return 1;
    528523}
     
    563558                        return 0;
    564559                }
    565                 child->ipc_inpa = gaim_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
     560                child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
    566561               
    567562                child_list = g_slist_append( child_list, child );
  • ipc.h

    r881fd4e r41ca004  
    4040
    4141
    42 void ipc_master_read( gpointer data, gint source, GaimInputCondition cond );
    43 void ipc_child_read( gpointer data, gint source, GaimInputCondition cond );
     42gboolean ipc_master_read( gpointer data, gint source, b_input_condition cond );
     43gboolean ipc_child_read( gpointer data, gint source, b_input_condition cond );
    4444
    4545void ipc_master_free_one( struct bitlbee_child *child );
  • irc.c

    r881fd4e r41ca004  
    2929#include "ipc.h"
    3030
    31 static gboolean irc_userping( gpointer _irc );
     31static gboolean irc_userping( gpointer _irc, int fd, b_input_condition cond );
    3232
    3333GSList *irc_connection_list = NULL;
     
    5454       
    5555        irc->fd = fd;
    56         irc->io_channel = g_io_channel_unix_new( fd );
    57 #ifdef GLIB2
    58         g_io_channel_set_encoding (irc->io_channel, NULL, NULL);
    59         g_io_channel_set_buffered (irc->io_channel, FALSE);
    60         g_io_channel_set_flags( irc->io_channel, G_IO_FLAG_NONBLOCK, NULL );
    61 #else
    62         fcntl( irc->fd, F_SETFL, O_NONBLOCK);
    63 #endif
    64         irc->r_watch_source_id = g_io_add_watch( irc->io_channel, G_IO_IN | G_IO_ERR | G_IO_HUP, bitlbee_io_current_client_read, irc );
     56        sock_make_nonblocking( irc->fd );
     57       
     58        irc->r_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_READ, bitlbee_io_current_client_read, irc );
    6559       
    6660        irc->status = USTATUS_OFFLINE;
     
    120114
    121115        if( global.conf->ping_interval > 0 && global.conf->ping_timeout > 0 )
    122                 irc->ping_source_id = g_timeout_add( global.conf->ping_interval * 1000, irc_userping, irc );
     116                irc->ping_source_id = b_timeout_add( global.conf->ping_interval * 1000, irc_userping, irc );
    123117       
    124118        irc_write( irc, ":%s NOTICE AUTH :%s", irc->myhost, "BitlBee-IRCd initialized, please go on" );
     
    190184                   bitlbee_.._write doesn't do it first. */
    191185               
    192                 g_source_remove( irc->r_watch_source_id );
    193                 irc->r_watch_source_id = g_timeout_add_full( G_PRIORITY_HIGH, 1000, (GSourceFunc) irc_free, irc, NULL );
     186                b_event_remove( irc->r_watch_source_id );
     187                irc->r_watch_source_id = b_timeout_add( 1000, (b_event_handler) irc_free, irc );
    194188        }
    195189        else
     
    224218       
    225219        if( irc->ping_source_id > 0 )
    226                 g_source_remove( irc->ping_source_id );
    227         g_source_remove( irc->r_watch_source_id );
     220                b_event_remove( irc->ping_source_id );
     221        b_event_remove( irc->r_watch_source_id );
    228222        if( irc->w_watch_source_id > 0 )
    229                 g_source_remove( irc->w_watch_source_id );
    230        
    231         g_io_channel_unref( irc->io_channel );
     223                b_event_remove( irc->w_watch_source_id );
     224       
    232225        irc_connection_list = g_slist_remove( irc_connection_list, irc );
    233226       
     
    279272                        if(user->host!=user->nick) g_free(user->host);
    280273                        if(user->realname!=user->nick) g_free(user->realname);
    281                         gaim_input_remove(user->sendbuf_timer);
     274                        b_event_remove(user->sendbuf_timer);
    282275                                       
    283276                        usertmp = user;
     
    329322       
    330323        if( global.conf->runmode == RUNMODE_INETD || global.conf->runmode == RUNMODE_FORKDAEMON )
    331                 g_main_quit( global.loop );
     324                b_main_quit();
    332325}
    333326
     
    583576        char line[IRC_MAX_LINE+1], *cs;
    584577               
    585         if( irc->quit )
     578        /* Don't try to write anything new anymore when shutting down. */
     579        if( irc->status == USTATUS_SHUTDOWN )
    586580                return;
    587581       
     
    600594        strcat( line, "\r\n" );
    601595       
    602         if( irc->sendbuffer != NULL ) {
     596        if( irc->sendbuffer != NULL )
     597        {
    603598                size = strlen( irc->sendbuffer ) + strlen( line );
    604599                irc->sendbuffer = g_renew ( char, irc->sendbuffer, size + 1 );
    605600                strcpy( ( irc->sendbuffer + strlen( irc->sendbuffer ) ), line );
    606601        }
    607         else
    608                 irc->sendbuffer = g_strdup(line);       
     602        else
     603        {
     604                irc->sendbuffer = g_strdup(line);
     605        }
    609606       
    610607        if( irc->w_watch_source_id == 0 )
    611608        {
    612                 irc->w_watch_source_id = g_io_add_watch( irc->io_channel, G_IO_OUT, bitlbee_io_current_client_write, irc );
     609                /* If the buffer is empty we can probably write, so call the write event handler
     610                   immediately. If it returns TRUE, it should be called again, so add the event to
     611                   the queue. If it's FALSE, we emptied the buffer and saved ourselves some work
     612                   in the event queue. */
     613                if( bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE ) )
     614                        irc->w_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_WRITE, bitlbee_io_current_client_write, irc );
    613615        }
    614616       
     
    636638                if( now )
    637639                {
    638                         bitlbee_io_current_client_write( irc->io_channel, G_IO_OUT, irc );
     640                        bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE );
    639641                }
    640642                temp = temp->next;
     
    10171019}
    10181020
    1019 gboolean buddy_send_handler_delayed( gpointer data )
     1021static gboolean buddy_send_handler_delayed( gpointer data, gint fd, b_input_condition cond )
    10201022{
    10211023        user_t *u = data;
     
    10301032        u->sendbuf_flags = 0;
    10311033       
    1032         return( FALSE );
     1034        return FALSE;
    10331035}
    10341036
     
    10441046                {
    10451047                        //Flush the buffer
    1046                         g_source_remove( u->sendbuf_timer );
    1047                         buddy_send_handler_delayed( u );
     1048                        b_event_remove( u->sendbuf_timer );
     1049                        buddy_send_handler_delayed( u, -1, 0 );
    10481050                }
    10491051
     
    10691071               
    10701072                if( u->sendbuf_timer > 0 )
    1071                         g_source_remove( u->sendbuf_timer );
    1072                 u->sendbuf_timer = g_timeout_add( delay, buddy_send_handler_delayed, u );
     1073                        b_event_remove( u->sendbuf_timer );
     1074                u->sendbuf_timer = b_timeout_add( delay, buddy_send_handler_delayed, u );
    10731075        }
    10741076        else
     
    11541156   pongs from the user. When not connected yet, we don't ping but drop the
    11551157   connection when the user fails to connect in IRC_LOGIN_TIMEOUT secs. */
    1156 static gboolean irc_userping( gpointer _irc )
     1158static gboolean irc_userping( gpointer _irc, gint fd, b_input_condition cond )
    11571159{
    11581160        irc_t *irc = _irc;
  • irc.h

    r881fd4e r41ca004  
    6161        char *sendbuffer;
    6262        char *readbuffer;
    63         int quit;
    6463
    6564        int sentbytes;
     
    9392        struct set *set;
    9493
    95         GIOChannel *io_channel;
    9694        gint r_watch_source_id;
    9795        gint w_watch_source_id;
  • protocols/Makefile

    r881fd4e r41ca004  
    1010
    1111# [SH] Program variables
    12 objects = http_client.o md5.o nogaim.o proxy.o sha.o $(SSL_CLIENT)
     12objects = $(EVENT_HANDLER) http_client.o md5.o nogaim.o proxy.o sha.o $(SSL_CLIENT)
    1313
    1414# [SH] The next two lines should contain the directory name (in $(subdirs))
  • protocols/http_client.c

    r881fd4e r41ca004  
    3232
    3333
    34 static void http_connected( gpointer data, int source, GaimInputCondition cond );
    35 static void http_ssl_connected( gpointer data, void *source, GaimInputCondition cond );
    36 static void http_incoming_data( gpointer data, int source, GaimInputCondition cond );
     34static gboolean http_connected( gpointer data, int source, b_input_condition cond );
     35static gboolean http_ssl_connected( gpointer data, void *source, b_input_condition cond );
     36static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond );
    3737
    3838
     
    104104/* This one is actually pretty simple... Might get more calls if we can't write
    105105   the whole request at once. */
    106 static void http_connected( gpointer data, int source, GaimInputCondition cond )
     106static gboolean http_connected( gpointer data, int source, b_input_condition cond )
    107107{
    108108        struct http_request *req = data;
     
    113113       
    114114        if( req->inpa > 0 )
    115                 gaim_input_remove( req->inpa );
     115                b_event_remove( req->inpa );
    116116       
    117117        sock_make_nonblocking( req->fd );
     
    148148       
    149149        if( req->bytes_written < req->request_length )
    150                 req->inpa = gaim_input_add( source,
    151                                             req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_WRITE,
    152                                             http_connected, req );
    153         else
    154                 req->inpa = gaim_input_add( source, GAIM_INPUT_READ, http_incoming_data, req );
    155        
    156         return;
     150                req->inpa = b_input_add( source,
     151                                         req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_WRITE,
     152                                         http_connected, req );
     153        else
     154                req->inpa = b_input_add( source, GAIM_INPUT_READ, http_incoming_data, req );
     155       
     156        return FALSE;
    157157       
    158158error:
     
    162162        g_free( req );
    163163       
    164         return;
     164        return FALSE;
    165165}
    166166
    167 static void http_ssl_connected( gpointer data, void *source, GaimInputCondition cond )
     167static gboolean http_ssl_connected( gpointer data, void *source, b_input_condition cond )
    168168{
    169169        struct http_request *req = data;
     
    177177}
    178178
    179 static void http_incoming_data( gpointer data, int source, GaimInputCondition cond )
     179static gboolean http_incoming_data( gpointer data, int source, b_input_condition cond )
    180180{
    181181        struct http_request *req = data;
     
    186186       
    187187        if( req->inpa > 0 )
    188                 gaim_input_remove( req->inpa );
     188                b_event_remove( req->inpa );
    189189       
    190190        if( req->ssl )
     
    233233       
    234234        /* There will be more! */
    235         req->inpa = gaim_input_add( req->fd,
    236                                     req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_READ,
    237                                     http_incoming_data, req );
    238        
    239         return;
     235        req->inpa = b_input_add( req->fd,
     236                                 req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_READ,
     237                                 http_incoming_data, req );
     238       
     239        return FALSE;
    240240
    241241got_reply:
     
    396396                req->reply_headers = req->reply_body = NULL;
    397397               
    398                 return;
     398                return FALSE;
    399399        }
    400400       
     
    414414        g_free( req->reply_headers );
    415415        g_free( req );
     416       
     417        return FALSE;
    416418}
  • protocols/jabber/jabber.c

    r881fd4e r41ca004  
    471471}
    472472
    473 static void jabber_callback(gpointer data, gint source, GaimInputCondition condition)
     473static gboolean jabber_callback(gpointer data, gint source, b_input_condition condition)
    474474{
    475475        struct gaim_connection *gc = (struct gaim_connection *)data;
     
    477477
    478478        gjab_recv(jd->gjc);
     479       
     480        return TRUE;
    479481}
    480482
     
    487489}
    488490
    489 static void gjab_connected(gpointer data, gint source, GaimInputCondition cond)
     491static gboolean gjab_connected(gpointer data, gint source, b_input_condition cond)
    490492{
    491493        xmlnode x;
     
    497499        if (!g_slist_find(get_connections(), gc)) {
    498500                closesocket(source);
    499                 return;
     501                return FALSE;
    500502        }
    501503
     
    508510        if (source == -1) {
    509511                STATE_EVT(JCONN_STATE_OFF)
    510                 return;
     512                return FALSE;
    511513        }
    512514
     
    530532
    531533        gc = GJ_GC(gjc);
    532         gc->inpa = gaim_input_add(gjc->fd, GAIM_INPUT_READ, jabber_callback, gc);
    533 }
    534 
    535 static void gjab_connected_ssl(gpointer data, void *source, GaimInputCondition cond)
     534        gc->inpa = b_input_add(gjc->fd, GAIM_INPUT_READ, jabber_callback, gc);
     535       
     536        return FALSE;
     537}
     538
     539static gboolean gjab_connected_ssl(gpointer data, void *source, b_input_condition cond)
    536540{
    537541        struct gaim_connection *gc = data;
     
    544548        if (source == NULL) {
    545549                STATE_EVT(JCONN_STATE_OFF)
    546                 return;
     550                return FALSE;
    547551        }
    548552       
    549553        if (!g_slist_find(get_connections(), gc)) {
    550554                ssl_disconnect(source);
    551                 return;
     555                return FALSE;
    552556        }
    553557       
    554         gjab_connected(data, gjc->fd, cond);
     558        return gjab_connected(data, gjc->fd, cond);
    555559}
    556560
     
    15431547}
    15441548
    1545 static gboolean jabber_free(gpointer data)
     1549static gboolean jabber_free(gpointer data, gint fd, b_input_condition cond)
    15461550{
    15471551        struct jabber_data *jd = data;
     
    15881592        }
    15891593        if (gc->inpa)
    1590                 gaim_input_remove(gc->inpa);
     1594                b_event_remove(gc->inpa);
    15911595
    15921596        if(jd) {
    1593                 g_timeout_add(50, jabber_free, jd);
     1597                b_timeout_add(50, jabber_free, jd);
    15941598                if(jd->gjc != NULL)
    15951599                        xmlnode_free(jd->gjc->current);
  • protocols/msn/msn.h

    r881fd4e r41ca004  
    146146
    147147/* ns.c */
    148 void msn_ns_connected( gpointer data, gint source, GaimInputCondition cond );
     148gboolean msn_ns_connected( gpointer data, gint source, b_input_condition cond );
    149149
    150150/* msn_util.c */
     
    173173void msn_sb_to_chat( struct msn_switchboard *sb );
    174174void msn_sb_destroy( struct msn_switchboard *sb );
    175 void msn_sb_connected( gpointer data, gint source, GaimInputCondition cond );
     175gboolean msn_sb_connected( gpointer data, gint source, b_input_condition cond );
  • protocols/msn/ns.c

    r881fd4e r41ca004  
    3030#include "md5.h"
    3131
    32 static void msn_ns_callback( gpointer data, gint source, GaimInputCondition cond );
     32static gboolean msn_ns_callback( gpointer data, gint source, b_input_condition cond );
    3333static int msn_ns_command( gpointer data, char **cmd, int num_parts );
    3434static int msn_ns_message( gpointer data, char *msg, int msglen, char **cmd, int num_parts );
     
    3636static void msn_auth_got_passport_id( struct passport_reply *rep );
    3737
    38 void msn_ns_connected( gpointer data, gint source, GaimInputCondition cond )
     38gboolean msn_ns_connected( gpointer data, gint source, b_input_condition cond )
    3939{
    4040        struct gaim_connection *gc = data;
     
    4343       
    4444        if( !g_slist_find( msn_connections, gc ) )
    45                 return;
     45                return FALSE;
    4646       
    4747        if( source == -1 )
     
    4949                hide_login_progress( gc, "Could not connect to server" );
    5050                signoff( gc );
    51                 return;
     51                return FALSE;
    5252        }
    5353       
     
    7575        if( msn_write( gc, s, strlen( s ) ) )
    7676        {
    77                 gc->inpa = gaim_input_add( md->fd, GAIM_INPUT_READ, msn_ns_callback, gc );
     77                gc->inpa = b_input_add( md->fd, GAIM_INPUT_READ, msn_ns_callback, gc );
    7878                set_login_progress( gc, 1, "Connected to server, waiting for reply" );
    7979        }
     80       
     81        return FALSE;
    8082}
    8183
    82 void msn_ns_callback( gpointer data, gint source, GaimInputCondition cond )
     84static gboolean msn_ns_callback( gpointer data, gint source, b_input_condition cond )
    8385{
    8486        struct gaim_connection *gc = data;
     
    8991                hide_login_progress( gc, "Error while reading from server" );
    9092                signoff( gc );
    91         }
     93               
     94                return FALSE;
     95        }
     96        else
     97                return TRUE;
    9298}
    9399
     
    130136                if( num_parts == 6 && strcmp( cmd[2], "NS" ) == 0 )
    131137                {
    132                         gaim_input_remove( gc->inpa );
     138                        b_event_remove( gc->inpa );
    133139                        gc->inpa = 0;
    134140                        closesocket( md->fd );
  • protocols/msn/sb.c

    r881fd4e r41ca004  
    3030#include "md5.h"
    3131
    32 static void msn_sb_callback( gpointer data, gint source, GaimInputCondition cond );
     32static gboolean msn_sb_callback( gpointer data, gint source, b_input_condition cond );
    3333static int msn_sb_command( gpointer data, char **cmd, int num_parts );
    3434static int msn_sb_message( gpointer data, char *msg, int msglen, char **cmd, int num_parts );
     
    237237        }
    238238       
    239         if( sb->inp ) gaim_input_remove( sb->inp );
     239        if( sb->inp ) b_event_remove( sb->inp );
    240240        closesocket( sb->fd );
    241241       
     
    245245}
    246246
    247 void msn_sb_connected( gpointer data, gint source, GaimInputCondition cond )
     247gboolean msn_sb_connected( gpointer data, gint source, b_input_condition cond )
    248248{
    249249        struct msn_switchboard *sb = data;
     
    254254        /* Are we still alive? */
    255255        if( !g_slist_find( msn_switchboards, sb ) )
    256                 return;
     256                return FALSE;
    257257       
    258258        gc = sb->gc;
     
    263263                debug( "ERROR %d while connecting to switchboard server", 1 );
    264264                msn_sb_destroy( sb );
    265                 return;
     265                return FALSE;
    266266        }
    267267       
     
    280280       
    281281        if( msn_sb_write( sb, buf, strlen( buf ) ) )
    282                 sb->inp = gaim_input_add( sb->fd, GAIM_INPUT_READ, msn_sb_callback, sb );
     282                sb->inp = b_input_add( sb->fd, GAIM_INPUT_READ, msn_sb_callback, sb );
    283283        else
    284284                debug( "ERROR %d while connecting to switchboard server", 2 );
    285 }
    286 
    287 static void msn_sb_callback( gpointer data, gint source, GaimInputCondition cond )
     285       
     286        return FALSE;
     287}
     288
     289static gboolean msn_sb_callback( gpointer data, gint source, b_input_condition cond )
    288290{
    289291        struct msn_switchboard *sb = data;
     
    293295                debug( "ERROR: Switchboard died" );
    294296                msn_sb_destroy( sb );
    295         }
     297               
     298                return FALSE;
     299        }
     300        else
     301                return TRUE;
    296302}
    297303
  • protocols/nogaim.c

    r881fd4e r41ca004  
    22  * BitlBee -- An IRC to other IM-networks gateway                     *
    33  *                                                                    *
    4   * Copyright 2002-2004 Wilmer van der Gaast and others                *
     4  * Copyright 2002-2006 Wilmer van der Gaast and others                *
    55  \********************************************************************/
    66
     
    1313 * from scratch for BitlBee and doesn't contain any code from Gaim anymore
    1414 * (except for the function names).
    15  *
    16  * Copyright 2002-2006 Wilmer van der Gaast <wilmer@gaast.net> and others
    1715 */
    1816
     
    250248         * This fixes daemon mode breakage where IRC doesn't point to the currently active connection.
    251249         */
    252         gc->irc=user->irc;
     250        gc->irc = user->irc;
    253251       
    254252        connections = g_slist_append( connections, gc );
     
    330328}
    331329
    332 static gboolean send_keepalive( gpointer d )
     330static gboolean send_keepalive( gpointer d, gint fd, b_input_condition cond )
    333331{
    334332        struct gaim_connection *gc = d;
     
    354352        serv_got_crap( gc, "Logged in" );
    355353       
    356         gc->keepalive = g_timeout_add( 60000, send_keepalive, gc );
     354        gc->keepalive = b_timeout_add( 60000, send_keepalive, gc );
    357355        gc->flags |= OPT_LOGGED_IN;
    358356       
     
    362360}
    363361
    364 gboolean auto_reconnect( gpointer data )
     362gboolean auto_reconnect( gpointer data, gint fd, b_input_condition cond )
    365363{
    366364        account_t *a = data;
     
    374372void cancel_auto_reconnect( account_t *a )
    375373{
    376         while( g_source_remove_by_user_data( (gpointer) a ) );
     374        /* while( b_event_remove_by_data( (gpointer) a ) ); */
     375        b_event_remove( a->reconnect );
    377376        a->reconnect = 0;
    378377}
     
    386385        serv_got_crap( gc, "Signing off.." );
    387386
    388         gaim_input_remove( gc->keepalive );
     387        b_event_remove( gc->keepalive );
    389388        gc->keepalive = 0;
    390389        gc->prpl->close( gc );
    391         gaim_input_remove( gc->inpa );
     390        b_event_remove( gc->inpa );
    392391       
    393392        while( u )
     
    416415        {
    417416                int delay = set_getint( irc, "auto_reconnect_delay" );
     417               
    418418                serv_got_crap( gc, "Reconnecting in %d seconds..", delay );
    419                
    420                 a->reconnect = 1;
    421                 g_timeout_add( delay * 1000, auto_reconnect, a );
     419                a->reconnect = b_timeout_add( delay * 1000, auto_reconnect, a );
    422420        }
    423421       
  • protocols/nogaim.h

    r881fd4e r41ca004  
    201201char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value );
    202202
    203 gboolean auto_reconnect( gpointer data );
     203gboolean auto_reconnect( gpointer data, gint fd, b_input_condition cond );
    204204void cancel_auto_reconnect( struct account *a );
    205205
  • protocols/oscar/oscar.c

    r881fd4e r41ca004  
    253253static int msgerrreasonlen = 25;
    254254
    255 static void oscar_callback(gpointer data, gint source,
    256                                 GaimInputCondition condition) {
     255static gboolean oscar_callback(gpointer data, gint source,
     256                                b_input_condition condition) {
    257257        aim_conn_t *conn = (aim_conn_t *)data;
    258258        aim_session_t *sess = aim_conn_getsess(conn);
     
    262262        if (!gc) {
    263263                /* gc is null. we return, else we seg SIGSEG on next line. */
    264                 return;
     264                return FALSE;
    265265        }
    266266     
     
    268268                /* oh boy. this is probably bad. i guess the only thing we
    269269                 * can really do is return? */
    270                 return;
     270                return FALSE;
    271271        }
    272272
     
    288288                                c->conn = NULL;
    289289                                if (c->inpa > 0)
    290                                         gaim_input_remove(c->inpa);
     290                                        b_event_remove(c->inpa);
    291291                                c->inpa = 0;
    292292                                c->fd = -1;
     
    296296                        } else if (conn->type == AIM_CONN_TYPE_CHATNAV) {
    297297                                if (odata->cnpa > 0)
    298                                         gaim_input_remove(odata->cnpa);
     298                                        b_event_remove(odata->cnpa);
    299299                                odata->cnpa = 0;
    300300                                while (odata->create_rooms) {
     
    310310                        } else if (conn->type == AIM_CONN_TYPE_AUTH) {
    311311                                if (odata->paspa > 0)
    312                                         gaim_input_remove(odata->paspa);
     312                                        b_event_remove(odata->paspa);
    313313                                odata->paspa = 0;
    314314                                aim_conn_kill(odata->sess, &conn);
     
    317317                        }
    318318                }
    319         }
    320 }
    321 
    322 static void oscar_login_connect(gpointer data, gint source, GaimInputCondition cond)
     319        } else {
     320                /* WTF??? */
     321                return FALSE;
     322        }
     323               
     324        return TRUE;
     325}
     326
     327static gboolean oscar_login_connect(gpointer data, gint source, b_input_condition cond)
    323328{
    324329        struct gaim_connection *gc = data;
     
    329334        if (!g_slist_find(get_connections(), gc)) {
    330335                closesocket(source);
    331                 return;
     336                return FALSE;
    332337        }
    333338
     
    339344                hide_login_progress(gc, _("Couldn't connect to host"));
    340345                signoff(gc);
    341                 return;
     346                return FALSE;
    342347        }
    343348
    344349        aim_conn_completeconnect(sess, conn);
    345         gc->inpa = gaim_input_add(conn->fd, GAIM_INPUT_READ,
     350        gc->inpa = b_input_add(conn->fd, GAIM_INPUT_READ,
    346351                        oscar_callback, conn);
     352       
     353        return FALSE;
    347354}
    348355
     
    412419                struct chat_connection *n = odata->oscar_chats->data;
    413420                if (n->inpa > 0)
    414                         gaim_input_remove(n->inpa);
     421                        b_event_remove(n->inpa);
    415422                g_free(n->name);
    416423                g_free(n->show);
     
    431438                g_free(odata->oldp);
    432439        if (gc->inpa > 0)
    433                 gaim_input_remove(gc->inpa);
     440                b_event_remove(gc->inpa);
    434441        if (odata->cnpa > 0)
    435                 gaim_input_remove(odata->cnpa);
     442                b_event_remove(odata->cnpa);
    436443        if (odata->paspa > 0)
    437                 gaim_input_remove(odata->paspa);
     444                b_event_remove(odata->paspa);
    438445        aim_session_kill(odata->sess);
    439446        g_free(odata->sess);
     
    443450}
    444451
    445 static void oscar_bos_connect(gpointer data, gint source, GaimInputCondition cond) {
     452static gboolean oscar_bos_connect(gpointer data, gint source, b_input_condition cond) {
    446453        struct gaim_connection *gc = data;
    447454        struct oscar_data *odata;
     
    451458        if (!g_slist_find(get_connections(), gc)) {
    452459                closesocket(source);
    453                 return;
     460                return FALSE;
    454461        }
    455462
     
    461468                hide_login_progress(gc, _("Could Not Connect"));
    462469                signoff(gc);
    463                 return;
     470                return FALSE;
    464471        }
    465472
    466473        aim_conn_completeconnect(sess, bosconn);
    467         gc->inpa = gaim_input_add(bosconn->fd, GAIM_INPUT_READ,
     474        gc->inpa = b_input_add(bosconn->fd, GAIM_INPUT_READ,
    468475                        oscar_callback, bosconn);
    469476        set_login_progress(gc, 4, _("Connection established, cookie sent"));
     477       
     478        return FALSE;
    470479}
    471480
     
    570579        }
    571580        aim_sendcookie(sess, bosconn, info->cookie);
    572         gaim_input_remove(gc->inpa);
     581        b_event_remove(gc->inpa);
    573582
    574583        return 1;
     
    585594};
    586595
    587 static void damn_you(gpointer data, gint source, GaimInputCondition c)
     596static gboolean damn_you(gpointer data, gint source, b_input_condition c)
    588597{
    589598        struct pieceofcrap *pos = data;
     
    605614                do_error_dialog(pos->gc, "Gaim was unable to get a valid hash for logging into AIM."
    606615                                " You may be disconnected shortly.", "Login Error");
    607                 gaim_input_remove(pos->inpa);
     616                b_event_remove(pos->inpa);
    608617                closesocket(pos->fd);
    609618                g_free(pos);
    610                 return;
     619                return FALSE;
    611620        }
    612621        /* [WvG] Wheeeee! Who needs error checking anyway? ;-) */
    613622        read(pos->fd, m, 16);
    614623        m[16] = '\0';
    615         gaim_input_remove(pos->inpa);
     624        b_event_remove(pos->inpa);
    616625        closesocket(pos->fd);
    617626        aim_sendmemblock(od->sess, pos->conn, 0, 16, m, AIM_SENDMEMBLOCK_FLAG_ISHASH);
    618627        g_free(pos);
    619 }
    620 
    621 static void straight_to_hell(gpointer data, gint source, GaimInputCondition cond) {
     628       
     629        return FALSE;
     630}
     631
     632static gboolean straight_to_hell(gpointer data, gint source, b_input_condition cond) {
    622633        struct pieceofcrap *pos = data;
    623634        char buf[BUF_LONG];
     
    629640                        g_free(pos->modname);
    630641                g_free(pos);
    631                 return;
     642                return FALSE;
    632643        }
    633644
     
    638649        if (pos->modname)
    639650                g_free(pos->modname);
    640         pos->inpa = gaim_input_add(pos->fd, GAIM_INPUT_READ, damn_you, pos);
    641         return;
     651        pos->inpa = b_input_add(pos->fd, GAIM_INPUT_READ, damn_you, pos);
     652        return FALSE;
    642653}
    643654
     
    761772}
    762773
    763 static void oscar_chatnav_connect(gpointer data, gint source, GaimInputCondition cond) {
     774static gboolean oscar_chatnav_connect(gpointer data, gint source, b_input_condition cond) {
    764775        struct gaim_connection *gc = data;
    765776        struct oscar_data *odata;
     
    769780        if (!g_slist_find(get_connections(), gc)) {
    770781                closesocket(source);
    771                 return;
     782                return FALSE;
    772783        }
    773784
     
    778789        if (source < 0) {
    779790                aim_conn_kill(sess, &tstconn);
    780                 return;
     791                return FALSE;
    781792        }
    782793
    783794        aim_conn_completeconnect(sess, tstconn);
    784         odata->cnpa = gaim_input_add(tstconn->fd, GAIM_INPUT_READ,
     795        odata->cnpa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
    785796                                        oscar_callback, tstconn);
    786 }
    787 
    788 static void oscar_auth_connect(gpointer data, gint source, GaimInputCondition cond)
     797       
     798        return FALSE;
     799}
     800
     801static gboolean oscar_auth_connect(gpointer data, gint source, b_input_condition cond)
    789802{
    790803        struct gaim_connection *gc = data;
     
    795808        if (!g_slist_find(get_connections(), gc)) {
    796809                closesocket(source);
    797                 return;
     810                return FALSE;
    798811        }
    799812
     
    804817        if (source < 0) {
    805818                aim_conn_kill(sess, &tstconn);
    806                 return;
     819                return FALSE;
    807820        }
    808821
    809822        aim_conn_completeconnect(sess, tstconn);
    810         odata->paspa = gaim_input_add(tstconn->fd, GAIM_INPUT_READ,
     823        odata->paspa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
    811824                                oscar_callback, tstconn);
    812 }
    813 
    814 static void oscar_chat_connect(gpointer data, gint source, GaimInputCondition cond)
     825       
     826        return FALSE;
     827}
     828
     829static gboolean oscar_chat_connect(gpointer data, gint source, b_input_condition cond)
    815830{
    816831        struct chat_connection *ccon = data;
     
    825840                g_free(ccon->name);
    826841                g_free(ccon);
    827                 return;
     842                return FALSE;
    828843        }
    829844
     
    837852                g_free(ccon->name);
    838853                g_free(ccon);
    839                 return;
     854                return FALSE;
    840855        }
    841856
    842857        aim_conn_completeconnect(sess, ccon->conn);
    843         ccon->inpa = gaim_input_add(tstconn->fd,
     858        ccon->inpa = b_input_add(tstconn->fd,
    844859                        GAIM_INPUT_READ,
    845860                        oscar_callback, tstconn);
    846861        odata->oscar_chats = g_slist_append(odata->oscar_chats, ccon);
     862       
     863        return FALSE;
    847864}
    848865
     
    25582575        od->oscar_chats = g_slist_remove(od->oscar_chats, cc);
    25592576        if (cc->inpa > 0)
    2560                 gaim_input_remove(cc->inpa);
     2577                b_event_remove(cc->inpa);
    25612578        aim_conn_kill(od->sess, &cc->conn);
    25622579        g_free(cc->name);
  • protocols/proxy.c

    r881fd4e r41ca004  
    2121 */
    2222
    23 /* this is a little piece of code to handle proxy connection */
    24 /* it is intended to : 1st handle http proxy, using the CONNECT command
    25  , 2nd provide an easy way to add socks support */
    26 
    2723#define BITLBEE_CORE
    2824#include <stdio.h>
     
    4642#include "proxy.h"
    4743
    48 #define GAIM_READ_COND  (G_IO_IN | G_IO_HUP | G_IO_ERR)
    49 #define GAIM_WRITE_COND (G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL)
    50 #define GAIM_ERR_COND   (G_IO_HUP | G_IO_ERR | G_IO_NVAL)
    51 
    5244char proxyhost[128] = "";
    5345int proxyport = 0;
     
    5749
    5850struct PHB {
    59         GaimInputFunction func, proxy_func;
     51        b_event_handler func, proxy_func;
    6052        gpointer data, proxy_data;
    6153        char *host;
     
    6456        gint inpa;
    6557};
    66 
    67 typedef struct _GaimIOClosure {
    68         GaimInputFunction function;
    69         guint result;
    70         gpointer data;
    71 } GaimIOClosure;
    7258
    7359
     
    9278}
    9379
    94 static void gaim_io_destroy(gpointer data)
    95 {
    96         g_free(data);
    97 }
    98 
    99 static gboolean gaim_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
    100 {
    101         GaimIOClosure *closure = data;
    102         GaimInputCondition gaim_cond = 0;
    103 
    104         if (condition & GAIM_READ_COND)
    105                 gaim_cond |= GAIM_INPUT_READ;
    106         if (condition & GAIM_WRITE_COND)
    107                 gaim_cond |= GAIM_INPUT_WRITE;
    108 
    109         closure->function(closure->data, g_io_channel_unix_get_fd(source), gaim_cond);
    110 
    111         return TRUE;
    112 }
    113 
    114 static void gaim_io_connected(gpointer data, gint source, GaimInputCondition cond)
     80static gboolean gaim_io_connected(gpointer data, gint source, b_input_condition cond)
    11581{
    11682        struct PHB *phb = data;
     
    12288        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
    12389                closesocket(source);
    124                 gaim_input_remove(phb->inpa);
     90                b_event_remove(phb->inpa);
    12591                if( phb->proxy_func )
    12692                        phb->proxy_func(phb->proxy_data, -1, GAIM_INPUT_READ);
     
    12995                        g_free(phb);
    13096                }
    131                 return;
     97                return FALSE;
    13298        }
    13399#endif
    134100        sock_make_blocking(source);
    135         gaim_input_remove(phb->inpa);
     101        b_event_remove(phb->inpa);
    136102        if( phb->proxy_func )
    137103                phb->proxy_func(phb->proxy_data, source, GAIM_INPUT_READ);
     
    140106                g_free(phb);
    141107        }
     108       
     109        return FALSE;
    142110}
    143111
     
    158126
    159127        sock_make_nonblocking(fd);
    160 
     128       
     129        event_debug("proxy_connect_none( \"%s\", %d ) = %d\n", host, port, fd);
     130       
    161131        if (connect(fd, (struct sockaddr *)sin, sizeof(*sin)) < 0) {
    162132                if (sockerr_again()) {
    163                         phb->inpa = gaim_input_add(fd, GAIM_INPUT_WRITE, gaim_io_connected, phb);
     133                        phb->inpa = b_input_add(fd, GAIM_INPUT_WRITE, gaim_io_connected, phb);
    164134                        phb->fd = fd;
    165135                } else {
     
    179149#define HTTP_GOODSTRING2 "HTTP/1.1 200 Connection established"
    180150
    181 static void http_canread(gpointer data, gint source, GaimInputCondition cond)
     151static gboolean http_canread(gpointer data, gint source, b_input_condition cond)
    182152{
    183153        int nlc = 0;
     
    186156        char inputline[8192];
    187157
    188         gaim_input_remove(phb->inpa);
     158        b_event_remove(phb->inpa);
    189159
    190160        while ((pos < sizeof(inputline)-1) && (nlc != 2) && (read(source, &inputline[pos++], 1) == 1)) {
     
    201171                g_free(phb->host);
    202172                g_free(phb);
    203                 return;
     173                return FALSE;
    204174        }
    205175
     
    208178        g_free(phb->host);
    209179        g_free(phb);
    210         return;
    211 }
    212 
    213 static void http_canwrite(gpointer data, gint source, GaimInputCondition cond)
     180       
     181        return FALSE;
     182}
     183
     184static gboolean http_canwrite(gpointer data, gint source, b_input_condition cond)
    214185{
    215186        char cmd[384];
     
    218189        int error = ETIMEDOUT;
    219190        if (phb->inpa > 0)
    220                 gaim_input_remove(phb->inpa);
     191                b_event_remove(phb->inpa);
    221192        len = sizeof(error);
    222193        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
     
    225196                g_free(phb->host);
    226197                g_free(phb);
    227                 return;
     198                return FALSE;
    228199        }
    229200        sock_make_blocking(source);
     
    236207                g_free(phb->host);
    237208                g_free(phb);
    238                 return;
     209                return FALSE;
    239210        }
    240211
     
    251222                        g_free(phb->host);
    252223                        g_free(phb);
    253                         return;
     224                        return FALSE;
    254225                }
    255226        }
     
    261232                g_free(phb->host);
    262233                g_free(phb);
    263                 return;
    264         }
    265 
    266         phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, http_canread, phb);
     234                return FALSE;
     235        }
     236
     237        phb->inpa = b_input_add(source, GAIM_INPUT_READ, http_canread, phb);
     238       
     239        return FALSE;
    267240}
    268241
     
    280253/* Connecting to SOCKS4 proxies */
    281254
    282 static void s4_canread(gpointer data, gint source, GaimInputCondition cond)
     255static gboolean s4_canread(gpointer data, gint source, b_input_condition cond)
    283256{
    284257        unsigned char packet[12];
    285258        struct PHB *phb = data;
    286259
    287         gaim_input_remove(phb->inpa);
     260        b_event_remove(phb->inpa);
    288261
    289262        memset(packet, 0, sizeof(packet));
     
    292265                g_free(phb->host);
    293266                g_free(phb);
    294                 return;
     267                return FALSE;
    295268        }
    296269
     
    299272        g_free(phb->host);
    300273        g_free(phb);
    301 }
    302 
    303 static void s4_canwrite(gpointer data, gint source, GaimInputCondition cond)
     274       
     275        return FALSE;
     276}
     277
     278static gboolean s4_canwrite(gpointer data, gint source, b_input_condition cond)
    304279{
    305280        unsigned char packet[12];
     
    309284        int error = ETIMEDOUT;
    310285        if (phb->inpa > 0)
    311                 gaim_input_remove(phb->inpa);
     286                b_event_remove(phb->inpa);
    312287        len = sizeof(error);
    313288        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
     
    316291                g_free(phb->host);
    317292                g_free(phb);
    318                 return;
     293                return FALSE;
    319294        }
    320295        sock_make_blocking(source);
     
    326301                g_free(phb->host);
    327302                g_free(phb);
    328                 return;
     303                return FALSE;
    329304        }
    330305
     
    343318                g_free(phb->host);
    344319                g_free(phb);
    345                 return;
    346         }
    347 
    348         phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s4_canread, phb);
     320                return FALSE;
     321        }
     322
     323        phb->inpa = b_input_add(source, GAIM_INPUT_READ, s4_canread, phb);
     324       
     325        return FALSE;
    349326}
    350327
     
    362339/* Connecting to SOCKS5 proxies */
    363340
    364 static void s5_canread_again(gpointer data, gint source, GaimInputCondition cond)
     341static gboolean s5_canread_again(gpointer data, gint source, b_input_condition cond)
    365342{
    366343        unsigned char buf[512];
    367344        struct PHB *phb = data;
    368345
    369         gaim_input_remove(phb->inpa);
     346        b_event_remove(phb->inpa);
    370347
    371348        if (read(source, buf, 10) < 10) {
     
    374351                g_free(phb->host);
    375352                g_free(phb);
    376                 return;
     353                return FALSE;
    377354        }
    378355        if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
     
    381358                g_free(phb->host);
    382359                g_free(phb);
    383                 return;
     360                return FALSE;
    384361        }
    385362
     
    387364        g_free(phb->host);
    388365        g_free(phb);
    389         return;
     366       
     367        return FALSE;
    390368}
    391369
     
    395373        struct PHB *phb = data;
    396374        int hlen = strlen(phb->host);
    397 
     375       
    398376        buf[0] = 0x05;
    399377        buf[1] = 0x01;          /* CONNECT */
     
    413391        }
    414392
    415         phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s5_canread_again, phb);
    416 }
    417 
    418 static void s5_readauth(gpointer data, gint source, GaimInputCondition cond)
     393        phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_canread_again, phb);
     394}
     395
     396static gboolean s5_readauth(gpointer data, gint source, b_input_condition cond)
    419397{
    420398        unsigned char buf[512];
    421399        struct PHB *phb = data;
    422400
    423         gaim_input_remove(phb->inpa);
     401        b_event_remove(phb->inpa);
    424402
    425403        if (read(source, buf, 2) < 2) {
     
    428406                g_free(phb->host);
    429407                g_free(phb);
    430                 return;
     408                return FALSE;
    431409        }
    432410
     
    436414                g_free(phb->host);
    437415                g_free(phb);
    438                 return;
     416                return FALSE;
    439417        }
    440418
    441419        s5_sendconnect(phb, source);
    442 }
    443 
    444 static void s5_canread(gpointer data, gint source, GaimInputCondition cond)
     420       
     421        return FALSE;
     422}
     423
     424static gboolean s5_canread(gpointer data, gint source, b_input_condition cond)
    445425{
    446426        unsigned char buf[512];
    447427        struct PHB *phb = data;
    448428
    449         gaim_input_remove(phb->inpa);
     429        b_event_remove(phb->inpa);
    450430
    451431        if (read(source, buf, 2) < 2) {
     
    454434                g_free(phb->host);
    455435                g_free(phb);
    456                 return;
     436                return FALSE;
    457437        }
    458438
     
    462442                g_free(phb->host);
    463443                g_free(phb);
    464                 return;
     444                return FALSE;
    465445        }
    466446
     
    477457                        g_free(phb->host);
    478458                        g_free(phb);
    479                         return;
     459                        return FALSE;
    480460                }
    481461
    482                 phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s5_readauth, phb);
     462                phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_readauth, phb);
    483463        } else {
    484464                s5_sendconnect(phb, source);
    485465        }
    486 }
    487 
    488 static void s5_canwrite(gpointer data, gint source, GaimInputCondition cond)
     466       
     467        return FALSE;
     468}
     469
     470static gboolean s5_canwrite(gpointer data, gint source, b_input_condition cond)
    489471{
    490472        unsigned char buf[512];
     
    494476        int error = ETIMEDOUT;
    495477        if (phb->inpa > 0)
    496                 gaim_input_remove(phb->inpa);
     478                b_event_remove(phb->inpa);
    497479        len = sizeof(error);
    498480        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
     
    501483                g_free(phb->host);
    502484                g_free(phb);
    503                 return;
     485                return FALSE;
    504486        }
    505487        sock_make_blocking(source);
     
    523505                g_free(phb->host);
    524506                g_free(phb);
    525                 return;
    526         }
    527 
    528         phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, s5_canread, phb);
     507                return FALSE;
     508        }
     509
     510        phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_canread, phb);
     511       
     512        return FALSE;
    529513}
    530514
     
    542526/* Export functions */
    543527
    544 gint gaim_input_add(gint source, GaimInputCondition condition, GaimInputFunction function, gpointer data)
    545 {
    546         GaimIOClosure *closure = g_new0(GaimIOClosure, 1);
    547         GIOChannel *channel;
    548         GIOCondition cond = 0;
    549        
    550         closure->function = function;
    551         closure->data = data;
    552        
    553         if (condition & GAIM_INPUT_READ)
    554                 cond |= GAIM_READ_COND;
    555         if (condition & GAIM_INPUT_WRITE)
    556                 cond |= GAIM_WRITE_COND;
    557        
    558         channel = g_io_channel_unix_new(source);
    559         closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond,
    560                                               gaim_io_invoke, closure, gaim_io_destroy);
    561        
    562         g_io_channel_unref(channel);
    563         return closure->result;
    564 }
    565 
    566 void gaim_input_remove(gint tag)
    567 {
    568         if (tag > 0)
    569                 g_source_remove(tag);
    570 }
    571 
    572 int proxy_connect(const char *host, int port, GaimInputFunction func, gpointer data)
     528int proxy_connect(const char *host, int port, b_event_handler func, gpointer data)
    573529{
    574530        struct PHB *phb;
  • protocols/proxy.h

    r881fd4e r41ca004  
    11/*
    2  * gaim
     2 * nogaim
    33 *
    44 * Copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
     
    3636#include <gmodule.h>
    3737
     38#include "events.h"
     39
    3840#define PROXY_NONE 0
    3941#define PROXY_HTTP 1
     
    4749extern char proxypass[128];
    4850
    49 typedef enum {
    50         GAIM_INPUT_READ = 1 << 0,
    51         GAIM_INPUT_WRITE = 1 << 1
    52 } GaimInputCondition;
    53 typedef void (*GaimInputFunction)(gpointer, gint, GaimInputCondition);
    54 
    55 G_MODULE_EXPORT gint gaim_input_add(int, GaimInputCondition, GaimInputFunction, gpointer);
    56 G_MODULE_EXPORT void gaim_input_remove(gint);
    57 
    58 G_MODULE_EXPORT int proxy_connect(const char *host, int port, GaimInputFunction func, gpointer data);
     51G_MODULE_EXPORT int proxy_connect(const char *host, int port, b_event_handler func, gpointer data);
    5952
    6053#endif /* _PROXY_H_ */
  • protocols/ssl_bogus.c

    r881fd4e r41ca004  
    5252}
    5353
    54 GaimInputCondition ssl_getdirection( void *conn )
     54b_input_condition ssl_getdirection( void *conn )
    5555{
    5656        return GAIM_INPUT_READ;
  • protocols/ssl_client.h

    r881fd4e r41ca004  
    3333extern int ssl_errno;
    3434
    35 typedef void (*ssl_input_function)(gpointer, void*, GaimInputCondition);
     35typedef gboolean (*ssl_input_function)(gpointer, void*, b_input_condition);
    3636
    3737G_MODULE_EXPORT void *ssl_connect( char *host, int port, ssl_input_function func, gpointer data );
     
    4040G_MODULE_EXPORT void ssl_disconnect( void *conn_ );
    4141G_MODULE_EXPORT int ssl_getfd( void *conn );
    42 G_MODULE_EXPORT GaimInputCondition ssl_getdirection( void *conn );
     42G_MODULE_EXPORT b_input_condition ssl_getdirection( void *conn );
  • protocols/ssl_gnutls.c

    r881fd4e r41ca004  
    4848};
    4949
    50 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond );
     50static gboolean ssl_connected( gpointer data, gint source, b_input_condition cond );
    5151
    5252
     
    8181}
    8282
    83 static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond );
    84 
    85 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond )
     83static gboolean ssl_handshake( gpointer data, gint source, b_input_condition cond );
     84
     85static gboolean ssl_connected( gpointer data, gint source, b_input_condition cond )
    8686{
    8787        struct scd *conn = data;
     
    9696                g_free( conn );
    9797               
    98                 return;
     98                return FALSE;
    9999        }
    100100       
     
    102102        gnutls_transport_set_ptr( conn->session, (gnutls_transport_ptr) conn->fd );
    103103       
    104         ssl_handshake( data, source, cond );
    105 }
    106 
    107 static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond )
     104        return ssl_handshake( data, source, cond );
     105}
     106
     107static gboolean ssl_handshake( gpointer data, gint source, b_input_condition cond )
    108108{
    109109        struct scd *conn = data;
    110110        int st;
    111111       
    112         if( conn->inpa != -1 )
    113         {
    114                 gaim_input_remove( conn->inpa );
    115                 conn->inpa = -1;
    116         }
    117        
    118112        if( ( st = gnutls_handshake( conn->session ) ) < 0 )
    119113        {
    120114                if( st == GNUTLS_E_AGAIN || st == GNUTLS_E_INTERRUPTED )
    121115                {
    122                         conn->inpa = gaim_input_add( conn->fd, ssl_getdirection( conn ),
    123                                                      ssl_handshake, data );
     116                        conn->inpa = b_input_add( conn->fd, ssl_getdirection( conn ),
     117                                                  ssl_handshake, data );
    124118                }
    125119                else
     
    142136                conn->func( conn->data, conn, cond );
    143137        }
     138       
     139        return FALSE;
    144140}
    145141
     
    187183       
    188184        if( conn->inpa != -1 )
    189                 gaim_input_remove( conn->inpa );
     185                b_event_remove( conn->inpa );
    190186       
    191187        if( conn->established )
     
    204200}
    205201
    206 GaimInputCondition ssl_getdirection( void *conn )
     202b_input_condition ssl_getdirection( void *conn )
    207203{
    208204        return( gnutls_record_get_direction( ((struct scd*)conn)->session ) ?
  • protocols/ssl_nss.c

    r881fd4e r41ca004  
    5252};
    5353
    54 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond );
     54static gboolean ssl_connected( gpointer data, gint source, b_input_condition cond );
    5555
    5656
     
    116116}
    117117
    118 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond )
     118static gboolean ssl_connected( gpointer data, gint source, b_input_condition cond )
    119119{
    120120        struct scd *conn = data;
     
    140140        conn->established = TRUE;
    141141        conn->func( conn->data, conn, cond );
    142         return;
     142        return FALSE;
    143143       
    144144        ssl_connected_failure:
     
    149149        if( source >= 0 ) closesocket( source );
    150150        g_free( conn );
     151       
     152        return FALSE;
    151153}
    152154
     
    182184}
    183185
    184 GaimInputCondition ssl_getdirection( void *conn )
     186b_input_condition ssl_getdirection( void *conn )
    185187{
    186188        /* Just in case someone calls us, let's return the most likely case: */
  • protocols/ssl_openssl.c

    r881fd4e r41ca004  
    5252};
    5353
    54 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond );
    55 
     54static gboolean ssl_connected( gpointer data, gint source, b_input_condition cond );
    5655
    5756
     
    9594}
    9695
    97 static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond );
    98 
    99 static void ssl_connected( gpointer data, gint source, GaimInputCondition cond )
     96static gboolean ssl_handshake( gpointer data, gint source, b_input_condition cond );
     97
     98static gboolean ssl_connected( gpointer data, gint source, b_input_condition cond )
    10099{
    101100        struct scd *conn = data;
     
    104103                return ssl_handshake( data, -1, cond );
    105104       
    106         /* Make it non-blocking at least during the handshake... */
     105        /* We can do at least the handshake with non-blocking I/O */
    107106        sock_make_nonblocking( conn->fd );
    108107        SSL_set_fd( conn->ssl, conn->fd );
     
    111110}       
    112111
    113 static void ssl_handshake( gpointer data, gint source, GaimInputCondition cond )
     112static gboolean ssl_handshake( gpointer data, gint source, b_input_condition cond )
    114113{
    115114        struct scd *conn = data;
    116115        int st;
    117        
    118         if( conn->inpa != -1 )
    119         {
    120                 gaim_input_remove( conn->inpa );
    121                 conn->inpa = -1;
    122         }
    123116       
    124117        if( ( st = SSL_connect( conn->ssl ) ) < 0 )
     
    128121                        goto ssl_connected_failure;
    129122               
    130                 conn->inpa = gaim_input_add( conn->fd, ssl_getdirection( conn ), ssl_handshake, data );
    131                 return;
     123                conn->inpa = b_input_add( conn->fd, ssl_getdirection( conn ), ssl_handshake, data );
     124                return FALSE;
    132125        }
    133126       
     
    135128        sock_make_blocking( conn->fd );         /* For now... */
    136129        conn->func( conn->data, conn, cond );
    137         return;
     130        return FALSE;
    138131       
    139132ssl_connected_failure:
     
    151144        if( source >= 0 ) closesocket( source );
    152145        g_free( conn );
     146       
     147        return FALSE;
    153148}
    154149
     
    204199       
    205200        if( conn->inpa != -1 )
    206                 gaim_input_remove( conn->inpa );
     201                b_event_remove( conn->inpa );
    207202       
    208203        if( conn->established )
     
    221216}
    222217
    223 GaimInputCondition ssl_getdirection( void *conn )
     218b_input_condition ssl_getdirection( void *conn )
    224219{
    225220        return( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE ? GAIM_INPUT_WRITE : GAIM_INPUT_READ );
  • protocols/yahoo/yahoo.c

    r881fd4e r41ca004  
    443443};
    444444
    445 void byahoo_connect_callback( gpointer data, gint source, GaimInputCondition cond )
     445void byahoo_connect_callback( gpointer data, gint source, b_input_condition cond )
    446446{
    447447        struct byahoo_connect_callback_data *d = data;
     
    465465};
    466466
    467 void byahoo_read_ready_callback( gpointer data, gint source, GaimInputCondition cond )
     467gboolean byahoo_read_ready_callback( gpointer data, gint source, b_input_condition cond )
    468468{
    469469        struct byahoo_read_ready_data *d = data;
    470470       
    471471        if( !byahoo_get_gc_by_id( d->id ) )
    472         {
    473472                /* WTF doesn't libyahoo clean this up? */
    474                 ext_yahoo_remove_handler( d->id, d->tag );
    475                 return;
    476         }
     473                return FALSE;
    477474       
    478475        yahoo_read_ready( d->id, d->fd, d->data );
     476       
     477        return TRUE;
    479478}
    480479
     
    487486};
    488487
    489 void byahoo_write_ready_callback( gpointer data, gint source, GaimInputCondition cond )
     488gboolean byahoo_write_ready_callback( gpointer data, gint source, b_input_condition cond )
    490489{
    491490        struct byahoo_write_ready_data *d = data;
    492491       
    493492        if( !byahoo_get_gc_by_id( d->id ) )
    494         {
    495493                /* WTF doesn't libyahoo clean this up? */
    496                 ext_yahoo_remove_handler( d->id, d->tag );
    497                 return;
    498         }
     494                return FALSE;
    499495       
    500496        yahoo_write_ready( d->id, d->fd, d->data );
     497       
     498        return FALSE;
    501499}
    502500
     
    687685               
    688686                inp->d = d;
    689                 d->tag = inp->h = gaim_input_add( fd, GAIM_INPUT_READ, (GaimInputFunction) byahoo_read_ready_callback, (gpointer) d );
     687                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
    690688        }
    691689        else if( cond == YAHOO_INPUT_WRITE )
     
    698696               
    699697                inp->d = d;
    700                 d->tag = inp->h = gaim_input_add( fd, GAIM_INPUT_WRITE, (GaimInputFunction) byahoo_write_ready_callback, (gpointer) d );
     698                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
    701699        }
    702700        else
     
    729727        }
    730728       
    731         gaim_input_remove( tag );
     729        b_event_remove( tag );
    732730}
    733731
     
    738736       
    739737        d = g_new0( struct byahoo_connect_callback_data, 1 );
    740         if( ( fd = proxy_connect( host, port, (GaimInputFunction) byahoo_connect_callback, (gpointer) d ) ) < 0 )
     738        if( ( fd = proxy_connect( host, port, (b_event_handler) byahoo_connect_callback, (gpointer) d ) ) < 0 )
    741739        {
    742740                g_free( d );
  • sock.h

    r881fd4e r41ca004  
    1818#define sock_make_blocking(fd) fcntl(fd, F_SETFL, 0)
    1919#define sockerr_again() (errno == EINPROGRESS || errno == EINTR)
     20#ifndef EVENTS_LIBEVENT
    2021#define closesocket(a) close(a)
     22#endif
    2123#else
    2224# include <winsock2.h>
  • unix.c

    r881fd4e r41ca004  
    4747        memset( &global, 0, sizeof( global_t ) );
    4848       
    49         global.loop = g_main_new( FALSE );
     49        b_main_init();
    5050       
    5151        log_init();
     
    117117                log_message( LOGLVL_WARNING, "Error opening helpfile %s.", HELP_FILE );
    118118       
    119         g_main_run( global.loop );
     119        b_main_run();
    120120       
    121121        if( global.restart )
     
    165165                       
    166166                        log_message( LOGLVL_ERROR, "SIGTERM received, cleaning up process." );
    167                         g_timeout_add_full( G_PRIORITY_LOW, 1, (GSourceFunc) bitlbee_shutdown, NULL, NULL );
     167                        b_timeout_add( 1, (b_event_handler) bitlbee_shutdown, NULL );
    168168                       
    169169                        first = 0;
  • user.c

    r881fd4e r41ca004  
    109109                        if( u->handle ) g_free( u->handle );
    110110                        if( u->sendbuf ) g_free( u->sendbuf );
    111                         if( u->sendbuf_timer ) g_source_remove( u->sendbuf_timer );
     111                        if( u->sendbuf_timer ) b_event_remove( u->sendbuf_timer );
    112112                        g_free( u );
    113113                       
Note: See TracChangeset for help on using the changeset viewer.