← Back to branch summary

~ubuntu-branches/ubuntu/hardy/pidgin/hardy

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Pedro Fragoso
  • Date: 2007-12-21 02:48:06 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071221024806-pd44a5k9tiyh12mp
Tags: 1:2.3.1-2ubuntu1
https://launchpad.net/bugs/177811
* Sync with Debian, remaining Ubuntu changes; (LP: #177811)
  - Set Maintainer to Ubuntu Core Developers.
  - Add build-deps on liblaunchpad-integration-dev, intltool,
    libnm-glib-dev (for --enable-nm) (Ubuntu #112720).
  - Drop build-deps on libsilc-1.1-2-dev | libsilc-dev (>= 1.1.1) as 
    this library is in universe.
  - Drop the libpurple0 recommends on libpurple-bin.
  - Add a gaim transitionnal package for upgrades.
  - Ship compatibility symlinks via debian/gaim.links.
  - Pass --enable-nm to configure to enable NetworkManager support.
  - Pass --disable-silc to configure to disable silc support even if 
    it's installed in the build environment.
  - Add X-Ubuntu-Gettext-Domain to the desktop file and update the
    translation templates in common-install-impl::.
   - Update debian/prefs.xml to set the notify plugin prefs
    /plugins/gtk/X11/notify/* and set /pidgin/plugins/loaded to load 
    the notify plugin; Ubuntu: #13389.
  - Add LPI integration patch, 02_lpi.
  - Add patch 04_let_crasher_for_apport to stop catching the SIGSEGV signal
    and let apport handle it.
  - Add patch 05_default_to_irc_ubuntu_com to set the default IRC 
    server to irc.ubuntu.com.
  - Add autoconf patch, 70_autoconf.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libpurple/protocols/msn/notification.c
25
25
#include "notification.h"
26
26
#include "state.h"
27
27
#include "error.h"
28
 
#include "msn-utils.h"
 
28
#include "msnutils.h"
29
29
#include "page.h"
30
30
 
31
31
#include "userlist.h"
34
34
 
35
35
static MsnTable *cbs_table;
36
36
 
 
37
/****************************************************************************
 
38
 *      Local Function Prototype
 
39
 ****************************************************************************/
 
40
 
 
41
static void msn_notification_post_adl(MsnCmdProc *cmdproc, const char *payload, int payload_len);
 
42
static void
 
43
msn_add_contact_xml(MsnSession *session, xmlnode *mlNode,const char *passport,
 
44
                                         MsnListOp list_op, MsnUserType type);
 
45
 
37
46
/**************************************************************************
38
47
 * Main
39
48
 **************************************************************************/
92
101
        MsnCmdProc *cmdproc;
93
102
        MsnSession *session;
94
103
        PurpleAccount *account;
95
 
        char **a, **c, *vers;
 
104
        GString *vers;
 
105
        const char *ver_str;
96
106
        int i;
97
107
 
98
108
        g_return_if_fail(servconn != NULL);
101
111
        session = servconn->session;
102
112
        account = session->account;
103
113
 
104
 
        /* Allocate an array for CVR0, NULL, and all the versions */
105
 
        a = c = g_new0(char *, session->protocol_ver - 8 + 3);
106
 
 
107
 
        for (i = session->protocol_ver; i >= 8; i--)
108
 
                *c++ = g_strdup_printf("MSNP%d", i);
109
 
 
110
 
        *c++ = g_strdup("CVR0");
111
 
 
112
 
        vers = g_strjoinv(" ", a);
 
114
        vers = g_string_new("");
 
115
 
 
116
/*      for (i = session->protocol_ver; i >= WLM_MIN_PROTOCOL; i--) */
 
117
        for (i = WLM_MAX_PROTOCOL; i >= WLM_MIN_PROTOCOL; i--)
 
118
                g_string_append_printf(vers, " MSNP%d", i);
 
119
 
 
120
        g_string_append(vers, " CVR0");
113
121
 
114
122
        if (session->login_step == MSN_LOGIN_STEP_START)
115
123
                msn_session_set_login_step(session, MSN_LOGIN_STEP_HANDSHAKE);
116
124
        else
117
125
                msn_session_set_login_step(session, MSN_LOGIN_STEP_HANDSHAKE2);
118
126
 
119
 
        msn_cmdproc_send(cmdproc, "VER", "%s", vers);
 
127
        /* Skip the initial space */
 
128
        ver_str = (vers->str + 1);
 
129
        msn_cmdproc_send(cmdproc, "VER", "%s", ver_str);
120
130
 
121
 
        g_strfreev(a);
122
 
        g_free(vers);
 
131
        g_string_free(vers, TRUE);
123
132
}
124
133
 
125
134
gboolean
153
162
 **************************************************************************/
154
163
 
155
164
static void
156
 
group_error_helper(MsnSession *session, const char *msg, int group_id, int error)
 
165
group_error_helper(MsnSession *session, const char *msg, const char *group_id, int error)
157
166
{
158
167
        PurpleAccount *account;
159
168
        PurpleConnection *gc;
172
181
                else
173
182
                {
174
183
                        const char *group_name;
175
 
                        group_name =
176
 
                                msn_userlist_find_group_name(session->userlist,
177
 
                                                                                         group_id);
 
184
                        group_name = msn_userlist_find_group_name(session->userlist,group_id);
178
185
                        reason = g_strdup_printf(_("%s is not a valid group."),
179
 
                                                                         group_name);
 
186
                                                                         group_name ? group_name : "");
180
187
                }
181
188
        }
182
189
        else
214
221
        PurpleAccount *account;
215
222
 
216
223
        account = cmdproc->session->account;
217
 
 
218
224
        msn_cmdproc_send(cmdproc, "USR", "TWN I %s",
219
225
                                         purple_account_get_username(account));
220
226
}
224
230
{
225
231
        MsnSession *session;
226
232
        PurpleAccount *account;
227
 
        PurpleConnection *gc;
228
233
 
229
234
        session = cmdproc->session;
230
235
        account = session->account;
231
 
        gc = purple_account_get_connection(account);
232
236
 
233
237
        if (!g_ascii_strcasecmp(cmd->params[1], "OK"))
234
238
        {
235
 
                /* OK */
 
239
                /* authenticate OK */
 
240
                /* friendly name part no longer true in msnp11 */
 
241
#if 0
236
242
                const char *friendly = purple_url_decode(cmd->params[3]);
237
243
 
238
244
                purple_connection_set_display_name(gc, friendly);
239
 
 
 
245
#endif
240
246
                msn_session_set_login_step(session, MSN_LOGIN_STEP_SYN);
241
247
 
242
 
                msn_cmdproc_send(cmdproc, "SYN", "%s", "0");
 
248
//              msn_cmdproc_send(cmdproc, "SYN", "%s", "0");
 
249
                //TODO we should use SOAP contact to fetch contact list
243
250
        }
244
251
        else if (!g_ascii_strcasecmp(cmd->params[1], "TWN"))
245
252
        {
249
256
                session->nexus = msn_nexus_new(session);
250
257
 
251
258
                /* Parse the challenge data. */
252
 
 
 
259
                session->nexus->challenge_data_str = g_strdup(cmd->params[3]);
253
260
                elems = g_strsplit(cmd->params[3], ",", 0);
254
261
 
255
262
                for (cur = elems; *cur != NULL; cur++)
256
263
                {
257
 
                                tokens = g_strsplit(*cur, "=", 2);
 
264
                        tokens = g_strsplit(*cur, "=", 2);
 
265
                        if(tokens[0] && tokens[1])
 
266
                        {
 
267
                                purple_debug_info("MSNP14","challenge %p,key:%s,value:%s\n",
 
268
                                                                        session->nexus->challenge_data,tokens[0],tokens[1]);
258
269
                                g_hash_table_insert(session->nexus->challenge_data, tokens[0], tokens[1]);
259
270
                                /* Don't free each of the tokens, only the array. */
260
271
                                g_free(tokens);
 
272
                        } else
 
273
                                g_strfreev(tokens);
261
274
                }
262
275
 
263
276
                g_strfreev(elems);
322
335
                return;
323
336
        }
324
337
 
 
338
        /*
 
339
         * Windows Live Messenger 8.0 
 
340
         * Notice :CVR String discriminate!
 
341
         * reference of http://www.microsoft.com/globaldev/reference/oslocversion.mspx
 
342
         * to see the Local ID
 
343
         */
325
344
        msn_cmdproc_send(cmdproc, "CVR",
326
 
                                         "0x0409 winnt 5.1 i386 MSNMSGR 6.0.0602 MSMSGS %s",
 
345
//                                       "0x0409 winnt 5.1 i386 MSG80BETA 8.0.0689 msmsgs %s",
 
346
                                        "0x0804 winnt 5.1 i386 MSNMSGR 8.0.0792 msmsgs %s",
327
347
                                         purple_account_get_username(account));
328
348
}
329
349
 
