Changes in / [842cd8d:638feab]


Ignore:
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • account.c

    r842cd8d r638feab  
    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 );
    5658       
    5759        s = set_add( &a->set, "password", NULL, set_eval_account, a );

  • bitlbee.c

    r842cd8d r638feab  
    109109                chdir( "/" );
    110110               
    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 );
     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                                }
    116118        }
    117119#endif

  • bitlbee.conf

    r842cd8d r638feab  
    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
    122130
    123131[defaults]

  • bitlbee.h

    r842cd8d r638feab  
    2727#define _BITLBEE_H
    2828
     29#ifndef _GNU_SOURCE
    2930#define _GNU_SOURCE /* Stupid GNU :-P */
     31#endif
    3032
    3133/* Depend on Windows 2000 for now since we need getaddrinfo() */
    … …  
    3335
    3436#define PACKAGE "BitlBee"
    35 #define BITLBEE_VERSION "1.2.4"
     37#define BITLBEE_VERSION "1.2.5"
    3638#define VERSION BITLBEE_VERSION
    3739

  • conf.c

    r842cd8d r638feab  
    6363        conf->ping_timeout = 300;
    6464        conf->user = NULL;
     65        conf->protocols = NULL;
    6566        proxytype = 0;
    6667       
    … …  
    307308                                conf->user = g_strdup( ini->value );
    308309                        }
     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                        }
    309315                        else
    310316                        {

  • conf.h

    r842cd8d r638feab  
    5050        int ping_timeout;
    5151        char *user;
     52        char **protocols;
    5253} conf_t;
    5354

  • configure

    r842cd8d r638feab  
    444444fi
    445445
     446if [ ! -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.'
     450fi
     451
    446452echo
    447453if [ -z "$BITLBEE_VERSION" -a -d .bzr ] && type bzr > /dev/null 2> /dev/null; then
    … …  
    529535;;
    530536Darwin )
     537        echo 'STRIP=\# skip strip' >> Makefile.settings
    531538;;
    532539IRIX )

  • doc/CHANGES

    r842cd8d r638feab  
    33
    44http://bugs.bitlbee.org/bitlbee/timeline?daysback=90&changeset=on
     5
     6Version 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
     25Fixed 17 Mar 2010
    526
    627Version 1.2.4:

  • doc/user-guide/commands.xml

    r842cd8d r638feab  
    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
    610625        <bitlbee-setting name="ops" type="string" scope="global">
    611626                <default>both</default>
    … …  
    701716
    702717        <bitlbee-setting name="resource_select" type="string" scope="account">
    703                 <default>priority</default>
     718                <default>activity</default>
    704719                <possible-values>priority, activity</possible-values>
    705720

  • irc.c

    r842cd8d r638feab  
    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", "false", set_eval_bool, irc );
     168        s = set_add( &irc->set, "auto_reconnect", "true", 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

    r842cd8d r638feab  
    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 );
    499501               
    500502                irc_reply( irc, 318, "%s :End of /WHOIS list", nick );

  • lib/misc.c

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

  • lib/misc.h

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

  • protocols/jabber/io.c

    r842cd8d r638feab  
    375375       
    376376        if( ( c = xt_find_node( node->children, "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         }
     377                jd->flags |= JFLAG_WANT_BIND;
    388378       
    389379        if( ( c = xt_find_node( node->children, "session" ) ) )
    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         }
     380                jd->flags |= JFLAG_WANT_SESSION;
     381       
     382        if( jd->flags & JFLAG_AUTHENTICATED )
     383                return jabber_pkt_bind_sess( ic, NULL, NULL );
    410384       
    411385        return XT_HANDLED;
    … …  
    441415        imcb_log( ic, "Converting stream to TLS" );
    442416       
     417        jd->flags |= JFLAG_STARTTLS_DONE;
    443418        jd->ssl = ssl_starttls( jd->fd, jabber_connected_ssl, ic );
    444419       
    … …  
    531506                jd->r_inpa = b_input_add( jd->fd, GAIM_INPUT_READ, jabber_read_callback, ic );
    532507       
    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 );
     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 );
    536512       
    537513        st = jabber_write( ic, greet, strlen( greet ) );

  • protocols/jabber/iq.c

    r842cd8d r638feab  
    298298{
    299299        struct jabber_data *jd = ic->proto_data;
    300         struct xt_node *c;
     300        struct xt_node *c, *reply = NULL;
    301301        char *s;
    302302       
    303         if( ( c = xt_find_node( node->children, "bind" ) ) )
     303        if( node && ( 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                 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 )
     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 )
    318333        {
    319334                if( !jabber_get_roster( ic ) )

  • protocols/jabber/jabber.h

    r842cd8d r638feab  
    4040        JFLAG_STREAM_RESTART = 4,       /* Set when we want to restart the stream (after
    4141                                           SASL or TLS). */
    42         JFLAG_WAIT_SESSION = 8,         /* Set if we sent a <session> tag and need a reply
     42        JFLAG_WANT_SESSION = 8,         /* Set if the server wants a <session/> tag
    4343                                           before we continue. */
    44         JFLAG_WAIT_BIND = 16,           /* ... for <bind> tag. */
     44        JFLAG_WANT_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. */
    4849} jabber_flags_t;
    4950

  • protocols/msn/msn.c

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

  • protocols/msn/msn.h

    r842cd8d r638feab  
    135135#define STATUS_SB_CHAT_SPARE    8       /* Same, but also for groupchats (not used yet). */
    136136
    137 int msn_chat_id;
     137extern int 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 GSList *msn_connections;
    147 GSList *msn_switchboards;
     146extern GSList *msn_connections;
     147extern GSList *msn_switchboards;
    148148
    149149/* ns.c */

  • protocols/msn/ns.c

    r842cd8d r638feab  
    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                         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] );
     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" );
    244251                        }
    245252                       

  • protocols/nogaim.c

    r842cd8d r638feab  
    9898void register_protocol (struct prpl *p)
    9999{
    100         protocols = g_list_append(protocols, p);
     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);
    101113}
    102114
    … …  
    371383/* list.c */
    372384
    373 void imcb_add_buddy( struct im_connection *ic, char *handle, char *group )
     385void imcb_add_buddy( struct im_connection *ic, const char *handle, const char *group )
    374386{
    375387        user_t *u;
    … …  
    445457}
    446458
    447 void imcb_rename_buddy( struct im_connection *ic, char *handle, char *realname )
     459void imcb_rename_buddy( struct im_connection *ic, const char *handle, const char *realname )
    448460{
    449461        user_t *u = user_findhandle( ic, handle );
     462        char *set;
    450463       
    451464        if( !u || !realname ) return;
    … …  
    460473                        imcb_log( ic, "User `%s' changed name to `%s'", u->nick, u->realname );
    461474        }
    462 }
    463 
    464 void imcb_remove_buddy( struct im_connection *ic, char *handle, char *group )
     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
     494void imcb_remove_buddy( struct im_connection *ic, const char *handle, char *group )
    465495{
    466496        user_t *u;
    … …  
    472502/* Mainly meant for ICQ (and now also for Jabber conferences) to allow IM
    473503   modules to suggest a nickname for a handle. */
    474 void imcb_buddy_nick_hint( struct im_connection *ic, char *handle, char *nick )
     504void imcb_buddy_nick_hint( struct im_connection *ic, const char *handle, const char *nick )
    475505{
    476506        user_t *u = user_findhandle( ic, handle );
    … …  
    617647        oo = u->online;
    618648       
    619         if( u->away )
    620         {
    621                 g_free( u->away );
    622                 u->away = NULL;
    623         }
     649        g_free( u->away );
     650        g_free( u->status_msg );
     651        u->away = u->status_msg = NULL;
    624652       
    625653        if( ( flags & OPT_LOGGED_IN ) && !u->online )
    … …  
    659687                }
    660688        }
    661         /* else waste_any_state_information_for_now(); */
     689        else
     690        {
     691                u->status_msg = g_strdup( message );
     692        }
    662693       
    663694        /* LISPy... */
    … …  
    684715}
    685716
    686 void imcb_buddy_msg( struct im_connection *ic, char *handle, char *msg, uint32_t flags, time_t sent_at )
     717void imcb_buddy_msg( struct im_connection *ic, const char *handle, char *msg, uint32_t flags, time_t sent_at )
    687718{
    688719        irc_t *irc = ic->irc;
    … …  
    817848}
    818849
    819 void imcb_chat_msg( struct groupchat *c, char *who, char *msg, uint32_t flags, time_t sent_at )
     850void imcb_chat_msg( struct groupchat *c, const char *who, char *msg, uint32_t flags, time_t sent_at )
    820851{
    821852        struct im_connection *ic = c->ic;
    … …  
    889920/* buddy_chat.c */
    890921
    891 void imcb_chat_add_buddy( struct groupchat *b, char *handle )
     922void imcb_chat_add_buddy( struct groupchat *b, const char *handle )
    892923{
    893924        user_t *u = user_findhandle( b->ic, handle );
    … …  
    924955
    925956/* This function is one BIG hack... :-( EREWRITE */
    926 void imcb_chat_remove_buddy( struct groupchat *b, char *handle, char *reason )
     957void imcb_chat_remove_buddy( struct groupchat *b, const char *handle, const char *reason )
    927958{
    928959        user_t *u;

  • protocols/nogaim.h

    r842cd8d r638feab  
    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, char *handle, char *group );
    278 G_MODULE_EXPORT void imcb_remove_buddy( struct im_connection *ic, char *handle, char *group );
     277G_MODULE_EXPORT void imcb_add_buddy( struct im_connection *ic, const char *handle, const char *group );
     278G_MODULE_EXPORT void imcb_remove_buddy( struct im_connection *ic, const 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, char *handle, char *realname );
    281 G_MODULE_EXPORT void imcb_buddy_nick_hint( struct im_connection *ic, char *handle, char *nick );
     280G_MODULE_EXPORT void imcb_rename_buddy( struct im_connection *ic, const char *handle, const char *realname );
     281G_MODULE_EXPORT void imcb_buddy_nick_hint( struct im_connection *ic, const char *handle, const 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, char *handle, char *msg, uint32_t flags, time_t sent_at );
     291G_MODULE_EXPORT void imcb_buddy_msg( struct im_connection *ic, const 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, char *handle );
     304G_MODULE_EXPORT void imcb_chat_add_buddy( struct groupchat *b, const 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, char *handle, char *reason );
     306G_MODULE_EXPORT void imcb_chat_remove_buddy( struct groupchat *b, const char *handle, const 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, char *who, char *msg, uint32_t flags, time_t sent_at );
     308G_MODULE_EXPORT void imcb_chat_msg( struct groupchat *c, const 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

    r842cd8d r638feab  
    855855}
    856856
    857 static 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 
    906857static char * getcookie(char *rawcookie)
    907858{
    … …  
    13601311}
    13611312
    1362 
    1363 static void yahoo_process_status(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1313static void yahoo_process_status(struct yahoo_input_data *yid,
     1314        struct yahoo_packet *pkt)
    13641315{
    13651316        YList *l;
    13661317        struct yahoo_data *yd = yid->yd;
    13671318
    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;
     1319        struct yahoo_process_status_entry *u;
    13891320
    13901321        YList *users = 0;
    1391        
     1322
    13921323        if (pkt->service == YAHOO_SERVICE_LOGOFF && pkt->status == -1) {
    1393                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_DUPL, NULL);
    1394                 return;
    1395         }
     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;
    13961334
    13971335        for (l = pkt->hash; l; l = l->next) {
    … …  
    13991337
    14001338                switch (pair->key) {
    1401                 case 0: /* we won't actually do anything with this */
     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);
     1342                        }
     1343                        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 */
    14021355                        NOTICE(("key %d:%s", pair->key, pair->value));
    14031356                        break;
    1404                 case 1: /* we don't get the full buddy list here. */
     1357                case 1: /* we don't get the full buddy list here. */
    14051358                        if (!yd->logged_in) {
    1406                                 yd->logged_in = TRUE;
    1407                                 if(yd->current_status < 0)
     1359                                yd->logged_in = 1;
     1360                                if (yd->current_status < 0)
    14081361                                        yd->current_status = yd->initial_status;
    1409                                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
     1362                                YAHOO_CALLBACK(ext_yahoo_login_response) (yd->
     1363                                        client_id, YAHOO_LOGIN_OK, NULL);
    14101364                        }
    14111365                        break;
    1412                 case 8: /* how many online buddies we have */
     1366                case 8: /* how many online buddies we have */
    14131367                        NOTICE(("key %d:%s", pair->key, pair->value));
    14141368                        break;
    1415                 case 7: /* the current buddy */
    1416                         u = y_new0(struct user, 1);
     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                        }
    14171375                        u->name = pair->value;
    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 */
     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 */
    14421399                        /* sometimes going offline makes this 2, but invisible never sends it */
    1443                         ((struct user*)users->data)->mobile = atoi(pair->value);
     1400                        u->mobile = atoi(pair->value);
    14441401                        break;
    14451402                case 138:
    1446                         ((struct user*)users->data)->f138 = atoi(pair->value);
     1403                        u->f138 = atoi(pair->value);
    14471404                        break;
    14481405                case 184:
    1449                         ((struct user*)users->data)->f184 = pair->value;
     1406                        u->f184 = pair->value;
    14501407                        break;
    14511408                case 192:
    1452                         ((struct user*)users->data)->f192 = atoi(pair->value);
     1409                        u->f192 = atoi(pair->value);
    14531410                        break;
    14541411                case 10001:
    1455                         ((struct user*)users->data)->f10001 = atoi(pair->value);
     1412                        u->f10001 = atoi(pair->value);
    14561413                        break;
    14571414                case 10002:
    1458                         ((struct user*)users->data)->f10002 = atoi(pair->value);
     1415                        u->f10002 = atoi(pair->value);
    14591416                        break;
    14601417                case 198:
    1461                         ((struct user*)users->data)->f198 = atoi(pair->value);
     1418                        u->f198 = atoi(pair->value);
    14621419                        break;
    14631420                case 197:
    1464                         ((struct user*)users->data)->f197 = pair->value;
     1421                        u->f197 = pair->value;
    14651422                        break;
    14661423                case 205:
    1467                         ((struct user*)users->data)->f205 = pair->value;
     1424                        u->f205 = pair->value;
    14681425                        break;
    14691426                case 213:
    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);
     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);
    14741432                        break;
    14751433                default:
    1476                         WARNING(("unknown status key %d:%s", pair->key, pair->value));
    1477                         break;
    1478                 }
    1479         }
    1480        
     1434                        WARNING(("unknown status key %d:%s", pair->key,
     1435                                        pair->value));
     1436                        break;
     1437                }
     1438        }
     1439
    14811440        while (users) {
    14821441                YList *t = users;
    1483                 struct user *u = users->data;
     1442                struct yahoo_process_status_entry *u = users->data;
    14841443
    14851444                if (u->name != NULL) {
    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);
     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);
    14881451                        } else {
    14891452                                /* Key 47 always seems to be 1 for YMSG16 */
    1490                                 if(!u->state)
     1453                                if (!u->state)
    14911454                                        u->away = 0;
    14921455                                else
    14931456                                        u->away = 1;
    14941457
    1495                                 YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, u->state, u->msg, u->away, u->idle, u->mobile);
     1458                                YAHOO_CALLBACK(ext_yahoo_status_changed) (yd->
     1459                                        client_id, u->name, u->state, u->msg,
     1460                                        u->away, u->idle, u->mobile);
    14961461                        }
    14971462                }
    … …  
    15031468}
    15041469
    1505 static void yahoo_process_buddy_list(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1470static void yahoo_process_buddy_list(struct yahoo_input_data *yid,
     1471        struct yahoo_packet *pkt)
    15061472{
    15071473        struct yahoo_data *yd = yid->yd;
    … …  
    15151481                struct yahoo_pair *pair = l->data;
    15161482
    1517                 switch(pair->key) {
     1483                switch (pair->key) {
    15181484                case 300:
    15191485                case 301:
    15201486                case 302:
     1487                        break;  /* Separators. Our logic does not need them */
    15211488                case 303:
    1522                         if ( 315 == atoi(pair->value) )
     1489                        if (318 == atoi(pair->value))
    15231490                                last_packet = 1;
    15241491                        break;
    15251492                case 65:
    1526                         g_free(cur_group);
    15271493                        cur_group = strdup(pair->value);
    15281494                        break;
    … …  
    15301496                        newbud = y_new0(struct yahoo_buddy, 1);
    15311497                        newbud->id = strdup(pair->value);
    1532                         if (cur_group) {
     1498                        if (cur_group)
    15331499                                newbud->group = strdup(cur_group);
    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                         }
     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");
    15461508
    15471509                        yd->buddies = y_list_append(yd->buddies, newbud);
    … …  
    15501512                }
    15511513        }
    1552        
    1553         g_free(cur_group);
    15541514
    15551515        /* we could be getting multiple packets here */
    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 */
     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 */
    15621522        if (!yd->logged_in) {
    1563                 yd->logged_in = TRUE;
    1564                 if(yd->current_status < 0)
     1523                yd->logged_in = 1;
     1524                if (yd->current_status < 0)
    15651525                        yd->current_status = yd->initial_status;
    1566                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
    1567         }
    1568 }
    1569 
    1570 static void yahoo_process_list(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     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
     1539static void yahoo_process_list(struct yahoo_input_data *yid,
     1540        struct yahoo_packet *pkt)
    15711541{
    15721542        struct yahoo_data *yd = yid->yd;
    15731543        YList *l;
    15741544
    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 
     1545        /* we could be getting multiple packets here */
    15821546        for (l = pkt->hash; l; l = l->next) {
    15831547                struct yahoo_pair *pair = l->data;
    15841548
    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);
     1549                switch (pair->key) {
     1550                case 89:        /* identities */
     1551                        {
     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,
     1558                                                strdup(identities[i]));
     1559                                y_strfreev(identities);
    15911560                        }
    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 */
    1601                         {
    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,
    1606                                                 strdup(identities[i]));
    1607                         y_strfreev(identities);
    1608                         }
    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') {
     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') {
    16241566                                FREE(yd->cookie_y);
    16251567                                FREE(yd->login_cookie);
    … …  
    16281570                                yd->login_cookie = getlcookie(yd->cookie_y);
    16291571
    1630                         } else if(pair->value[0]=='T') {
     1572                        } else if (pair->value[0] == 'T') {
    16311573                                FREE(yd->cookie_t);
    16321574                                yd->cookie_t = getcookie(pair->value);
    16331575
    1634                         } else if(pair->value[0]=='C') {
     1576                        } else if (pair->value[0] == 'C') {
    16351577                                FREE(yd->cookie_c);
    16361578                                yd->cookie_c = getcookie(pair->value);
    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         }
     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);
    16521594}
    16531595

  • protocols/yahoo/yahoo.c

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

  • protocols/yahoo/yahoo2_types.h

    r842cd8d r638feab  
    196196
    197197        void  *server_settings;
     198       
     199        struct yahoo_process_status_entry *half_user;
    198200};
    199201
    … …  
    261263};
    262264
     265struct 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
    263286#ifdef __cplusplus
    264287}

  • root_commands.c

    r842cd8d r638feab  
    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        }
    145151       
    146152        switch (status) {
    … …  
    908914                online = 1;
    909915        else
    910                 online =  away = 1;
     916                online = away = 1;
    911917       
    912918        if( strchr( irc->umode, 'b' ) != NULL )
    … …  
    921927                if( online == 1 )
    922928                {
     929                        char st[256] = "Online";
     930                       
     931                        if( u->status_msg )
     932                                g_snprintf( st, sizeof( st ) - 1, "Online (%s)", u->status_msg );
     933                       
    923934                        g_snprintf( s, sizeof( s ) - 1, "%s@%s %s(%s)", u->user, u->host, u->ic->acc->prpl->name, u->ic->acc->user );
    924                         irc_usermsg( irc, format, u->nick, s, "Online" );
     935                        irc_usermsg( irc, format, u->nick, s, st );
    925936                }
    926937               

  • user.h

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