← Back to branch summary

~micahg/ubuntu/natty/pidgin/2.7.9-2

« back to all changes in this revision

Viewing changes to libpurple/protocols/msn/user.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2010-12-02 16:45:52 UTC
  • mfrom: (2.3.14 sid)
  • Revision ID: james.westby@ubuntu.com-20101202164552-z64wykojzacbb546
Tags: 1:2.7.7-1ubuntu1
New upstream version, drop msn workaround

Show diffs side-by-side

added added

removed removed

Lines of Context:
libpurple/protocols/msn/user.c
21
21
 * along with this program; if not, write to the Free Software
22
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
23
23
 */
24
 
#include "msn.h"
 
24
 
 
25
#include "internal.h"
 
26
#include "debug.h"
 
27
#include "util.h"
 
28
 
25
29
#include "user.h"
26
30
#include "slp.h"
27
31
 
 
32
static void free_user_endpoint(MsnUserEndpoint *data)
 
33
{
 
34
        g_free(data->id);
 
35
        g_free(data->name);
 
36
        g_free(data);
 
37
}
 
38
 
28
39
/*new a user object*/
29
40
MsnUser *
30
41
msn_user_new(MsnUserList *userlist, const char *passport,
39
50
        msn_user_set_passport(user, passport);
40
51
        msn_user_set_friendly_name(user, friendly_name);
41
52
 
42
 
        return user;
 
53
        return msn_user_ref(user);
43
54
}
44
55
 
45
56
/*destroy a user object*/
46
 
void
 
57
static void
47
58
msn_user_destroy(MsnUser *user)
48
59
{
49
60
        g_return_if_fail(user != NULL);
50
61
 
 
62
        if (user->refcount > 1) {
 
63
                msn_user_unref(user);
 
64
                return;
 
65
        }
 
66
 
 
67
        while (user->endpoints != NULL) {
 
68
                free_user_endpoint(user->endpoints->data);
 
69
                user->endpoints = g_slist_delete_link(user->endpoints, user->endpoints);
 
70
        }
 
71
 
51
72
        if (user->clientcaps != NULL)
52
73
                g_hash_table_destroy(user->clientcaps);
53
74
 
82
103
        g_free(user);
83
104
}
84
105
 
 
106
MsnUser *
 
107
msn_user_ref(MsnUser *user)
 
108
{
 
109
        g_return_val_if_fail(user != NULL, NULL);
 
110
 
 
111
        user->refcount++;
 
112
 
 
113
        return user;
 
114
}
 
115
 
 
116
void
 
117
msn_user_unref(MsnUser *user)
 
118
{
 
119
        g_return_if_fail(user != NULL);
 
120
 
 
121
        user->refcount--;
 
122
 
 
123
        if(user->refcount == 0)
 
124
                msn_user_destroy(user);
 
125
}
 
126
 