366
386
 
367
387
        msg = msn_message_new_from_cmd(cmdproc->session, cmd);
368
388
 
369
 
        msn_message_parse_payload(msg, payload, len);
 
389
        msn_message_parse_payload(msg, payload, len,MSG_LINE_DEM,MSG_BODY_DEM);
370
390
#ifdef MSN_DEBUG_NS
371
391
        msn_message_show_readable(msg, "Notification", TRUE);
372
392
#endif
379
399
static void
380
400
msg_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
381
401
{
 
402
        purple_debug_info("MSNP14","Processing MSG... \n");
 
403
        if(cmd->payload_len == 0){
 
404
                return;
 
405
        }
382
406
        /* NOTE: cmd is not always cmdproc->last_cmd, sometimes cmd is a queued
383
407
         * command and we are processing it */
384
 
 
385
408
        if (cmd->payload == NULL)
386
409
        {
387
410
                cmdproc->last_cmd->payload_cb  = msg_cmd_post;
391
414
        {
392
415
                g_return_if_fail(cmd->payload_cb != NULL);
393
416
 
 
417
                purple_debug_info("MSNP14","MSG payload:{%.*s}\n",cmd->payload_len, cmd->payload);
394
418
                cmd->payload_cb(cmdproc, cmd, cmd->payload, cmd->payload_len);
395
419
        }
396
420
}
397
421
 
 
422
/*send Message to Yahoo Messenger*/
 
423
void
 
424
uum_send_msg(MsnSession *session,MsnMessage *msg)
 
425
{
 
426
        MsnCmdProc *cmdproc;
 
427
        MsnTransaction *trans;
 
428
        char *payload;
 
429
        gsize payload_len;
 
430
        int type;
 
431
        
 
432
        cmdproc = session->notification->cmdproc;
 
433
        g_return_if_fail(msg     != NULL);
 
434
        payload = msn_message_gen_payload(msg, &payload_len);
 
435
        purple_debug_info("MSNP14","send UUM,payload{%s},strlen:%d,len:%d\n",
 
436
                payload,strlen(payload),payload_len);
 
437
        type = msg->type;
 
438
        trans = msn_transaction_new(cmdproc, "UUM","%s 32 %d %d",msg->remote_user,type,payload_len);
 
439
        msn_transaction_set_payload(trans, payload, strlen(payload));
 
440
        msn_cmdproc_send_trans(cmdproc, trans);
 
441
}
 
442
 
 
443
static void
 
444
ubm_cmd_post(MsnCmdProc *cmdproc, MsnCommand *cmd, char *payload,
 
445
                         size_t len)
 
446
{
 
447
        MsnMessage *msg;
 
448
        PurpleConnection *gc;
 
449
        const char *passport;
 
450
        const char *content_type;
 
451
 
 
452
        purple_debug_info("MSNP14","Process UBM payload:%.*s\n", len, payload);
 
453
        msg = msn_message_new_from_cmd(cmdproc->session, cmd);
 
454
 
 
455
        msn_message_parse_payload(msg, payload, len,MSG_LINE_DEM,MSG_BODY_DEM);
 
456
#ifdef MSN_DEBUG_NS
 
457
        msn_message_show_readable(msg, "Notification", TRUE);
 
458
#endif
 
459
 
 
460
        gc = cmdproc->session->account->gc;
 
461
        passport = msg->remote_user;
 
462
 
 
463
        content_type = msn_message_get_content_type(msg);
 
464
        purple_debug_info("MSNP14","type:%d\n",content_type);
 
465
        if(!strcmp(content_type,"text/plain")){
 
466
                const char *value;
 
467
                const char *body;
 
468
                char *body_enc;
 
469
                char *body_final = NULL;
 
470
                size_t body_len;
 
471
 
 
472
                body = msn_message_get_bin_data(msg, &body_len);
 
473
                body_enc = g_markup_escape_text(body, body_len);
 
474
 
 
475
                if ((value = msn_message_get_attr(msg, "X-MMS-IM-Format")) != NULL)     {
 
476
                        char *pre, *post;
 
477
 
 
478
                        msn_parse_format(value, &pre, &post);
 
479
                        body_final = g_strdup_printf("%s%s%s", pre ? pre : "",
 
480
                                                        body_enc ? body_enc : "", post ? post : "");
 
481
                        g_free(pre);
 
482
                        g_free(post);
 
483
                }
 
484
                g_free(body_enc);
 
485
                serv_got_im(gc, passport, body_final, 0, time(NULL));
 
486
                g_free(body_final);
 
487
        }
 
488
        if(!strcmp(content_type,"text/x-msmsgscontrol")){
 
489
                if(msn_message_get_attr(msg, "TypingUser") != NULL){
 
490
                        serv_got_typing(gc, passport, MSN_TYPING_RECV_TIMEOUT,
 
491
                                                PURPLE_TYPING);
 
492
                }
 
493
        }
 
494
        if(!strcmp(content_type,"text/x-msnmsgr-datacast")){
 
495
                char *username, *str;
 
496
                PurpleAccount *account;
 
497
                PurpleBuddy *buddy;
 
498
                const char *user;
 
499
 
 
500
                account = cmdproc->session->account;
 
501
                user = msg->remote_user;
 
502
 
 
503
                if ((buddy = purple_find_buddy(account, user)) != NULL){
 
504
                        username = g_markup_escape_text(purple_buddy_get_alias(buddy), -1);
 
505
                }else{
 
506
                        username = g_markup_escape_text(user, -1);
 
507
                }
 
508
 
 
509
                str = g_strdup_printf(_("%s just sent you a Nudge!"), username);
 
510
                g_free(username);
 
511
                msn_session_report_user(cmdproc->session,user,str,PURPLE_MESSAGE_SYSTEM);
 
512
                g_free(str);
 
513
        }
 
514
        msn_message_destroy(msg);
 
515
}
 
516
 
 
517
/*Yahoo msg process*/
 
518
static void
 
519
ubm_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
520
{
 
521
        purple_debug_info("MSNP14","Processing UBM... \n");
 
522
        if(cmd->payload_len == 0){
 
523
                return;
 
524
        }
 
525
        /* NOTE: cmd is not always cmdproc->last_cmd, sometimes cmd is a queued
 
526
         * command and we are processing it */
 
527
        if (cmd->payload == NULL){
 
528
                cmdproc->last_cmd->payload_cb  = ubm_cmd_post;
 
529
                cmdproc->servconn->payload_len = atoi(cmd->params[2]);
 
530
        }else{
 
531
                g_return_if_fail(cmd->payload_cb != NULL);
 
532
 
 
533
                purple_debug_info("MSNP14","UBM payload:{%.*s}\n", cmd->payload_len, cmd->payload);
 
534
                ubm_cmd_post(cmdproc, cmd, cmd->payload, cmd->payload_len);
 
535
        }
 
536
}
 
537
 
398
538
/**************************************************************************
399
539
 * Challenges
 
540
 *  we use MD5 to caculate the Challenges
400
541
 **************************************************************************/
401
 
 
402
542
static void
403
543
chl_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
404
544
{
405
545
        MsnTransaction *trans;
406
546
        char buf[33];
407
 
        const char *challenge_resp;
408
 
        PurpleCipher *cipher;
409
 
        PurpleCipherContext *context;
410
 
        guchar digest[16];
411
 
        int i;
412
547
 
 
548
#if 0
413
549
        cipher = purple_ciphers_find_cipher("md5");
414
550
        context = purple_cipher_context_new(cipher, NULL);
415
 
 
416
551
        purple_cipher_context_append(context, (const guchar *)cmd->params[1],
417
552
                                                           strlen(cmd->params[1]));
418
 
 
419
 
        challenge_resp = "VT6PX?UQTM4WM%YR";
 
553
        challenge_resp = MSNP13_WLM_PRODUCT_KEY;
420
554
 
421
555
        purple_cipher_context_append(context, (const guchar *)challenge_resp,
422
556
                                                           strlen(challenge_resp));
424
558
        purple_cipher_context_destroy(context);
425
559
 
426
560
        for (i = 0; i < 16; i++)
 
561
        {
427
562
                g_snprintf(buf + (i*2), 3, "%02x", digest[i]);
428
 
 
429
 
        trans = msn_transaction_new(cmdproc, "QRY", "%s 32", "PROD0038W!61ZTF9");
 
563
        }
 
564
#else
 
565
        msn_handle_chl(cmd->params[1], buf);
 
566
#endif
 
567
//      purple_debug_info("MSNP14","<<challenge:{%s}:{%s}\n",cmd->params[1],buf);
 
568
        trans = msn_transaction_new(cmdproc, "QRY", "%s 32", MSNP13_WLM_PRODUCT_ID);
430
569
 
431
570
        msn_transaction_set_payload(trans, buf, 32);
432
571
 
436
575
/**************************************************************************
437
576
 * Buddy Lists
438
577
 **************************************************************************/
439
 
 
440
 
static void
441
 
add_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
442
 
{
443
 
        MsnSession *session;
 
578
/* add contact to xmlnode */
 
579
static void
 
580
msn_add_contact_xml(MsnSession *session, xmlnode *mlNode,const char *passport, MsnListOp list_op, MsnUserType type)
 
581
{
 
582
        xmlnode *d_node,*c_node;
 
583
        char **tokens;
 
584
        const char *email,*domain;
 
585
        char fmt_str[3];
 
586
 
 
587
        g_return_if_fail(passport != NULL);
 
588
 
 
589
        purple_debug_info("MSNP14","Passport: %s, type: %d\n", passport, type);
 
590
        tokens = g_strsplit(passport, "@", 2);
 
591
        email = tokens[0];
 
592
        domain = tokens[1];
 
593
 
 
594
        if (email == NULL || domain == NULL) {
 
595
                purple_debug_error("msn", "Invalid passport (%s) specified to add to contact xml.\n", passport);
 
596
                g_strfreev(tokens);
 
597
                g_return_if_reached();
 
598
        }
 
599
 
 
600
        /*find a domain Node*/
 
601
        for(d_node = xmlnode_get_child(mlNode,"d"); d_node; d_node = xmlnode_get_next_twin(d_node))
 
602
        {
 
603
                const char *attr = xmlnode_get_attrib(d_node,"n");
 
604
                if (attr == NULL)
 
605
                        continue;
 
606
                if (!strcmp(attr,domain))
 
607
                        break;
 
608
        }
 
609
 
 
610
        if(d_node == NULL)
 
611
        {
 
612
                /*domain not found, create a new domain Node*/
 
613
                purple_debug_info("msn", "Didn't find existing domain node, adding one.\n");
 
614
                d_node = xmlnode_new("d");
 
615
                xmlnode_set_attrib(d_node, "n", domain);
 
616
                xmlnode_insert_child(mlNode, d_node);
 
617
        }
 
618
 
 
619
        /*create contact node*/
 
620
        c_node = xmlnode_new("c");
 
621
        xmlnode_set_attrib(c_node, "n", email);
 
622
 
 
623
        purple_debug_info("MSNP14", "list_op: %d\n", list_op);
 
624
        g_snprintf(fmt_str, sizeof(fmt_str), "%d", list_op);
 
625
        xmlnode_set_attrib(c_node, "l", fmt_str);
 
626
 
 
627
        if (type != MSN_USER_TYPE_UNKNOWN)
 
628
                g_snprintf(fmt_str, sizeof(fmt_str), "%d", type);
 
629
        else if (msn_user_is_yahoo(session->account, passport))
 
630
                g_snprintf(fmt_str, sizeof(fmt_str), "%d", MSN_USER_TYPE_YAHOO);
 
631
        else
 
632
                g_snprintf(fmt_str, sizeof(fmt_str), "%d", MSN_USER_TYPE_PASSPORT);
 
633
 
 
634
        /*mobile*/
 
635
        //type_str = g_strdup_printf("4");
 
636
        xmlnode_set_attrib(c_node, "t", fmt_str);
 
637
 
 
638
        xmlnode_insert_child(d_node, c_node);
 
639
 
 
640
        g_strfreev(tokens);
 
641
}
 
642
 
 
643
static void
 
644
msn_notification_post_adl(MsnCmdProc *cmdproc, const char *payload, int payload_len)
 
645
{
 
646
        MsnTransaction *trans;
 
647
        purple_debug_info("MSN Notification","Sending ADL with payload: %s\n", payload);
 
648
        trans = msn_transaction_new(cmdproc, "ADL","%d", strlen(payload));
 
649
        msn_transaction_set_payload(trans, payload, strlen(payload));
 
650
        msn_cmdproc_send_trans(cmdproc, trans);
 
651
}
 
652
 
 
653
/*dump contact info to NS*/
 
654
void
 
655
msn_notification_dump_contact(MsnSession *session)
 
656
{
444
657
        MsnUser *user;
445
 
        const char *list;
446
 
        const char *passport;
447
 
        const char *friendly;
448
 
        MsnListId list_id;
449
 
        int group_id;
450
 
 
451
 
        list     = cmd->params[1];
452
 
        passport = cmd->params[3];
453
 
        friendly = purple_url_decode(cmd->params[4]);
454
 
 
455
 
        session = cmdproc->session;
456
 
 
457
 
        user = msn_userlist_find_user(session->userlist, passport);
458
 
 
459
 
        if (user == NULL)
460
 
        {
461
 
                user = msn_user_new(session->userlist, passport, friendly);
462
 
                msn_userlist_add_user(session->userlist, user);
463
 
        }
464
 
        else
465
 
                msn_user_set_friendly_name(user, friendly);
466
 
 
467
 
        list_id = msn_get_list_id(list);
468
 
 
469
 
        if (cmd->param_count >= 6)
470
 
                group_id = atoi(cmd->params[5]);
471
 
        else
472
 
                group_id = -1;
473
 
 
474
 
        msn_got_add_user(session, user, list_id, group_id);
475
 
        msn_user_update(user);
 
658
        GList *l;
 
659
        xmlnode *adl_node;
 
660
        char *payload;
 
661
        int payload_len;
 
662
        int adl_count = 0;
 
663
        const char *display_name;
 
664
 
 
665
        adl_node = xmlnode_new("ml");
 
666
        adl_node->child = NULL;
 
667
        xmlnode_set_attrib(adl_node, "l", "1");
 
668
 
 
669
        /*get the userlist*/
 
670
        for (l = session->userlist->users; l != NULL; l = l->next){
 
671
                user = l->data;
 
672
 
 
673
                /* skip RL & PL during initial dump */
 
674
                if (!(user->list_op & MSN_LIST_OP_MASK))
 
675
                        continue;
 
676
 
 
677
                msn_add_contact_xml(session, adl_node, user->passport,
 
678
                        user->list_op & MSN_LIST_OP_MASK, user->type);
 
679
 
 
680
                /* each ADL command may contain up to 150 contacts */
 
681
                if (++adl_count % 150 == 0 || l->next == NULL) {
 
682
                        payload = xmlnode_to_str(adl_node,&payload_len);
 
683
 
 
684
                        msn_notification_post_adl(session->notification->cmdproc,
 
685
                                payload, payload_len);
 
686
 
 
687
                        g_free(payload);
 
688
                        xmlnode_free(adl_node);
 
689
 
 
690
                        if (l->next) {
 
691
                                adl_node = xmlnode_new("ml");
 
692
                                adl_node->child = NULL;
 
693
                                xmlnode_set_attrib(adl_node, "l", "1");
 
694
                        }
 
695
                }
 
696
        }
 
697
 
 
698
        if (adl_count == 0) {
 
699
                payload = xmlnode_to_str(adl_node,&payload_len);
 
700
 
 
701
                msn_notification_post_adl(session->notification->cmdproc, payload, payload_len);
 
702
 
 
703
                g_free(payload);
 
704
                xmlnode_free(adl_node);
 
705
        }
 
706
 
 
707
        display_name = purple_connection_get_display_name(session->account->gc);
 
708
        if (display_name 
 
709
            && strcmp(display_name, 
 
710
                      purple_account_get_username(session->account))) {
 
711
                msn_act_id(session->account->gc, display_name);
 
712
        }
 
713
 
 
714
}
 
715
 
 
716
/*Post FQY to NS,Inform add a Yahoo User*/
 
717
void
 
718
msn_notification_send_fqy(MsnSession *session, const char *passport)
 
719
{
 
720
        MsnTransaction *trans;
 
721
        MsnCmdProc *cmdproc;
 
722
        char* email,*domain,*payload;
 
723
        char **tokens;
 
724
 
 
725
        cmdproc = session->notification->cmdproc;
 
726
 
 
727
        tokens = g_strsplit(passport, "@", 2);
 
728
        email = tokens[0];
 
729
        domain = tokens[1];
 
730
 
 
731
        payload = g_strdup_printf("<ml><d n=\"%s\"><c n=\"%s\"/></d></ml>", domain, email);
 
732
        trans = msn_transaction_new(cmdproc, "FQY","%d", strlen(payload));
 
733
        msn_transaction_set_payload(trans, payload, strlen(payload));
 
734
        msn_cmdproc_send_trans(cmdproc, trans);
 
735
 
 
736
        g_free(payload);
 
737
        g_strfreev(tokens);
 
738
}
 
739
 
 
740
static void
 
741
blp_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
742
{
 
743
}
 
744
 
 
745
static void
 
746
adl_cmd_parse(MsnCmdProc *cmdproc, MsnCommand *cmd, char *payload,
 
747
                                         size_t len)
 
748
{
 
749
        xmlnode *root, *domain_node;
 
750
 
 
751
        purple_debug_misc("MSN Notification", "Parsing received ADL XML data\n");
 
752
 
 
753
        g_return_if_fail(payload != NULL);
 
754
        
 
755
        root = xmlnode_from_str(payload, (gssize) len);
 
756
        
 
757
        if (root == NULL) {
 
758
                purple_debug_info("MSN Notification", "Invalid XML!\n");
 
759
                return;
 
760
        }
 
761
        for (domain_node = xmlnode_get_child(root, "d"); domain_node; domain_node = xmlnode_get_next_twin(domain_node)) {
 
762
                const gchar * domain = NULL; 
 
763
                xmlnode *contact_node = NULL;
 
764
 
 
765
                domain = xmlnode_get_attrib(domain_node, "n");
 
766
 
 
767
                for (contact_node = xmlnode_get_child(domain_node, "c"); contact_node; contact_node = xmlnode_get_next_twin(contact_node)) {
 
768
//                      gchar *name = NULL, *friendlyname = NULL, *passport= NULL;
 
769
                        const gchar *list;
 
770
                        gint list_op = 0;
 
771
 
 
772
//                      name = xmlnode_get_attrib(contact_node, "n");
 
773
                        list = xmlnode_get_attrib(contact_node, "l");
 
774
                        if (list != NULL) {
 
775
                                list_op = atoi(list);
 
776
                        }
 
777
//                      friendlyname = xmlnode_get_attrib(contact_node, "f");
 
778
 
 
779
//                      passport = g_strdup_printf("%s@%s", name, domain);
 
780
 
 
781
//                      if (friendlyname != NULL) {
 
782
//                              decoded_friendlyname = g_strdup(purple_url_decode(friendlyname));
 
783
//                      } else {
 
784
//                              decoded_friendlyname = g_strdup(passport);
 
785
//                      }
 
786
 
 
787
                        if (list_op & MSN_LIST_RL_OP) {
 
788
                                /* someone is adding us */
 
789
//                              got_new_entry(cmdproc->session->account->gc, passport, decoded_friendly_name);
 
790
                                msn_get_contact_list(cmdproc->session->contact, MSN_PS_PENDING_LIST, NULL);
 
791
                        }
 
792
 
 
793
//                      g_free(decoded_friendly_name);
 
794
//                      g_free(passport);
 
795
                }
 
796
        }
 
797
 
 
798
        xmlnode_free(root);
 
799
}
 
800
 
 
801
static void
 
802
adl_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
803
{
 
804
        MsnSession *session;
 
805
 
 
806
        g_return_if_fail(cmdproc != NULL);
 
807
        g_return_if_fail(cmdproc->session != NULL);
 
808
        g_return_if_fail(cmdproc->last_cmd != NULL);
 
809
        g_return_if_fail(cmd != NULL);
 
810
 
 
811
        session = cmdproc->session;
 
812
 
 
813
        if ( !strcmp(cmd->params[1], "OK")) {
 
814
                /* ADL ack */
 
815
                msn_session_finish_login(session);
 
816
        } else {
 
817
                cmdproc->last_cmd->payload_cb = adl_cmd_parse;
 
818
        }
 
819
 
 
820
        return;
 
821
}
 
822
 
 
823
static void
 
824
adl_error(MsnCmdProc *cmdproc, MsnTransaction *trans, int error)
 
825
{
 
826
        MsnSession *session;
 
827
        PurpleAccount *account;
 
828
        PurpleConnection *gc;
 
829
        char *reason = NULL;
 
830
 
 
831
        session = cmdproc->session;
 
832
        account = session->account;
 
833
        gc = purple_account_get_connection(account);
 
834
 
 
835
        purple_debug_error("msn","ADL error\n");
 
836
        reason = g_strdup_printf(_("Unknown error (%d)"), error);
 
837
        purple_notify_error(gc, NULL, _("Unable to add user"), reason);
 
838
        g_free(reason);
 
839
}
 
840
 
 
841
static void
 
842
fqy_cmd_post(MsnCmdProc *cmdproc, MsnCommand *cmd, char *payload,
 
843
                         size_t len)
 
844
{
 
845
        purple_debug_info("MSN Notification","FQY payload:\n%s\n", payload);
 
846
        g_return_if_fail(cmdproc->session != NULL);
 
847
        g_return_if_fail(cmdproc->session->contact != NULL);
 
848
//      msn_notification_post_adl(cmdproc, payload, len);
 
849
//      msn_get_address_book(cmdproc->session->contact, MSN_AB_SAVE_CONTACT, NULL, NULL);
 
850
}
 
851
 
 
852
static void
 
853
fqy_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
854
{
 
855
        purple_debug_info("MSNP14","Process FQY\n");
 
856
        cmdproc->last_cmd->payload_cb = fqy_cmd_post;
 
857
}
 
858
 
 
859
static void
 
860
rml_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
861
{
 
862
#if 0
 
863
        MsnTransaction *trans;
 
864
        char * payload;
 
865
#endif
 
866
 
 
867
        purple_debug_info("MSNP14","Process RML\n");
 
868
#if 0
 
869
        trans = msn_transaction_new(cmdproc, "RML","");
 
870
 
 
871
        msn_transaction_set_payload(trans, payload, strlen(payload));
 
872
 
 
873
        msn_cmdproc_send_trans(cmdproc, trans);
 
874
#endif
476
875
}
477
876
 
478
877
static void
567
966
 
568
967
        group_name = purple_url_decode(cmd->params[2]);
569
968
 
570
 
        msn_group_new(session->userlist, group_id, group_name);
 
969
        msn_group_new(session->userlist, cmd->params[3], group_name);
571
970
 
572
 
        /* There is a user that must me moved to this group */
 
971
        /* There is a user that must be moved to this group */
573
972
        if (cmd->trans->data)
574
973
        {
575
974
                /* msn_userlist_move_buddy(); */
576
975
                MsnUserList *userlist = cmdproc->session->userlist;
577
 
                MsnMoveBuddy *data = cmd->trans->data;
 
976
                MsnCallbackState *data = cmd->trans->data;
578
977
 
579
978
                if (data->old_group_name != NULL)
580
979
                {
581
 
                        msn_userlist_rem_buddy(userlist, data->who, MSN_LIST_FL, data->old_group_name);
 
980
                        msn_userlist_move_buddy(userlist, data->who, data->old_group_name, group_name);
582
981
                        g_free(data->old_group_name);
 
982
                } else {
 
983
                        // msn_add_contact_to_group(userlist, data, data->who, group_name);
583
984
                }
584
 
 
585
 
                msn_userlist_add_buddy(userlist, data->who, MSN_LIST_FL, group_name);
586
 
                g_free(data->who);
587
 
 
588
985
        }
589
986
}
590
987
 
642
1039
        PurpleConnection *gc;
643
1040
        MsnUser *user;
644
1041
        MsnObject *msnobj;
 
1042
        int wlmclient;
645
1043
        const char *state, *passport, *friendly;
646
1044
 
647
1045
        session = cmdproc->session;
650
1048
 
651
1049
        state    = cmd->params[1];
652
1050
        passport = cmd->params[2];
653
 
        friendly = purple_url_decode(cmd->params[3]);
 
1051
        /*if a contact is actually on the WLM part or the yahoo part*/
 
1052
        wlmclient = atoi(cmd->params[3]);
 
1053
        friendly = purple_url_decode(cmd->params[4]);
654
1054
 
655
1055
        user = msn_userlist_find_user(session->userlist, passport);
656
1056
 
658
1058
 
659
1059
        msn_user_set_friendly_name(user, friendly);
660
1060
 
661
 
        if (session->protocol_ver >= 9 && cmd->param_count == 6)
 
1061
        if (session->protocol_ver >= 9 && cmd->param_count == 8)
662
1062
        {
663
 
                msnobj = msn_object_new_from_string(purple_url_decode(cmd->params[5]));
 
1063
                msnobj = msn_object_new_from_string(purple_url_decode(cmd->params[6]));
664
1064
                msn_user_set_object(user, msnobj);
665
1065
        }
666
1066
 
692
1092
        MsnUser *user;
693
1093
        MsnObject *msnobj;
694
1094
        int clientid;
 
1095
        int wlmclient;
695
1096
        const char *state, *passport, *friendly, *old_friendly;
696
1097
 
697
1098
        session = cmdproc->session;
700
1101
 
701
1102
        state    = cmd->params[0];
702
1103
        passport = cmd->params[1];
703
 
        friendly = purple_url_decode(cmd->params[2]);
 
1104
        wlmclient = atoi(cmd->params[2]);
 
1105
        friendly = purple_url_decode(cmd->params[3]);
704
1106
 
705
1107
        user = msn_userlist_find_user(session->userlist, passport);
706
1108
 
713
1115
 
714
1116
        if (session->protocol_ver >= 9)
715
1117
        {
716
 
                if (cmd->param_count == 5)
 
1118
                if (cmd->param_count == 7)
717
1119
                {
718
 
                        msnobj =
719
 
                                msn_object_new_from_string(purple_url_decode(cmd->params[4]));
 
1120
                        msnobj = msn_object_new_from_string(purple_url_decode(cmd->params[5]));
720
1121
                        msn_user_set_object(user, msnobj);
721
1122
                }
722
1123
                else
725
1126
                }
726
1127
        }
727
1128
 
728
 
        clientid = atoi(cmd->params[3]);
 
1129
        clientid = atoi(cmd->params[4]);
729
1130
        user->mobile = (clientid & MSN_CLIENT_CAP_MSNMOBILE);
730
1131
 
731
1132
        msn_user_set_state(user, state);
780
1181
static void
781
1182
rea_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
782
1183
{
783
 
        /* TODO: This might be for us too */
784
 
 
785
1184
        MsnSession *session;
 
1185
        PurpleAccount *account;
786
1186
        PurpleConnection *gc;
787
1187
        const char *friendly;
 
1188
        char *username;
788
1189
 
789
1190
        session = cmdproc->session;
790
 
        gc = session->account->gc;
 
1191
        account = session->account;
 
1192
        username = g_strdup(purple_normalize(account,
 
1193
                                                purple_account_get_username(account)));
 
1194
 
 
1195
        /* Only set display name if our *own* friendly name changed! */
 
1196
        if (strcmp(username, purple_normalize(account, cmd->params[2])))
 
1197
        {
 
1198
                g_free(username);
 
1199
                return;
 
1200
        }
 
1201
 
 
1202
        g_free(username);
 
1203
 
 
1204
        gc = account->gc;
791
1205
        friendly = purple_url_decode(cmd->params[3]);
792
1206
 
793
1207
        purple_connection_set_display_name(gc, friendly);
797
1211
prp_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
798
1212
{
799
1213
        MsnSession *session = cmdproc->session;
800
 
        const char *type, *value;
 
1214
        const char *type, *value, *friendlyname;
801
1215
 
802
1216
        g_return_if_fail(cmd->param_count >= 3);
803
1217
 
821
1235
                        msn_user_set_work_phone(session->user, NULL);
822
1236
                else if (!strcmp(type, "PHM"))
823
1237
                        msn_user_set_mobile_phone(session->user, NULL);
 
1238
                else {
 
1239
                        type = cmd->params[1];
 
1240
                        if (!strcmp(type, "MFN")) {
 
1241
                                friendlyname = purple_url_decode(cmd->params[2]);
 
1242
                                
 
1243
                                msn_update_contact(session->contact, friendlyname);
 
1244
 
 
1245
                                purple_connection_set_display_name(
 
1246
                                        purple_account_get_connection(session->account),
 
1247
                                        friendlyname);
 
1248
                        }
 
1249
                }
824
1250
        }
825
1251
}
826
1252
 
828
1254
reg_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
829
1255
{
830
1256
        MsnSession *session;
831
 
        int group_id;
832
 
        const char *group_name;
 
1257
        const char *group_id, *group_name;
833
1258
 
834
1259
        session = cmdproc->session;
835
 
        group_id = atoi(cmd->params[2]);
 
1260
        group_id = cmd->params[2];
836
1261
        group_name = purple_url_decode(cmd->params[3]);
837
1262
 
838
1263
        msn_userlist_rename_group_id(session->userlist, group_id, group_name);
841
1266
static void
842
1267
reg_error(MsnCmdProc *cmdproc, MsnTransaction *trans, int error)
843
1268
{
844
 
        int group_id;
 
1269
        const char * group_id;
845
1270
        char **params;
846
1271
 
847
1272
        params = g_strsplit(trans->params, " ", 0);
848
1273
 
849
 
        group_id = atoi(params[0]);
 
1274
        group_id = params[0];
850
1275
 
851
1276
        group_error_helper(cmdproc->session, _("Unable to rename group"), group_id, error);
852
1277
 
853
1278
        g_strfreev(params);
854
1279
}
855
1280
 
 
1281
#if 0
856
1282
static void
857
1283
rem_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
858
1284
{
859
1285
        MsnSession *session;
860
1286
        MsnUser *user;
861
 
        const char *list;
862
 
        const char *passport;
 
1287
        const char *group_id, *list, *passport;
863
1288
        MsnListId list_id;
864
 
        int group_id;
865
1289
 
866
1290
        session = cmdproc->session;
867
1291
        list = cmd->params[1];
873
1297
        list_id = msn_get_list_id(list);
874
1298
 
875
1299
        if (cmd->param_count == 5)
876
 
                group_id = atoi(cmd->params[4]);
 
1300
                group_id = cmd->params[4];
877
1301
        else
878
 
                group_id = -1;
 
1302
                group_id = NULL;
879
1303
 
880
1304
        msn_got_rem_user(session, user, list_id, group_id);
881
1305
        msn_user_update(user);
882
1306
}
 
1307
#endif
883
1308
 
884
1309
static void
885
1310
rmg_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
886
1311
{
887
1312
        MsnSession *session;
888
 
        int group_id;
 
1313
        const char *group_id;
889
1314
 
890
1315
        session = cmdproc->session;
891
 
        group_id = atoi(cmd->params[2]);
 
1316
        group_id = cmd->params[2];
892
1317
 
893
1318
        msn_userlist_remove_group_id(session->userlist, group_id);
894
1319
}
896
1321
static void
897
1322
rmg_error(MsnCmdProc *cmdproc, MsnTransaction *trans, int error)
898
1323
{
899
 
        int group_id;
 
1324
        const char *group_id;
900
1325
        char **params;
901
1326
 
902
1327
        params = g_strsplit(trans->params, " ", 0);
903
1328
 
904
 
        group_id = atoi(params[0]);
 
1329
        group_id = params[0];
905
1330
 
906
1331
        group_error_helper(cmdproc->session, _("Unable to delete group"), group_id, error);
907
1332
 
908
1333
        g_strfreev(params);
909
1334
}
910
1335
 
 
1336
#if 0
911
1337
static void
912
1338
syn_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
913
1339
{
938
1364
        session->sync = sync;
939
1365
        cmdproc->cbs_table = sync->cbs_table;
940
1366
}
 
1367
#endif
941
1368
 
942
1369
/**************************************************************************
943
1370
 * Misc commands
997
1424
        {
998
1425
                purple_debug_error("msn",
999
1426
                                                 "Error opening temp passport file: %s\n",
1000
 
                                                 strerror(errno));
 
1427
                                                 g_strerror(errno));
1001
1428
        }
1002
1429
        else
1003
1430
        {
1046
1473
                {
1047
1474
                        purple_debug_error("msn",
1048
1475
                                                         "Error closing temp passport file: %s\n",
1049
 
                                                         strerror(errno));
 
1476
                                                         g_strerror(errno));
1050
1477
 
1051
1478
                        g_unlink(session->passport_info.file);
1052
1479
                        g_free(session->passport_info.file);
1146
1573
        g_free(host);
1147
1574
}
1148
1575
 
 
1576
static void
 
1577
gcf_cmd_post(MsnCmdProc *cmdproc, MsnCommand *cmd, char *payload,
 
1578
                         size_t len)
 
1579
{
 
1580
        xmlnode * root;
 
1581
        gchar * buf;
 
1582
 
 
1583
        g_return_if_fail(cmd->payload != NULL);
 
1584
 
 
1585
        if ( (root = xmlnode_from_str(cmd->payload, cmd->payload_len)) == NULL)
 
1586
        {
 
1587
                purple_debug_error("MSN","Unable to parse GCF payload into a XML tree");
 
1588
                return;
 
1589
        }
 
1590
        
 
1591
        buf = xmlnode_to_formatted_str(root, NULL);
 
1592
 
 
1593
        /* get the payload content */
 
1594
        purple_debug_info("MSNP14","GCF command payload:\n%s\n",buf);
 
1595
        
 
1596
        g_free(buf);
 
1597
        xmlnode_free(root);
 
1598
}
 
1599
 
 
1600
static void
 
1601
gcf_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
1602
{
 
1603
        purple_debug_info("MSNP14","Processing GCF command\n");
 
1604
        cmdproc->last_cmd->payload_cb  = gcf_cmd_post;
 
1605
        return;
 
1606
}
 
1607
 
 
1608
static void
 
1609
sbs_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
1610
{
 
1611
        purple_debug_info("MSNP14","Processing SBS... \n");
 
1612
        if(cmd->payload_len == 0){
 
1613
                return;
 
1614
        }
 
1615
        /*get the payload content*/
 
1616
}
 
1617
 
 
1618
/*
 
1619
 * Get the UBX's PSM info
 
1620
 * Post it to the User status
 
1621
 * Thanks for Chris <ukdrizzle@yahoo.co.uk>'s code
 
1622
 */
 
1623
static void
 
1624
ubx_cmd_post(MsnCmdProc *cmdproc, MsnCommand *cmd, char *payload,
 
1625
                         size_t len)
 
1626
{
 
1627
        MsnSession *session;
 
1628
        PurpleAccount *account;
 
1629
        MsnUser *user;
 
1630
        const char *passport;
 
1631
        char *psm_str, *str;
 
1632
        CurrentMedia media = {NULL, NULL, NULL};
 
1633
 
 
1634
        session = cmdproc->session;
 
1635
        account = session->account;
 
1636
 
 
1637
        passport = cmd->params[0];
 
1638
        user = msn_userlist_find_user(session->userlist, passport);
 
1639
        
 
1640
        psm_str = msn_get_psm(cmd->payload,len);
 
1641
        msn_user_set_statusline(user, psm_str);
 
1642
        g_free(psm_str);
 
1643
 
 
1644
        str = msn_get_currentmedia(cmd->payload, len);
 
1645
        if (msn_parse_currentmedia(str, &media))
 
1646
                msn_user_set_currentmedia(user, &media);
 
1647
        else
 
1648
                msn_user_set_currentmedia(user, NULL);
 
1649
        g_free(str);
 
1650
 
 
1651
        msn_user_update(user);
 
1652
}
 
1653
 
 
1654
static void
 
1655
ubx_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
1656
{
 
1657
        purple_debug_misc("MSNP14","UBX received.\n");
 
1658
        if(cmd->payload_len == 0){
 
1659
                return;
 
1660
        }
 
1661
        cmdproc->last_cmd->payload_cb  = ubx_cmd_post;
 
1662
}
 
1663
 
 
1664
static void
 
1665
uux_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
 
1666
{
 
1667
        purple_debug_misc("MSNP14","UUX received.\n");
 
1668
}
 
1669
 
1149
1670
/**************************************************************************
1150
1671
 * Message Types
1151
1672
 **************************************************************************/
1155
1676
{
1156
1677
        MsnSession *session;
1157
1678
        const char *value;
 
1679
        const char *clLastChange;
1158
1680
 
1159
1681
        session = cmdproc->session;
1160
1682
 
1187
1709
        }
1188
1710
 
1189
1711
        if ((value = msn_message_get_attr(msg, "ClientPort")) != NULL)
 
1712
        {
1190
1713
                session->passport_info.client_port = ntohs(atoi(value));
 
1714
        }
1191
1715
 
1192
1716
        if ((value = msn_message_get_attr(msg, "LoginTime")) != NULL)
1193
1717
                session->passport_info.sl = atol(value);
 
1718
 
 
1719
        /*starting retrieve the contact list*/
 
1720
        clLastChange = purple_account_get_string(session->account, "CLLastChange", NULL);
 
1721
        session->contact = msn_contact_new(session);
 
1722
#ifdef MSN_PARTIAL_LISTS
 
1723
        /* msn_userlist_load defeats all attempts at trying to detect blist sync issues */
 
1724
        msn_userlist_load(session);
 
1725
        msn_get_contact_list(session->contact, MSN_PS_INITIAL, clLastChange);
 
1726
#else
 
1727
        /* always get the full list? */
 
1728
        msn_get_contact_list(session->contact, MSN_PS_INITIAL, NULL);
 
1729
#endif
 
1730
#if 0
 
1731
        msn_contact_connect(session->contact);
 
1732
#endif
1194
1733
}
1195
1734
 
