Changes in / [4e04194:fb51d85]


Ignore:
Files:
2 deleted
23 edited

Legend:

Unmodified
Added
Removed
  • bitlbee.c

    r4e04194 rfb51d85  
    9393        }
    9494       
    95         global.listen_watch_source_id = b_input_add( global.listen_socket, B_EV_IO_READ, bitlbee_io_new_client, NULL );
     95        global.listen_watch_source_id = b_input_add( global.listen_socket, GAIM_INPUT_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, B_EV_IO_READ, ipc_master_read, child );
     286                        child->ipc_inpa = b_input_add( child->ipc_fd, GAIM_INPUT_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], B_EV_IO_READ, ipc_child_read, irc );
     314                        global.listen_watch_source_id = b_input_add( fds[1], GAIM_INPUT_READ, ipc_child_read, irc );
    315315                       
    316316                        close( fds[0] );
  • configure

    r4e04194 rfb51d85  
    2626oscar=1
    2727yahoo=1
    28 purple=0
    2928
    3029debug=0
     
    6766--oscar=0/1     Disable/enable Oscar part (ICQ, AIM)    $oscar
    6867--yahoo=0/1     Disable/enable Yahoo part               $yahoo
    69 
    70 --purple=0/1    Disable/enable libpurple support        $purple
    7168
    7269--debug=0/1     Disable/enable debugging                $debug
     
    450447protoobjs=''
    451448
    452 if [ "$purple" = 0 ]; then
    453         echo '#undef WITH_PURPLE' >> config.h
    454 else
    455         echo '#define WITH_PURPLE' >> config.h
    456         echo 'EFLAGS += $$(pkg-config purple --libs)' >> Makefile.settings
    457         protocols=$protocols'purple '
    458         protoobjs=$protoobjs'purple_mod.o '
    459 
    460         # Having both libpurple and native IM modules in one binary may
    461         # do strange things. Let's not do that.
    462         msn=0
    463         jabber=0
    464         oscar=0
    465         yahoo=0
    466 fi
    467 
    468449if [ "$msn" = 0 ]; then
    469450        echo '#undef WITH_MSN' >> config.h
  • ipc.c

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

    r4e04194 rfb51d85  
    9090        sock_make_nonblocking( irc->fd );
    9191       
    92         irc->r_watch_source_id = b_input_add( irc->fd, B_EV_IO_READ, bitlbee_io_current_client_read, irc );
     92        irc->r_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_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, B_EV_IO_WRITE ) ) */
     655                if( bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE ) ) */
    656656               
    657657                /* So just always do it via the event handler. */
    658                 irc->w_watch_source_id = b_input_add( irc->fd, B_EV_IO_WRITE, bitlbee_io_current_client_write, irc );
     658                irc->w_watch_source_id = b_input_add( irc->fd, GAIM_INPUT_WRITE, bitlbee_io_current_client_write, irc );
    659659        }
    660660       
     
    682682                if( now )
    683683                {
    684                         bitlbee_io_current_client_write( irc, irc->fd, B_EV_IO_WRITE );
     684                        bitlbee_io_current_client_write( irc, irc->fd, GAIM_INPUT_WRITE );
    685685                }
    686686                temp = temp->next;
  • lib/events.h

    r4e04194 rfb51d85  
    4848   the given callback function. */
    4949typedef enum {
    50         B_EV_IO_READ = 1 << 0,
    51         B_EV_IO_WRITE = 1 << 1,
    52         B_EV_FLAG_FORCE_ONCE = 1 << 16,
    53         B_EV_FLAG_FORCE_REPEAT = 1 << 17,
     50        GAIM_INPUT_READ = 1 << 1,
     51        GAIM_INPUT_WRITE = 1 << 2
    5452} b_input_condition;
    5553typedef gboolean (*b_event_handler)(gpointer data, gint fd, b_input_condition cond);
  • lib/events_glib.c

    r4e04194 rfb51d85  
    4949        b_event_handler function;
    5050        gpointer data;
    51         guint flags;
    5251} GaimIOClosure;
    5352
     
    7776
    7877        if (condition & GAIM_READ_COND)
    79                 gaim_cond |= B_EV_IO_READ;
     78                gaim_cond |= GAIM_INPUT_READ;
    8079        if (condition & GAIM_WRITE_COND)
    81                 gaim_cond |= B_EV_IO_WRITE;
     80                gaim_cond |= GAIM_INPUT_WRITE;
    8281       
    8382        event_debug( "gaim_io_invoke( %d, %d, 0x%x )\n", g_io_channel_unix_get_fd(source), condition, data );
     
    8887                event_debug( "Returned FALSE, cancelling.\n" );
    8988       
    90         if (closure->flags & B_EV_FLAG_FORCE_ONCE)
    91                 return FALSE;
    92         else if (closure->flags & B_EV_FLAG_FORCE_REPEAT)
    93                 return TRUE;
    94         else
    95                 return st;
     89        return st;
    9690}
    9791
     
    111105        closure->function = function;
    112106        closure->data = data;
    113         closure->flags = condition;
    114107       
    115         if (condition & B_EV_IO_READ)
     108        if (condition & GAIM_INPUT_READ)
    116109                cond |= GAIM_READ_COND;
    117         if (condition & B_EV_IO_WRITE)
     110        if (condition & GAIM_INPUT_WRITE)
    118111                cond |= GAIM_WRITE_COND;
    119112       
  • lib/events_libevent.c

    r4e04194 rfb51d85  
    6060        b_event_handler function;
    6161        void *data;
    62         guint flags;
    6362};
    6463
     
    127126        {
    128127                if( event & EV_READ )
    129                         cond |= B_EV_IO_READ;
     128                        cond |= GAIM_INPUT_READ;
    130129                if( event & EV_WRITE )
    131                         cond |= B_EV_IO_WRITE;
     130                        cond |= GAIM_INPUT_WRITE;
    132131        }
    133132       
     
    151150                return;
    152151        }
    153         else if( !st && !( b_ev->flags & B_EV_FLAG_FORCE_REPEAT ) )
     152        else if( !st )
    154153        {
    155154                event_debug( "Handler returned FALSE: " );
     
    175174        event_debug( "b_input_add( %d, %d, 0x%x, 0x%x ) ", fd, condition, function, data );
    176175       
    177         if( ( condition & B_EV_IO_READ  && ( b_ev = g_hash_table_lookup( read_hash,  &fd ) ) ) ||
    178             ( condition & B_EV_IO_WRITE && ( b_ev = g_hash_table_lookup( write_hash, &fd ) ) ) )
     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 ) ) ) )
    179178        {
    180179                /* We'll stick with this libevent entry, but give it a new BitlBee id. */
     
    199198               
    200199                out_cond = EV_PERSIST;
    201                 if( condition & B_EV_IO_READ )
     200                if( condition & GAIM_INPUT_READ )
    202201                        out_cond |= EV_READ;
    203                 if( condition & B_EV_IO_WRITE )
     202                if( condition & GAIM_INPUT_WRITE )
    204203                        out_cond |= EV_WRITE;
    205204               
     
    213212        }
    214213       
    215         b_ev->flags = condition;
    216214        g_hash_table_insert( id_hash, &b_ev->id, b_ev );
    217215        return b_ev->id;
  • lib/http_client.c

    r4e04194 rfb51d85  
    149149        if( req->bytes_written < req->request_length )
    150150                req->inpa = b_input_add( source,
    151                                          req->ssl ? ssl_getdirection( req->ssl ) : B_EV_IO_WRITE,
     151                                         req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_WRITE,
    152152                                         http_connected, req );
    153153        else
    154                 req->inpa = b_input_add( source, B_EV_IO_READ, http_incoming_data, req );
     154                req->inpa = b_input_add( source, GAIM_INPUT_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 ) : B_EV_IO_READ,
     236                                 req->ssl ? ssl_getdirection( req->ssl ) : GAIM_INPUT_READ,
    237237                                 http_incoming_data, req );
    238238       
  • lib/proxy.c

    r4e04194 rfb51d85  
    9191                b_event_remove(phb->inpa);
    9292                if( phb->proxy_func )
    93                         phb->proxy_func(phb->proxy_data, -1, B_EV_IO_READ);
     93                        phb->proxy_func(phb->proxy_data, -1, GAIM_INPUT_READ);
    9494                else {
    95                         phb->func(phb->data, -1, B_EV_IO_READ);
     95                        phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     104                phb->proxy_func(phb->proxy_data, source, GAIM_INPUT_READ);
    105105        else {
    106                 phb->func(phb->data, source, B_EV_IO_READ);
     106                phb->func(phb->data, source, GAIM_INPUT_READ);
    107107                g_free(phb);
    108108        }
     
    147147                return -1;
    148148        } else {
    149                 phb->inpa = b_input_add(fd, B_EV_IO_WRITE, gaim_io_connected, phb);
     149                phb->inpa = b_input_add(fd, GAIM_INPUT_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, B_EV_IO_READ);
     181                phb->func(phb->data, source, GAIM_INPUT_READ);
    182182                g_free(phb->host);
    183183                g_free(phb);
     
    186186
    187187        close(source);
    188         phb->func(phb->data, -1, B_EV_IO_READ);
     188        phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     206                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     217                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     232                        phb->func(phb->data, -1, GAIM_INPUT_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, 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);
     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);
    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, B_EV_IO_READ);
     275                phb->func(phb->data, source, GAIM_INPUT_READ);
    276276                g_free(phb->host);
    277277                g_free(phb);
     
    280280
    281281        close(source);
    282         phb->func(phb->data, -1, B_EV_IO_READ);
     282        phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     301                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     311                phb->func(phb->data, -1, GAIM_INPUT_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, 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);
     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);
    335335       
    336336        return FALSE;
     
    359359        if (read(source, buf, 10) < 10) {
    360360                close(source);
    361                 phb->func(phb->data, -1, B_EV_IO_READ);
     361                phb->func(phb->data, -1, GAIM_INPUT_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, 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);
     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);
    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, B_EV_IO_READ);
     398                phb->func(phb->data, -1, GAIM_INPUT_READ);
    399399                g_free(phb->host);
    400400                g_free(phb);
     
    402402        }
    403403
    404         phb->inpa = b_input_add(source, B_EV_IO_READ, s5_canread_again, phb);
     404        phb->inpa = b_input_add(source, GAIM_INPUT_READ, s5_canread_again, phb);
    405405}
    406406
     
    414414        if (read(source, buf, 2) < 2) {
    415415                close(source);
    416                 phb->func(phb->data, -1, B_EV_IO_READ);
     416                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     424                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     444                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     452                phb->func(phb->data, -1, GAIM_INPUT_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, B_EV_IO_READ);
     467                        phb->func(phb->data, -1, GAIM_INPUT_READ);
    468468                        g_free(phb->host);
    469469                        g_free(phb);
     
    471471                }
    472472
    473                 phb->inpa = b_input_add(source, B_EV_IO_READ, s5_readauth, phb);
     473                phb->inpa = b_input_add(source, GAIM_INPUT_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, B_EV_IO_READ);
     493                phb->func(phb->data, -1, GAIM_INPUT_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, 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);
     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);
    522522       
    523523        return FALSE;
  • lib/ssl_bogus.c

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

    r4e04194 rfb51d85  
    7171G_MODULE_EXPORT int ssl_getfd( void *conn );
    7272
    73 /* This function returns B_EV_IO_READ/WRITE. With SSL connections it's
     73/* This function returns GAIM_INPUT_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

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

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

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

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

    r4e04194 rfb51d85  
    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, B_EV_IO_WRITE, jabber_write_callback, ic );
     66                        jd->w_inpa = b_input_add( jd->fd, GAIM_INPUT_WRITE, jabber_write_callback, ic );
    6767        }
    6868        else
     
    529529       
    530530        if( jd->r_inpa <= 0 )
    531                 jd->r_inpa = b_input_add( jd->fd, B_EV_IO_READ, jabber_read_callback, ic );
     531                jd->r_inpa = b_input_add( jd->fd, GAIM_INPUT_READ, jabber_read_callback, ic );
    532532       
    533533        greet = g_strdup_printf( "<?xml version='1.0' ?>"
  • protocols/msn/ns.c

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

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

    r4e04194 rfb51d85  
    104104{
    105105        GList *gl;
    106        
    107         for( gl = protocols; gl; gl = gl->next )
     106        for (gl = protocols; gl; gl = gl->next)
    108107        {
    109108                struct prpl *proto = gl->data;
    110                
    111                 if( g_strcasecmp( proto->name, name ) == 0 )
     109                if(!g_strcasecmp(proto->name, name))
    112110                        return proto;
    113 
    114 #ifdef WITH_PURPLE
    115                 /* I know, hardcoding is evil, but that doesn't make it
    116                    impossible. :-) */
    117                 if( g_strncasecmp( proto->name, "prpl-", 5 ) == 0 &&
    118                     g_strcasecmp( proto->name + 5, name ) == 0 )
    119                         return proto;
    120 #endif
    121111        }
    122        
    123112        return NULL;
    124113}
     
    131120        extern void byahoo_initmodule();
    132121        extern void jabber_initmodule();
    133         extern void purple_initmodule();
    134122
    135123#ifdef WITH_MSN
     
    147135#ifdef WITH_JABBER
    148136        jabber_initmodule();
    149 #endif
    150        
    151 #ifdef WITH_PURPLE
    152         purple_initmodule();
    153137#endif
    154138
  • protocols/oscar/oscar.c

    r4e04194 rfb51d85  
    291291        odata = (struct oscar_data *)ic->proto_data;
    292292
    293         if (condition & B_EV_IO_READ) {
     293        if (condition & GAIM_INPUT_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, B_EV_IO_READ,
     365        ic->inpa = b_input_add(conn->fd, GAIM_INPUT_READ,
    366366                        oscar_callback, conn);
    367367       
     
    487487
    488488        aim_conn_completeconnect(sess, bosconn);
    489         ic->inpa = b_input_add(bosconn->fd, B_EV_IO_READ,
     489        ic->inpa = b_input_add(bosconn->fd, GAIM_INPUT_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, B_EV_IO_READ, damn_you, pos);
     665        pos->inpa = b_input_add(pos->fd, GAIM_INPUT_READ, damn_you, pos);
    666666        return FALSE;
    667667}
     
    832832
    833833        aim_conn_completeconnect(sess, tstconn);
    834         odata->cnpa = b_input_add(tstconn->fd, B_EV_IO_READ,
     834        odata->cnpa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
    835835                                        oscar_callback, tstconn);
    836836       
     
    860860
    861861        aim_conn_completeconnect(sess, tstconn);
    862         odata->paspa = b_input_add(tstconn->fd, B_EV_IO_READ,
     862        odata->paspa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
    863863                                oscar_callback, tstconn);
    864864       
     
    896896        aim_conn_completeconnect(sess, ccon->conn);
    897897        ccon->inpa = b_input_add(tstconn->fd,
    898                         B_EV_IO_READ,
     898                        GAIM_INPUT_READ,
    899899                        oscar_callback, tstconn);
    900900        odata->oscar_chats = g_slist_append(odata->oscar_chats, ccon);
  • protocols/yahoo/yahoo.c

    r4e04194 rfb51d85  
    700700               
    701701                inp->d = d;
    702                 d->tag = inp->h = b_input_add( fd, B_EV_IO_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
     702                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_READ, (b_event_handler) byahoo_read_ready_callback, (gpointer) d );
    703703        }
    704704        else if( cond == YAHOO_INPUT_WRITE )
     
    711711               
    712712                inp->d = d;
    713                 d->tag = inp->h = b_input_add( fd, B_EV_IO_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
     713                d->tag = inp->h = b_input_add( fd, GAIM_INPUT_WRITE, (b_event_handler) byahoo_write_ready_callback, (gpointer) d );
    714714        }
    715715        else
  • set.c

    r4e04194 rfb51d85  
    2929char *SET_INVALID = "nee";
    3030
    31 set_t *set_add( set_t **head, const char *key, const char *def, set_eval eval, void *data )
     31set_t *set_add( set_t **head, char *key, char *def, set_eval eval, void *data )
    3232{
    3333        set_t *s = set_find( head, key );
     
    6363}
    6464
    65 set_t *set_find( set_t **head, const char *key )
     65set_t *set_find( set_t **head, char *key )
    6666{
    6767        set_t *s = *head;
     
    7777}
    7878
    79 char *set_getstr( set_t **head, const char *key )
     79char *set_getstr( set_t **head, char *key )
    8080{
    8181        set_t *s = set_find( head, key );
     
    8787}
    8888
    89 int set_getint( set_t **head, const char *key )
     89int set_getint( set_t **head, char *key )
    9090{
    9191        char *s = set_getstr( head, key );
     
    101101}
    102102
    103 int set_getbool( set_t **head, const char *key )
     103int set_getbool( set_t **head, char *key )
    104104{
    105105        char *s = set_getstr( head, key );
     
    111111}
    112112
    113 int set_setstr( set_t **head, const char *key, char *value )
     113int set_setstr( set_t **head, char *key, char *value )
    114114{
    115115        set_t *s = set_find( head, key );
     
    150150}
    151151
    152 int set_setint( set_t **head, const char *key, int value )
     152int set_setint( set_t **head, char *key, int value )
    153153{
    154154        char s[24];     /* Not quite 128-bit clean eh? ;-) */
     
    158158}
    159159
    160 void set_del( set_t **head, const char *key )
     160void set_del( set_t **head, char *key )
    161161{
    162162        set_t *s = *head, *t = NULL;
     
    182182}
    183183
    184 int set_reset( set_t **head, const char *key )
     184int set_reset( set_t **head, char *key )
    185185{
    186186        set_t *s;
  • set.h

    r4e04194 rfb51d85  
    7373
    7474/* Should be pretty clear. */
    75 set_t *set_add( set_t **head, const char *key, const char *def, set_eval eval, void *data );
     75set_t *set_add( set_t **head, char *key, char *def, set_eval eval, void *data );
    7676
    7777/* Returns the raw set_t. Might be useful sometimes. */
    78 set_t *set_find( set_t **head, const char *key );
     78set_t *set_find( set_t **head, char *key );
    7979
    8080/* Returns a pointer to the string value of this setting. Don't modify the
    8181   returned string, and don't free() it! */
    82 G_MODULE_EXPORT char *set_getstr( set_t **head, const char *key );
     82G_MODULE_EXPORT char *set_getstr( set_t **head, char *key );
    8383
    8484/* Get an integer. In previous versions set_getint() was also used to read
    8585   boolean values, but this SHOULD be done with set_getbool() now! */
    86 G_MODULE_EXPORT int set_getint( set_t **head, const char *key );
    87 G_MODULE_EXPORT int set_getbool( set_t **head, const char *key );
     86G_MODULE_EXPORT int set_getint( set_t **head, char *key );
     87G_MODULE_EXPORT int set_getbool( set_t **head, char *key );
    8888
    8989/* set_setstr() strdup()s the given value, so after using this function
    9090   you can free() it, if you want. */
    91 int set_setstr( set_t **head, const char *key, char *value );
    92 int set_setint( set_t **head, const char *key, int value );
    93 void set_del( set_t **head, const char *key );
    94 int set_reset( set_t **head, const char *key );
     91int set_setstr( set_t **head, char *key, char *value );
     92int set_setint( set_t **head, char *key, int value );
     93void set_del( set_t **head, char *key );
     94int set_reset( set_t **head, char *key );
    9595
    9696/* Two very useful generic evaluators. */
Note: See TracChangeset for help on using the changeset viewer.