85
127
void
86
128
msn_user_update(MsnUser *user)
87
129
{
186
228
{
187
229
        g_return_val_if_fail(user != NULL, FALSE);
188
230
 
 
231
        if (user == user->userlist->session->user)
 
232
                return FALSE;
 
233
 
189
234
        if (user->friendly_name && name && (!strcmp(user->friendly_name, name) ||
190
235
                                !strcmp(user->passport, name)))
191
236
                return FALSE;
217
262
}
218
263
 
219
264
void
 
265
msn_user_set_endpoint_data(MsnUser *user, const char *input, MsnUserEndpoint *newep)
 
266
{
 
267
        MsnUserEndpoint *ep;
 
268
        char *endpoint;
 
269
        GSList *l;
 
270
 
 
271
        g_return_if_fail(user != NULL);
 
272
        g_return_if_fail(input != NULL);
 
273
 
 
274
        endpoint = g_ascii_strdown(input, -1);
 
275
 
 
276
        for (l = user->endpoints; l; l = l->next) {
 
277
                ep = l->data;
 
278
                if (g_str_equal(ep->id, endpoint)) {
 
279
                        /* We have info about this endpoint! */
 
280
 
 
281
                        g_free(endpoint);
 
282
 
 
283
                        if (newep == NULL) {
 
284
                                /* Delete it and exit */
 
285
                                user->endpoints = g_slist_delete_link(user->endpoints, l);
 
286
                                free_user_endpoint(ep);
 
287
                                return;
 
288
                        }
 
289
 
 
290
                        /* Break out of our loop and update it */
 
291
                        break;
 
292
                }
 
293
        }
 
294
        if (l == NULL) {
 
295
                /* Need to add a new endpoint */
 
296
                ep = g_new0(MsnUserEndpoint, 1);
 
297
                ep->id = endpoint;
 
298
                user->endpoints = g_slist_prepend(user->endpoints, ep);
 
299
        }
 
300
 
 
301
        ep->clientid = newep->clientid;
 
302
        ep->extcaps = newep->extcaps;
 
303
}
 
304
 
 
305
void
220
306
msn_user_set_op(MsnUser *user, MsnListOp list_op)
221
307
{
222
308
        g_return_if_fail(user != NULL);
406
492
}
407
493
 
408
494
void
 
495
msn_user_set_extcaps(MsnUser *user, guint extcaps)
 
496
{
 
497
        g_return_if_fail(user != NULL);
 
498
 
 
499
        user->extcaps = extcaps;
 
500
}
 
501
 
 
502
void
409
503
msn_user_set_network(MsnUser *user, MsnNetwork network)
410
504
{
411
505
        g_return_if_fail(user != NULL);
413
507
        user->networkid = network;
414
508
}
415
509
 
 
510
static gboolean
 
511
buddy_icon_cached(PurpleConnection *gc, MsnObject *obj)
 
512
{
 
513
        PurpleAccount *account;
 
514
        PurpleBuddy *buddy;
 
515
        const char *old;
 
516
        const char *new;
 
517
 
 
518
        g_return_val_if_fail(obj != NULL, FALSE);
 
519
 
 
520
        account = purple_connection_get_account(gc);
 
521
 
 
522
        buddy = purple_find_buddy(account, msn_object_get_creator(obj));
 
523
        if (buddy == NULL)
 
524
                return FALSE;
 
525
 
 
526
        old = purple_buddy_icons_get_checksum_for_user(buddy);
 
527
        new = msn_object_get_sha1(obj);
 
528
 
 
529
        if (new == NULL)
 
530
                return FALSE;
 
531
 
 
532
        /* If the old and new checksums are the same, and the file actually exists,
 
533
         * then return TRUE */
 
534
        if (old != NULL && !strcmp(old, new))
 
535
                return TRUE;
 
536
 
 
537
        return FALSE;
 
538
}
 
539
 
 
540
static void
 
541
queue_buddy_icon_request(MsnUser *user)
 
542
{
 
543
        PurpleAccount *account;
 
544
        MsnObject *obj;
 
545
        GQueue *queue;
 
546
 
 
547
        g_return_if_fail(user != NULL);
 
548
 
 
549
        account = user->userlist->session->account;
 
550
 
 
551
        obj = msn_user_get_object(user);
 
552
 
 
553
        if (obj == NULL) {
 
554
                purple_buddy_icons_set_for_user(account, user->passport, NULL, 0, NULL);
 
555
                return;
 
556
        }
 
557
 
 
558
        if (!buddy_icon_cached(account->gc, obj)) {
 
559
                MsnUserList *userlist;
 
560
 
 
561
                userlist = user->userlist;
 
562
                queue = userlist->buddy_icon_requests;
 
563
 
 
564
                if (purple_debug_is_verbose())
 
565
                        purple_debug_info("msn", "Queueing buddy icon request for %s (buddy_icon_window = %i)\n",
 
566
                                          user->passport, userlist->buddy_icon_window);
 
567
 
 
568
                g_queue_push_tail(queue, user);
 
569
 
 
570
                if (userlist->buddy_icon_window > 0)
 
571
                        msn_release_buddy_icon_request(userlist);
 
572
        }
 
573
}
 
574
 
416
575
void
417
576
msn_user_set_object(MsnUser *user, MsnObject *obj)
418
577
{
419
578
        g_return_if_fail(user != NULL);
420
579
 
421
 
        if (user->msnobj != NULL)
 
580
        if (user->msnobj != NULL && !msn_object_find_local(msn_object_get_sha1(obj)))
422
581
                msn_object_destroy(user->msnobj);
423
582
 
424
583
        user->msnobj = obj;
425
584
 
426
 
        if (user->list_op & MSN_LIST_FL_OP)
427
 
                msn_queue_buddy_icon_request(user);
 
585
        if (user != user->userlist->session->user && user->list_op & MSN_LIST_FL_OP)
 
586
                queue_buddy_icon_request(user);
428
587
}
429
588
 
430
589
void
496
655
        return user->clientid;
497
656
}
498
657
 
 
658
guint
 