1196
1735
static void
1246
1785
        g_hash_table_destroy(table);
1247
1786
}
1248
1787
 
 
1788
/*offline Message notification process*/
 
1789
static void
 
1790
initial_mdata_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
 
1791
{
 
1792
        MsnSession *session;
 
1793
        PurpleConnection *gc;
 
1794
        GHashTable *table;
 
1795
        const char *mdata, *unread;
 
1796
 
 
1797
        session = cmdproc->session;
 
1798
        gc = session->account->gc;
 
1799
 
 
1800
        if (strcmp(msg->remote_user, "Hotmail"))
 
1801
                /* This isn't an official message. */
 
1802
                return;
 
1803
 
 
1804
        /*new a oim session*/
 
1805
//      session->oim = msn_oim_new(session);
 
1806
//      msn_oim_connect(session->oim);
 
1807
 
 
1808
        table = msn_message_get_hashtable_from_body(msg);
 
1809
 
 
1810
        mdata = g_hash_table_lookup(table, "Mail-Data");
 
1811
 
 
1812
        if (mdata != NULL)
 
1813
                msn_parse_oim_msg(session->oim, mdata);
 
1814
 
 
1815
        if (g_hash_table_lookup(table, "Inbox-URL") == NULL)
 
1816
        {
 
1817
                g_hash_table_destroy(table);
 
1818
                return;
 
1819
        }
 
1820
 
 
1821
        if (session->passport_info.file == NULL)
 
1822
        {
 
1823
                MsnTransaction *trans;
 
1824
                trans = msn_transaction_new(cmdproc, "URL", "%s", "INBOX");
 
1825
                msn_transaction_queue_cmd(trans, msg->cmd);
 
1826
 
 
1827
                msn_cmdproc_send_trans(cmdproc, trans);
 
1828
 
 
1829
                g_hash_table_destroy(table);
 
1830
                return;
 
1831
        }
 
1832
 
 
1833
        if (!purple_account_get_check_mail(session->account))
 
1834
        {
 
1835
                g_hash_table_destroy(table);
 
1836
                return;
 
1837
        }
 
1838
 
 
1839
        unread = g_hash_table_lookup(table, "Inbox-Unread");
 
1840
 
 
1841
        if (unread != NULL)
 
1842
        {
 
1843
                int count = atoi(unread);
 
1844
 
 
1845
                if (count > 0)
 
1846
                {
 
1847
                        const char *passport;
 
1848
                        const char *url;
 
1849
 
 
1850
                        passport = msn_user_get_passport(session->user);
 
1851
                        url = session->passport_info.file;
 
1852
 
 
1853
                        purple_notify_emails(gc, atoi(unread), FALSE, NULL, NULL,
 
1854
                                                           &passport, &url, NULL, NULL);
 
1855
                }
 
1856
        }
 
1857
 
 
1858
        g_hash_table_destroy(table);
 
1859
}
 
