Changeset d8d63a2 for protocols


Ignore:
Timestamp:
2006-12-05T20:40:17Z (18 years ago)
Author:
Jelmer Vernooij <jelmer@…>
Branches:
master
Children:
7740c4c
Parents:
f4aa393 (diff), 55078f5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

[merge] wilmer

Location:
protocols
Files:
1 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • protocols/Makefile

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

  • protocols/jabber/jabber.c

    rf4aa393 rd8d63a2  
    561561static void gjab_start(gjconn gjc)
    562562{
    563         struct aim_user *user;
     563        account_t *acc;
    564564        int port = -1, ssl = 0;
    565         char *server = NULL, *s;
     565        char *server = NULL;
    566566
    567567        if (!gjc || gjc->state != JCONN_STATE_OFF)
    568568                return;
    569569
    570         user = GJ_GC(gjc)->user;
    571         if (*user->proto_opt[0]) {
    572                 /* If there's a dot, assume there's a hostname in the beginning */
    573                 if (strchr(user->proto_opt[0], '.')) {
    574                         server = g_strdup(user->proto_opt[0]);
    575                         if ((s = strchr(server, ':')))
    576                                 *s = 0;
    577                 }
    578                
    579                 /* After the hostname, there can be a port number */
    580                 s = strchr(user->proto_opt[0], ':');
    581                 if (s && isdigit(s[1]))
    582                         sscanf(s + 1, "%d", &port);
    583                
    584                 /* And if there's the string ssl, the user wants an SSL-connection */
    585                 if (strstr(user->proto_opt[0], ":ssl") || g_strcasecmp(user->proto_opt[0], "ssl") == 0)
    586                         ssl = 1;
    587         }
    588        
    589         if (port == -1 && !ssl)
    590                 port = DEFAULT_PORT;
    591         else if (port == -1 && ssl)
    592                 port = DEFAULT_PORT_SSL;
    593         else if (port < JABBER_PORT_MIN || port > JABBER_PORT_MAX) {
     570        acc = GJ_GC(gjc)->acc;
     571        server = acc->server;
     572        port = set_getint(&acc->set, "port");
     573        ssl = set_getbool(&acc->set, "ssl");
     574       
     575        if (port < JABBER_PORT_MIN || port > JABBER_PORT_MAX) {
    594576                serv_got_crap(GJ_GC(gjc), "For security reasons, the Jabber port number must be in the %d-%d range.", JABBER_PORT_MIN, JABBER_PORT_MAX);
    595577                STATE_EVT(JCONN_STATE_OFF)
    … …  
    614596        }
    615597       
    616         g_free(server);
    617        
    618         if (!user->gc || (gjc->fd < 0)) {
     598        if (!acc->gc || (gjc->fd < 0)) {
    619599                STATE_EVT(JCONN_STATE_OFF)
    620600                return;
    … …  
    15161496}
    15171497
    1518 static void jabber_login(struct aim_user *user)
    1519 {
    1520         struct gaim_connection *gc = new_gaim_conn(user);
    1521         struct jabber_data *jd = gc->proto_data = g_new0(struct jabber_data, 1);
    1522         char *loginname = create_valid_jid(user->username, DEFAULT_SERVER, "BitlBee");
    1523 
     1498static void jabber_acc_init(account_t *acc)
     1499{
     1500        set_t *s;
     1501       
     1502        s = set_add( &acc->set, "port", "5222", set_eval_int, acc );
     1503        s->flags |= ACC_SET_OFFLINE_ONLY;
     1504       
     1505        s = set_add( &acc->set, "resource", "BitlBee", NULL, acc );
     1506        s->flags |= ACC_SET_OFFLINE_ONLY;
     1507       
     1508        s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
     1509        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
     1510       
     1511        s = set_add( &acc->set, "ssl", "false", set_eval_bool, acc );
     1512        s->flags |= ACC_SET_OFFLINE_ONLY;
     1513}
     1514
     1515static void jabber_login(account_t *acc)
     1516{
     1517        struct gaim_connection *gc;
     1518        struct jabber_data *jd;
     1519        char *resource, *loginname;
     1520       
     1521        /* Time to move some data/things from the old syntax to the new one: */
     1522        if (acc->server) {
     1523                char *s, *tmp_server;
     1524                int port;
     1525               
     1526                if (g_strcasecmp(acc->server, "ssl") == 0) {
     1527                        set_setstr(&acc->set, "server", "");
     1528                        set_setint(&acc->set, "port", DEFAULT_PORT_SSL);
     1529                        set_setstr(&acc->set, "ssl", "true");
     1530                       
     1531                        g_free(acc->server);
     1532                        acc->server = NULL;
     1533                } else if ((s = strchr(acc->server, ':'))) {
     1534                        if (strstr(acc->server, ":ssl")) {
     1535                                set_setint(&acc->set, "port", DEFAULT_PORT_SSL);
     1536                                set_setstr(&acc->set, "ssl", "true");
     1537                        }
     1538                        if (isdigit(s[1])) {
     1539                                if (sscanf(s + 1, "%d", &port) == 1)
     1540                                        set_setint(&acc->set, "port", port);
     1541                        }
     1542                        tmp_server = g_strndup(acc->server, s - acc->server);
     1543                        set_setstr(&acc->set, "server", tmp_server);
     1544                        g_free(tmp_server);
     1545                }
     1546        }
     1547       
     1548        gc = new_gaim_conn(acc);
     1549        jd = gc->proto_data = g_new0(struct jabber_data, 1);
     1550       
     1551        if( strchr( acc->user, '@' ) == NULL )
     1552        {
     1553                hide_login_progress( gc, "Invalid account name" );
     1554                signoff( gc );
     1555                return;
     1556        }
     1557       
     1558        resource = set_getstr(&acc->set, "resource");
     1559        loginname = create_valid_jid(acc->user, DEFAULT_SERVER, resource);
     1560       
    15241561        jd->hash = g_hash_table_new(g_str_hash, g_str_equal);
    15251562        jd->chats = NULL;       /* we have no chats yet */
    … …  
    15271564        set_login_progress(gc, 1, _("Connecting"));
    15281565
    1529         if (!(jd->gjc = gjab_new(loginname, user->password, gc))) {
     1566        if (!(jd->gjc = gjab_new(loginname, acc->pass, gc))) {
    15301567                g_free(loginname);
    15311568                hide_login_progress(gc, _("Unable to connect"));
    … …  
    23372374        ret->name = "jabber";
    23382375        ret->away_states = jabber_away_states;
     2376        ret->acc_init = jabber_acc_init;
    23392377        ret->login = jabber_login;
    23402378        ret->close = jabber_close;
    … …  
    23492387        ret->alias_buddy = jabber_roster_update;
    23502388        ret->group_buddy = jabber_group_change;
    2351         ret->cmp_buddynames = g_strcasecmp;
     2389        ret->handle_cmp = g_strcasecmp;
    23522390
    23532391        register_protocol (ret);

  • protocols/msn/msn.c

    rf4aa393 rd8d63a2  
    2727#include "msn.h"
    2828
    29 static void msn_login( struct aim_user *acct )
    30 {
    31         struct gaim_connection *gc = new_gaim_conn( acct );
     29static char *msn_set_display_name( set_t *set, char *value );
     30
     31static void msn_acc_init( account_t *acc )
     32{
     33        set_t *s;
     34       
     35        s = set_add( &acc->set, "display_name", NULL, msn_set_display_name, acc );
     36        s->flags |= ACC_SET_NOSAVE | ACC_SET_ONLINE_ONLY;
     37}
     38
     39static void msn_login( account_t *acc )
     40{
     41        struct gaim_connection *gc = new_gaim_conn( acc );
    3242        struct msn_data *md = g_new0( struct msn_data, 1 );
    33        
    34         set_login_progress( gc, 1, "Connecting" );
    3543       
    3644        gc->proto_data = md;
    3745        md->fd = -1;
    3846       
    39         if( strchr( acct->username, '@' ) == NULL )
     47        if( strchr( acc->user, '@' ) == NULL )
    4048        {
    4149                hide_login_progress( gc, "Invalid account name" );
    … …  
    4452        }
    4553       
     54        set_login_progress( gc, 1, "Connecting" );
     55       
    4656        md->fd = proxy_connect( "messenger.hotmail.com", 1863, msn_ns_connected, gc );
    4757        if( md->fd < 0 )
    … …  
    4959                hide_login_progress( gc, "Could not connect to server" );
    5060                signoff( gc );
    51         }
    52         else
    53         {
    54                 md->gc = gc;
    55                 md->away_state = msn_away_state_list;
    56                
    57                 msn_connections = g_slist_append( msn_connections, gc );
    58         }
     61                return;
     62        }
     63       
     64        md->gc = gc;
     65        md->away_state = msn_away_state_list;
     66       
     67        msn_connections = g_slist_append( msn_connections, gc );
    5968}
    6069
    … …  
    212221static void msn_set_info( struct gaim_connection *gc, char *info )
    213222{
    214         int i;
    215         char buf[1024], *fn, *s;
    216         struct msn_data *md = gc->proto_data;
    217        
    218         if( strlen( info ) > 129 )
    219         {
    220                 do_error_dialog( gc, "Maximum name length exceeded", "MSN" );
    221                 return;
    222         }
    223        
    224         /* Of course we could use http_encode() here, but when we encode
    225            every character, the server is less likely to complain about the
    226            chosen name. However, the MSN server doesn't seem to like escaped
    227            non-ASCII chars, so we keep those unescaped. */
    228         s = fn = g_new0( char, strlen( info ) * 3 + 1 );
    229         for( i = 0; info[i]; i ++ )
    230                 if( info[i] & 128 )
    231                 {
    232                         *s = info[i];
    233                         s ++;
    234                 }
    235                 else
    236                 {
    237                         g_snprintf( s, 4, "%%%02X", info[i] );
    238                         s += 3;
    239                 }
    240        
    241         g_snprintf( buf, sizeof( buf ), "REA %d %s %s\r\n", ++md->trId, gc->username, fn );
    242         msn_write( gc, buf, strlen( buf ) );
    243         g_free( fn );
     223        msn_set_display_name( set_find( &gc->acc->set, "display_name" ), info );
    244224}
    245225
    … …  
    380360}
    381361
     362static char *msn_set_display_name( set_t *set, char *value )
     363{
     364        account_t *acc = set->data;
     365        struct gaim_connection *gc = acc->gc;
     366        struct msn_data *md;
     367        char buf[1024], *fn;
     368       
     369        /* Double-check. */
     370        if( gc == NULL )
     371                return NULL;
     372       
     373        md = gc->proto_data;
     374       
     375        if( strlen( value ) > 129 )
     376        {
     377                serv_got_crap( gc, "Maximum name length exceeded" );
     378                return NULL;
     379        }
     380       
     381        fn = msn_http_encode( value );
     382       
     383        g_snprintf( buf, sizeof( buf ), "REA %d %s %s\r\n", ++md->trId, gc->username, fn );
     384        msn_write( gc, buf, strlen( buf ) );
     385        g_free( fn );
     386       
     387        /* Returning NULL would be better, because the server still has to
     388           confirm the name change. However, it looks a bit confusing to the
     389           user. */
     390        return value;
     391}
     392
    382393void msn_init()
    383394{
    384395        struct prpl *ret = g_new0(struct prpl, 1);
     396       
    385397        ret->name = "msn";
    386398        ret->login = msn_login;
     399        ret->acc_init = msn_acc_init;
    387400        ret->close = msn_close;
    388401        ret->send_im = msn_send_im;
    … …  
    404417        ret->rem_deny = msn_rem_deny;
    405418        ret->send_typing = msn_send_typing;
    406         ret->cmp_buddynames = g_strcasecmp;
     419        ret->handle_cmp = g_strcasecmp;
    407420
    408421        register_protocol(ret);

  • protocols/msn/msn.h

    rf4aa393 rd8d63a2  
    157157char **msn_linesplit( char *line );
    158158int msn_handler( struct msn_handler_data *h );
     159char *msn_http_encode( const char *input );
    159160
    160161/* tables.c */

  • protocols/msn/msn_util.c

    rf4aa393 rd8d63a2  
    5454{
    5555        struct msn_data *md = gc->proto_data;
    56         GSList *l, **lp = NULL;
    5756        char buf[1024], *realname;
    5857       
    59         if( strcmp( list, "AL" ) == 0 )
    60                 lp = &gc->permit;
    61         else if( strcmp( list, "BL" ) == 0 )
    62                 lp = &gc->deny;
    63        
    64         if( lp )
    65                 for( l = *lp; l; l = l->next )
    66                         if( g_strcasecmp( l->data, who ) == 0 )
    67                                 return( 1 );
    68        
    69         realname = g_new0( char, strlen( realname_ ) * 3 + 1 );
    70         strcpy( realname, realname_ );
    71         http_encode( realname );
     58        realname = msn_http_encode( realname_ );
    7259       
    7360        g_snprintf( buf, sizeof( buf ), "ADD %d %s %s %s\r\n", ++md->trId, list, who, realname );
    … …  
    7663                g_free( realname );
    7764               
    78                 if( lp )
    79                         *lp = g_slist_append( *lp, g_strdup( who ) );
    80                
    8165                return( 1 );
    8266        }
    … …  
    9074{
    9175        struct msn_data *md = gc->proto_data;
    92         GSList *l = NULL, **lp = NULL;
    9376        char buf[1024];
    94        
    95         if( strcmp( list, "AL" ) == 0 )
    96                 lp = &gc->permit;
    97         else if( strcmp( list, "BL" ) == 0 )
    98                 lp = &gc->deny;
    99        
    100         if( lp )
    101         {
    102                 for( l = *lp; l; l = l->next )
    103                         if( g_strcasecmp( l->data, who ) == 0 )
    104                                 break;
    105                
    106                 if( !l )
    107                         return( 1 );
    108         }
    10977       
    11078        g_snprintf( buf, sizeof( buf ), "REM %d %s %s\r\n", ++md->trId, list, who );
    11179        if( msn_write( gc, buf, strlen( buf ) ) )
    112         {
    113                 if( lp )
    114                         *lp = g_slist_remove( *lp, l->data );
    115                
    11680                return( 1 );
    117         }
    11881       
    11982        return( 0 );
    … …  
    350313        return( 1 );
    351314}
     315
     316/* The difference between this function and the normal http_encode() function
     317   is that this one escapes every 7-bit ASCII character because this is said
     318   to avoid some lame server-side checks when setting a real-name. Also,
     319   non-ASCII characters are not escaped because MSN servers don't seem to
     320   appreciate that! */
     321char *msn_http_encode( const char *input )
     322{
     323        char *ret, *s;
     324        int i;
     325       
     326        ret = s = g_new0( char, strlen( input ) * 3 + 1 );
     327        for( i = 0; input[i]; i ++ )
     328                if( input[i] & 128 )
     329                {
     330                        *s = input[i];
     331                        s ++;
     332                }
     333                else
     334                {
     335                        g_snprintf( s, 4, "%%%02X", input[i] );
     336                        s += 3;
     337                }
     338       
     339        return ret;
     340}

  • protocols/msn/ns.c

    rf4aa393 rd8d63a2  
    223223                else if( num_parts == 7 && strcmp( cmd[2], "OK" ) == 0 )
    224224                {
     225                        set_t *s;
     226                       
    225227                        http_decode( cmd[4] );
    226228                       
    227229                        strncpy( gc->displayname, cmd[4], sizeof( gc->displayname ) );
    228230                        gc->displayname[sizeof(gc->displayname)-1] = 0;
     231                       
     232                        if( ( s = set_find( &gc->acc->set, "display_name" ) ) )
     233                        {
     234                                g_free( s->value );
     235                                s->value = g_strdup( cmd[4] );
     236                        }
    229237                       
    230238                        set_login_progress( gc, 1, "Authenticated, getting buddy list" );
    … …  
    517525                if( g_strcasecmp( cmd[3], gc->username ) == 0 )
    518526                {
     527                        set_t *s;
     528                       
    519529                        http_decode( cmd[4] );
    520530                        strncpy( gc->displayname, cmd[4], sizeof( gc->displayname ) );
    521531                        gc->displayname[sizeof(gc->displayname)-1] = 0;
     532                       
     533                        if( ( s = set_find( &gc->acc->set, "display_name" ) ) )
     534                        {
     535                                g_free( s->value );
     536                                s->value = g_strdup( cmd[4] );
     537                        }
    522538                }
    523539                else

  • protocols/msn/passport.c

    rf4aa393 rd8d63a2  
    5959        rep->data = data;
    6060        rep->func = func;
     61        rep->header = header;
    6162       
    6263        server = g_strdup( prd_cached );
    … …  
    125126static char *passport_create_header( char *cookie, char *email, char *pwd )
    126127{
    127         char *buffer = g_new0( char, 2048 );
     128        char *buffer;
    128129        char *currenttoken;
    129130        char *email_enc, *pwd_enc;
     131       
     132        currenttoken = strstr( cookie, "lc=" );
     133        if( currenttoken == NULL )
     134                return NULL;
    130135       
    131136        email_enc = g_new0( char, strlen( email ) * 3 + 1 );
    … …  
    137142        http_encode( pwd_enc );
    138143       
    139         currenttoken = strstr( cookie, "lc=" );
    140         if( currenttoken == NULL )
    141                 return( NULL );
    142        
    143         g_snprintf( buffer, 2048,
    144                     "Authorization: Passport1.4 OrgVerb=GET,"
    145                     "OrgURL=http%%3A%%2F%%2Fmessenger%%2Emsn%%2Ecom,"
    146                     "sign-in=%s,pwd=%s,%s", email_enc, pwd_enc,
    147                     currenttoken );
     144        buffer = g_strdup_printf( "Authorization: Passport1.4 OrgVerb=GET,"
     145                                  "OrgURL=http%%3A%%2F%%2Fmessenger%%2Emsn%%2Ecom,"
     146                                  "sign-in=%s,pwd=%s,%s", email_enc, pwd_enc,
     147                                  currenttoken );
    148148       
    149149        g_free( email_enc );
    150150        g_free( pwd_enc );
    151151       
    152         return( buffer );
     152        return buffer;
    153153}
    154154
    … …  
    212212        if( passport_get_id_real( rep->func, rep->data, rep->header ) )
    213213        {
     214                rep->header = NULL;
    214215                destroy_reply( rep );
    215216                return;

  • protocols/nogaim.c

    rf4aa393 rd8d63a2  
    145145/* multi.c */
    146146
    147 struct gaim_connection *new_gaim_conn( struct aim_user *user )
     147struct gaim_connection *new_gaim_conn( account_t *acc )
    148148{
    149149        struct gaim_connection *gc;
    150         account_t *a;
    151150       
    152151        gc = g_new0( struct gaim_connection, 1 );
    153152       
    154         gc->prpl = user->prpl;
    155         g_snprintf( gc->username, sizeof( gc->username ), "%s", user->username );
    156         g_snprintf( gc->password, sizeof( gc->password ), "%s", user->password );
    157         /* [MD] BUGFIX: don't set gc->irc to the global IRC, but use the one from the struct aim_user.
    158          * This fixes daemon mode breakage where IRC doesn't point to the currently active connection.
    159          */
    160         gc->irc = user->irc;
     153        /* Maybe we should get rid of this memory waste later. ;-) */
     154        g_snprintf( gc->username, sizeof( gc->username ), "%s", acc->user );
     155        g_snprintf( gc->password, sizeof( gc->password ), "%s", acc->pass );
     156       
     157        gc->irc = acc->irc;
     158        gc->acc = acc;
     159        acc->gc = gc;
    161160       
    162161        connections = g_slist_append( connections, gc );
    163        
    164         user->gc = gc;
    165         gc->user = user;
    166        
    167         // Find the account_t so we can set its gc pointer
    168         for( a = gc->irc->accounts; a; a = a->next )
    169                 if( ( struct aim_user * ) a->gc == user )
    170                 {
    171                         a->gc = gc;
    172                         break;
    173                 }
    174162       
    175163        return( gc );
    … …  
    189177       
    190178        connections = g_slist_remove( connections, gc );
    191         g_free( gc->user );
    192179        g_free( gc );
    193180}
    … …  
    220207        va_end( params );
    221208
    222         if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    223             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
     209        if( ( g_strcasecmp( set_getstr( &gc->irc->set, "strip_html" ), "always" ) == 0 ) ||
     210            ( ( gc->flags & OPT_CONN_HTML ) && set_getbool( &gc->irc->set, "strip_html" ) ) )
    224211                strip_html( text );
    225212       
    226213        /* Try to find a different connection on the same protocol. */
    227214        for( a = gc->irc->accounts; a; a = a->next )
    228                 if( a->prpl == gc->prpl && a->gc != gc )
     215                if( a->prpl == gc->acc->prpl && a->gc != gc )
    229216                        break;
    230217       
    231218        /* If we found one, include the screenname in the message. */
    232219        if( a )
    233                 irc_usermsg( gc->irc, "%s(%s) - %s", gc->prpl->name, gc->username, text );
     220                irc_usermsg( gc->irc, "%s(%s) - %s", gc->acc->prpl->name, gc->username, text );
    234221        else
    235                 irc_usermsg( gc->irc, "%s - %s", gc->prpl->name, text );
     222                irc_usermsg( gc->irc, "%s - %s", gc->acc->prpl->name, text );
    236223       
    237224        g_free( text );
    … …  
    242229        struct gaim_connection *gc = d;
    243230       
    244         if( gc->prpl && gc->prpl->keepalive )
    245                 gc->prpl->keepalive( gc );
     231        if( gc->acc->prpl->keepalive )
     232                gc->acc->prpl->keepalive( gc );
    246233       
    247234        return TRUE;
    … …  
    297284        b_event_remove( gc->keepalive );
    298285        gc->flags |= OPT_LOGGING_OUT;
     286       
    299287        gc->keepalive = 0;
    300         gc->prpl->close( gc );
     288        gc->acc->prpl->close( gc );
    301289        b_event_remove( gc->inpa );
    302290       
    … …  
    323311                /* Uhm... This is very sick. */
    324312        }
    325         else if( !gc->wants_to_die && set_getint( irc, "auto_reconnect" ) )
    326         {
    327                 int delay = set_getint( irc, "auto_reconnect_delay" );
     313        else if( !gc->wants_to_die && set_getbool( &irc->set, "auto_reconnect" ) &&
     314                 set_getbool( &a->set, "auto_reconnect" ) )
     315        {
     316                int delay = set_getint( &irc->set, "auto_reconnect_delay" );
    328317               
    329318                serv_got_crap( gc, "Reconnecting in %d seconds..", delay );
    … …  
    364353        irc_t *irc = gc->irc;
    365354       
    366         if( set_getint( irc, "debug" ) && 0 ) /* This message is too useless */
     355        if( set_getbool( &irc->set, "debug" ) && 0 ) /* This message is too useless */
    367356                serv_got_crap( gc, "Receiving user add from handle: %s", handle );
    368357       
    369358        if( user_findhandle( gc, handle ) )
    370359        {
    371                 if( set_getint( irc, "debug" ) )
     360                if( set_getbool( &irc->set, "debug" ) )
    372361                        serv_got_crap( gc, "User already exists, ignoring add request: %s", handle );
    373362               
    … …  
    378367       
    379368        memset( nick, 0, MAX_NICK_LENGTH + 1 );
    380         strcpy( nick, nick_get( gc->irc, handle, gc->prpl, realname ) );
     369        strcpy( nick, nick_get( gc->acc, handle, realname ) );
    381370       
    382371        u = user_add( gc->irc, nick );
    … …  
    390379                u->user = g_strndup( handle, s - handle );
    391380        }
    392         else if( gc->user->proto_opt[0] && *gc->user->proto_opt[0] )
     381        else if( gc->acc->server )
    393382        {
    394383                char *colon;
    395384               
    396                 if( ( colon = strchr( gc->user->proto_opt[0], ':' ) ) )
    397                         u->host = g_strndup( gc->user->proto_opt[0],
    398                                              colon - gc->user->proto_opt[0] );
     385                if( ( colon = strchr( gc->acc->server, ':' ) ) )
     386                        u->host = g_strndup( gc->acc->server,
     387                                             colon - gc->acc->server );
    399388                else
    400                         u->host = g_strdup( gc->user->proto_opt[0] );
     389                        u->host = g_strdup( gc->acc->server );
    401390               
    402391                u->user = g_strdup( handle );
    … …  
    409398        else
    410399        {
    411                 u->host = g_strdup( gc->user->prpl->name );
     400                u->host = g_strdup( gc->acc->prpl->name );
    412401                u->user = g_strdup( handle );
    413402        }
    … …  
    457446                u->realname = g_strdup( realname );
    458447               
    459                 if( ( gc->flags & OPT_LOGGED_IN ) && set_getint( gc->irc, "display_namechanges" ) )
     448                if( ( gc->flags & OPT_LOGGED_IN ) && set_getbool( &gc->irc->set, "display_namechanges" ) )
    460449                        serv_got_crap( gc, "User `%s' changed name to `%s'", u->nick, u->realname );
    461450        }
    … …  
    479468void show_got_added_yes( gpointer w, struct show_got_added_data *data )
    480469{
    481         data->gc->prpl->add_buddy( data->gc, data->handle );
     470        data->gc->acc->prpl->add_buddy( data->gc, data->handle );
    482471        add_buddy( data->gc, NULL, data->handle, data->handle );
    483472       
    … …  
    513502        if( !u )
    514503        {
    515                 if( g_strcasecmp( set_getstr( gc->irc, "handle_unknown" ), "add" ) == 0 )
     504                if( g_strcasecmp( set_getstr( &gc->irc->set, "handle_unknown" ), "add" ) == 0 )
    516505                {
    517506                        add_buddy( gc, NULL, handle, NULL );
    … …  
    520509                else
    521510                {
    522                         if( set_getint( gc->irc, "debug" ) || g_strcasecmp( set_getstr( gc->irc, "handle_unknown" ), "ignore" ) != 0 )
     511                        if( set_getbool( &gc->irc->set, "debug" ) || g_strcasecmp( set_getstr( &gc->irc->set, "handle_unknown" ), "ignore" ) != 0 )
    523512                        {
    524513                                serv_got_crap( gc, "serv_got_update() for handle %s:", handle );
    … …  
    558547        }
    559548       
    560         if( ( type & UC_UNAVAILABLE ) && ( !strcmp(gc->prpl->name, "oscar") || !strcmp(gc->prpl->name, "icq")) )
     549        if( ( type & UC_UNAVAILABLE ) && ( strcmp( gc->acc->prpl->name, "oscar" ) == 0 || strcmp( gc->acc->prpl->name, "icq" ) == 0 ) )
    561550        {
    562551                u->away = g_strdup( "Away" );
    563552        }
    564         else if( ( type & UC_UNAVAILABLE ) && ( !strcmp(gc->prpl->name, "jabber") ) )
     553        else if( ( type & UC_UNAVAILABLE ) && ( strcmp( gc->acc->prpl->name, "jabber" ) == 0 ) )
    565554        {
    566555                if( type & UC_DND )
    … …  
    571560                        u->away = g_strdup( "Away" );
    572561        }
    573         else if( ( type & UC_UNAVAILABLE ) && gc->prpl->get_status_string )
    574         {
    575                 u->away = g_strdup( gc->prpl->get_status_string( gc, type ) );
     562        else if( ( type & UC_UNAVAILABLE ) && gc->acc->prpl->get_status_string )
     563        {
     564                u->away = g_strdup( gc->acc->prpl->get_status_string( gc, type ) );
    576565        }
    577566        else
    … …  
    579568       
    580569        /* LISPy... */
    581         if( ( set_getint( gc->irc, "away_devoice" ) ) &&                /* Don't do a thing when user doesn't want it */
     570        if( ( set_getbool( &gc->irc->set, "away_devoice" ) ) &&         /* Don't do a thing when user doesn't want it */
    582571            ( u->online ) &&                                            /* Don't touch offline people */
    583572            ( ( ( u->online != oo ) && !u->away ) ||                    /* Voice joining people */
    584573              ( ( u->online == oo ) && ( oa == !u->away ) ) ) )         /* (De)voice people changing state */
    585574        {
    586                 irc_write( gc->irc, ":%s!%s@%s MODE %s %cv %s", gc->irc->mynick, gc->irc->mynick, gc->irc->myhost,
     575                irc_write( gc->irc, ":%s MODE %s %cv %s", gc->irc->myhost,
    587576                                                                gc->irc->channel, u->away?'-':'+', u->nick );
    588577        }
    … …  
    598587        if( !u )
    599588        {
    600                 char *h = set_getstr( irc, "handle_unknown" );
     589                char *h = set_getstr( &irc->set, "handle_unknown" );
    601590               
    602591                if( g_strcasecmp( h, "ignore" ) == 0 )
    603592                {
    604                         if( set_getint( irc, "debug" ) )
     593                        if( set_getbool( &irc->set, "debug" ) )
    605594                                serv_got_crap( gc, "Ignoring message from unknown handle %s", handle );
    606595                       
    … …  
    609598                else if( g_strncasecmp( h, "add", 3 ) == 0 )
    610599                {
    611                         int private = set_getint( irc, "private" );
     600                        int private = set_getbool( &irc->set, "private" );
    612601                       
    613602                        if( h[3] )
    … …  
    630619        }
    631620       
    632         if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    633             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
     621        if( ( g_strcasecmp( set_getstr( &gc->irc->set, "strip_html" ), "always" ) == 0 ) ||
     622            ( ( gc->flags & OPT_CONN_HTML ) && set_getbool( &gc->irc->set, "strip_html" ) ) )
    634623                strip_html( msg );
    635624
    … …  
    671660        user_t *u;
    672661       
    673         if( !set_getint( gc->irc, "typing_notice" ) )
     662        if( !set_getbool( &gc->irc->set, "typing_notice" ) )
    674663                return;
    675664       
    … …  
    693682        GList *ir;
    694683       
    695         if( set_getint( gc->irc, "debug" ) )
     684        if( set_getbool( &gc->irc->set, "debug" ) )
    696685                serv_got_crap( gc, "You were removed from conversation %d", (int) id );
    697686       
    … …  
    732721       
    733722        /* Gaim sends own messages through this too. IRC doesn't want this, so kill them */
    734         if( g_strcasecmp( who, gc->user->username ) == 0 )
     723        if( g_strcasecmp( who, gc->username ) == 0 )
    735724                return;
    736725       
    … …  
    738727        for( c = gc->conversations; c && c->id != id; c = c->next );
    739728       
    740         if( ( g_strcasecmp( set_getstr( gc->irc, "strip_html" ), "always" ) == 0 ) ||
    741             ( ( gc->flags & OPT_CONN_HTML ) && set_getint( gc->irc, "strip_html" ) ) )
     729        if( ( g_strcasecmp( set_getstr( &gc->irc->set, "strip_html" ), "always" ) == 0 ) ||
     730            ( ( gc->flags & OPT_CONN_HTML ) && set_getbool( &gc->irc->set, "strip_html" ) ) )
    742731                strip_html( msg );
    743732       
    … …  
    772761        g_free( s );
    773762       
    774         if( set_getint( gc->irc, "debug" ) )
     763        if( set_getbool( &gc->irc->set, "debug" ) )
    775764                serv_got_crap( gc, "Creating new conversation: (id=%d,handle=%s)", id, handle );
    776765       
    … …  
    786775        int me = 0;
    787776       
    788         if( set_getint( b->gc->irc, "debug" ) )
     777        if( set_getbool( &b->gc->irc->set, "debug" ) )
    789778                serv_got_crap( b->gc, "User %s added to conversation %d", handle, b->id );
    790779       
    791780        /* It might be yourself! */
    792         if( b->gc->prpl->cmp_buddynames( handle, b->gc->user->username ) == 0 )
     781        if( b->gc->acc->prpl->handle_cmp( handle, b->gc->username ) == 0 )
    793782        {
    794783                u = user_find( b->gc->irc, b->gc->irc->nick );
    … …  
    820809        int me = 0;
    821810       
    822         if( set_getint( b->gc->irc, "debug" ) )
     811        if( set_getbool( &b->gc->irc->set, "debug" ) )
    823812                serv_got_crap( b->gc, "User %s removed from conversation %d (%s)", handle, b->id, reason ? reason : "" );
    824813       
    825814        /* It might be yourself! */
    826         if( g_strcasecmp( handle, b->gc->user->username ) == 0 )
     815        if( g_strcasecmp( handle, b->gc->username ) == 0 )
    827816        {
    828817                u = user_find( b->gc->irc, b->gc->irc->nick );
    … …  
    882871}
    883872
    884 char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value )
    885 {
     873char *set_eval_away_devoice( set_t *set, char *value )
     874{
     875        irc_t *irc = set->data;
    886876        int st;
    887877       
    … …  
    897887        /* Horror.... */
    898888       
    899         if( st != set_getint( irc, "away_devoice" ) )
     889        if( st != set_getbool( &irc->set, "away_devoice" ) )
    900890        {
    901891                char list[80] = "";
    … …  
    917907                                {
    918908                                        for( i = 0; i < count; v[i++] = 'v' ); v[i] = 0;
    919                                         irc_write( irc, ":%s!%s@%s MODE %s %c%s%s",
    920                                                    irc->mynick, irc->mynick, irc->myhost,
     909                                        irc_write( irc, ":%s MODE %s %c%s%s",
     910                                                   irc->myhost,
    921911                                                   irc->channel, pm, v, list );
    922912                                       
    … …  
    933923                /* $v = 'v' x $i */
    934924                for( i = 0; i < count; v[i++] = 'v' ); v[i] = 0;
    935                 irc_write( irc, ":%s!%s@%s MODE %s %c%s%s", irc->mynick, irc->mynick, irc->myhost,
     925                irc_write( irc, ":%s MODE %s %c%s%s", irc->myhost,
    936926                                                            irc->channel, pm, v, list );
    937927        }
    938928       
    939         return( set_eval_bool( irc, set, value ) );
     929        return( set_eval_bool( set, value ) );
    940930}
    941931
    … …  
    957947        }
    958948       
    959         st = gc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
     949        st = gc->acc->prpl->send_im( gc, handle, msg, strlen( msg ), flags );
    960950        g_free( buf );
    961951       
    … …  
    974964        }
    975965       
    976         st = gc->prpl->chat_send( gc, id, msg );
     966        st = gc->acc->prpl->chat_send( gc, id, msg );
    977967        g_free( buf );
    978968       
    … …  
    988978       
    989979        if( !away ) away = "";
    990         ms = m = gc->prpl->away_states( gc );
     980        ms = m = gc->acc->prpl->away_states( gc );
    991981       
    992982        while( m )
    … …  
    1009999        if( m )
    10101000        {
    1011                 gc->prpl->set_away( gc, m->data, *away ? away : NULL );
     1001                gc->acc->prpl->set_away( gc, m->data, *away ? away : NULL );
    10121002        }
    10131003        else
    … …  
    10161006                if( s )
    10171007                {
    1018                         gc->prpl->set_away( gc, s, away );
    1019                         if( set_getint( gc->irc, "debug" ) )
     1008                        gc->acc->prpl->set_away( gc, s, away );
     1009                        if( set_getbool( &gc->irc->set, "debug" ) )
    10201010                                serv_got_crap( gc, "Setting away state to %s", s );
    10211011                }
    10221012                else
    1023                         gc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
     1013                        gc->acc->prpl->set_away( gc, GAIM_AWAY_CUSTOM, away );
    10241014        }
    10251015       
    … …  
    10731063void bim_add_allow( struct gaim_connection *gc, char *handle )
    10741064{
    1075         if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
     1065        if( g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) == NULL )
    10761066        {
    10771067                gc->permit = g_slist_prepend( gc->permit, g_strdup( handle ) );
    10781068        }
    10791069       
    1080         gc->prpl->add_permit( gc, handle );
     1070        gc->acc->prpl->add_permit( gc, handle );
    10811071}
    10821072
    … …  
    10851075        GSList *l;
    10861076       
    1087         if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
     1077        if( ( l = g_slist_find_custom( gc->permit, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) ) )
    10881078        {
    10891079                g_free( l->data );
    … …  
    10911081        }
    10921082       
    1093         gc->prpl->rem_permit( gc, handle );
     1083        gc->acc->prpl->rem_permit( gc, handle );
    10941084}
    10951085
    10961086void bim_add_block( struct gaim_connection *gc, char *handle )
    10971087{
    1098         if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) == NULL )
     1088        if( g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) == NULL )
    10991089        {
    11001090                gc->deny = g_slist_prepend( gc->deny, g_strdup( handle ) );
    11011091        }
    11021092       
    1103         gc->prpl->add_deny( gc, handle );
     1093        gc->acc->prpl->add_deny( gc, handle );
    11041094}
    11051095
    … …  
    11081098        GSList *l;
    11091099       
    1110         if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->prpl->cmp_buddynames ) ) )
     1100        if( ( l = g_slist_find_custom( gc->deny, handle, (GCompareFunc) gc->acc->prpl->handle_cmp ) ) )
    11111101        {
    11121102                g_free( l->data );
    … …  
    11141104        }
    11151105       
    1116         gc->prpl->rem_deny( gc, handle );
    1117 }
     1106        gc->acc->prpl->rem_deny( gc, handle );
     1107}

  • protocols/nogaim.h

    rf4aa393 rd8d63a2  
    3939
    4040#include "bitlbee.h"
     41#include "account.h"
    4142#include "proxy.h"
    4243#include "md5.h"
    … …  
    6364struct gaim_connection
    6465{
    65         struct prpl *prpl;
     66        account_t *acc;
    6667        guint32 flags;
    6768       
    … …  
    7879        GSList *deny;
    7980        int permdeny;
    80        
    81         struct aim_user *user;
    8281       
    8382        char username[64];
    … …  
    126125};
    127126
    128 struct aim_user {
    129         char username[64];
    130         char alias[SELF_ALIAS_LEN];
    131         char password[32];
    132         char user_info[2048];
    133         int options;
    134         struct prpl *prpl;
    135         /* prpls can use this to save information about the user,
    136          * like which server to connect to, etc */
    137         char proto_opt[7][256];
    138 
    139         struct gaim_connection *gc;
    140         irc_t *irc;
    141 };
    142 
    143127struct prpl {
    144128        int options;
    145129        const char *name;
    146130
    147         void (* login)          (struct aim_user *);
     131        void (* acc_init)       (account_t *);
     132        void (* login)          (account_t *);
    148133        void (* keepalive)      (struct gaim_connection *);
    149134        void (* close)          (struct gaim_connection *);
    … …  
    180165       
    181166        /* Mainly for AOL, since they think "Bung hole" == "Bu ngho le". *sigh* */
    182         int (* cmp_buddynames) (const char *who1, const char *who2);
     167        int (* handle_cmp) (const char *who1, const char *who2);
    183168};
    184169
    … …  
    206191
    207192void nogaim_init();
    208 char *set_eval_away_devoice( irc_t *irc, set_t *set, char *value );
     193char *set_eval_away_devoice( set_t *set, char *value );
    209194
    210195gboolean auto_reconnect( gpointer data, gint fd, b_input_condition cond );
    … …  
    212197
    213198/* multi.c */
    214 G_MODULE_EXPORT struct gaim_connection *new_gaim_conn( struct aim_user *user );
     199G_MODULE_EXPORT struct gaim_connection *new_gaim_conn( account_t *acc );
    215200G_MODULE_EXPORT void destroy_gaim_conn( struct gaim_connection *gc );
    216201G_MODULE_EXPORT void set_login_progress( struct gaim_connection *gc, int step, char *msg );

  • protocols/oscar/info.c

    rf4aa393 rd8d63a2  
    261261                if (!identified) {
    262262                        /*FIXME*/
     263                        /*REMOVEME :-)
    263264                        g_strdup_printf("unknown capability: {%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
    264265                                        cap[0], cap[1], cap[2], cap[3],
    … …  
    268269                                        cap[10], cap[11], cap[12], cap[13],
    269270                                        cap[14], cap[15]);
    270                        
     271                        */
    271272                }
    272273

  • protocols/oscar/oscar.c

    rf4aa393 rd8d63a2  
    356356}
    357357
    358 static void oscar_login(struct aim_user *user) {
     358static void oscar_acc_init(account_t *acc)
     359{
     360        set_t *s;
     361       
     362        s = set_add( &acc->set, "server", NULL, set_eval_account, acc );
     363        s->flags |= ACC_SET_NOSAVE | ACC_SET_OFFLINE_ONLY;
     364       
     365        if (isdigit(acc->user[0])) {
     366                s = set_add( &acc->set, "web_aware", "false", set_eval_bool, acc );
     367                s->flags |= ACC_SET_OFFLINE_ONLY;
     368        }
     369}
     370
     371static void oscar_login(account_t *acc) {
    359372        aim_session_t *sess;
    360373        aim_conn_t *conn;
    361374        char buf[256];
    362         struct gaim_connection *gc = new_gaim_conn(user);
     375        struct gaim_connection *gc = new_gaim_conn(acc);
    363376        struct oscar_data *odata = gc->proto_data = g_new0(struct oscar_data, 1);
    364377
    365         if (isdigit(*user->username)) {
     378        if (isdigit(acc->user[0])) {
    366379                odata->icq = TRUE;
    367380                /* This is odd but it's necessary for a proper do_import and do_export.
    368381                   We don't do those anymore, but let's stick with it, just in case
    369                    it accidentally fixes something else too... */
     382                   it accidentally fixes something else too... </bitlbee> */
    370383                gc->password[8] = 0;
    371384        } else {
    … …  
    390403        }
    391404       
    392         if (g_strcasecmp(user->proto_opt[USEROPT_AUTH], "login.icq.com") != 0 &&
    393             g_strcasecmp(user->proto_opt[USEROPT_AUTH], "login.oscar.aol.com") != 0) {
    394                 serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",user->proto_opt[USEROPT_AUTH]);
     405        if (acc->server == NULL) {
     406                hide_login_progress(gc, "No servername specified");
     407                signoff(gc);
     408                return;
     409        }
     410       
     411        if (g_strcasecmp(acc->server, "login.icq.com") != 0 &&
     412            g_strcasecmp(acc->server, "login.oscar.aol.com") != 0) {
     413                serv_got_crap(gc, "Warning: Unknown OSCAR server: `%s'. Please review your configuration if the connection fails.",acc->server);
    395414        }
    396415       
    … …  
    402421
    403422        conn->status |= AIM_CONN_STATUS_INPROGRESS;
    404         conn->fd = proxy_connect(user->proto_opt[USEROPT_AUTH][0] ?
    405                                         user->proto_opt[USEROPT_AUTH] : AIM_DEFAULT_LOGIN_SERVER,
    406                                  user->proto_opt[USEROPT_AUTHPORT][0] ?
    407                                         atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
    408                                  oscar_login_connect, gc);
     423        conn->fd = proxy_connect(acc->server, AIM_LOGIN_PORT, oscar_login_connect, gc);
    409424        if (conn->fd < 0) {
    410425                hide_login_progress(gc, _("Couldn't connect to host"));
    … …  
    485500        struct aim_authresp_info *info;
    486501        int i; char *host; int port;
    487         struct aim_user *user;
    488502        aim_conn_t *bosconn;
    489503
    490504        struct gaim_connection *gc = sess->aux_data;
    491505        struct oscar_data *od = gc->proto_data;
    492         user = gc->user;
    493         port = user->proto_opt[USEROPT_AUTHPORT][0] ?
    494                 atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
     506        port = AIM_LOGIN_PORT;
    495507
    496508        va_start(ap, fr);
    … …  
    871883        struct aim_redirect_data *redir;
    872884        struct gaim_connection *gc = sess->aux_data;
    873         struct aim_user *user = gc->user;
    874885        aim_conn_t *tstconn;
    875886        int i;
    … …  
    877888        int port;
    878889
    879         port = user->proto_opt[USEROPT_AUTHPORT][0] ?
    880                 atoi(user->proto_opt[USEROPT_AUTHPORT]) : AIM_LOGIN_PORT,
    881 
    882890        va_start(ap, fr);
    883891        redir = va_arg(ap, struct aim_redirect_data *);
    884892        va_end(ap);
    885893
     894        port = AIM_LOGIN_PORT;
    886895        for (i = 0; i < (int)strlen(redir->ip); i++) {
    887896                if (redir->ip[i] == ':') {
    … …  
    12421251        channel = va_arg(ap, int);
    12431252        userinfo = va_arg(ap, aim_userinfo_t *);
    1244 
    1245     if (set_getint(sess->aux_data, "debug")) {
    1246         serv_got_crap(sess->aux_data, "channel %i called", channel);
    1247     }
    12481253
    12491254        switch (channel) {
    … …  
    17231728        odata->rights.maxsiglen = odata->rights.maxawaymsglen = (guint)maxsiglen;
    17241729
     1730        /* FIXME: It seems we're not really using this, and it broke now that
     1731           struct aim_user is dead.
    17251732        aim_bos_setprofile(sess, fr->conn, gc->user->user_info, NULL, gaim_caps);
    1726 
     1733        */
     1734       
    17271735        return 1;
    17281736}
    … …  
    22892297        }
    22902298        info_string_append(str, "\n", _("Mobile Phone"), info->mobile);
    2291         info_string_append(str, "\n", _("Gender"), info->gender==1 ? _("Female") : _("Male"));
     2299        info_string_append(str, "\n", _("Gender"), info->gender==1 ? _("Female") : info->gender==2 ? _("Male") : _("Unknown"));
    22922300        if (info->birthyear || info->birthmonth || info->birthday) {
    22932301                char date[30];
    … …  
    26562664        ret->away_states = oscar_away_states;
    26572665        ret->login = oscar_login;
     2666        ret->acc_init = oscar_acc_init;
    26582667        ret->close = oscar_close;
    26592668        ret->send_im = oscar_send_im;
    … …  
    26732682        ret->set_permit_deny = oscar_set_permit_deny;
    26742683        ret->keepalive = oscar_keepalive;
    2675         ret->cmp_buddynames = aim_sncmp;
    26762684        ret->get_status_string = oscar_get_status_string;
    26772685        ret->send_typing = oscar_send_typing;
     2686       
     2687        ret->handle_cmp = aim_sncmp;
    26782688
    26792689        register_protocol(ret);

  • protocols/oscar/rxhandlers.c

    rf4aa393 rd8d63a2  
    112112                /* Following SNAC will be related */
    113113        }
    114 
    115     if (set_getint(sess->aux_data, "debug")) {
    116         serv_got_crap(sess->aux_data, "snac %x/%x received", snac.family, snac.subtype);
    117     }
    118114
    119115        for (cur = (aim_module_t *)sess->modlistv; cur; cur = cur->next) {

  • protocols/oscar/service.c

    rf4aa393 rd8d63a2  
    732732        guint32 data;
    733733        int tlvlen;
     734        struct gaim_connection *gc = sess ? sess->aux_data : NULL;
    734735
    735736        data = AIM_ICQ_STATE_HIDEIP | status; /* yay for error checking ;^) */
     737       
     738        if (gc && set_getbool(&gc->acc->set, "web_aware"))
     739                data |= AIM_ICQ_STATE_WEBAWARE;
    736740
    737741        tlvlen = aim_addtlvtochain32(&tl, 0x0006, data);

  • protocols/yahoo/libyahoo2.c

    rf4aa393 rd8d63a2  
    8989#define vsnprintf _vsnprintf
    9090#endif
     91
     92#include "base64.h"
    9193
    9294#ifdef USE_STRUCT_CALLBACKS
    … …  
    695697}
    696698
    697 static char base64digits[] =    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    698                                 "abcdefghijklmnopqrstuvwxyz"
    699                                 "0123456789._";
     699/* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
    700700static void to_y64(unsigned char *out, const unsigned char *in, int inlen)
    701 /* raw bytes in quasi-big-endian order to base 64 string (NUL-terminated) */
    702 {
    703         for (; inlen >= 3; inlen -= 3)
    704                 {
    705                         *out++ = base64digits[in[0] >> 2];
    706                         *out++ = base64digits[((in[0]<<4) & 0x30) | (in[1]>>4)];
    707                         *out++ = base64digits[((in[1]<<2) & 0x3c) | (in[2]>>6)];
    708                         *out++ = base64digits[in[2] & 0x3f];
    709                         in += 3;
    710                 }
    711         if (inlen > 0)
    712                 {
    713                         unsigned char fragment;
    714 
    715                         *out++ = base64digits[in[0] >> 2];
    716                         fragment = (in[0] << 4) & 0x30;
    717                         if (inlen > 1)
    718                                 fragment |= in[1] >> 4;
    719                         *out++ = base64digits[fragment];
    720                         *out++ = (inlen < 2) ? '-'
    721                                         : base64digits[(in[1] << 2) & 0x3c];
    722                         *out++ = '-';
    723                 }
    724         *out = '\0';
     701{
     702        base64_encode_real(in, inlen, out, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-");
    725703}
    726704

  • protocols/yahoo/yahoo.c

    rf4aa393 rd8d63a2  
    121121}
    122122
    123 static void byahoo_login( struct aim_user *user )
    124 {
    125         struct gaim_connection *gc = new_gaim_conn( user );
     123static void byahoo_login( account_t *acc )
     124{
     125        struct gaim_connection *gc = new_gaim_conn( acc );
    126126        struct byahoo_data *yd = gc->proto_data = g_new0( struct byahoo_data, 1 );
    127127       
    … …  
    130130       
    131131        set_login_progress( gc, 1, "Connecting" );
    132         yd->y2_id = yahoo_init( user->username, user->password );
     132        yd->y2_id = yahoo_init( acc->user, acc->pass );
    133133        yahoo_login( yd->y2_id, yd->current_status );
    134134}
    … …  
    192192        gc->away = NULL;
    193193       
    194         if( msg )
     194        if( state && msg && g_strcasecmp( state, msg ) != 0 )
    195195        {
    196196                yd->current_status = YAHOO_STATUS_CUSTOM;
    197197                gc->away = "";
    198198        }
    199         if( state )
    200         {
     199        else if( state )
     200        {
     201                /* Set msg to NULL since (if it isn't NULL already) it's equal
     202                   to state. msg must be empty if we want to use an existing
     203                   away state. */
     204                msg = NULL;
     205               
    201206                gc->away = "";
    202207                if( g_strcasecmp( state, "Available" ) == 0 )
    … …  
    235240                yd->current_status = YAHOO_STATUS_AVAILABLE;
    236241       
    237         if( yd->current_status == YAHOO_STATUS_INVISIBLE )
    238                 yahoo_set_away( yd->y2_id, yd->current_status, NULL, gc->away != NULL );
    239         else
    240                 yahoo_set_away( yd->y2_id, yd->current_status, msg, gc->away != NULL );
     242        yahoo_set_away( yd->y2_id, yd->current_status, msg, gc->away != NULL );
    241243}
    242244
    … …  
    409411        ret->chat_leave = byahoo_chat_leave;
    410412        ret->chat_open = byahoo_chat_open;
    411         ret->cmp_buddynames = g_strcasecmp;
     413
     414        ret->handle_cmp = g_strcasecmp;
    412415       
    413416        register_protocol(ret);
    … …  
    425428                yd = gc->proto_data;
    426429               
    427                 if( !strcmp(gc->prpl->name, "yahoo") && yd->y2_id == id )
     430                if( strcmp( gc->acc->prpl->name, "yahoo" ) == 0 && yd->y2_id == id )
    428431                        return( gc );
    429432        }
Note: See TracChangeset for help on using the changeset viewer.