659
msn_user_get_extcaps(const MsnUser *user)
 
660
{
 
661
        g_return_val_if_fail(user != NULL, 0);
 
662
 
 
663
        return user->extcaps;
 
664
}
 
665
 
 
666
MsnUserEndpoint *
 
667
msn_user_get_endpoint_data(MsnUser *user, const char *input)
 
668
{
 
669
        char *endpoint;
 
670
        GSList *l;
 
671
        MsnUserEndpoint *ep;
 
672
 
 
673
        g_return_val_if_fail(user != NULL, NULL);
 
674
        g_return_val_if_fail(input != NULL, NULL);
 
675
 
 
676
        endpoint = g_ascii_strdown(input, -1);
 
677
 
 
678
        for (l = user->endpoints; l; l = l->next) {
 
679
                ep = l->data;
 
680
                if (g_str_equal(ep->id, endpoint)) {
 
681
                        g_free(endpoint);
 
682
                        return ep;
 
683
                }
 
684
        }
 
685
 
 
686
        g_free(endpoint);
 
687
 
 
688
        return NULL;
 
689
}
 
690
 
499
691
MsnObject *
500
692
msn_user_get_object(const MsnUser *user)
501
693
{
520
712
        return user->invite_message;
521
713
}
522
714
 
 
715
gboolean
 
716
msn_user_is_capable(MsnUser *user, char *endpoint, guint capability, guint extcap)
 
717
{
 
718
        g_return_val_if_fail(user != NULL, FALSE);
 
719
 
 
720
        if (endpoint != NULL) {
 
721
                MsnUserEndpoint *ep = msn_user_get_endpoint_data(user, endpoint);
 
722
                if (ep != NULL)
 
723
                        return (ep->clientid & capability) && (ep->extcaps & extcap);
 
724
                else
 
725
                        return FALSE;
 
726
        }
 
727
 
 
728
        return (user->clientid & capability) && (user->extcaps & extcap);
 
729
}
 
730
 
 
731
/**************************************************************************
 
732
 * Utility functions
 
733
 **************************************************************************/
 
734
 
 
735
int
 
736
msn_user_passport_cmp(MsnUser *user, const char *passport)
 
737
{
 
738
        const char *str;
 
739
        char *pass;
 
740
        int result;
 
741
 
 
742
        str = purple_normalize_nocase(NULL, msn_user_get_passport(user));
 
743
        pass = g_strdup(str);
 
744
 
 
745
#if GLIB_CHECK_VERSION(2,16,0)
 
746
        result = g_strcmp0(pass, purple_normalize_nocase(NULL, passport));
 
747
#else
 
748
        str = purple_normalize_nocase(NULL, passport);
 
749
        if (!pass)
 
750
                result = -(pass != str);
 
751
        else if (!str)
 
752
                result = pass != str;
 
753
        else
 
754
                result = strcmp(pass, str);
 
755
#endif /* GLIB < 2.16.0 */
 
756
 
 
757
        g_free(pass);
 
758
 
 
759
        return result;
 
760
}
 
761
 
 
762
gboolean
 
763
msn_user_is_in_group(MsnUser *user, const char * group_id)
 
764
{
 
765
        if (user == NULL)
 
766
                return FALSE;
 
767
 
 
768
        if (group_id == NULL)
 
769
                return FALSE;
 
770
 
 
771
        return (g_list_find_custom(user->group_ids, group_id, (GCompareFunc)strcmp)) != NULL;
 
772
}
 
773
 
 
774
gboolean
 
775
msn_user_is_in_list(MsnUser *user, MsnListId list_id)
 
776
{
 
777
        if (user == NULL)
 
778
                return FALSE;
 
779
 
 
780
        return (user->list_op & (1 << list_id));
 
781
}
 
782