1860
 
 
1861
/*offline Message Notification*/
 
1862
static void
 
1863
delete_oim_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
 
1864
{
 
1865
        purple_debug_misc("MSN Notification","Delete OIM message.\n");
 
1866
}
 
1867
 
1249
1868
static void
1250
1869
email_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
1251
1870
{
1347
1966
}
1348
1967
 
1349
1968
void
1350
 
msn_notification_add_buddy(MsnNotification *notification, const char *list,
1351
 
                                                   const char *who, const char *store_name,
1352
 
                                                   int group_id)
 
1969
msn_notification_add_buddy_to_list(MsnNotification *notification, MsnListId list_id,
 
1970
                                                          const char *who)
1353
1971
{
1354
1972
        MsnCmdProc *cmdproc;
 
1973
        MsnListOp list_op = 1 << list_id;
 
1974
        xmlnode *adl_node;
 
1975
        char *payload;
 
1976
        int payload_len;
 
1977
 
1355
1978
        cmdproc = notification->servconn->cmdproc;
1356
1979
 
1357
 
        if (group_id < 0 && !strcmp(list, "FL"))
1358
 
                group_id = 0;
1359
 
 
1360
 
        if (group_id >= 0)
1361
 
        {
1362
 
                msn_cmdproc_send(cmdproc, "ADD", "%s %s %s %d",
1363
 
                                                 list, who, store_name, group_id);
1364
 
        }
1365
 
        else
1366
 
        {
1367
 
                msn_cmdproc_send(cmdproc, "ADD", "%s %s %s", list, who, store_name);
1368
 
        }
 
1980
        adl_node = xmlnode_new("ml");
 
1981
        adl_node->child = NULL;
 
1982
 
 
1983
        msn_add_contact_xml(notification->session, adl_node, who, list_op, 
 
1984
                                                MSN_USER_TYPE_PASSPORT);
 
1985
 
 
1986
        payload = xmlnode_to_str(adl_node,&payload_len);
 
1987
        xmlnode_free(adl_node);
 
1988
        
 
1989
        msn_notification_post_adl(notification->servconn->cmdproc,
 
1990
                                                payload,payload_len);
 
1991
        g_free(payload);
1369
1992
}
1370
1993
 
