Changeset e046390 for lib


Ignore:
Timestamp:
2009-10-10T23:25:54Z (15 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.

Location:
lib
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • 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}
Note: See TracChangeset for help on using the changeset viewer.