Mercurial > pidgin.yaz

comparison libpurple/protocols/msn/directconn.c @ 30443:ecd237d3f578

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Minor cleanups.
author Elliott Sales de Andrade <qulogic@pidgin.im>
date Sun, 11 Apr 2010 05:53:02 +0000
parents ca7dec8303cb
children db0f95b6a2cf
comparison
equal deleted inserted replaced
30442:ca7dec8303cb 30443:ecd237d3f578
92 } 92 }
93 93
94 static void 94 static void
95 msn_dc_destroy_packet(MsnDirectConnPacket *p) 95 msn_dc_destroy_packet(MsnDirectConnPacket *p)
96 { 96 {
97 if (p->data) 97 g_free(p->data);
98 g_free(p->data);
99 98
100 if (p->msg) 99 if (p->msg)
101 msn_message_unref(p->msg); 100 msn_message_unref(p->msg);
102 101
103 g_free(p); 102 g_free(p);
645 static void 644 static void
646 msn_dc_send_handshake(MsnDirectConn *dc) 645 msn_dc_send_handshake(MsnDirectConn *dc)
647 { 646 {
648 MsnDirectConnPacket *p; 647 MsnDirectConnPacket *p;
649 const gchar *h; 648 const gchar *h;
650 guint32 l; 649 guint32 len;
651 650
652 g_return_if_fail(dc != NULL); 651 g_return_if_fail(dc != NULL);
653 652
654 p = msn_dc_new_packet(); 653 p = msn_dc_new_packet();
655 654
656 p->length = 4 + DC_PACKET_HEADER_SIZE; 655 p->length = 4 + DC_PACKET_HEADER_SIZE;
657 p->data = g_malloc(p->length); 656 p->data = g_malloc(p->length);
658 657
659 l = DC_PACKET_HEADER_SIZE; 658 len = GUINT32_TO_LE(DC_PACKET_HEADER_SIZE);
660 l = GUINT32_TO_LE(l); 659 memcpy(p->data, &len, 4);
661 memcpy(p->data, &l, 4);
662 660
663 dc->header.session_id = 0; 661 dc->header.session_id = 0;
664 dc->header.id = dc->slpcall->slplink->slp_seq_id++; 662 dc->header.id = dc->slpcall->slplink->slp_seq_id++;
665 dc->header.offset = 0; 663 dc->header.offset = 0;
666 dc->header.total_size = 0; 664 dc->header.total_size = 0;
677 static void 675 static void
678 msn_dc_send_handshake_reply(MsnDirectConn *dc) 676 msn_dc_send_handshake_reply(MsnDirectConn *dc)
679 { 677 {
680 MsnDirectConnPacket *p; 678 MsnDirectConnPacket *p;
681 const gchar *h; 679 const gchar *h;
682 guint32 l; 680 guint32 len;
683 681
684 g_return_if_fail(dc != NULL); 682 g_return_if_fail(dc != NULL);
685 683
686 p = msn_dc_new_packet(); 684 p = msn_dc_new_packet();
687 685
688 p->length = 4 + DC_PACKET_HEADER_SIZE; 686 p->length = 4 + DC_PACKET_HEADER_SIZE;
689 p->data = g_malloc(p->length); 687 p->data = g_malloc(p->length);
690 688
691 l = DC_PACKET_HEADER_SIZE; 689 len = GUINT32_TO_LE(DC_PACKET_HEADER_SIZE);
692 l = GUINT32_TO_LE(l); 690 memcpy(p->data, &len, 4);
693 memcpy(p->data, &l, 4);
694 691
695 dc->header.id = dc->slpcall->slplink->slp_seq_id++; 692 dc->header.id = dc->slpcall->slplink->slp_seq_id++;
696 dc->header.length = 0; 693 dc->header.length = 0;
697 694
698 h = msn_dc_serialize_binary_header(dc); 695 h = msn_dc_serialize_binary_header(dc);
722 memcpy(p->data, &length, 4); 719 memcpy(p->data, &length, 4);
723 memcpy(p->data + 4, &msg->msnslp_header, DC_PACKET_HEADER_SIZE); 720 memcpy(p->data + 4, &msg->msnslp_header, DC_PACKET_HEADER_SIZE);
724 memcpy(p->data + 4 + DC_PACKET_HEADER_SIZE, msg->body, msg->body_len); 721 memcpy(p->data + 4 + DC_PACKET_HEADER_SIZE, msg->body, msg->body_len);
725 722
726 p->sent_cb = msn_dc_send_packet_cb; 723 p->sent_cb = msn_dc_send_packet_cb;
727 p->msg = msg; 724 p->msg = msn_message_ref(msg);
728 msn_message_ref(msg);
729 725
730 msn_dc_enqueue_packet(dc, p); 726 msn_dc_enqueue_packet(dc, p);
731 } 727 }
732 728
733 static int 729 static int
737 733
738 switch (dc->state) { 734 switch (dc->state) {
739 case DC_STATE_CLOSED: 735 case DC_STATE_CLOSED:
740 break; 736 break;
741 737
742 case DC_STATE_FOO: { 738 case DC_STATE_FOO:
743 /* FOO message is always 4 bytes long */ 739 /* FOO message is always 4 bytes long */
744 if (packet_length != 4 || memcmp(dc->in_buffer, "\4\0\0\0foo", 8) != 0) 740 if (packet_length != 4 || memcmp(dc->in_buffer, "\4\0\0\0foo", 8) != 0)
745 return DC_PROCESS_FALLBACK; 741 return DC_PROCESS_FALLBACK;
746 742
747 dc->state = DC_STATE_HANDSHAKE; 743 dc->state = DC_STATE_HANDSHAKE;
748 break; 744 break;
749 } 745
750 746 case DC_STATE_HANDSHAKE:
751 case DC_STATE_HANDSHAKE: {
752 if (packet_length != DC_PACKET_HEADER_SIZE) 747 if (packet_length != DC_PACKET_HEADER_SIZE)
753 return DC_PROCESS_FALLBACK; 748 return DC_PROCESS_FALLBACK;
754 749
755 /* TODO: Check! */ 750 /* TODO: Check! */
756 msn_dc_send_handshake_reply(dc); 751 msn_dc_send_handshake_reply(dc);
757 dc->state = DC_STATE_ESTABLISHED; 752 dc->state = DC_STATE_ESTABLISHED;
758 753
759 msn_slpcall_session_init(dc->slpcall); 754 msn_slpcall_session_init(dc->slpcall);
760 dc->slpcall = NULL; 755 dc->slpcall = NULL;
761 break; 756 break;
762 }
763 757
764 case DC_STATE_HANDSHAKE_REPLY: 758 case DC_STATE_HANDSHAKE_REPLY:
765 /* TODO: Check! */ 759 /* TODO: Check! */
766 dc->state = DC_STATE_ESTABLISHED; 760 dc->state = DC_STATE_ESTABLISHED;
767 761