1371
1994
void
1372
 
msn_notification_rem_buddy(MsnNotification *notification, const char *list,
1373
 
                                                   const char *who, int group_id)
 
1995
msn_notification_rem_buddy_from_list(MsnNotification *notification, MsnListId list_id,
 
1996
                                                   const char *who)
1374
1997
{
1375
1998
        MsnCmdProc *cmdproc;
 
1999
        MsnTransaction *trans;
 
2000
        MsnListOp list_op = 1 << list_id;
 
2001
        xmlnode *rml_node;
 
2002
        char *payload;
 
2003
        int payload_len;
 
2004
 
1376
2005
        cmdproc = notification->servconn->cmdproc;
1377
2006
 
1378
 
        if (group_id >= 0)
1379
 
        {
1380
 
                msn_cmdproc_send(cmdproc, "REM", "%s %s %d", list, who, group_id);
1381
 
        }
1382
 
        else
1383
 
        {
1384
 
                msn_cmdproc_send(cmdproc, "REM", "%s %s", list, who);
1385
 
        }
 
2007
        rml_node = xmlnode_new("ml");
 
2008
        rml_node->child = NULL;
 
2009
 
 
2010
        msn_add_contact_xml(notification->session, rml_node, who, list_op, MSN_USER_TYPE_PASSPORT);
 
2011
 
 
2012
        payload = xmlnode_to_str(rml_node, &payload_len);
 
2013
        xmlnode_free(rml_node);
 
2014
 
 
2015
        purple_debug_info("MSN Notification","Send RML with payload:\n%s\n", payload);
 
2016
        trans = msn_transaction_new(cmdproc, "RML","%d", strlen(payload));
 
2017
        msn_transaction_set_payload(trans, payload, strlen(payload));
 
2018
        msn_cmdproc_send_trans(cmdproc, trans);
 
2019
        g_free(payload);
1386
2020
}
1387
2021
 
