Changeset e046390


Ignore:
Timestamp:
2009-10-10T23:25:54Z (10 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
c5c18c1
Parents:
0cbef26
Message:

Make purple use BitlBee's event handling API. Since the APIs never really
diverged too much this is fairly transparent. I did rename and redefine
GAIM_INPUT_* variables to really make it work without adding another stupid
layer in between.

One problem left, the new libpurple input API doesn't care about return
values. Fixing that in the next CL.

Files:
20 edited

Legend:

Unmodified
Added
Removed
  • bitlbee.c

    r0cbef26 re046390  
    9393        }
    9494       
    95         global.listen_watch_source_id = b_input_add( global.listen_socket, GAIM_INPUT_READ, bitlbee_io_new_client, NULL );
     95        global.listen_watch_source_id = b_input_add( global.listen_socket, B_EV_IO_READ, bitlbee_io_new_client, NULL );
    9696       
    9797#ifndef _WIN32
     
    284284                        child->pid = client_pid;
    285285                        child->ipc_fd = fds[0];
    286                         child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
     286                        child->ipc_inpa = b_input_add( child->ipc_fd, B_EV_IO_READ, ipc_master_read, child );
    287287                        child_list = g_slist_append( child_list, child );
    288288                       
     
    312312                        /* We can store the IPC fd there now. */
    313313                        global.listen_socket = fds[1];
    314                         global.listen_watch_source_id = b_input_add( fds[1], GAIM_INPUT_READ, ipc_child_read, irc );
     314                        global.listen_watch_source_id = b_input_add( fds[1], B_EV_IO_READ, ipc_child_read, irc );
    315315                       
    316316                        close( fds[0] );
  • ipc.c

    r0cbef26 re046390  
    514514        }
    515515               
    516         child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
     516        child->ipc_inpa = b_input_add( child->ipc_fd, B_EV_IO_READ, ipc_master_read, child );
    517517       
    518518        child_list = g_slist_append( child_list, child );
     
    552552        }
    553553       
    554         b_input_add( serversock, GAIM_INPUT_READ, new_ipc_client, NULL );
     554        b_input_add( serversock, B_EV_IO_READ, new_ipc_client, NULL );
    555555       
    556556        return 1;
     
    597597                        return 0;
    598598                }
    599                 child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_READ, ipc_master_read, child );
     599                child->ipc_inpa = b_input_add( child->ipc_fd, B_EV_IO_READ, ipc_master_read, child );
    600600               
    601601                child_list = g_slist_append( child_list, child );
  • irc.c

    r0cbef26 re046390  
    9090        sock_make_nonblocking( irc->fd );
    9191       
    92         irc->r_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_READ, bitlbee_io_current_client_read, irc );
     92        irc->r_watch_source_id = b_input_add( irc->fd, B_EV_IO_READ, bitlbee_io_current_client_read, irc );
    9393       
    9494        irc->status = USTATUS_OFFLINE;
     
    653653                   in the event queue. */
    654654                /* Really can't be done as long as the code doesn't do error checking very well:
    655                 if( bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE ) ) */
     655                if( bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE ) ) */
    656656               
    657657                /* So just always do it via the event handler. */
    658                 irc->w_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_WRITE, bitlbee_io_current_client_write, irc );
     658                irc->w_watch_source_id = b_input_add( irc->fd, B_EV_IO_WRITE, bitlbee_io_current_client_write, irc );
    659659        }
    660660       
     
    682682                if( now )
    683683                {
    684                         bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE );
     684                        bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE );
    685685                }
    686686                temp = temp->next;
  • lib/events.h

    r0cbef26 re046390  
    4848   the given callback function. */
    4949typedef enum {
    50         GAIM_INPUT_READ = 1 << 1,
    51         GAIM_INPUT_WRITE = 1 << 2
     50        B_EV_IO_READ = 1 << 0,
     51        B_EV_IO_WRITE = 1 << 1
    5252} b_input_condition;
    5353typedef gboolean (*b_event_handler)(gpointer data, gint fd, b_input_condition cond);
  • lib/events_glib.c

    r0cbef26 re046390  
    7676
    7777        if (condition & GAIM_READ_COND)
    78                 gaim_cond |= GAIM_INPUT_READ;
     78                gaim_cond |= B_EV_IO_READ;
    7979        if (condition & GAIM_WRITE_COND)
    80                 gaim_cond |= GAIM_INPUT_WRITE;
     80                gaim_cond |= B_EV_IO_WRITE;
    8181       
    8282        event_debug( "gaim_io_invoke( %d, %d, 0x%x )\n", g_io_channel_unix_get_fd(source), condition, data );
     
    106106        closure->data = data;
    107107       
    108         if (condition & GAIM_INPUT_READ)
     108        if (condition & B_EV_IO_READ)
    109109                cond |= GAIM_READ_COND;
    110         if (condition & GAIM_INPUT_WRITE)
     110        if (condition & B_EV_IO_WRITE)
    111111                cond |= GAIM_WRITE_COND;
    112112       
  • lib/events_libevent.c

    r0cbef26 re046390  
    126126        {
    127127                if( event & EV_READ )
    128                         cond |= GAIM_INPUT_READ;
     128                        cond |= B_EV_IO_READ;
    129129                if( event & EV_WRITE )
    130                         cond |= GAIM_INPUT_WRITE;
     130                        cond |= B_EV_IO_WRITE;
    131131        }
    132132       
     
    174174        event_debug( "b_input_add( %d, %d, 0x%x, 0x%x ) ", fd, condition, function, data );
    175175       
    176         if( ( condition & GAIM_INPUT_READ  && ( b_ev = g_hash_table_lookup( read_hash,  &fd ) ) ) ||
    177             ( condition & GAIM_INPUT_WRITE && ( b_ev = g_hash_table_lookup( write_hash, &fd ) ) ) )
     176        if( ( condition & B_EV_IO_READ  && ( b_ev = g_hash_table_lookup( read_hash,  &fd ) ) ) ||
     177            ( condition & B_EV_IO_WRITE && ( b_ev = g_hash_table_lookup( write_hash, &fd ) ) ) )
    178178        {
    179179                /* We'll stick with this libevent entry, but give it a new BitlBee id. */
     
    198198               
    199199                out_cond = EV_PERSIST;
    200                 if( condition & GAIM_INPUT_READ )
     200                if( condition & B_EV_IO_READ )
    201201                        out_cond |= EV_READ;
    202                 if( condition & GAIM_INPUT_WRITE )
     202                if( condition & B_EV_IO_WRITE )
    203203                        out_cond |= EV_WRITE;
    204204               
  • lib/http_client.c

    r0cbef26 re046390  
    149149        if( req->bytes_written < req->request_length )
    150150                req->inpa = b_input_add( source,
    151                                          req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_WRITE,
     151                                         req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_WRITE,
    152152                                         http_connected, req );
    153153        else
    154                 req->inpa = b_input_add( source, GAIM_INPUT_READ, http_incoming_data, req );
     154                req->inpa = b_input_add( source, B_EV_IO_READ, http_incoming_data, req );
    155155       
    156156        return FALSE;
     
    234234        /* There will be more! */
    235235        req->inpa = b_input_add( req->fd,
    236                                  req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_READ,
     236                                 req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_READ,
    237237                                 http_incoming_data, req );
    238238       
  • lib/proxy.c

    r0cbef26 re046390  
    9191                b_event_remove(phb->inpa);
    9292                if( phb->proxy_func )
    93                         phb->proxy_func(phb->proxy_data, -1, GAIM_INPUT_READ);
     93                        phb->proxy_func(phb->proxy_data, -1, B_EV_IO_READ);
    9494                else {
    95                         phb->func(phb->data, -1, GAIM_INPUT_READ);
     95                        phb->func(phb->data, -1, B_EV_IO_READ);
    9696                        g_free(phb);
    9797                }
     
    102102        b_event_remove(phb->inpa);
    103103        if( phb->proxy_func )
    104                 phb->proxy_func(phb->proxy_data, source, GAIM_INPUT_READ);
     104                phb->proxy_func(phb->proxy_data, source, B_EV_IO_READ);
    105105        else {
    106                 phb->func(phb->data, source, GAIM_INPUT_READ);
     106                phb->func(phb->data, source, B_EV_IO_READ);
    107107                g_free(phb);
    108108        }
     
    147147                return -1;
    148148        } else {
    149                 phb->inpa = b_input_add(fd, GAIM_INPUT_WRITE, gaim_io_connected, phb);
     149                phb->inpa = b_input_add(fd, B_EV_IO_WRITE, gaim_io_connected, phb);
    150150                phb->fd = fd;
    151151               
     
    179179        if ((memcmp(HTTP_GOODSTRING, inputline, strlen(HTTP_GOODSTRING)) == 0) ||
    180180            (memcmp(HTTP_GOODSTRING2, inputline, strlen(HTTP_GOODSTRING2)) == 0)) {
    181                 phb->func(phb->data, source, GAIM_INPUT_READ);
     181                phb->func(phb->data, source, B_EV_IO_READ);
    182182                g_free(phb->host);
    183183                g_free(phb);
     
    186186
    187187        close(source);
    188         phb->func(phb->data, -1, GAIM_INPUT_READ);
     188        phb->func(phb->data, -1, B_EV_IO_READ);
    189189        g_free(phb->host);
    190190        g_free(phb);
     
    204204        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
    205205                close(source);
    206                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     206                phb->func(phb->data, -1, B_EV_IO_READ);
    207207                g_free(phb->host);
    208208                g_free(phb);
     
    215215        if (send(source, cmd, strlen(cmd), 0) < 0) {
    216216                close(source);
    217                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     217                phb->func(phb->data, -1, B_EV_IO_READ);
    218218                g_free(phb->host);
    219219                g_free(phb);
     
    230230                if (send(source, cmd, strlen(cmd), 0) < 0) {
    231231                        close(source);
    232                         phb->func(phb->data, -1, GAIM_INPUT_READ);
     232                        phb->func(phb->data, -1, B_EV_IO_READ);
    233233                        g_free(phb->host);
    234234                        g_free(phb);
     
    240240        if (send(source, cmd, strlen(cmd), 0) < 0) {
    241241                close(source);
    242                 phb->func(phb->data, -1, GAIM_INPUT_READ);
    243                 g_free(phb->host);
    244                 g_free(phb);
    245                 return FALSE;
    246         }
    247 
    248         phb->inpa = b_input_add(source, GAIM_INPUT_READ, http_canread, phb);
     242                phb->func(phb->data, -1, B_EV_IO_READ);
     243                g_free(phb->host);
     244                g_free(phb);
     245                return FALSE;
     246        }
     247
     248        phb->inpa = b_input_add(source, B_EV_IO_READ, http_canread, phb);
    249249       
    250250        return FALSE;
     
    273273        memset(packet, 0, sizeof(packet));
    274274        if (read(source, packet, 9) >= 4 && packet[1] == 90) {
    275                 phb->func(phb->data, source, GAIM_INPUT_READ);
     275                phb->func(phb->data, source, B_EV_IO_READ);
    276276                g_free(phb->host);
    277277                g_free(phb);
     
    280280
    281281        close(source);
    282         phb->func(phb->data, -1, GAIM_INPUT_READ);
     282        phb->func(phb->data, -1, B_EV_IO_READ);
    283283        g_free(phb->host);
    284284        g_free(phb);
     
    299299        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
    300300                close(source);
    301                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     301                phb->func(phb->data, -1, B_EV_IO_READ);
    302302                g_free(phb->host);
    303303                g_free(phb);
     
    309309        if (!(hp = gethostbyname(phb->host))) {
    310310                close(source);
    311                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     311                phb->func(phb->data, -1, B_EV_IO_READ);
    312312                g_free(phb->host);
    313313                g_free(phb);
     
    326326        if (write(source, packet, 9) != 9) {
    327327                close(source);
    328                 phb->func(phb->data, -1, GAIM_INPUT_READ);
    329                 g_free(phb->host);
    330                 g_free(phb);
    331                 return FALSE;
    332         }
    333 
    334         phb->inpa = b_input_add(source, GAIM_INPUT_READ, s4_canread, phb);
     328                phb->func(phb->data, -1, B_EV_IO_READ);
     329                g_free(phb->host);
     330                g_free(phb);
     331                return FALSE;
     332        }
     333
     334        phb->inpa = b_input_add(source, B_EV_IO_READ, s4_canread, phb);
    335335       
    336336        return FALSE;
     
    359359        if (read(source, buf, 10) < 10) {
    360360                close(source);
    361                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     361                phb->func(phb->data, -1, B_EV_IO_READ);
    362362                g_free(phb->host);
    363363                g_free(phb);
     
    366366        if ((buf[0] != 0x05) || (buf[1] != 0x00)) {
    367367                close(source);
    368                 phb->func(phb->data, -1, GAIM_INPUT_READ);
    369                 g_free(phb->host);
    370                 g_free(phb);
    371                 return FALSE;
    372         }
    373 
    374         phb->func(phb->data, source, GAIM_INPUT_READ);
     368                phb->func(phb->data, -1, B_EV_IO_READ);
     369                g_free(phb->host);
     370                g_free(phb);
     371                return FALSE;
     372        }
     373
     374        phb->func(phb->data, source, B_EV_IO_READ);
    375375        g_free(phb->host);
    376376        g_free(phb);
     
    396396        if (write(source, buf, (5 + strlen(phb->host) + 2)) < (5 + strlen(phb->host) + 2)) {
    397397                close(source);
    398                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     398                phb->func(phb->data, -1, B_EV_IO_READ);
    399399                g_free(phb->host);
    400400                g_free(phb);
     
    402402        }
    403403
    404         phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_canread_again, phb);
     404        phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread_again, phb);
    405405}
    406406
     
    414414        if (read(source, buf, 2) < 2) {
    415415                close(source);
    416                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     416                phb->func(phb->data, -1, B_EV_IO_READ);
    417417                g_free(phb->host);
    418418                g_free(phb);
     
    422422        if ((buf[0] != 0x01) || (buf[1] != 0x00)) {
    423423                close(source);
    424                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     424                phb->func(phb->data, -1, B_EV_IO_READ);
    425425                g_free(phb->host);
    426426                g_free(phb);
     
    442442        if (read(source, buf, 2) < 2) {
    443443                close(source);
    444                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     444                phb->func(phb->data, -1, B_EV_IO_READ);
    445445                g_free(phb->host);
    446446                g_free(phb);
     
    450450        if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
    451451                close(source);
    452                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     452                phb->func(phb->data, -1, B_EV_IO_READ);
    453453                g_free(phb->host);
    454454                g_free(phb);
     
    465465                if (write(source, buf, 3 + i + j) < 3 + i + j) {
    466466                        close(source);
    467                         phb->func(phb->data, -1, GAIM_INPUT_READ);
     467                        phb->func(phb->data, -1, B_EV_IO_READ);
    468468                        g_free(phb->host);
    469469                        g_free(phb);
     
    471471                }
    472472
    473                 phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_readauth, phb);
     473                phb->inpa = b_input_add(source, B_EV_IO_READ, s5_readauth, phb);
    474474        } else {
    475475                s5_sendconnect(phb, source);
     
    491491        if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
    492492                close(source);
    493                 phb->func(phb->data, -1, GAIM_INPUT_READ);
     493                phb->func(phb->data, -1, B_EV_IO_READ);
    494494                g_free(phb->host);
    495495                g_free(phb);
     
    513513        if (write(source, buf, i) < i) {
    514514                close(source);
    515                 phb->func(phb->data, -1, GAIM_INPUT_READ);
    516                 g_free(phb->host);
    517                 g_free(phb);
    518                 return FALSE;
    519         }
    520 
    521         phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_canread, phb);
     515                phb->func(phb->data, -1, B_EV_IO_READ);
     516                g_free(phb->host);
     517                g_free(phb);
     518                return FALSE;
     519        }
     520
     521        phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread, phb);
    522522       
    523523        return FALSE;
  • lib/ssl_bogus.c

    r0cbef26 re046390  
    5959b_input_condition ssl_getdirection( void *conn )
    6060{
    61         return GAIM_INPUT_READ;
     61        return B_EV_IO_READ;
    6262}
    6363
  • lib/ssl_client.h

    r0cbef26 re046390  
    7171G_MODULE_EXPORT int ssl_getfd( void *conn );
    7272
    73 /* This function returns GAIM_INPUT_READ/WRITE. With SSL connections it's
     73/* This function returns B_EV_IO_READ/WRITE. With SSL connections it's
    7474   possible that something has to be read while actually were trying to
    7575   write something (think about key exchange/refresh/etc). So when an
  • lib/ssl_gnutls.c

    r0cbef26 re046390  
    106106        struct scd *conn = data;
    107107       
    108         return ssl_connected( conn, conn->fd, GAIM_INPUT_WRITE );
     108        return ssl_connected( conn, conn->fd, B_EV_IO_WRITE );
    109109}
    110110
     
    244244{
    245245        return( gnutls_record_get_direction( ((struct scd*)conn)->session ) ?
    246                 GAIM_INPUT_WRITE : GAIM_INPUT_READ );
    247 }
     246                B_EV_IO_WRITE : B_EV_IO_READ );
     247}
  • lib/ssl_nss.c

    r0cbef26 re046390  
    193193{
    194194        /* Just in case someone calls us, let's return the most likely case: */
    195         return GAIM_INPUT_READ;
     195        return B_EV_IO_READ;
    196196}
  • lib/ssl_openssl.c

    r0cbef26 re046390  
    102102        struct scd *conn = data;
    103103       
    104         return ssl_connected( conn, conn->fd, GAIM_INPUT_WRITE );
     104        return ssl_connected( conn, conn->fd, B_EV_IO_WRITE );
    105105}
    106106
     
    270270b_input_condition ssl_getdirection( void *conn )
    271271{
    272         return( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE ? GAIM_INPUT_WRITE : GAIM_INPUT_READ );
    273 }
     272        return( ((struct scd*)conn)->lasterr == SSL_ERROR_WANT_WRITE ? B_EV_IO_WRITE : B_EV_IO_READ );
     273}
  • lib/ssl_sspi.c

    r0cbef26 re046390  
    275275GaimInputCondition ssl_getdirection( void *conn )
    276276{
    277         return GAIM_INPUT_WRITE; /* FIXME: or GAIM_INPUT_READ */
    278 }
     277        return B_EV_IO_WRITE; /* FIXME: or B_EV_IO_READ */
     278}
  • protocols/jabber/io.c

    r0cbef26 re046390  
    6464                   most cases it probably won't be necessary.) */
    6565                if( ( ret = jabber_write_queue( ic ) ) && jd->tx_len > 0 )
    66                         jd->w_inpa = b_input_add( jd->fd, GAIM_INPUT_WRITE, jabber_write_callback, ic );
     66                        jd->w_inpa = b_input_add( jd->fd, B_EV_IO_WRITE, jabber_write_callback, ic );
    6767        }
    6868        else
     
    529529       
    530530        if( jd->r_inpa <= 0 )
    531                 jd->r_inpa = b_input_add( jd->fd, GAIM_INPUT_READ, jabber_read_callback, ic );
     531                jd->r_inpa = b_input_add( jd->fd, B_EV_IO_READ, jabber_read_callback, ic );
    532532       
    533533        greet = g_strdup_printf( "<?xml version='1.0' ?>"
  • protocols/msn/ns.c

    r0cbef26 re046390  
    7575        if( msn_write( ic, s, strlen( s ) ) )
    7676        {
    77                 ic->inpa = b_input_add( md->fd, GAIM_INPUT_READ, msn_ns_callback, ic );
     77                ic->inpa = b_input_add( md->fd, B_EV_IO_READ, msn_ns_callback, ic );
    7878                imcb_log( ic, "Connected to server, waiting for reply" );
    7979        }
  • protocols/msn/sb.c

    r0cbef26 re046390  
    309309       
    310310        if( msn_sb_write( sb, buf, strlen( buf ) ) )
    311                 sb->inp = b_input_add( sb->fd, GAIM_INPUT_READ, msn_sb_callback, sb );
     311                sb->inp = b_input_add( sb->fd, B_EV_IO_READ, msn_sb_callback, sb );
    312312        else
    313313                debug( "Error %d while connecting to switchboard server", 2 );
  • protocols/oscar/oscar.c

    r0cbef26 re046390  
    291291        odata = (struct oscar_data *)ic->proto_data;
    292292
    293         if (condition & GAIM_INPUT_READ) {
     293        if (condition & B_EV_IO_READ) {
    294294                if (aim_get_command(odata->sess, conn) >= 0) {
    295295                        aim_rxdispatch(odata->sess);
     
    363363
    364364        aim_conn_completeconnect(sess, conn);
    365         ic->inpa = b_input_add(conn->fd, GAIM_INPUT_READ,
     365        ic->inpa = b_input_add(conn->fd, B_EV_IO_READ,
    366366                        oscar_callback, conn);
    367367       
     
    487487
    488488        aim_conn_completeconnect(sess, bosconn);
    489         ic->inpa = b_input_add(bosconn->fd, GAIM_INPUT_READ,
     489        ic->inpa = b_input_add(bosconn->fd, B_EV_IO_READ,
    490490                        oscar_callback, bosconn);
    491491        imcb_log(ic, _("Connection established, cookie sent"));
     
    663663        if (pos->modname)
    664664                g_free(pos->modname);
    665         pos->inpa = b_input_add(pos->fd, GAIM_INPUT_READ, damn_you, pos);
     665        pos->inpa = b_input_add(pos->fd, B_EV_IO_READ, damn_you, pos);
    666666        return FALSE;
    667667}
     
    832832
    833833        aim_conn_completeconnect(sess, tstconn);
    834         odata->cnpa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
     834        odata->cnpa = b_input_add(tstconn->fd, B_EV_IO_READ,
    835835                                        oscar_callback, tstconn);
    836836       
     
    860860
    861861        aim_conn_completeconnect(sess, tstconn);
    862         odata->paspa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
     862        odata->paspa = b_input_add(tstconn->fd, B_EV_IO_READ,
    863863                                oscar_callback, tstconn);
    864864       
     
    896896        aim_conn_completeconnect(sess, ccon->conn);
    897897        ccon->inpa = b_input_add(tstconn->fd,
    898                         GAIM_INPUT_READ,
     898                        B_EV_IO_READ,
    899899                        oscar_callback, tstconn);
    900900        odata->oscar_chats = g_slist_append(odata->oscar_chats, ccon);
  • protocols/purple/purple.c

    r0cbef26 re046390  
    6363}
    6464
    65 static void purple_glib_io_destroy(gpointer data)
    66 {
    67         g_free(data);
    68 }
    69 
    70 static gboolean purple_glib_io_invoke(GIOChannel *source, GIOCondition condition, gpointer data)
    71 {
    72         PurpleGLibIOClosure *closure = data;
    73         PurpleInputCondition purple_cond = 0;
    74 
    75         if (condition & PURPLE_GLIB_READ_COND)
    76                 purple_cond |= PURPLE_INPUT_READ;
    77         if (condition & PURPLE_GLIB_WRITE_COND)
    78                 purple_cond |= PURPLE_INPUT_WRITE;
    79 
    80         closure->function(closure->data, g_io_channel_unix_get_fd(source),
    81                           purple_cond);
    82 
    83         return TRUE;
    84 }
    85 
    86 static guint glib_input_add(gint fd, PurpleInputCondition condition, PurpleInputFunction function,
    87                                                            gpointer data)
    88 {
    89         PurpleGLibIOClosure *closure = g_new0(PurpleGLibIOClosure, 1);
    90         GIOChannel *channel;
    91         GIOCondition cond = 0;
    92 
    93         closure->function = function;
    94         closure->data = data;
    95 
    96         if (condition & PURPLE_INPUT_READ)
    97                 cond |= PURPLE_GLIB_READ_COND;
    98         if (condition & PURPLE_INPUT_WRITE)
    99                 cond |= PURPLE_GLIB_WRITE_COND;
    100 
    101         channel = g_io_channel_unix_new(fd);
    102         closure->result = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT, cond,
    103                                               purple_glib_io_invoke, closure, purple_glib_io_destroy);
    104 
    105         g_io_channel_unref(channel);
    106         return closure->result;
     65static guint prplcb_ev_timeout_add( guint interval, GSourceFunc func, gpointer udata )
     66{
     67        return b_timeout_add( interval, (b_event_handler) func, udata );
     68}
     69
     70static guint prplcb_ev_input_add( int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer udata )
     71{
     72        return (guint) b_input_add( fd, cond, (b_event_handler) func, udata );
    10773}
    10874
    10975static PurpleEventLoopUiOps glib_eventloops =
    11076{
    111         g_timeout_add,
    112         g_source_remove,
    113         glib_input_add,
    114         g_source_remove,
    115         NULL,
    116 #if GLIB_CHECK_VERSION(2,14,0)
    117         g_timeout_add_seconds,
    118 #else
    119         NULL,
    120 #endif
    121 
    122         /* padding */
    123         NULL,
    124         NULL,
    125         NULL
     77        prplcb_ev_timeout_add,
     78        b_event_remove,
     79        prplcb_ev_input_add,
     80        b_event_remove,
    12681};
    12782
     
    13792        PurpleAccount *pa;
    13893        //PurpleSavedStatus *ps;
    139         GList *i;
     94        //GList *i;
    14095       
    14196        /* For now this is needed in the _connected() handlers if using
     
    343298        NULL,                      /* write_chat           */
    344299        prplcb_conv_im,            /* write_im             */
    345         NULL, //null_write_conv,           /* write_conv           */
     300        NULL,                      /* write_conv           */
    346301        NULL,                      /* chat_add_users       */
    347302        NULL,                      /* chat_rename_user     */
     
    381336{
    382337        GList *prots;
     338       
     339        if( B_EV_IO_READ != PURPLE_INPUT_READ ||
     340            B_EV_IO_WRITE != PURPLE_INPUT_WRITE )
     341        {
     342                /* FIXME FIXME FIXME FIXME FIXME :-) */
     343                exit( 1 );
     344        }
    383345       
    384346        purple_util_set_user_dir("/tmp");
  • protocols/yahoo/yahoo.c

    r0cbef26 re046390  
    682682               
    683683                inp->d = d;
    684                 d->tag = inp->h = b_input_add( fd, GAIM_INPUT_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
     684                d->tag = inp->h = b_input_add( fd, B_EV_IO_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
    685685        }
    686686        else if( cond == YAHOO_INPUT_WRITE )
     
    693693               
    694694                inp->d = d;
    695                 d->tag = inp->h = b_input_add( fd, GAIM_INPUT_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
     695                d->tag = inp->h = b_input_add( fd, B_EV_IO_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
    696696        }
    697697        else
Note: See TracChangeset for help on using the changeset viewer.