Changeset 3f81999


Ignore:
Timestamp:
2010-06-03T10:31:46Z (9 years ago)
Author:
Sven Moritz Hallberg <pesco@…>
Branches:
master
Children:
5f8ab6a9
Parents:
fc34fb5 (diff), 2e44b1f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

merge in bitlbee 1.2.4

Files:
16 edited

Legend:

Unmodified
Added
Removed
  • bitlbee.h

    rfc34fb5 r3f81999  
    3636
    3737#define PACKAGE "BitlBee"
    38 #define BITLBEE_VERSION "1.2.3"
     38#define BITLBEE_VERSION "1.2.4"
    3939#define VERSION BITLBEE_VERSION
    4040
  • doc/CHANGES

    rfc34fb5 r3f81999  
    33
    44http://bugs.bitlbee.org/bitlbee/timeline?daysback=90&changeset=on
     5
     6Version 1.2.4:
     7- Most important change (and main reason for releasing now): Upgraded Yahoo!
     8  module to a newer version to get it working again.
     9- join_chat command replaced with the much better chat command:
     10  * Similar to how account replaced login/slist/logout. Add a chatroom once,
     11    then just /join it like any other room. Also automatic joining at login
     12    time is now possible.
     13  * Note that the old way of starting groupchats (/join #nickname) is now
     14    also deprecated, use "chat with" instead.
     15  * See "help chat" and "help chat add" for more information.
     16- Rewrote bitlbee.conf parser to be less dumb.
     17- Fixed compatibility (hopefully) with AIM mobile messages, certain kinds
     18  of Google Talk chatrooms.
     19- Fixed numerous stability/reliability bugs over the last year.
     20
     21Finished 17 Oct 2009
    522
    623Version 1.2.3:
  • doc/user-guide/commands.xml

    rfc34fb5 r3f81999  
    175175                                        After adding a room to your list, you can simply use the IRC /join command to enter the room. Also, you can tell BitlBee to automatically join the room when you log in. (See <emphasis>chat set</emphasis>)
    176176                                </para>
     177
     178                                <para>
     179                                        Password-protected rooms work exactly like on IRC, by passing the password as an extra argument to /join.
     180                                </para>
    177181                        </description>
    178182
  • irc_commands.c

    rfc34fb5 r3f81999  
    415415                        if( g_hash_table_lookup_extended( irc->watches, nick, &okey, &ovalue ) )
    416416                        {
     417                                g_hash_table_remove( irc->watches, okey );
    417418                                g_free( okey );
    418                                 g_hash_table_remove( irc->watches, okey );
    419419                               
    420420                                irc_reply( irc, 602, "%s %s %s %d :%s", nick, "*", "*", 0, "Stopped watching" );
  • lib/ini.c

    rfc34fb5 r3f81999  
    4343                ini->cur = ini->file;
    4444                ini->c_section = "";
     45               
     46                close( fd );
     47               
    4548                return ini;
    4649        }
    47        
    48         g_free( ini );
     50
    4951        if( fd >= 0 )
    5052                close( fd );
     53       
     54        ini_close( ini );
    5155
    5256        return NULL;
  • protocols/jabber/conference.c

    rfc34fb5 r3f81999  
    234234                            ( strcmp( s, XMLNS_MUC_USER ) == 0 ) )
    235235                        {
    236                                 c = xt_find_node( c->children, "item" );
    237                                 if( ( s = xt_find_attr( c, "jid" ) ) )
     236                                struct xt_node *item;
     237                               
     238                                item = xt_find_node( c->children, "item" );
     239                                if( ( s = xt_find_attr( item, "jid" ) ) )
    238240                                {
    239241                                        /* Yay, found what we need. :-) */
     
    283285        else if( type ) /* type can only be NULL or "unavailable" in this function */
    284286        {
    285                 s = strchr( bud->ext_jid, '/' );
    286                 if( s ) *s = 0;
    287                 imcb_chat_remove_buddy( chat, bud->ext_jid, NULL );
    288                 if( bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS )
    289                         imcb_remove_buddy( ic, bud->ext_jid, NULL );
    290                 if( s ) *s = '/';
     287                if( ( bud->flags & JBFLAG_IS_CHATROOM ) && bud->ext_jid )
     288                {
     289                        s = strchr( bud->ext_jid, '/' );
     290                        if( s ) *s = 0;
     291                        imcb_chat_remove_buddy( chat, bud->ext_jid, NULL );
     292                        if( bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS )
     293                                imcb_remove_buddy( ic, bud->ext_jid, NULL );
     294                        if( s ) *s = '/';
     295                }
    291296               
    292297                if( bud == jc->me )
  • protocols/jabber/iq.c

    rfc34fb5 r3f81999  
    5151        {
    5252                if( !( ( c = xt_find_node( node->children, "query" ) ) ||
    53                        ( c = xt_find_node( node->children, "ping" ) ) ) || /* O_o WHAT is wrong with just <query/> ????? */
     53                       ( c = xt_find_node( node->children, "ping" ) ) ) ||
    5454                    !( s = xt_find_attr( c, "xmlns" ) ) )
    5555                {
    56                         imcb_log( ic, "Warning: Received incomplete IQ-%s packet", type );
     56                        /* Sigh. Who decided to suddenly invent new elements
     57                           instead of just sticking with <query/>? */
    5758                        return XT_HANDLED;
    5859                }
  • protocols/nogaim.c

    rfc34fb5 r3f81999  
    506506}
    507507
    508 /* prpl.c */
    509 
    510 struct show_got_added_data
     508
     509struct imcb_ask_cb_data
    511510{
    512511        struct im_connection *ic;
     
    514513};
    515514
    516 void show_got_added_no( void *data )
    517 {
    518         g_free( ((struct show_got_added_data*)data)->handle );
     515static void imcb_ask_auth_cb_no( void *data )
     516{
     517        struct imcb_ask_cb_data *cbd = data;
     518       
     519        cbd->ic->acc->prpl->auth_deny( cbd->ic, cbd->handle );
     520       
     521        g_free( cbd->handle );
     522        g_free( cbd );
     523}
     524
     525static void imcb_ask_auth_cb_yes( void *data )
     526{
     527        struct imcb_ask_cb_data *cbd = data;
     528       
     529        cbd->ic->acc->prpl->auth_allow( cbd->ic, cbd->handle );
     530       
     531        g_free( cbd->handle );
     532        g_free( cbd );
     533}
     534
     535void imcb_ask_auth( struct im_connection *ic, const char *handle, const char *realname )
     536{
     537        struct imcb_ask_cb_data *data = g_new0( struct imcb_ask_cb_data, 1 );
     538        char *s, *realname_ = NULL;
     539       
     540        if( realname != NULL )
     541                realname_ = g_strdup_printf( " (%s)", realname );
     542       
     543        s = g_strdup_printf( "The user %s%s wants to add you to his/her buddy list.",
     544                             handle, realname_ ?: "" );
     545       
     546        g_free( realname_ );
     547       
     548        data->ic = ic;
     549        data->handle = g_strdup( handle );
     550        query_add( ic->irc, ic, s, imcb_ask_auth_cb_yes, imcb_ask_auth_cb_no, data );
     551}
     552
     553
     554static void imcb_ask_add_cb_no( void *data )
     555{
     556        g_free( ((struct imcb_ask_cb_data*)data)->handle );
    519557        g_free( data );
    520558}
    521559
    522 void show_got_added_yes( void *data )
    523 {
    524         struct show_got_added_data *sga = data;
    525        
    526         sga->ic->acc->prpl->add_buddy( sga->ic, sga->handle, NULL );
    527         /* imcb_add_buddy( sga->ic, NULL, sga->handle, sga->handle ); */
    528        
    529         return show_got_added_no( data );
    530 }
    531 
    532 void imcb_ask_add( struct im_connection *ic, char *handle, const char *realname )
    533 {
    534         struct show_got_added_data *data = g_new0( struct show_got_added_data, 1 );
     560static void imcb_ask_add_cb_yes( void *data )
     561{
     562        struct imcb_ask_cb_data *cbd = data;
     563       
     564        cbd->ic->acc->prpl->add_buddy( cbd->ic, cbd->handle, NULL );
     565       
     566        return imcb_ask_add_cb_no( data );
     567}
     568
     569void imcb_ask_add( struct im_connection *ic, const char *handle, const char *realname )
     570{
     571        struct imcb_ask_cb_data *data = g_new0( struct imcb_ask_cb_data, 1 );
    535572        char *s;
    536573       
     
    543580        data->ic = ic;
    544581        data->handle = g_strdup( handle );
    545         query_add( ic->irc, ic, s, show_got_added_yes, show_got_added_no, data );
     582        query_add( ic->irc, ic, s, imcb_ask_add_cb_yes, imcb_ask_add_cb_no, data );
    546583}
    547584
  • protocols/nogaim.h

    rfc34fb5 r3f81999  
    228228         * - Most protocols will just want to set this to g_strcasecmp().*/
    229229        int (* handle_cmp) (const char *who1, const char *who2);
     230
     231        /* Implement these callbacks if you want to use imcb_ask_auth() */
     232        void (* auth_allow)     (struct im_connection *, const char *who);
     233        void (* auth_deny)      (struct im_connection *, const char *who);
    230234};
    231235
     
    256260/* To tell the user an error, ie. before logging out when an error occurs. */
    257261G_MODULE_EXPORT void imcb_error( struct im_connection *ic, char *format, ... ) G_GNUC_PRINTF( 2, 3 );
     262
    258263/* To ask a your about something.
    259264 * - 'msg' is the question.
     
    262267 */
    263268G_MODULE_EXPORT void imcb_ask( struct im_connection *ic, char *msg, void *data, query_callback doit, query_callback dont );
    264 G_MODULE_EXPORT void imcb_ask_add( struct im_connection *ic, char *handle, const char *realname );
     269
     270/* Two common questions you may want to ask:
     271 * - X added you to his contact list, allow?
     272 * - X is not in your contact list, want to add?
     273 */
     274G_MODULE_EXPORT void imcb_ask_auth( struct im_connection *ic, const char *handle, const char *realname );
     275G_MODULE_EXPORT void imcb_ask_add( struct im_connection *ic, const char *handle, const char *realname );
    265276
    266277/* Buddy management */
  • protocols/oscar/aim.h

    rfc34fb5 r3f81999  
    144144}
    145145
     146#define AIM_CLIENTINFO_KNOWNGOOD_5_1_3036 { \
     147        "AOL Instant Messenger, version 5.1.3036/WIN32", \
     148        0x0109, \
     149        0x0005, \
     150        0x0001, \
     151        0x0000, \
     152        0x0bdc, \
     153        "us", \
     154        "en", \
     155}
     156
    146157/*
    147158 * I would make 4.1.2010 the default, but they seem to have found
     
    152163 * around. (see login.c::memrequest())
    153164 */
    154 #define AIM_CLIENTINFO_KNOWNGOOD AIM_CLIENTINFO_KNOWNGOOD_3_5_1670
     165#define AIM_CLIENTINFO_KNOWNGOOD AIM_CLIENTINFO_KNOWNGOOD_5_1_3036
    155166
    156167#ifndef TRUE
  • protocols/yahoo/libyahoo2.c

    rfc34fb5 r3f81999  
    9191
    9292#include "base64.h"
     93#include "http_client.h"
    9394
    9495#ifdef USE_STRUCT_CALLBACKS
     
    171172        YAHOO_SERVICE_GOTGROUPRENAME, /* < 1, 36(old), 37(new) */
    172173        YAHOO_SERVICE_SYSMESSAGE = 0x14,
     174        YAHOO_SERVICE_SKINNAME = 0x15,
    173175        YAHOO_SERVICE_PASSTHROUGH2 = 0x16,
    174176        YAHOO_SERVICE_CONFINVITE = 0x18,
     
    194196        YAHOO_SERVICE_LIST,
    195197        YAHOO_SERVICE_AUTH = 0x57,
     198        YAHOO_SERVICE_AUTHBUDDY = 0x6d,
    196199        YAHOO_SERVICE_ADDBUDDY = 0x83,
    197200        YAHOO_SERVICE_REMBUDDY,
     
    199202        YAHOO_SERVICE_REJECTCONTACT,
    200203        YAHOO_SERVICE_GROUPRENAME = 0x89, /* > 1, 65(new), 66(0), 67(old) */
     204        YAHOO_SERVICE_Y7_PING = 0x8A, /* 0 - id and that's it?? */
    201205        YAHOO_SERVICE_CHATONLINE = 0x96, /* > 109(id), 1, 6(abcde) < 0,1*/
    202206        YAHOO_SERVICE_CHATGOTO,
     
    204208        YAHOO_SERVICE_CHATLEAVE,
    205209        YAHOO_SERVICE_CHATEXIT = 0x9b,
     210        YAHOO_SERVICE_CHATADDINVITE = 0x9d,
    206211        YAHOO_SERVICE_CHATLOGOUT = 0xa0,
    207212        YAHOO_SERVICE_CHATPING,
     
    211216        YAHOO_SERVICE_PICTURE = 0xbe,
    212217        YAHOO_SERVICE_PICTURE_UPDATE = 0xc1,
    213         YAHOO_SERVICE_PICTURE_UPLOAD = 0xc2
     218        YAHOO_SERVICE_PICTURE_UPLOAD = 0xc2,
     219        YAHOO_SERVICE_Y6_VISIBILITY=0xc5,
     220        YAHOO_SERVICE_Y6_STATUS_UPDATE=0xc6,
     221        YAHOO_PHOTOSHARE_INIT=0xd2,     
     222        YAHOO_SERVICE_CONTACT_YMSG13=0xd6,
     223        YAHOO_PHOTOSHARE_PREV=0xd7,
     224        YAHOO_PHOTOSHARE_KEY=0xd8,
     225        YAHOO_PHOTOSHARE_TRANS=0xda,
     226        YAHOO_FILE_TRANSFER_INIT_YMSG13=0xdc,
     227        YAHOO_FILE_TRANSFER_GET_YMSG13=0xdd,
     228        YAHOO_FILE_TRANSFER_PUT_YMSG13=0xde,
     229        YAHOO_SERVICE_YMSG15_STATUS=0xf0,
     230        YAHOO_SERVICE_YMSG15_BUDDY_LIST=0xf1,
    214231};
    215232
     
    735752
    736753        memcpy(data + pos, "YMSG", 4); pos += 4;
    737         pos += yahoo_put16(data + pos, 0x000c);
     754        pos += yahoo_put16(data + pos, YAHOO_PROTO_VER);
    738755        pos += yahoo_put16(data + pos, 0x0000);
    739756        pos += yahoo_put16(data + pos, pktlen + extra_pad);
     
    749766                yahoo_send_data(yid->fd, data, len);
    750767        else
    751         yahoo_add_to_send_queue(yid, data, len);
     768                yahoo_add_to_send_queue(yid, data, len);
    752769        FREE(data);
    753770}
     
    14691486
    14701487                if (u->name != NULL) {
    1471                         if (pkt->service == YAHOO_SERVICE_LOGOFF || u->flags == 0) {
     1488                        if (pkt->service == YAHOO_SERVICE_LOGOFF) { /* || u->flags == 0) { Not in YMSG16 */
    14721489                                YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, YAHOO_STATUS_OFFLINE, NULL, 1, 0, 0);
    14731490                        } else {
     1491                                /* Key 47 always seems to be 1 for YMSG16 */
     1492                                if(!u->state)
     1493                                        u->away = 0;
     1494                                else
     1495                                        u->away = 1;
     1496
    14741497                                YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, u->name, u->state, u->msg, u->away, u->idle, u->mobile);
    14751498                        }
     
    14791502                y_list_free_1(t);
    14801503                FREE(u);
     1504        }
     1505}
     1506
     1507static void yahoo_process_buddy_list(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     1508{
     1509        struct yahoo_data *yd = yid->yd;
     1510        YList *l;
     1511        int last_packet = 0;
     1512        char *cur_group = NULL;
     1513        struct yahoo_buddy *newbud = NULL;
     1514
     1515        /* we could be getting multiple packets here */
     1516        for (l = pkt->hash; l; l = l->next) {
     1517                struct yahoo_pair *pair = l->data;
     1518
     1519                switch(pair->key) {
     1520                case 300:
     1521                case 301:
     1522                case 302:
     1523                case 303:
     1524                        if ( 315 == atoi(pair->value) )
     1525                                last_packet = 1;
     1526                        break;
     1527                case 65:
     1528                        g_free(cur_group);
     1529                        cur_group = strdup(pair->value);
     1530                        break;
     1531                case 7:
     1532                        newbud = y_new0(struct yahoo_buddy, 1);
     1533                        newbud->id = strdup(pair->value);
     1534                        if(cur_group)
     1535                                newbud->group = strdup(cur_group);
     1536                        else {
     1537                                struct yahoo_buddy *lastbud = (struct yahoo_buddy *)y_list_nth(
     1538                                                                yd->buddies, y_list_length(yd->buddies)-1)->data;
     1539                                newbud->group = strdup(lastbud->group);
     1540                        }
     1541
     1542                        yd->buddies = y_list_append(yd->buddies, newbud);
     1543
     1544                        break;
     1545                }
     1546        }
     1547       
     1548        g_free(cur_group);
     1549
     1550        /* we could be getting multiple packets here */
     1551        if (last_packet)
     1552                return;
     1553
     1554        YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
     1555
     1556        /*** We login at the very end of the packet communication */
     1557        if (!yd->logged_in) {
     1558                yd->logged_in = TRUE;
     1559                if(yd->current_status < 0)
     1560                        yd->current_status = yd->initial_status;
     1561                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
    14811562        }
    14821563}
     
    15511632                        }
    15521633
    1553                         if(yd->cookie_y && yd->cookie_t && yd->cookie_c)
     1634                        if(yd->cookie_y && yd->cookie_t)
    15541635                                YAHOO_CALLBACK(ext_yahoo_got_cookies)(yd->client_id);
    15551636
     
    22282309}
    22292310
     2311struct yahoo_https_auth_data
     2312{
     2313        struct yahoo_input_data *yid;
     2314        char *token;
     2315        char *chal;
     2316};
     2317
     2318static void yahoo_https_auth_token_init(struct yahoo_https_auth_data *had);
     2319static void yahoo_https_auth_token_finish(struct http_request *req);
     2320static void yahoo_https_auth_init(struct yahoo_https_auth_data *had);
     2321static void yahoo_https_auth_finish(struct http_request *req);
     2322
     2323/* Extract a value from a login.yahoo.com response. Assume CRLF-linebreaks
     2324   and FAIL miserably if they're not there... */
     2325static char *yahoo_ha_find_key(char *response, char *key)
     2326{
     2327        char *s, *end;
     2328        int len = strlen(key);
     2329       
     2330        s = response;
     2331        do {
     2332                if (strncmp(s, key, len) == 0 && s[len] == '=') {
     2333                        s += len + 1;
     2334                        if ((end = strchr(s, '\r')))
     2335                                return g_strndup(s, end - s);
     2336                        else
     2337                                return g_strdup(s);
     2338                }
     2339               
     2340                if ((s = strchr(s, '\n')))
     2341                        s ++;
     2342        } while (s && *s);
     2343       
     2344        return NULL;
     2345}
     2346
     2347static enum yahoo_status yahoo_https_status_parse(int code)
     2348{
     2349        switch (code)
     2350        {
     2351                case 1212: return YAHOO_LOGIN_PASSWD;
     2352                case 1213: return YAHOO_LOGIN_LOCK;
     2353                case 1235: return YAHOO_LOGIN_UNAME;
     2354                default: return (enum yahoo_status) code;
     2355        }
     2356}
     2357
     2358static void yahoo_process_auth_0x10(struct yahoo_input_data *yid, const char *seed, const char *sn)
     2359{
     2360        struct yahoo_https_auth_data *had = g_new0(struct yahoo_https_auth_data, 1);
     2361       
     2362        had->yid = yid;
     2363        had->chal = g_strdup(seed);
     2364       
     2365        yahoo_https_auth_token_init(had);
     2366}
     2367
     2368static void yahoo_https_auth_token_init(struct yahoo_https_auth_data *had)
     2369{
     2370        struct yahoo_input_data *yid = had->yid;
     2371        struct yahoo_data *yd = yid->yd;
     2372        struct http_request *req;
     2373        char *login, *passwd, *chal;
     2374        char *url;
     2375       
     2376        login = g_strndup(yd->user, 3 * strlen(yd->user));
     2377        http_encode(login);
     2378        passwd = g_strndup(yd->password, 3 * strlen(yd->password));
     2379        http_encode(passwd);
     2380        chal = g_strndup(had->chal, 3 * strlen(had->chal));
     2381        http_encode(chal);
     2382       
     2383        url = g_strdup_printf("https://login.yahoo.com/config/pwtoken_get?src=ymsgr&ts=%d&login=%s&passwd=%s&chal=%s",
     2384                               (int) time(NULL), login, passwd, chal);
     2385       
     2386        req = http_dorequest_url(url, yahoo_https_auth_token_finish, had);
     2387       
     2388        g_free(url);
     2389        g_free(chal);
     2390        g_free(passwd);
     2391        g_free(login);
     2392}
     2393
     2394static void yahoo_https_auth_token_finish(struct http_request *req)
     2395{
     2396        struct yahoo_https_auth_data *had = req->data;
     2397        struct yahoo_input_data *yid = had->yid;
     2398        struct yahoo_data *yd = yid->yd;
     2399        int st;
     2400       
     2401        if (req->status_code != 200) {
     2402                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 2000 + req->status_code, NULL);
     2403                goto fail;
     2404        }
     2405       
     2406        if (sscanf(req->reply_body, "%d", &st) != 1 || st != 0) {
     2407                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, yahoo_https_status_parse(st), NULL);
     2408                goto fail;
     2409        }
     2410       
     2411        if ((had->token = yahoo_ha_find_key(req->reply_body, "ymsgr")) == NULL) {
     2412                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 3001, NULL);
     2413                goto fail;
     2414        }
     2415       
     2416        return yahoo_https_auth_init(had);
     2417       
     2418fail:
     2419        g_free(had->token);
     2420        g_free(had->chal);
     2421        g_free(had);
     2422}
     2423
     2424static void yahoo_https_auth_init(struct yahoo_https_auth_data *had)
     2425{
     2426        struct http_request *req;
     2427        char *url;
     2428       
     2429        url = g_strdup_printf("https://login.yahoo.com/config/pwtoken_login?src=ymsgr&ts=%d&token=%s",
     2430                              (int) time(NULL), had->token);
     2431       
     2432        req = http_dorequest_url(url, yahoo_https_auth_finish, had);
     2433       
     2434        g_free(url);
     2435}
     2436
     2437static void yahoo_https_auth_finish(struct http_request *req)
     2438{
     2439        struct yahoo_https_auth_data *had = req->data;
     2440        struct yahoo_input_data *yid = had->yid;
     2441        struct yahoo_data *yd = yid->yd;
     2442        struct yahoo_packet *pack;
     2443        char *crumb;
     2444        int st;
     2445       
     2446        md5_byte_t result[16];
     2447        md5_state_t ctx;
     2448       
     2449        unsigned char yhash[32];
     2450
     2451        if (req->status_code != 200) {
     2452                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 2000 + req->status_code, NULL);
     2453                goto fail;
     2454        }
     2455       
     2456        if (sscanf(req->reply_body, "%d", &st) != 1 || st != 0) {
     2457                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, yahoo_https_status_parse(st), NULL);
     2458                goto fail;
     2459        }
     2460       
     2461        if ((yd->cookie_y = yahoo_ha_find_key(req->reply_body, "Y")) == NULL ||
     2462            (yd->cookie_t = yahoo_ha_find_key(req->reply_body, "T")) == NULL ||
     2463            (crumb = yahoo_ha_find_key(req->reply_body, "crumb")) == NULL) {
     2464                YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, 3002, NULL);
     2465                goto fail;
     2466        }
     2467       
     2468        md5_init(&ctx); 
     2469        md5_append(&ctx, (unsigned char*) crumb, 11);
     2470        md5_append(&ctx, (unsigned char*) had->chal, strlen(had->chal));
     2471        md5_finish(&ctx, result);
     2472        to_y64(yhash, result, 16);
     2473
     2474        pack = yahoo_packet_new(YAHOO_SERVICE_AUTHRESP, yd->initial_status, yd->session_id);
     2475        yahoo_packet_hash(pack, 1, yd->user);
     2476        yahoo_packet_hash(pack, 0, yd->user);
     2477        yahoo_packet_hash(pack, 277, yd->cookie_y);
     2478        yahoo_packet_hash(pack, 278, yd->cookie_t);
     2479        yahoo_packet_hash(pack, 307, (char*) yhash);
     2480        yahoo_packet_hash(pack, 244, "524223");
     2481        yahoo_packet_hash(pack, 2, yd->user);
     2482        yahoo_packet_hash(pack, 2, "1");
     2483        yahoo_packet_hash(pack, 98, "us");
     2484        yahoo_packet_hash(pack, 135, "7.5.0.647");
     2485       
     2486        yahoo_send_packet(yid, pack, 0);
     2487               
     2488        yahoo_packet_free(pack);
     2489       
     2490fail:
     2491        g_free(crumb);
     2492        g_free(had->token);
     2493        g_free(had->chal);
     2494        g_free(had);
     2495}
     2496
    22302497static void yahoo_process_auth(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
    22312498{
     
    22552522                case 1:
    22562523                        yahoo_process_auth_0x0b(yid, seed, sn);
     2524                        break;
     2525                case 2:
     2526                        yahoo_process_auth_0x10(yid, seed, sn);
    22572527                        break;
    22582528                default:
     
    24102680               
    24112681                yd->buddies = y_list_append(yd->buddies, bud);
    2412                
     2682       
    24132683                /* Possibly called already, but at least the call above doesn't
    24142684                   seem to happen every time (not anytime I tried). */
     
    24172687
    24182688/*      YAHOO_CALLBACK(ext_yahoo_status_changed)(yd->client_id, who, status, NULL, (status==YAHOO_STATUS_AVAILABLE?0:1)); */
     2689}
     2690
     2691static void yahoo_process_contact_ymsg13(struct yahoo_input_data *yid, struct yahoo_packet *pkt)
     2692{
     2693        char* who=NULL;
     2694        char* me=NULL; 
     2695        char* msg=NULL;
     2696        YList *l;
     2697        for (l = pkt->hash; l; l = l->next) {
     2698                struct yahoo_pair *pair = l->data;
     2699                if (pair->key == 4)
     2700                        who = pair->value;
     2701                else if (pair->key == 5)
     2702                        me = pair->value;
     2703                else
     2704                        DEBUG_MSG(("unknown key: %d = %s", pair->key, pair->value));
     2705        }
     2706
     2707        if(pkt->status==3)
     2708                YAHOO_CALLBACK(ext_yahoo_contact_auth_request)(yid->yd->client_id, me, who, msg);
    24192709}
    24202710
     
    26302920
    26312921        YList *l;
    2632         yahoo_dump_unhandled(pkt);
     2922        // yahoo_dump_unhandled(pkt);
    26332923        for (l = pkt->hash; l; l = l->next) {
    26342924                struct yahoo_pair *pair = l->data;
     
    26522942{
    26532943        DEBUG_MSG(("yahoo_packet_process: 0x%02x", pkt->service));
     2944        yahoo_dump_unhandled(pkt);
    26542945        switch (pkt->service)
    26552946        {
     
    26632954        case YAHOO_SERVICE_IDACT:
    26642955        case YAHOO_SERVICE_IDDEACT:
     2956        case YAHOO_SERVICE_Y6_STATUS_UPDATE:
     2957        case YAHOO_SERVICE_YMSG15_STATUS:
    26652958                yahoo_process_status(yid, pkt);
    26662959                break;
     
    26762969                yahoo_process_mail(yid, pkt);
    26772970                break;
     2971        case YAHOO_SERVICE_REJECTCONTACT:
    26782972        case YAHOO_SERVICE_NEWCONTACT:
    26792973                yahoo_process_contact(yid, pkt);
     
    27163010                yahoo_process_buddyadd(yid, pkt);
    27173011                break;
     3012        case YAHOO_SERVICE_CONTACT_YMSG13:
     3013                yahoo_process_contact_ymsg13(yid,pkt);
     3014                break;
    27183015        case YAHOO_SERVICE_REMBUDDY:
    27193016                yahoo_process_buddydel(yid, pkt);
     
    27443041        case YAHOO_SERVICE_CHATLOGOFF:
    27453042        case YAHOO_SERVICE_CHATMSG:
    2746         case YAHOO_SERVICE_REJECTCONTACT:
    27473043        case YAHOO_SERVICE_PEERTOPEER:
    27483044                WARNING(("unhandled service 0x%02x", pkt->service));
     
    27583054                yahoo_process_picture_upload(yid, pkt);
    27593055                break; 
     3056        case YAHOO_SERVICE_YMSG15_BUDDY_LIST:   /* Buddy List */
     3057                yahoo_process_buddy_list(yid, pkt);
    27603058        default:
    27613059                WARNING(("unknown service 0x%02x", pkt->service));
     
    35413839        yahoo_process_webcam_connection,
    35423840        yahoo_process_chatcat_connection,
    3543         yahoo_process_search_connection
     3841        yahoo_process_search_connection,
    35443842};
    35453843
     
    35593857        } while(len == -1 && errno == EINTR);
    35603858
    3561         if(len == -1 && errno == EAGAIN)        /* we'll try again later */
     3859        if(len == -1 && (errno == EAGAIN||errno == EINTR))      /* we'll try again later */
    35623860                return 1;
    35633861
     
    37624060
    37634061        yahoo_packet_hash(pkt, 5, who);
    3764         yahoo_packet_hash(pkt, 4, from?from:yd->user);
     4062        yahoo_packet_hash(pkt, 1, from?from:yd->user);
    37654063        yahoo_packet_hash(pkt, 14, " ");
    37664064        yahoo_packet_hash(pkt, 13, typ ? "1" : "0");
     
    37774075        struct yahoo_data *yd;
    37784076        struct yahoo_packet *pkt = NULL;
    3779         int service;
     4077        int old_status;
    37804078        char s[4];
    37814079
     
    37854083        yd = yid->yd;
    37864084
    3787         if (msg) {
     4085        old_status = yd->current_status;
     4086
     4087        if (msg && strncmp(msg,"Invisible",9)) {
    37884088                yd->current_status = YAHOO_STATUS_CUSTOM;
    37894089        } else {
     
    37914091        }
    37924092
    3793         if (yd->current_status == YAHOO_STATUS_AVAILABLE)
    3794                 service = YAHOO_SERVICE_ISBACK;
    3795         else
    3796                 service = YAHOO_SERVICE_ISAWAY;
     4093        /* Thank you libpurple :) */
     4094        if (yd->current_status == YAHOO_STATUS_INVISIBLE) {
     4095                pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
     4096                yahoo_packet_hash(pkt, 13, "2");
     4097                yahoo_send_packet(yid, pkt, 0);
     4098                yahoo_packet_free(pkt);
     4099
     4100                return;
     4101        }
     4102
     4103        pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_STATUS_UPDATE, yd->current_status, yd->session_id);
     4104        snprintf(s, sizeof(s), "%d", yd->current_status);
     4105        yahoo_packet_hash(pkt, 10, s);
    37974106         
    3798         if ((away == 2) && (yd->current_status == YAHOO_STATUS_AVAILABLE)) {
    3799                 pkt = yahoo_packet_new(YAHOO_SERVICE_ISAWAY, YAHOO_STATUS_BRB, yd->session_id);
    3800                 yahoo_packet_hash(pkt, 10, "999");
    3801                 yahoo_packet_hash(pkt, 47, "2");
    3802         }else {
    3803                 pkt = yahoo_packet_new(service, YAHOO_STATUS_AVAILABLE, yd->session_id);
    3804                 snprintf(s, sizeof(s), "%d", yd->current_status);
    3805                 yahoo_packet_hash(pkt, 10, s);
    3806                 if (yd->current_status == YAHOO_STATUS_CUSTOM) {
    3807                         yahoo_packet_hash(pkt, 19, msg);
    3808                         yahoo_packet_hash(pkt, 47, (away == 2)? "2": (away) ?"1":"0");
    3809                 } else {
    3810                         yahoo_packet_hash(pkt, 47, (away == 2)? "2": (away) ?"1":"0");
    3811                 }
    3812                
    3813                
    3814                
    3815         }
     4107        if (yd->current_status == YAHOO_STATUS_CUSTOM) {
     4108                yahoo_packet_hash(pkt, 19, msg);
     4109        } else {
     4110                yahoo_packet_hash(pkt, 19, "");
     4111        }
     4112       
     4113        yahoo_packet_hash(pkt, 47, (away == 2)? "2": (away) ?"1":"0");
    38164114
    38174115        yahoo_send_packet(yid, pkt, 0);
    38184116        yahoo_packet_free(pkt);
     4117
     4118        if(old_status == YAHOO_STATUS_INVISIBLE) {
     4119                pkt = yahoo_packet_new(YAHOO_SERVICE_Y6_VISIBILITY, YAHOO_STATUS_AVAILABLE, 0);
     4120                yahoo_packet_hash(pkt, 13, "1");
     4121                yahoo_send_packet(yid, pkt, 0);
     4122                yahoo_packet_free(pkt);
     4123        }
    38194124}
    38204125
     
    38314136        LOG(("yahoo_logoff: current status: %d", yd->current_status));
    38324137
    3833         if(yd->current_status != -1) {
     4138        if(yd->current_status != -1 && 0) {
     4139                /* Meh. Don't send this. The event handlers are not going to
     4140                   get to do this so it'll just leak memory. And the TCP
     4141                   connection reset will hopefully be clear enough. */
    38344142                pkt = yahoo_packet_new(YAHOO_SERVICE_LOGOFF, YAHOO_STATUS_AVAILABLE, yd->session_id);
    38354143                yd->current_status = -1;
     
    40644372                return;
    40654373
    4066         pkt = yahoo_packet_new(YAHOO_SERVICE_ADDBUDDY, YAHOO_STATUS_AVAILABLE, yd->session_id);
    4067         yahoo_packet_hash(pkt, 1, yd->user);
    4068         yahoo_packet_hash(pkt, 7, who);
    4069         yahoo_packet_hash(pkt, 65, group);
     4374        pkt = yahoo_packet_new(YAHOO_SERVICE_ADDBUDDY, YPACKET_STATUS_DEFAULT, yd->session_id);
     4375
    40704376        if (msg != NULL) /* add message/request "it's me add me" */
    40714377                yahoo_packet_hash(pkt, 14, msg);
     4378        else
     4379                yahoo_packet_hash(pkt,14,"");
     4380
     4381        yahoo_packet_hash(pkt, 65, group);
     4382        yahoo_packet_hash(pkt, 97, "1");
     4383        yahoo_packet_hash(pkt, 1, yd->user);
     4384        yahoo_packet_hash(pkt, 302, "319");
     4385        yahoo_packet_hash(pkt, 300, "319");
     4386        yahoo_packet_hash(pkt, 7, who);
     4387        yahoo_packet_hash(pkt, 334, "0");
     4388        yahoo_packet_hash(pkt, 301, "319");
     4389        yahoo_packet_hash(pkt, 303, "319");
     4390
     4391
    40724392        yahoo_send_packet(yid, pkt, 0);
    40734393        yahoo_packet_free(pkt);
     
    40914411        yahoo_send_packet(yid, pkt, 0);
    40924412        yahoo_packet_free(pkt);
     4413}
     4414
     4415void yahoo_accept_buddy_ymsg13(int id,const char* me,const char* who){
     4416        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     4417        struct yahoo_data *yd;
     4418
     4419        if(!yid)
     4420                return;
     4421        yd = yid->yd;
     4422
     4423        struct yahoo_packet* pkt=NULL;
     4424        pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
     4425
     4426        yahoo_packet_hash(pkt,1,me ?: yd->user);       
     4427        yahoo_packet_hash(pkt,5,who);
     4428        yahoo_packet_hash(pkt,13,"1");
     4429        yahoo_packet_hash(pkt,334,"0");
     4430        yahoo_send_packet(yid, pkt, 0);
     4431        yahoo_packet_free(pkt);
     4432}
     4433
     4434void yahoo_reject_buddy_ymsg13(int id,const char* me,const char* who,const char* msg){
     4435        struct yahoo_input_data *yid = find_input_by_id_and_type(id, YAHOO_CONNECTION_PAGER);
     4436        struct yahoo_data *yd;
     4437
     4438        if(!yid)
     4439                return;
     4440        yd = yid->yd;
     4441
     4442        struct yahoo_packet* pkt=NULL;
     4443        pkt= yahoo_packet_new(YAHOO_SERVICE_CONTACT_YMSG13,YAHOO_STATUS_AVAILABLE,0);
     4444
     4445        yahoo_packet_hash(pkt,1,me ?: yd->user);       
     4446        yahoo_packet_hash(pkt,5,who);
     4447//      yahoo_packet_hash(pkt,241,YAHOO_PROTO_VER);
     4448        yahoo_packet_hash(pkt,13,"2");
     4449        yahoo_packet_hash(pkt,334,"0");
     4450        yahoo_packet_hash(pkt,97,"1");
     4451        yahoo_packet_hash(pkt,14,msg?:"");
     4452
     4453        yahoo_send_packet(yid, pkt, 0);
     4454        yahoo_packet_free(pkt);
     4455
    40934456}
    40944457
  • protocols/yahoo/yahoo.c

    rfc34fb5 r3f81999  
    254254static GList *byahoo_away_states( struct im_connection *ic )
    255255{
    256         GList *m = NULL;
    257 
    258         m = g_list_append( m, "Available" );
    259         m = g_list_append( m, "Be Right Back" );
    260         m = g_list_append( m, "Busy" );
    261         m = g_list_append( m, "Not At Home" );
    262         m = g_list_append( m, "Not At Desk" );
    263         m = g_list_append( m, "Not In Office" );
    264         m = g_list_append( m, "On Phone" );
    265         m = g_list_append( m, "On Vacation" );
    266         m = g_list_append( m, "Out To Lunch" );
    267         m = g_list_append( m, "Stepped Out" );
    268         m = g_list_append( m, "Invisible" );
    269         m = g_list_append( m, GAIM_AWAY_CUSTOM );
     256        static GList *m = NULL;
     257
     258        if( m == NULL )
     259        {
     260                m = g_list_append( m, "Available" );
     261                m = g_list_append( m, "Be Right Back" );
     262                m = g_list_append( m, "Busy" );
     263                m = g_list_append( m, "Not At Home" );
     264                m = g_list_append( m, "Not At Desk" );
     265                m = g_list_append( m, "Not In Office" );
     266                m = g_list_append( m, "On Phone" );
     267                m = g_list_append( m, "On Vacation" );
     268                m = g_list_append( m, "Out To Lunch" );
     269                m = g_list_append( m, "Stepped Out" );
     270                m = g_list_append( m, "Invisible" );
     271                m = g_list_append( m, GAIM_AWAY_CUSTOM );
     272        }
    270273       
    271274        return m;
     
    346349       
    347350        return c;
     351}
     352
     353static void byahoo_auth_allow( struct im_connection *ic, const char *who )
     354{
     355        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
     356       
     357        yahoo_accept_buddy_ymsg13( yd->y2_id, NULL, who );
     358}
     359
     360static void byahoo_auth_deny( struct im_connection *ic, const char *who )
     361{
     362        struct byahoo_data *yd = (struct byahoo_data *) ic->proto_data;
     363       
     364        yahoo_reject_buddy_ymsg13( yd->y2_id, NULL, who, NULL );
    348365}
    349366
     
    374391        ret->handle_cmp = g_strcasecmp;
    375392       
     393        ret->auth_allow = byahoo_auth_allow;
     394        ret->auth_deny = byahoo_auth_deny;
     395       
    376396        register_protocol(ret);
    377397}
     
    453473        struct byahoo_write_ready_data *d = data;
    454474       
    455         yahoo_write_ready( d->id, d->fd, d->data );
    456        
    457         return FALSE;
     475        return yahoo_write_ready( d->id, d->fd, d->data );
    458476}
    459477
     
    923941}
    924942
     943void ext_yahoo_contact_auth_request( int id, const char *myid, const char *who, const char *msg )
     944{
     945        struct im_connection *ic = byahoo_get_ic_by_id( id );
     946       
     947        imcb_ask_auth( ic, who, NULL );
     948}
     949
    925950void ext_yahoo_contact_added( int id, const char *myid, const char *who, const char *msg )
    926951{
    927         /* Groups schmoups. If I want to handle groups properly I can get the
    928            buddy data from some internal libyahoo2 structure. */
    929         imcb_add_buddy( byahoo_get_ic_by_id( id ), (char*) who, NULL );
     952        struct im_connection *ic = byahoo_get_ic_by_id( id );
     953       
     954        imcb_add_buddy( ic, (char*) who, NULL );
    930955}
    931956
  • protocols/yahoo/yahoo2.h

    rfc34fb5 r3f81999  
    217217void yahoo_buddyicon_request(int id, const char *who);
    218218
     219void yahoo_accept_buddy_ymsg13(int,const char*,const char*);
     220void yahoo_reject_buddy_ymsg13(int,const char*,const char*,const char*);
     221
    219222#include "yahoo_httplib.h"
    220223
  • protocols/yahoo/yahoo2_callbacks.h

    rfc34fb5 r3f81999  
    361361
    362362/*
     363 * Name: ext_yahoo_contact_auth_request
     364 *      Called when a contact wants to add you to his/her contact list
     365 * Params:
     366 *      id   - the id that identifies the server connection
     367 *      myid - the identity s/he added
     368 *      who  - who did it
     369 *      msg  - any message sent
     370 */
     371void YAHOO_CALLBACK_TYPE(ext_yahoo_contact_auth_request)(int id, const char *myid, const char *who, const char *msg);
     372
     373
     374/*
    363375 * Name: ext_yahoo_contact_added
    364376 *      Called when a contact is added to your list
  • protocols/yahoo/yahoo2_types.h

    rfc34fb5 r3f81999  
    5757        YAHOO_LOGIN_LOCK = 14,
    5858        YAHOO_LOGIN_DUPL = 99,
    59         YAHOO_LOGIN_SOCK = -1
     59        YAHOO_LOGIN_SOCK = -1,
     60};
     61
     62enum ypacket_status {
     63        YPACKET_STATUS_DISCONNECTED = -1,
     64        YPACKET_STATUS_DEFAULT = 0,
     65        YPACKET_STATUS_SERVERACK = 1,
     66        YPACKET_STATUS_GAME     = 0x2,
     67        YPACKET_STATUS_AWAY     = 0x4,
     68        YPACKET_STATUS_CONTINUED = 0x5,
     69        YPACKET_STATUS_INVISIBLE = 12,
     70        YPACKET_STATUS_NOTIFY = 0x16, /* TYPING */
     71        YPACKET_STATUS_WEBLOGIN = 0x5a55aa55,
     72        YPACKET_STATUS_OFFLINE = 0x5a55aa56
    6073};
    6174
     
    8598};
    8699
    87 #define YAHOO_PROTO_VER 0x000b
     100#define YAHOO_PROTO_VER 0x0010
    88101
    89102/* Yahoo style/color directives */
     
    115128        YAHOO_CONNECTION_WEBCAM,
    116129        YAHOO_CONNECTION_CHATCAT,
    117         YAHOO_CONNECTION_SEARCH
     130        YAHOO_CONNECTION_SEARCH,
     131        YAHOO_CONNECTION_AUTH,
    118132};
    119133
     
    131145/* chat member attribs */
    132146#define YAHOO_CHAT_MALE 0x8000
    133 #define YAHOO_CHAT_FEMALE 0x10000
    134147#define YAHOO_CHAT_FEMALE 0x10000
    135148#define YAHOO_CHAT_DUNNO 0x400
  • root_commands.c

    rfc34fb5 r3f81999  
    310310                int st;
    311311               
    312                 if( checkflags && checkflags( irc, s ) == 0 )
     312                if( s && checkflags && checkflags( irc, s ) == 0 )
    313313                        return 0;
    314314               
     
    10791079        else if( g_strcasecmp( cmd[1], "set" ) == 0 )
    10801080        {
     1081                MIN_ARGS( 2 );
     1082               
    10811083                cmd_set_real( irc, cmd + 1, cmd_chat_set_findhead, NULL );
    10821084        }
Note: See TracChangeset for help on using the changeset viewer.