Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • protocols/yahoo/libyahoo2.c

    r99c8f13 r9fca0657  
    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                                 struct yahoo_buddy *lastbud = (struct yahoo_buddy *)y_list_nth(
    1536                                                                 yd->buddies, y_list_length(yd->buddies)-1)->data;
     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;
    15371505                                newbud->group = strdup(lastbud->group);
    1538                         }
     1506                        } else
     1507                                newbud->group = strdup("Buddies");
    15391508
    15401509                        yd->buddies = y_list_append(yd->buddies, newbud);
     
    15431512                }
    15441513        }
    1545        
    1546         g_free(cur_group);
    15471514
    15481515        /* we could be getting multiple packets here */
    1549         if (last_packet)
    1550                 return;
    1551 
    1552         YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
    1553 
    1554         /*** 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 */
    15551522        if (!yd->logged_in) {
    1556                 yd->logged_in = TRUE;
    1557                 if(yd->current_status < 0)
     1523                yd->logged_in = 1;
     1524                if (yd->current_status < 0)
    15581525                        yd->current_status = yd->initial_status;
    1559                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
    1560         }
    1561 }
    1562 
    1563 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)
    15641541{
    15651542        struct yahoo_data *yd = yid->yd;
    15661543        YList *l;
    15671544
    1568         if (!yd->logged_in) {
    1569                 yd->logged_in = TRUE;
    1570                 if(yd->current_status < 0)
    1571                         yd->current_status = yd->initial_status;
    1572                 YAHOO_CALLBACK(ext_yahoo_login_response)(yd->client_id, YAHOO_LOGIN_OK, NULL);
    1573         }
    1574 
     1545        /* we could be getting multiple packets here */
    15751546        for (l = pkt->hash; l; l = l->next) {
    15761547                struct yahoo_pair *pair = l->data;
    15771548
    1578                 switch(pair->key) {
    1579                 case 87: /* buddies */
    1580                         if(!yd->rawbuddylist)
    1581                                 yd->rawbuddylist = strdup(pair->value);
    1582                         else {
    1583                                 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);
    15841560                        }
    1585                         break;
    1586 
    1587                 case 88: /* ignore list */
    1588                         if(!yd->ignorelist)
    1589                                 yd->ignorelist = strdup("Ignore:");
    1590                         yd->ignorelist = y_string_append(yd->ignorelist, pair->value);
    1591                         break;
    1592 
    1593                 case 89: /* identities */
    1594                         {
    1595                         char **identities = y_strsplit(pair->value, ",", -1);
    1596                         int i;
    1597                         for(i=0; identities[i]; i++)
    1598                                 yd->identities = y_list_append(yd->identities,
    1599                                                 strdup(identities[i]));
    1600                         y_strfreev(identities);
    1601                         }
    1602                         YAHOO_CALLBACK(ext_yahoo_got_identities)(yd->client_id, yd->identities);
    1603                         break;
    1604                 case 59: /* cookies */
    1605                         if(yd->ignorelist) {
    1606                                 yd->ignore = bud_str2list(yd->ignorelist);
    1607                                 FREE(yd->ignorelist);
    1608                                 YAHOO_CALLBACK(ext_yahoo_got_ignore)(yd->client_id, yd->ignore);
    1609                         }
    1610                         if(yd->rawbuddylist) {
    1611                                 yd->buddies = bud_str2list(yd->rawbuddylist);
    1612                                 FREE(yd->rawbuddylist);
    1613                                 YAHOO_CALLBACK(ext_yahoo_got_buddies)(yd->client_id, yd->buddies);
    1614                         }
    1615 
    1616                         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') {
    16171566                                FREE(yd->cookie_y);
    16181567                                FREE(yd->login_cookie);
     
    16211570                                yd->login_cookie = getlcookie(yd->cookie_y);
    16221571
    1623                         } else if(pair->value[0]=='T') {
     1572                        } else if (pair->value[0] == 'T') {
    16241573                                FREE(yd->cookie_t);
    16251574                                yd->cookie_t = getcookie(pair->value);
    16261575
    1627                         } else if(pair->value[0]=='C') {
     1576                        } else if (pair->value[0] == 'C') {
    16281577                                FREE(yd->cookie_c);
    16291578                                yd->cookie_c = getcookie(pair->value);
    1630                         } 
    1631 
    1632                         if(yd->cookie_y && yd->cookie_t)
    1633                                 YAHOO_CALLBACK(ext_yahoo_got_cookies)(yd->client_id);
    1634 
    1635                         break;
    1636                 case 3: /* my id */
    1637                 case 90: /* 1 */
    1638                 case 100: /* 0 */
    1639                 case 101: /* NULL */
    1640                 case 102: /* NULL */
    1641                 case 93: /* 86400/1440 */
    1642                         break;
    1643                 }
    1644         }
     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);
    16451594}
    16461595
     
    23932342{
    23942343        struct yahoo_https_auth_data *had = req->data;
    2395         struct yahoo_input_data *yid = had->yid;
    2396         struct yahoo_data *yd = yid->yd;
     2344        struct yahoo_input_data *yid;
     2345        struct yahoo_data *yd;
    23972346        int st;
     2347       
     2348        if (y_list_find(inputs, had->yid) == NULL)
     2349                return;
     2350       
     2351        yid = had->yid;
     2352        yd = yid->yd;
    23982353       
    23992354        if (req->status_code != 200) {
     
    24362391{
    24372392        struct yahoo_https_auth_data *had = req->data;
    2438         struct yahoo_input_data *yid = had->yid;
    2439         struct yahoo_data *yd = yid->yd;
     2393        struct yahoo_input_data *yid;
     2394        struct yahoo_data *yd;
    24402395        struct yahoo_packet *pack;
    2441         char *crumb;
     2396        char *crumb = NULL;
    24422397        int st;
     2398       
     2399        if (y_list_find(inputs, had->yid) == NULL)
     2400                return;
     2401       
     2402        yid = had->yid;
     2403        yd = yid->yd;
    24432404       
    24442405        md5_byte_t result[16];
     
    40804041
    40814042        yd = yid->yd;
    4082 
    40834043        old_status = yd->current_status;
    4084 
    4085         if (msg && strncmp(msg,"Invisible",9)) {
    4086                 yd->current_status = YAHOO_STATUS_CUSTOM;
    4087         } else {
    4088                 yd->current_status = state;
    4089         }
     4044        yd->current_status = state;
    40904045
    40914046        /* Thank you libpurple :) */
     
    41024057        snprintf(s, sizeof(s), "%d", yd->current_status);
    41034058        yahoo_packet_hash(pkt, 10, s);
    4104          
    4105         if (yd->current_status == YAHOO_STATUS_CUSTOM) {
    4106                 yahoo_packet_hash(pkt, 19, msg);
    4107         } else {
    4108                 yahoo_packet_hash(pkt, 19, "");
    4109         }
    4110        
     4059        yahoo_packet_hash(pkt, 19, msg && state == YAHOO_STATUS_CUSTOM ? msg : "");
    41114060        yahoo_packet_hash(pkt, 47, (away == 2)? "2": (away) ?"1":"0");
    4112 
    41134061        yahoo_send_packet(yid, pkt, 0);
    41144062        yahoo_packet_free(pkt);
Note: See TracChangeset for help on using the changeset viewer.