Changes in / [638feab:842cd8d]


Ignore:
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • account.c

    r638feab r842cd8d  
    5454       
    5555        s = set_add( &a->set, "auto_reconnect", "true", set_eval_bool, a );
    56        
    57         s = set_add( &a->set, "nick_source", "handle", NULL, a );
    5856       
    5957        s = set_add( &a->set, "password", NULL, set_eval_account, a );

  • bitlbee.c

    r638feab r842cd8d  
    109109                chdir( "/" );
    110110               
    111                 if( getenv( "_BITLBEE_RESTART_STATE" ) == NULL )
    112                         for( i = 0; i < 3; i ++ )
    113                                 if( close( i ) == 0 )
    114                                 {
    115                                         /* Keep something bogus on those fd's just in case. */
    116                                         open( "/dev/null", O_WRONLY );
    117                                 }
     111                /* Sometimes std* are already closed (for example when we're in a RESTARTed
     112                   BitlBee process. So let's only close TTY-fds. */
     113                if( isatty( 0 ) ) close( 0 );
     114                if( isatty( 1 ) ) close( 1 );
     115                if( isatty( 2 ) ) close( 2 );
    118116        }
    119117#endif

  • bitlbee.conf

    r638feab r842cd8d  
    120120## Proxy = socks5://socksproxy.localnet.com
    121121
    122 ## Protocols offered by bitlbee
    123 ##
    124 ## As recompiling may be quite unpractical for some people, this option
    125 ## allows to remove the support of protocol, even if compiled in. If
    126 ## nothing is given, there are no restrictions.
    127 ##
    128 ## Protocols = jabber yahoo
    129 
    130122
    131123[defaults]

  • bitlbee.h

    r638feab r842cd8d  
    2727#define _BITLBEE_H
    2828
    29 #ifndef _GNU_SOURCE
    3029#define _GNU_SOURCE /* Stupid GNU :-P */
    31 #endif
    3230
    3331/* Depend on Windows 2000 for now since we need getaddrinfo() */
    … …  
    3533
    3634#define PACKAGE "BitlBee"
    37 #define BITLBEE_VERSION "1.2.5"
     35#define BITLBEE_VERSION "1.2.4"
    3836#define VERSION BITLBEE_VERSION
    3937

  • conf.c

    r638feab r842cd8d  
    6363        conf->ping_timeout = 300;
    6464        conf->user = NULL;
    65         conf->protocols = NULL;
    6665        proxytype = 0;
    6766       
    … …  
    308307                                conf->user = g_strdup( ini->value );
    309308                        }
    310                         else if( g_strcasecmp( ini->key, "protocols" ) == 0 )
    311                         {
    312                                 g_strfreev( conf->protocols );
    313                                 conf->protocols = g_strsplit_set( ini->value, " \t,;", -1 );
    314                         }
    315309                        else
    316310                        {

  • conf.h

    r638feab r842cd8d  
    5050        int ping_timeout;
    5151        char *user;
    52         char **protocols;
    5352} conf_t;
    5453

  • configure

    r638feab r842cd8d  
    444444fi
    445445
    446 if [ ! -e doc/user-guide/help.txt ] && ! type xmlto > /dev/null 2> /dev/null; then
    447         echo
    448         echo 'WARNING: Building from an unreleased source tree without prebuilt helpfile.'
    449         echo 'Install xmlto if you want online help to work.'
    450 fi
    451 
    452446echo
    453447if [ -z "$BITLBEE_VERSION" -a -d .bzr ] && type bzr > /dev/null 2> /dev/null; then
    … …  
    535529;;
    536530Darwin )
    537         echo 'STRIP=\# skip strip' >> Makefile.settings
    538531;;
    539532IRIX )

  • doc/CHANGES

    r638feab r842cd8d  
    33
    44http://bugs.bitlbee.org/bitlbee/timeline?daysback=90&changeset=on
    5 
    6 Version 1.2.5:
    7 - Many bug fixes, including a fix for MSN login issues, Jabber login timing
    8   issues, Yahoo! crashes at login time with huge contact lists,
    9 - Avoid linking in a static version of libresolv now that glibc has all
    10   relevant functions available in the dynamic version.
    11 - Improved away state code and added the ability to set (non-away) status
    12   messages using "set status" (also possible per account) and see them in
    13   blist and /whois output.
    14 - Added a post-1.2 equivalent of encode/decode to quickly encrypt/decrypt
    15   passwords in a way that BitlBee can read them.
    16 - Allow using the full name for generating nicknames, instead of just the
    17   handle. This is especially useful when using the Facebook XMPP server.
    18 - Auto reconnect is now enabled by default since all protocols can properly
    19   detect cases where auto reconnect should be avoided (i.e. concurrent
    20   logins).
    21 - Changed the default resource_select setting which should reduce message
    22   routing issues on Jabber (i.e. messages going someone's phone instead of
    23   the main client).
    24 
    25 Fixed 17 Mar 2010
    265
    276Version 1.2.4:

  • doc/user-guide/commands.xml

    r638feab r842cd8d  
    608608        </bitlbee-setting>
    609609
    610         <bitlbee-setting name="nick_source" type="string" scope="account">
    611                 <default>handle</default>
    612                 <possible-values>handle, full_name, first_name</possible-values>
    613 
    614                 <description>
    615                         <para>
    616                                 By default, BitlBee generates a nickname for every contact by taking its handle and chopping off everything after the @. In some cases, this gives very inconvenient nicknames. The Facebook XMPP server is a good example, as all Facebook XMPP handles are numeric.
    617                         </para>
    618 
    619                         <para>
    620                                 With this setting set to <emphasis>full_name</emphasis>, the person's full name is used to generate a nickname. Or if you don't like long nicknames, set this setting to <emphasis>first_name</emphasis> instead and only the first word will be used. Note that the full name can be full of non-ASCII characters which will be stripped off.
    621                         </para>
    622                 </description>
    623         </bitlbee-setting>
    624 
    625610        <bitlbee-setting name="ops" type="string" scope="global">
    626611                <default>both</default>
    … …  
    716701
    717702        <bitlbee-setting name="resource_select" type="string" scope="account">
    718                 <default>activity</default>
     703                <default>priority</default>
    719704                <possible-values>priority, activity</possible-values>
    720705

  • irc.c

    r638feab r842cd8d  
    166166        s = set_add( &irc->set, "away_devoice", "true",  set_eval_away_devoice, irc );
    167167        s = set_add( &irc->set, "auto_connect", "true", set_eval_bool, irc );
    168         s = set_add( &irc->set, "auto_reconnect", "true", set_eval_bool, irc );
     168        s = set_add( &irc->set, "auto_reconnect", "false", set_eval_bool, irc );
    169169        s = set_add( &irc->set, "auto_reconnect_delay", "5*3<900", set_eval_account_reconnect_delay, irc );
    170170        s = set_add( &irc->set, "buddy_sendbuffer", "false", set_eval_bool, irc );

  • irc_commands.c

    r638feab r842cd8d  
    497497                else if( u->away )
    498498                        irc_reply( irc, 301, "%s :%s", u->nick, u->away );
    499                 if( u->status_msg )
    500                         irc_reply( irc, 333, "%s :Status: %s", u->nick, u->status_msg );
    501499               
    502500                irc_reply( irc, 318, "%s :End of /WHOIS list", nick );

  • lib/misc.c

    r638feab r842cd8d  
    3434#include "nogaim.h"
    3535#include "base64.h"
    36 #include "md5.h"
    3736#include <stdio.h>
    3837#include <stdlib.h>
    … …  
    524523
    525524/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */
    526 char *word_wrap( const char *msg, int line_len )
     525char *word_wrap( char *msg, int line_len )
    527526{
    528527        GString *ret = g_string_sized_new( strlen( msg ) + 16 );

  • lib/misc.h

    r638feab r842cd8d  
    6262G_MODULE_EXPORT struct ns_srv_reply *srv_lookup( char *service, char *protocol, char *domain );
    6363
    64 G_MODULE_EXPORT char *word_wrap( const char *msg, int line_len );
     64G_MODULE_EXPORT char *word_wrap( char *msg, int line_len );
    6565
    6666G_MODULE_EXPORT gboolean ssl_sockerr_again( void *ssl );

  • protocols/jabber/io.c

    r638feab r842cd8d  
    375375       
    376376        if( ( c = xt_find_node( node->children, "bind" ) ) )
    377                 jd->flags |= JFLAG_WANT_BIND;
     377        {
     378                reply = xt_new_node( "bind", NULL, xt_new_node( "resource", set_getstr( &ic->acc->set, "resource" ), NULL ) );
     379                xt_add_attr( reply, "xmlns", XMLNS_BIND );
     380                reply = jabber_make_packet( "iq", "set", NULL, reply );
     381                jabber_cache_add( ic, reply, jabber_pkt_bind_sess );
     382               
     383                if( !jabber_write_packet( ic, reply ) )
     384                        return XT_ABORT;
     385               
     386                jd->flags |= JFLAG_WAIT_BIND;
     387        }
    378388       
    379389        if( ( c = xt_find_node( node->children, "session" ) ) )
    380                 jd->flags |= JFLAG_WANT_SESSION;
    381        
    382         if( jd->flags & JFLAG_AUTHENTICATED )
    383                 return jabber_pkt_bind_sess( ic, NULL, NULL );
     390        {
     391                reply = xt_new_node( "session", NULL, NULL );
     392                xt_add_attr( reply, "xmlns", XMLNS_SESSION );
     393                reply = jabber_make_packet( "iq", "set", NULL, reply );
     394                jabber_cache_add( ic, reply, jabber_pkt_bind_sess );
     395               
     396                if( !jabber_write_packet( ic, reply ) )
     397                        return XT_ABORT;
     398               
     399                jd->flags |= JFLAG_WAIT_SESSION;
     400        }
     401       
     402        /* This flag is already set if we authenticated via SASL, so now
     403           we can resume the session in the new stream, if we don't have
     404           to bind/initialize the session. */
     405        if( jd->flags & JFLAG_AUTHENTICATED && ( jd->flags & ( JFLAG_WAIT_BIND | JFLAG_WAIT_SESSION ) ) == 0 )
     406        {
     407                if( !jabber_get_roster( ic ) )
     408                        return XT_ABORT;
     409        }
    384410       
    385411        return XT_HANDLED;
    … …  
    415441        imcb_log( ic, "Converting stream to TLS" );
    416442       
    417         jd->flags |= JFLAG_STARTTLS_DONE;
    418443        jd->ssl = ssl_starttls( jd->fd, jabber_connected_ssl, ic );
    419444       
    … …  
    506531                jd->r_inpa = b_input_add( jd->fd, GAIM_INPUT_READ, jabber_read_callback, ic );
    507532       
    508         greet = g_strdup_printf( "%s<stream:stream to=\"%s\" xmlns=\"jabber:client\" "
    509                                   "xmlns:stream=\"http://etherx.jabber.org/streams\" version=\"1.0\">",
    510                                   ( jd->flags & JFLAG_STARTTLS_DONE ) ? "" : "<?xml version='1.0' ?>",
    511                                   jd->server );
     533        greet = g_strdup_printf( "<?xml version='1.0' ?>"
     534                                 "<stream:stream to=\"%s\" xmlns=\"jabber:client\" "
     535                                  "xmlns:stream=\"http://etherx.jabber.org/streams\" version=\"1.0\">", jd->server );
    512536       
    513537        st = jabber_write( ic, greet, strlen( greet ) );

  • protocols/jabber/iq.c

    r638feab r842cd8d  
    298298{
    299299        struct jabber_data *jd = ic->proto_data;
    300         struct xt_node *c, *reply = NULL;
     300        struct xt_node *c;
    301301        char *s;
    302302       
    303         if( node && ( c = xt_find_node( node->children, "bind" ) ) )
     303        if( ( c = xt_find_node( node->children, "bind" ) ) )
    304304        {
    305305                c = xt_find_node( c->children, "jid" );
    … …  
    307307                    strcmp( s + 1, set_getstr( &ic->acc->set, "resource" ) ) != 0 )
    308308                        imcb_log( ic, "Server changed session resource string to `%s'", s + 1 );
    309         }
    310        
    311         if( jd->flags & JFLAG_WANT_BIND )
    312         {
    313                 reply = xt_new_node( "bind", NULL, xt_new_node( "resource", set_getstr( &ic->acc->set, "resource" ), NULL ) );
    314                 xt_add_attr( reply, "xmlns", XMLNS_BIND );
    315                 jd->flags &= ~JFLAG_WANT_BIND;
    316         }
    317         else if( jd->flags & JFLAG_WANT_SESSION )
    318         {
    319                 reply = xt_new_node( "session", NULL, NULL );
    320                 xt_add_attr( reply, "xmlns", XMLNS_SESSION );
    321                 jd->flags &= ~JFLAG_WANT_SESSION;
    322         }
    323        
    324         if( reply != NULL )
    325         {
    326                 reply = jabber_make_packet( "iq", "set", NULL, reply );
    327                 jabber_cache_add( ic, reply, jabber_pkt_bind_sess );
    328                
    329                 if( !jabber_write_packet( ic, reply ) )
    330                         return XT_ABORT;
    331         }
    332         else if( ( jd->flags & ( JFLAG_WANT_BIND | JFLAG_WANT_SESSION ) ) == 0 )
     309               
     310                jd->flags &= ~JFLAG_WAIT_BIND;
     311        }
     312        else
     313        {
     314                jd->flags &= ~JFLAG_WAIT_SESSION;
     315        }
     316       
     317        if( ( jd->flags & ( JFLAG_WAIT_BIND | JFLAG_WAIT_SESSION ) ) == 0 )
    333318        {
    334319                if( !jabber_get_roster( ic ) )

  • protocols/jabber/jabber.h

    r638feab r842cd8d  
    4040        JFLAG_STREAM_RESTART = 4,       /* Set when we want to restart the stream (after
    4141                                           SASL or TLS). */
    42         JFLAG_WANT_SESSION = 8,         /* Set if the server wants a <session/> tag
     42        JFLAG_WAIT_SESSION = 8,         /* Set if we sent a <session> tag and need a reply
    4343                                           before we continue. */
    44         JFLAG_WANT_BIND = 16,           /* ... for <bind> tag. */
     44        JFLAG_WAIT_BIND = 16,           /* ... for <bind> tag. */
    4545        JFLAG_WANT_TYPING = 32,         /* Set if we ever sent a typing notification, this
    4646                                           activates all XEP-85 related code. */
    4747        JFLAG_XMLCONSOLE = 64,          /* If the user added an xmlconsole buddy. */
    48         JFLAG_STARTTLS_DONE = 128,      /* If a plaintext session was converted to TLS. */
    4948} jabber_flags_t;
    5049

  • protocols/msn/msn.c

    r638feab r842cd8d  
    2626#include "nogaim.h"
    2727#include "msn.h"
    28 
    29 int msn_chat_id;
    30 GSList *msn_connections;
    31 GSList *msn_switchboards;
    3228
    3329static char *msn_set_display_name( set_t *set, char *value );

  • protocols/msn/msn.h

    r638feab r842cd8d  
    135135#define STATUS_SB_CHAT_SPARE    8       /* Same, but also for groupchats (not used yet). */
    136136
    137 extern int msn_chat_id;
     137int msn_chat_id;
    138138extern const struct msn_away_state msn_away_state_list[];
    139139extern const struct msn_status_code msn_status_code_list[];
    … …  
    144144   connection), the callback should check whether it's still listed here
    145145   before doing *anything* else. */
    146 extern GSList *msn_connections;
    147 extern GSList *msn_switchboards;
     146GSList *msn_connections;
     147GSList *msn_switchboards;
    148148
    149149/* ns.c */

  • protocols/msn/ns.c

    r638feab r842cd8d  
    229229                        }
    230230                }
    231                 else if( num_parts >= 7 && strcmp( cmd[2], "OK" ) == 0 )
     231                else if( num_parts == 7 && strcmp( cmd[2], "OK" ) == 0 )
    232232                {
    233233                        set_t *s;
    234234                       
    235                         if( num_parts == 7 )
    236                         {
    237                                 http_decode( cmd[4] );
    238                                
    239                                 strncpy( ic->displayname, cmd[4], sizeof( ic->displayname ) );
    240                                 ic->displayname[sizeof(ic->displayname)-1] = 0;
    241                                
    242                                 if( ( s = set_find( &ic->acc->set, "display_name" ) ) )
    243                                 {
    244                                         g_free( s->value );
    245                                         s->value = g_strdup( cmd[4] );
    246                                 }
    247                         }
    248                         else
    249                         {
    250                                 imcb_log( ic, "Warning: Friendly name in server response was corrupted" );
     235                        http_decode( cmd[4] );
     236                       
     237                        strncpy( ic->displayname, cmd[4], sizeof( ic->displayname ) );
     238                        ic->displayname[sizeof(ic->displayname)-1] = 0;
     239                       
     240                        if( ( s = set_find( &ic->acc->set, "display_name" ) ) )
     241                        {
     242                                g_free( s->value );
     243                                s->value = g_strdup( cmd[4] );
    251244                        }
    252245                       

  • protocols/nogaim.c

    r638feab r842cd8d  
    9898void register_protocol (struct prpl *p)
    9999{
    100         int i;
    101         gboolean refused = global.conf->protocols != NULL;
    102  
    103         for (i = 0; global.conf->protocols && global.conf->protocols[i]; i++)
    104         {
    105                 if (g_strcasecmp(p->name, global.conf->protocols[i]) == 0)
    106                         refused = FALSE;
    107         }
    108 
    109         if (refused)
    110                 log_message(LOGLVL_WARNING, "Protocol %s disabled\n", p->name);
    111         else
    112                 protocols = g_list_append(protocols, p);
     100        protocols = g_list_append(protocols, p);
    113101}
    114102
    … …  
    383371/* list.c */
    384372
    385 void imcb_add_buddy( struct im_connection *ic, const char *handle, const char *group )
     373void imcb_add_buddy( struct im_connection *ic, char *handle, char *group )
    386374{
    387375        user_t *u;
    … …  
    457445}
    458446
    459 void imcb_rename_buddy( struct im_connection *ic, const char *handle, const char *realname )
     447void imcb_rename_buddy( struct im_connection *ic, char *handle, char *realname )
    460448{
    461449        user_t *u = user_findhandle( ic, handle );
    462         char *set;
    463450       
    464451        if( !u || !realname ) return;
    … …  
    473460                        imcb_log( ic, "User `%s' changed name to `%s'", u->nick, u->realname );
    474461        }
    475        
    476         set = set_getstr( &ic->acc->set, "nick_source" );
    477         if( strcmp( set, "handle" ) != 0 )
    478         {
    479                 char *name = g_strdup( realname );
    480                
    481                 if( strcmp( set, "first_name" ) == 0 )
    482                 {
    483                         int i;
    484                         for( i = 0; name[i] && !isspace( name[i] ); i ++ ) {}
    485                         name[i] = '\0';
    486                 }
    487                
    488                 imcb_buddy_nick_hint( ic, handle, name );
    489                
    490                 g_free( name );
    491         }
    492 }
    493 
    494 void imcb_remove_buddy( struct im_connection *ic, const char *handle, char *group )
     462}
     463
     464void imcb_remove_buddy( struct im_connection *ic, char *handle, char *group )
    495465{
    496466        user_t *u;
    … …  
    502472/* Mainly meant for ICQ (and now also for Jabber conferences) to allow IM
    503473   modules to suggest a nickname for a handle. */
    504 void imcb_buddy_nick_hint( struct im_connection *ic, const char *handle, const char *nick )
     474void imcb_buddy_nick_hint( struct im_connection *ic, char *handle, char *nick )
    505475{
    506476        user_t *u = user_findhandle( ic, handle );
    … …  
    647617        oo = u->online;
    648618       
    649         g_free( u->away );
    650         g_free( u->status_msg );
    651         u->away = u->status_msg = NULL;
     619        if( u->away )
     620        {
     621                g_free( u->away );
     622                u->away = NULL;
     623        }
    652624       
    653625        if( ( flags & OPT_LOGGED_IN ) && !u->online )
    … …  
    687659                }
    688660        }
    689         else
    690         {
    691                 u->status_msg = g_strdup( message );
    692         }
     661        /* else waste_any_state_information_for_now(); */
    693662       
    694663        /* LISPy... */
    … …  
    715684}
    716685
    717 void imcb_buddy_msg( struct im_connection *ic, const char *handle, char *msg, uint32_t flags, time_t sent_at )
     686void imcb_buddy_msg( struct im_connection *ic, char *handle, char *msg, uint32_t flags, time_t sent_at )
    718687{
    719688        irc_t *irc = ic->irc;
    … …  
    848817}
    849818
    850 void imcb_chat_msg( struct groupchat *c, const char *who, char *msg, uint32_t flags, time_t sent_at )
     819void imcb_chat_msg( struct groupchat *c, char *who, char *msg, uint32_t flags, time_t sent_at )
    851820{
    852821        struct im_connection *ic = c->ic;
    … …  
    920889/* buddy_chat.c */
    921890
    922 void imcb_chat_add_buddy( struct groupchat *b, const char *handle )
     891void imcb_chat_add_buddy( struct groupchat *b, char *handle )
    923892{
    924893        user_t *u = user_findhandle( b->ic, handle );
    … …  
    955924
    956925/* This function is one BIG hack... :-( EREWRITE */
    957 void imcb_chat_remove_buddy( struct groupchat *b, const char *handle, const char *reason )
     926void imcb_chat_remove_buddy( struct groupchat *b, char *handle, char *reason )
    958927{
    959928        user_t *u;

  • protocols/nogaim.h

    r638feab r842cd8d  
    275275 * user, usually after a login, or if the user added a buddy and the IM
    276276 * server confirms that the add was successful. Don't forget to do this! */
    277 G_MODULE_EXPORT void imcb_add_buddy( struct im_connection *ic, const char *handle, const char *group );
    278 G_MODULE_EXPORT void imcb_remove_buddy( struct im_connection *ic, const char *handle, char *group );
     277G_MODULE_EXPORT void imcb_add_buddy( struct im_connection *ic, char *handle, char *group );
     278G_MODULE_EXPORT void imcb_remove_buddy( struct im_connection *ic, char *handle, char *group );
    279279G_MODULE_EXPORT struct buddy *imcb_find_buddy( struct im_connection *ic, char *handle );
    280 G_MODULE_EXPORT void imcb_rename_buddy( struct im_connection *ic, const char *handle, const char *realname );
    281 G_MODULE_EXPORT void imcb_buddy_nick_hint( struct im_connection *ic, const char *handle, const char *nick );
     280G_MODULE_EXPORT void imcb_rename_buddy( struct im_connection *ic, char *handle, char *realname );
     281G_MODULE_EXPORT void imcb_buddy_nick_hint( struct im_connection *ic, char *handle, char *nick );
    282282
    283283/* Buddy activity */
    … …  
    289289/* Not implemented yet! */ G_MODULE_EXPORT void imcb_buddy_times( struct im_connection *ic, const char *handle, time_t login, time_t idle );
    290290/* Call when a handle says something. 'flags' and 'sent_at may be just 0. */
    291 G_MODULE_EXPORT void imcb_buddy_msg( struct im_connection *ic, const char *handle, char *msg, uint32_t flags, time_t sent_at );
     291G_MODULE_EXPORT void imcb_buddy_msg( struct im_connection *ic, char *handle, char *msg, uint32_t flags, time_t sent_at );
    292292G_MODULE_EXPORT void imcb_buddy_typing( struct im_connection *ic, char *handle, uint32_t flags );
    293293G_MODULE_EXPORT void imcb_clean_handle( struct im_connection *ic, char *handle );
    … …  
    302302 *   user, too. */
    303303G_MODULE_EXPORT struct groupchat *imcb_chat_new( struct im_connection *ic, const char *handle );
    304 G_MODULE_EXPORT void imcb_chat_add_buddy( struct groupchat *b, const char *handle );
     304G_MODULE_EXPORT void imcb_chat_add_buddy( struct groupchat *b, char *handle );
    305305/* To remove a handle from a group chat. Reason can be NULL. */
    306 G_MODULE_EXPORT void imcb_chat_remove_buddy( struct groupchat *b, const char *handle, const char *reason );
     306G_MODULE_EXPORT void imcb_chat_remove_buddy( struct groupchat *b, char *handle, char *reason );
    307307/* To tell BitlBee 'who' said 'msg' in 'c'. 'flags' and 'sent_at' can be 0. */
    308 G_MODULE_EXPORT void imcb_chat_msg( struct groupchat *c, const char *who, char *msg, uint32_t flags, time_t sent_at );
     308G_MODULE_EXPORT void imcb_chat_msg( struct groupchat *c, char *who, char *msg, uint32_t flags, time_t sent_at );
    309309/* System messages specific to a groupchat, so they can be displayed in the right context. */
    310310G_MODULE_EXPORT void imcb_chat_log( struct groupchat *c, char *format, ... ) G_GNUC_PRINTF( 2, 3 );

  • protocols/yahoo/libyahoo2.c

    r638feab r842cd8d  
    855855}
    856856
     857static YList * bud_str2list(char *rawlist)
     858{
     859        YList * l = NULL;
     860
     861        char **lines;
     862        char **split;
     863        char **buddies;
     864        char **tmp, **bud;
     865
     866        lines = y_strsplit(rawlist, "\n", -1);
     867        for (tmp = lines; *tmp; tmp++) {
     868                struct yahoo_buddy *newbud;
     869
     870                split = y_strsplit(*tmp, ":", 2);
     871                if (!split)
     872                        continue;
     873                if (!split[0] || !split[1]) {
     874                        y_strfreev(split);
     875                        continue;
     876                }
     877                buddies = y_strsplit(split[1], ",", -1);
     878
     879                for (bud = buddies; bud && *bud; bud++) {
     880                        newbud = y_new0(struct yahoo_buddy, 1);
     881                        newbud->id = strdup(*bud);
     882                        newbud->group = strdup(split[0]);
     883
     884                        if(y_list_find_custom(l, newbud, is_same_bud)) {
     885                                FREE(newbud->id);
     886                                FREE(newbud->group);
     887                                FREE(newbud);
     888                                continue;
     889                        }
     890
     891                        newbud->real_name = NULL;
     892
     893                        l = y_list_append(l, newbud);
     894
     895                        NOTICE(("Added buddy %s to group %s", newbud->id, newbud->group));
     896                }
     897
     898                y_strfreev(buddies);
     899                y_strfreev(split);
     900        }
     901        y_strfreev(lines);
     902
     903        return l;
     904}
     905
    857906static char * getcookie(char *rawcookie)
    858907{
    … …  
    13111360}
    13121361
    1313 static void yahoo_process_status(struct yahoo_input_data *yid,
    1314         struct yahoo_packet *pkt)
     1362
     1363static void yahoo_process_status(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
    13151364{
    13161365        YList *l;
    13171366        struct yahoo_data *yd = yid->yd;
    13181367
    1319         struct yahoo_process_status_entry *u;
     1368        struct user
     1369        {
     1370                char *name;     /* 7    name */
     1371                int   state;    /* 10   state */
     1372                int   flags;    /* 13   flags, bit 0 = pager, bit 1 = chat, bit 2 = game */
     1373                int   mobile;   /* 60   mobile */
     1374                char *msg;      /* 19   custom status message */
     1375                int   away;     /* 47   away (or invisible)*/
     1376                int   buddy_session;    /* 11   state */
     1377                int   f17;      /* 17   in chat? then what about flags? */
     1378                int   idle;     /* 137  seconds idle */
     1379                int   f138;     /* 138  state */
     1380                char *f184;     /* 184  state */
     1381                int   f192;     /* 192  state */
     1382                int   f10001;   /* 10001        state */
     1383                int   f10002;   /* 10002        state */
     1384                int   f198;     /* 198  state */
     1385                char *f197;     /* 197  state */
     1386                char *f205;     /* 205  state */
     1387                int   f213;     /* 213  state */
     1388        } *u;
    13201389
    13211390        YList *users = 0;
    1322 
     1391       
    13231392        if (pkt->service == YAHOO_SERVICE_LOGOFF && pkt->status == -1) {
    1324                 YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id,
    1325                         YAHOO_LOGIN_DUPL, NULL);
    1326                 return;
    1327         }
    1328 
    1329         /* Status updates may be spread accross multiple packets and not
    1330            even on buddy boundaries, so keeping some state is important.
    1331            So, continue where we left off, and only add a user entry to
    1332            the list once it's complete (301-315 End buddy). */
    1333         u = yd->half_user;
     1393                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_DUPL, NULL);
     1394                return;
     1395        }
    13341396
    13351397        for (l = pkt->hash; l; l = l->next) {
    … …  
    13371399
    13381400                switch (pair->key) {
    1339                 case 300:       /* Begin buddy */
    1340                         if (!strcmp(pair->value, "315") && !u) {
    1341                                 u = yd->half_user = y_new0(struct yahoo_process_status_entry, 1);
     1401                case 0: /* we won't actually do anything with this */
     1402                        NOTICE(("key %d:%s", pair->key, pair->value));
     1403                        break;
     1404                case 1: /* we don't get the full buddy list here. */
     1405                        if (!yd->logged_in) {
     1406                                yd->logged_in = TRUE;
     1407                                if(yd->current_status < 0)
     1408                                        yd->current_status = yd->initial_status;
     1409                                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
    13421410                        }
    13431411                        break;
    1344                 case 301:       /* End buddy */
    1345                         if (!strcmp(pair->value, "315") && u) {
    1346                                 /* Sometimes user info comes in an odd format with no
    1347                                    "begin buddy" but *with* an "end buddy". Don't add
    1348                                    it twice. */
    1349                                 if (!y_list_find(users, u))
    1350                                         users = y_list_prepend(users, u);
    1351                                 u = yd->half_user = NULL;
    1352                         }
    1353                         break;
    1354                 case 0: /* we won't actually do anything with this */
     1412                case 8: /* how many online buddies we have */
    13551413                        NOTICE(("key %d:%s", pair->key, pair->value));
    13561414                        break;
    1357                 case 1: /* we don't get the full buddy list here. */
    1358                         if (!yd->logged_in) {
    1359                                 yd->logged_in = 1;
    1360                                 if (yd->current_status < 0)
    1361                                         yd->current_status = yd->initial_status;
    1362                                 YAHOO_CALLBACK(ext_yahoo_login_response) (yd->
    1363                                         client_id, YAHOO_LOGIN_OK, NULL);
    1364                         }
    1365                         break;
    1366                 case 8: /* how many online buddies we have */
    1367                         NOTICE(("key %d:%s", pair->key, pair->value));
    1368                         break;
    1369                 case 7: /* the current buddy */
    1370                         if (!u) {
    1371                                 /* This will only happen in case of a single level message */
    1372                                 u = y_new0(struct yahoo_process_status_entry, 1);
    1373                                 users = y_list_prepend(users, u);
    1374                         }
     1415                case 7: /* the current buddy */
     1416                        u = y_new0(struct user, 1);
    13751417                        u->name = pair->value;
    1376                         break;
    1377                 case 10:        /* state */
    1378                         u->state = strtol(pair->value, NULL, 10);
    1379                         break;
    1380                 case 19:        /* custom status message */
    1381                         u->msg = pair->value;
    1382                         break;
    1383                 case 47:        /* is it an away message or not. Not applicable for YMSG16 anymore */
    1384                         u->away = atoi(pair->value);
    1385                         break;
    1386                 case 137:       /* seconds idle */
    1387                         u->idle = atoi(pair->value);
    1388                         break;
    1389                 case 11:        /* this is the buddy's session id */
    1390                         u->buddy_session = atoi(pair->value);
    1391                         break;
    1392                 case 17:        /* in chat? */
    1393                         u->f17 = atoi(pair->value);
    1394                         break;
    1395                 case 13:        /* bitmask, bit 0 = pager, bit 1 = chat, bit 2 = game */
    1396                         u->flags = atoi(pair->value);
    1397                         break;
    1398                 case 60:        /* SMS -> 1 MOBILE USER */
     1418                        users = y_list_prepend(users, u);
     1419                        break;
     1420                case 10: /* state */
     1421                        ((struct user*)users->data)->state = strtol(pair->value, NULL, 10);
     1422                        break;
     1423                case 19: /* custom status message */
     1424                        ((struct user*)users->data)->msg = pair->value;
     1425                        break;
     1426                case 47: /* is it an away message or not */
     1427                        ((struct user*)users->data)->away = atoi(pair->value);
     1428                        break;
     1429                case 137: /* seconds idle */
     1430                        ((struct user*)users->data)->idle = atoi(pair->value);
     1431                        break;
     1432                case 11: /* this is the buddy's session id */
     1433                        ((struct user*)users->data)->buddy_session = atoi(pair->value);
     1434                        break;
     1435                case 17: /* in chat? */
     1436                        ((struct user*)users->data)->f17 = atoi(pair->value);
     1437                        break;
     1438                case 13: /* bitmask, bit 0 = pager, bit 1 = chat, bit 2 = game */
     1439                        ((struct user*)users->data)->flags = atoi(pair->value);
     1440                        break;
     1441                case 60: /* SMS -> 1 MOBILE USER */
    13991442                        /* sometimes going offline makes this 2, but invisible never sends it */
    1400                         u->mobile = atoi(pair->value);
     1443                        ((struct user*)users->data)->mobile = atoi(pair->value);
    14011444                        break;
    14021445                case 138:
    1403                         u->f138 = atoi(pair->value);
     1446                        ((struct user*)users->data)->f138 = atoi(pair->value);
    14041447                        break;
    14051448                case 184:
    1406                         u->f184 = pair->value;
     1449                        ((struct user*)users->data)->f184 = pair->value;
    14071450                        break;
    14081451                case 192:
    1409                         u->f192 = atoi(pair->value);
     1452                        ((struct user*)users->data)->f192 = atoi(pair->value);
    14101453                        break;
    14111454                case 10001:
    1412                         u->f10001 = atoi(pair->value);
     1455                        ((struct user*)users->data)->f10001 = atoi(pair->value);
    14131456                        break;
    14141457                case 10002:
    1415                         u->f10002 = atoi(pair->value);
     1458                        ((struct user*)users->data)->f10002 = atoi(pair->value);
    14161459                        break;
    14171460                case 198:
    1418                         u->f198 = atoi(pair->value);
     1461                        ((struct user*)users->data)->f198 = atoi(pair->value);
    14191462                        break;
    14201463                case 197:
    1421                         u->f197 = pair->value;
     1464                        ((struct user*)users->data)->f197 = pair->value;
    14221465                        break;
    14231466                case 205:
    1424                         u->f205 = pair->value;
     1467                        ((struct user*)users->data)->f205 = pair->value;
    14251468                        break;
    14261469                case 213:
    1427                         u->f213 = atoi(pair->value);
    1428                         break;
    1429                 case 16:        /* Custom error message */
    1430                         YAHOO_CALLBACK(ext_yahoo_error) (yd->client_id,
    1431                                 pair->value, 0, E_CUSTOM);
     1470                        ((struct user*)users->data)->f213 = atoi(pair->value);
     1471                        break;
     1472                case 16: /* Custom error message */
     1473                        YAHOO_CALLBACK(ext_yahoo_error)(yd->client_id, pair->value, 0, E_CUSTOM);
    14321474                        break;
    14331475                default:
    1434                         WARNING(("unknown status key %d:%s", pair->key,
    1435                                         pair->value));
    1436                         break;
    1437                 }
    1438         }
    1439 
     1476                        WARNING(("unknown status key %d:%s", pair->key, pair->value));
     1477                        break;
     1478                }
     1479        }
     1480       
    14401481        while (users) {
    14411482                YList *t = users;
    1442                 struct yahoo_process_status_entry *u = users->data;
     1483                struct user *u = users->data;
    14431484
    14441485                if (u->name != NULL) {
    1445                         if (pkt->service ==
    1446                                 YAHOO_SERVICE_LOGOFF
    1447                                 /*|| u->flags == 0 No flags for YMSG16 */ ) {
    1448                                 YAHOO_CALLBACK(ext_yahoo_status_changed) (yd->
    1449                                         client_id, u->name,
    1450                                         YAHOO_STATUS_OFFLINE, NULL, 1, 0, 0);
     1486                        if (pkt->service == YAHOO_SERVICE_LOGOFF) { /* || u->flags == 0) { Not in YMSG16 */
     1487                                YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, YAHOO_STATUS_OFFLINE, NULL, 1, 0, 0);
    14511488                        } else {
    14521489                                /* Key 47 always seems to be 1 for YMSG16 */
    1453                                 if (!u->state)
     1490                                if(!u->state)
    14541491                                        u->away = 0;
    14551492                                else
    14561493                                        u->away = 1;
    14571494
    1458                                 YAHOO_CALLBACK(ext_yahoo_status_changed) (yd->
    1459                                         client_id, u->name, u->state, u->msg,
    1460                                         u->away, u->idle, u->mobile);
     1495                                YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, u->state, u->msg, u->away, u->idle, u->mobile);
    14611496                        }
    14621497                }
    … …  
    14681503}
    14691504
    1470 static void yahoo_process_buddy_list(struct yahoo_input_data *yid,
    1471         struct yahoo_packet *pkt)
     1505static void yahoo_process_buddy_list(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
    14721506{
    14731507        struct yahoo_data *yd = yid->yd;
    … …  
    14811515                struct yahoo_pair *pair = l->data;
    14821516
    1483                 switch (pair->key) {
     1517                switch(pair->key) {
    14841518                case 300:
    14851519                case 301:
    14861520                case 302:
    1487                         break;  /* Separators. Our logic does not need them */
    14881521                case 303:
    1489                         if (318 == atoi(pair->value))
     1522                        if ( 315 == atoi(pair->value) )
    14901523                                last_packet = 1;
    14911524                        break;
    14921525                case 65:
     1526                        g_free(cur_group);
    14931527                        cur_group = strdup(pair->value);
    14941528                        break;
    … …  
    14961530                        newbud = y_new0(struct yahoo_buddy, 1);
    14971531                        newbud->id = strdup(pair->value);
    1498                         if (cur_group)
     1532                        if (cur_group) {
    14991533                                newbud->group = strdup(cur_group);
    1500                         else if (yd->buddies) {
    1501                                 struct yahoo_buddy *lastbud =
    1502                                         (struct yahoo_buddy *)y_list_nth(yd->
    1503                                         buddies,
    1504                                         y_list_length(yd->buddies) - 1)->data;
    1505                                 newbud->group = strdup(lastbud->group);
    1506                         } else
    1507                                 newbud->group = strdup("Buddies");
     1534                        } else {
     1535                                YList *last;
     1536                                struct yahoo_buddy *lastbud;
     1537                               
     1538                                for (last = yd->buddies; last && last->next; last = last->next);
     1539                                if (last) {
     1540                                        lastbud = last->data;
     1541                                        newbud->group = strdup(lastbud->group);
     1542                                } else {
     1543                                        newbud->group = strdup("Buddies");
     1544                                }
     1545                        }
    15081546
    15091547                        yd->buddies = y_list_append(yd->buddies, newbud);
    … …  
    15121550                }
    15131551        }
     1552       
     1553        g_free(cur_group);
    15141554
    15151555        /* we could be getting multiple packets here */
    1516         if (pkt->hash && !last_packet)
    1517                 return;
    1518 
    1519         YAHOO_CALLBACK(ext_yahoo_got_buddies) (yd->client_id, yd->buddies);
    1520 
    1521         /* Logged in */
     1556        if (last_packet)
     1557                return;
     1558
     1559        YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
     1560
     1561        /*** We login at the very end of the packet communication */
    15221562        if (!yd->logged_in) {
    1523                 yd->logged_in = 1;
    1524                 if (yd->current_status < 0)
     1563                yd->logged_in = TRUE;
     1564                if(yd->current_status < 0)
    15251565                        yd->current_status = yd->initial_status;
    1526                 YAHOO_CALLBACK(ext_yahoo_login_response) (yd->client_id,
    1527                         YAHOO_LOGIN_OK, NULL);
    1528 
    1529                 /*
    1530                 yahoo_set_away(yd->client_id, yd->initial_status, NULL,
    1531                         (yd->initial_status == YAHOO_STATUS_AVAILABLE) ? 0 : 1);
    1532 
    1533                 yahoo_get_yab(yd->client_id);
    1534                 */
    1535         }
    1536 
    1537 }
    1538 
    1539 static void yahoo_process_list(struct yahoo_input_data *yid,
    1540         struct yahoo_packet *pkt)
     1566                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
     1567        }
     1568}
     1569
     1570static void yahoo_process_list(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
    15411571{
    15421572        struct yahoo_data *yd = yid->yd;
    15431573        YList *l;
    15441574
    1545         /* we could be getting multiple packets here */
     1575        if (!yd->logged_in) {
     1576                yd->logged_in = TRUE;
     1577                if(yd->current_status < 0)
     1578                        yd->current_status = yd->initial_status;
     1579                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
     1580        }
     1581
    15461582        for (l = pkt->hash; l; l = l->next) {
    15471583                struct yahoo_pair *pair = l->data;
    15481584
    1549                 switch (pair->key) {
    1550                 case 89:        /* identities */
     1585                switch(pair->key) {
     1586                case 87: /* buddies */
     1587                        if(!yd->rawbuddylist)
     1588                                yd->rawbuddylist = strdup(pair->value);
     1589                        else {
     1590                                yd->rawbuddylist = y_string_append(yd->rawbuddylist, pair->value);
     1591                        }
     1592                        break;
     1593
     1594                case 88: /* ignore list */
     1595                        if(!yd->ignorelist)
     1596                                yd->ignorelist = strdup("Ignore:");
     1597                        yd->ignorelist = y_string_append(yd->ignorelist, pair->value);
     1598                        break;
     1599
     1600                case 89: /* identities */
    15511601                        {
    1552                                 char **identities =
    1553                                         y_strsplit(pair->value, ",", -1);
    1554                                 int i;
    1555                                 for (i = 0; identities[i]; i++)
    1556                                         yd->identities =
    1557                                                 y_list_append(yd->identities,
     1602                        char **identities = y_strsplit(pair->value, ",", -1);
     1603                        int i;
     1604                        for(i=0; identities[i]; i++)
     1605                                yd->identities = y_list_append(yd->identities,
    15581606                                                strdup(identities[i]));
    1559                                 y_strfreev(identities);
     1607                        y_strfreev(identities);
    15601608                        }
    1561                         YAHOO_CALLBACK(ext_yahoo_got_identities) (yd->client_id,
    1562                                 yd->identities);
    1563                         break;
    1564                 case 59:        /* cookies */
    1565                         if (pair->value[0] == 'Y') {
     1609                        YAHOO_CALLBACK(ext_yahoo_got_identities)(yd->client_id, yd->identities);
     1610                        break;
     1611                case 59: /* cookies */
     1612                        if(yd->ignorelist) {
     1613                                yd->ignore = bud_str2list(yd->ignorelist);
     1614                                FREE(yd->ignorelist);
     1615                                YAHOO_CALLBACK(ext_yahoo_got_ignore)(yd->client_id, yd->ignore);
     1616                        }
     1617                        if(yd->rawbuddylist) {
     1618                                yd->buddies = bud_str2list(yd->rawbuddylist);
     1619                                FREE(yd->rawbuddylist);
     1620                                YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
     1621                        }
     1622
     1623                        if(pair->value[0]=='Y') {
    15661624                                FREE(yd->cookie_y);
    15671625                                FREE(yd->login_cookie);
    … …  
    15701628                                yd->login_cookie = getlcookie(yd->cookie_y);
    15711629
    1572                         } else if (pair->value[0] == 'T') {
     1630                        } else if(pair->value[0]=='T') {
    15731631                                FREE(yd->cookie_t);
    15741632                                yd->cookie_t = getcookie(pair->value);
    15751633
    1576                         } else if (pair->value[0] == 'C') {
     1634                        } else if(pair->value[0]=='C') {
    15771635                                FREE(yd->cookie_c);
    15781636                                yd->cookie_c = getcookie(pair->value);
    1579                         }
    1580 
    1581                         break;
    1582                 case 3: /* my id */
    1583                 case 90:        /* 1 */
    1584                 case 100:       /* 0 */
    1585                 case 101:       /* NULL */
    1586                 case 102:       /* NULL */
    1587                 case 93:        /* 86400/1440 */
    1588                         break;
    1589                 }
    1590         }
    1591 
    1592         if (yd->cookie_y && yd->cookie_t)       /* We don't get cookie_c anymore */
    1593                 YAHOO_CALLBACK(ext_yahoo_got_cookies) (yd->client_id);
     1637                        } 
     1638
     1639                        if(yd->cookie_y && yd->cookie_t)
     1640                                YAHOO_CALLBACK(ext_yahoo_got_cookies)(yd->client_id);
     1641
     1642                        break;
     1643                case 3: /* my id */
     1644                case 90: /* 1 */
     1645                case 100: /* 0 */
     1646                case 101: /* NULL */
     1647                case 102: /* NULL */
     1648                case 93: /* 86400/1440 */
     1649                        break;
     1650                }
     1651        }
    15941652}
    15951653

  • protocols/yahoo/yahoo.c

    r638feab r842cd8d  
    227227                        yd->current_status = YAHOO_STATUS_CUSTOM;
    228228        }
    229         else if( msg )
     229        else if( state )
    230230                yd->current_status = YAHOO_STATUS_CUSTOM;
    231231        else

  • protocols/yahoo/yahoo2_types.h

    r638feab r842cd8d  
    196196
    197197        void  *server_settings;
    198        
    199         struct yahoo_process_status_entry *half_user;
    200198};
    201199
    … …  
    263261};
    264262
    265 struct yahoo_process_status_entry {
    266         char *name;     /* 7      name */
    267         int state;      /* 10     state */
    268         int flags;      /* 13     flags, bit 0 = pager, bit 1 = chat, bit 2 = game */
    269         int mobile;     /* 60     mobile */
    270         char *msg;      /* 19     custom status message */
    271         int away;       /* 47     away (or invisible) */
    272         int buddy_session; /* 11  state */
    273         int f17;        /* 17     in chat? then what about flags? */
    274         int idle;       /* 137    seconds idle */
    275         int f138;       /* 138    state */
    276         char *f184;     /* 184    state */
    277         int f192;       /* 192    state */
    278         int f10001;     /* 10001  state */
    279         int f10002;     /* 10002  state */
    280         int f198;       /* 198    state */
    281         char *f197;     /* 197    state */
    282         char *f205;     /* 205    state */
    283         int f213;       /* 213    state */
    284 };
    285 
    286263#ifdef __cplusplus
    287264}

  • root_commands.c

    r638feab r842cd8d  
    143143        storage_status_t status = storage_load( irc, cmd[1] );
    144144        char *account_on[] = { "account", "on", NULL };
    145        
    146         if( strchr( irc->umode, 'R' ) != NULL )
    147         {
    148                 irc_usermsg( irc, "You're already logged in." );
    149                 return;
    150         }
    151145       
    152146        switch (status) {
    … …  
    914908                online = 1;
    915909        else
    916                 online = away = 1;
     910                online =  away = 1;
    917911       
    918912        if( strchr( irc->umode, 'b' ) != NULL )
    … …  
    927921                if( online == 1 )
    928922                {
    929                         char st[256] = "Online";
    930                        
    931                         if( u->status_msg )
    932                                 g_snprintf( st, sizeof( st ) - 1, "Online (%s)", u->status_msg );
    933                        
    934923                        g_snprintf( s, sizeof( s ) - 1, "%s@%s %s(%s)", u->user, u->host, u->ic->acc->prpl->name, u->ic->acc->user );
    935                         irc_usermsg( irc, format, u->nick, s, st );
     924                        irc_usermsg( irc, format, u->nick, s, "Online" );
    936925                }
    937926               

  • user.h

    r638feab r842cd8d  
    3434       
    3535        char *away;
    36         char *status_msg; /* Non-IRC extension, but nice on IM. */
    3736       
    3837        char is_private;
Note: See TracChangeset for help on using the changeset viewer.