1388
2022
/**************************************************************************
1389
2023
 * Init
1390
2024
 **************************************************************************/
1391
 
 
1392
2025
void
1393
2026
msn_notification_init(void)
1394
2027
{
1399
2032
        /* Synchronous */
1400
2033
        msn_table_add_cmd(cbs_table, "CHG", "CHG", NULL);
1401
2034
        msn_table_add_cmd(cbs_table, "CHG", "ILN", iln_cmd);
1402
 
        msn_table_add_cmd(cbs_table, "ADD", "ADD", add_cmd);
1403
 
        msn_table_add_cmd(cbs_table, "ADD", "ILN", iln_cmd);
1404
 
        msn_table_add_cmd(cbs_table, "REM", "REM", rem_cmd);
 
2035
        msn_table_add_cmd(cbs_table, "ADL", "ILN", iln_cmd);
 
2036
//      msn_table_add_cmd(cbs_table, "REM", "REM", rem_cmd);    /* Removed as of MSNP13 */
1405
2037
        msn_table_add_cmd(cbs_table, "USR", "USR", usr_cmd);
1406
2038
        msn_table_add_cmd(cbs_table, "USR", "XFR", xfr_cmd);
1407
 
        msn_table_add_cmd(cbs_table, "SYN", "SYN", syn_cmd);
 
2039
        msn_table_add_cmd(cbs_table, "USR", "GCF", gcf_cmd);
 
2040
//      msn_table_add_cmd(cbs_table, "SYN", "SYN", syn_cmd);    /* Removed as of MSNP13 */
1408
2041
        msn_table_add_cmd(cbs_table, "CVR", "CVR", cvr_cmd);
1409
2042
        msn_table_add_cmd(cbs_table, "VER", "VER", ver_cmd);
1410
2043
        msn_table_add_cmd(cbs_table, "REA", "REA", rea_cmd);
1411
2044
        msn_table_add_cmd(cbs_table, "PRP", "PRP", prp_cmd);
1412
 
        /* msn_table_add_cmd(cbs_table, "BLP", "BLP", blp_cmd); */
1413
 
        msn_table_add_cmd(cbs_table, "BLP", "BLP", NULL);
 
2045
        msn_table_add_cmd(cbs_table, "BLP", "BLP", blp_cmd);
 
2046
//      msn_table_add_cmd(cbs_table, "BLP", "BLP", NULL);
1414
2047
        msn_table_add_cmd(cbs_table, "REG", "REG", reg_cmd);
1415
2048
        msn_table_add_cmd(cbs_table, "ADG", "ADG", adg_cmd);
1416
2049
        msn_table_add_cmd(cbs_table, "RMG", "RMG", rmg_cmd);
1419
2052
        /* Asynchronous */
1420
2053
        msn_table_add_cmd(cbs_table, NULL, "IPG", ipg_cmd);
1421
2054
        msn_table_add_cmd(cbs_table, NULL, "MSG", msg_cmd);
 
2055
        msn_table_add_cmd(cbs_table, NULL, "UBM", ubm_cmd);
 
2056
        msn_table_add_cmd(cbs_table, NULL, "GCF", gcf_cmd);
 
2057
        msn_table_add_cmd(cbs_table, NULL, "SBS", sbs_cmd);
1422
2058
        msn_table_add_cmd(cbs_table, NULL, "NOT", not_cmd);
1423
2059
 
1424
2060
        msn_table_add_cmd(cbs_table, NULL, "CHL", chl_cmd);
1425
 
        msn_table_add_cmd(cbs_table, NULL, "REM", rem_cmd);
1426
 
        msn_table_add_cmd(cbs_table, NULL, "ADD", add_cmd);
 
2061
        msn_table_add_cmd(cbs_table, NULL, "RML", rml_cmd);
 
2062
        msn_table_add_cmd(cbs_table, NULL, "ADL", adl_cmd);
 
2063
        msn_table_add_cmd(cbs_table, NULL, "FQY", fqy_cmd);
1427
2064
 
1428
2065
        msn_table_add_cmd(cbs_table, NULL, "QRY", NULL);
1429
2066
        msn_table_add_cmd(cbs_table, NULL, "QNG", qng_cmd);
1433
2070
        msn_table_add_cmd(cbs_table, NULL, "OUT", out_cmd);
1434
2071
        msn_table_add_cmd(cbs_table, NULL, "RNG", rng_cmd);
1435
2072
 
 
2073
        msn_table_add_cmd(cbs_table, NULL, "UBX", ubx_cmd);
 
2074
        msn_table_add_cmd(cbs_table, NULL, "UUX", uux_cmd);
 
2075
 
1436
2076
        msn_table_add_cmd(cbs_table, NULL, "URL", url_cmd);
1437
2077
 
1438
2078
        msn_table_add_cmd(cbs_table, "fallback", "XFR", xfr_cmd);
1439
2079
 
1440
2080
        msn_table_add_error(cbs_table, "ADD", add_error);
 
2081
        msn_table_add_error(cbs_table, "ADL", adl_error);
1441
2082
        msn_table_add_error(cbs_table, "REG", reg_error);
1442
2083
        msn_table_add_error(cbs_table, "RMG", rmg_error);
1443
2084
        /* msn_table_add_error(cbs_table, "REA", rea_error); */
1446
2087
        msn_table_add_msg_type(cbs_table,
1447
2088
                                                   "text/x-msmsgsprofile",
1448
2089
                                                   profile_msg);
 
2090
        /*initial OIM notification*/
 
2091
        msn_table_add_msg_type(cbs_table,
 
2092
                                                        "text/x-msmsgsinitialmdatanotification",
 
2093
                                                        initial_mdata_msg);     
 
2094
        /*OIM notification when user online*/
 
2095
        msn_table_add_msg_type(cbs_table,
 
2096
                                                        "text/x-msmsgsoimnotification",
 
2097
                                                        initial_mdata_msg);     
1449
2098
        msn_table_add_msg_type(cbs_table,
1450
2099
                                                   "text/x-msmsgsinitialemailnotification",
1451
2100
                                                   initial_email_msg);
1452
2101
        msn_table_add_msg_type(cbs_table,
1453
2102
                                                   "text/x-msmsgsemailnotification",
1454
2103
                                                   email_msg);
 
2104
        /*delete an offline Message notification*/
 
2105
        msn_table_add_msg_type(cbs_table,
 
2106
                                                        "text/x-msmsgsactivemailnotification",
 
2107
                                                   delete_oim_msg);
1455
2108
        msn_table_add_msg_type(cbs_table,
1456
2109
                                                   "application/x-msmsgssystemmessage",
1457
2110
                                                   system_msg);
1462
2115
{
1463
2116
        msn_table_destroy(cbs_table);
1464
2117
}
 
2118