im.c

ä¯ÀÀ¸ÃÎļþµÄÎĵµ¡£

// START OF FILE
/*****************************************************************************/
#include "conversation.h"       // GaimConeversation
#include "debug.h"              // gaim_debug
#include "internal.h"           // strlen, _("get_text")
#include "md5.h"                // md5 functions
#include "notify.h"             // gaim_notify_warning
#include "server.h"             // serv_got_im
#include "util.h"               // gaim_markup_find_tag, gaim_base16_decode

#include "utils.h"              // gen_ip_str
#include "packet_parse.h"       // create_packet
#include "buddy_info.h"         // qq_send_packet_get_info
#include "buddy_list.h"         // qq_send_packet_get_buddies_online
#include "buddy_opt.h"          // qq_add_buddy_by_recv_packet
#include "char_conv.h"          // qq_to_utf8, qq_encode_to_gaim
#include "crypt.h"              // qq_crypt
#include "group_im.h"           // qq_send_packet_group_im
#include "header_info.h"        // cmd alias
#include "im.h"
#include "send_core.h"          // qq_send_cmd
#include "qq.h"                 // qq_data
#include "send_file.h"

#define QQ_SEND_IM_REPLY_OK       0x00
#define DEFAULT_FONT_NAME_LEN     4

// a debug function
void _qq_show_packet(gchar * desc, gchar * buf, gint len);

enum
{
        QQ_NORMAL_IM_TEXT = 0x000b,
        QQ_NORMAL_IM_FILE_REQUEST = 0x0035,
        QQ_NORMAL_IM_FILE_APPROVE_UDP = 0x0037,
        QQ_NORMAL_IM_FILE_APPROVE_TCP = 0x0003,
        QQ_NORMAL_IM_FILE_REJECT_UDP = 0x0039,
        QQ_NORMAL_IM_FILE_REJECT_TCP = 0x0005,
        QQ_NORMAL_IM_FILE_NOTIFY = 0x003b,
        QQ_NORMAL_IM_FILE_CANCEL = 0x0049,
        QQ_NORMAL_IM_FILE_PASV = 0x003f,
};

enum {
        QQ_RECV_SYS_IM_KICK_OUT = 0x01,
};

/*
guint8 send_im_tail[QQ_SEND_IM_AFTER_MSG_LEN] = {
  0x00,       // end of msg
  0x0a,       // font attr, size=10, no bold, no italic, no underline
  0x00,       // font color red 00-ff
  0x00,       // font color green
  0x00,       // font color blue
  0x00,       // unknown
  0x86, 0x22, // encoding, 0x8622=GB, 0x0000=EN, define BIG5 support here
  0xcb, 0xce, 0xcc, 0xe5, 0x0d // font name, related, not fix length
};
*/

typedef struct _qq_recv_im_header qq_recv_im_header;
typedef struct _qq_recv_normal_im_text qq_recv_normal_im_text;
typedef struct _qq_recv_normal_im_common qq_recv_normal_im_common;
typedef struct _qq_recv_normal_im_unprocessed qq_recv_normal_im_unprocessed;

struct _qq_recv_normal_im_common {
        // this is the common part of normal_text
        guint16 sender_ver;
        guint32 sender_uid;
        guint32 receiver_uid;
        guint8 *session_md5;
        guint16 normal_im_type;
};

struct _qq_recv_normal_im_text {
        qq_recv_normal_im_common *common;
        // now comes the part fo text only
        guint16 msg_seq;
        guint32 send_time;
        guint8 unknown1;
        guint8 sender_icon;
        guint8 unknown2[3];
        guint8 is_there_font_attr;
        guint8 unknown3[4];
        guint8 msg_type;
        guint8 *msg;            // no fixed length, ends with 0x00
        guint8 *font_attr;
        gint font_attr_len;
};

struct _qq_recv_normal_im_unprocessed {
        qq_recv_normal_im_common *common;
        // now comes the part of unprocessed
        guint8 *unknown;        // no fixed length
        gint length;
};

struct _qq_recv_im_header {
        guint32 sender_uid;
        guint32 receiver_uid;
        guint32 server_im_seq;
        guint8 sender_ip[4];
        guint16 sender_port;
        guint16 im_type;
};

#define QQ_SEND_IM_AFTER_MSG_HEADER_LEN 8
#define DEFAULT_FONT_NAME "\0xcb\0xce\0xcc\0xe5"

guint8 *qq_get_send_im_tail(const gchar * font_color,
                            const gchar * font_size,
                            const gchar * font_name,
                            gboolean is_bold, gboolean is_italic, gboolean is_underline, guint tail_len)
{
        gchar *s1, *s2;
        unsigned char *rgb;
        guint font_name_len;
        guint8 *send_im_tail;
        const guint8 simsun[] = { 0xcb, 0xce, 0xcc, 0xe5 };

        if (font_name) {
                font_name_len = strlen(font_name);
        } else {
                font_name_len = DEFAULT_FONT_NAME_LEN;
                font_name = simsun;
        }

        send_im_tail = g_new0(guint8, tail_len);

        g_strlcpy(send_im_tail + QQ_SEND_IM_AFTER_MSG_HEADER_LEN,
                  font_name, tail_len - QQ_SEND_IM_AFTER_MSG_HEADER_LEN);
        send_im_tail[tail_len - 1] = tail_len;

        send_im_tail[0] = 0x00;
        if (font_size) {
                send_im_tail[1] = (guint8) (atoi(font_size) * 3 + 1);
        } else {
                send_im_tail[1] = 10;
        }
        if (is_bold)
                send_im_tail[1] |= 0x20;
        if (is_italic)
                send_im_tail[1] |= 0x40;
        if (is_underline)
                send_im_tail[1] |= 0x80;

        if (font_color) {
                s1 = g_strndup(font_color + 1, 6);
                /* Henry: maybe this is a bug of gaim, the string should have
                 * the length of odd number @_@
                 */
                s2 = g_strdup_printf("%sH", s1);
                gaim_base16_decode(s2, &rgb);
                g_free(s1);
                g_free(s2);
                memcpy(send_im_tail + 2, rgb, 3);
                g_free(rgb);
        } else {
                send_im_tail[2] = send_im_tail[3] = send_im_tail[4] = 0;
        }

        send_im_tail[5] = 0x00;
        send_im_tail[6] = 0x86;
        send_im_tail[7] = 0x22; // encoding, 0x8622=GB, 0x0000=EN, define BIG5 support here
        _qq_show_packet("QQ_MESG", send_im_tail, tail_len);
        return (guint8 *) send_im_tail;
}                               // qq_get_send_im_tail

/*****************************************************************************/
const gchar *qq_get_recv_im_type_str(gint type)
{
        switch (type) {
        case QQ_RECV_IM_TO_BUDDY:
                return "QQ_RECV_IM_TO_BUDDY";
        case QQ_RECV_IM_TO_UNKNOWN:
                return "QQ_RECV_IM_TO_UNKNOWN";
        case QQ_RECV_IM_UNKNOWN_GROUP_IM:
                return "QQ_RECV_IM_UNKNOWN_GROUP_IM";
        case QQ_RECV_IM_ADD_TO_GROUP:
                return "QQ_RECV_IM_ADD_TO_GROUP";
        case QQ_RECV_IM_DEL_FROM_GROUP:
                return "QQ_RECV_IM_DEL_FROM_GROUP";
        case QQ_RECV_IM_APPLY_ADD_TO_GROUP:
                return "QQ_RECV_IM_APPLY_ADD_TO_GROUP";
        case QQ_RECV_IM_CREATE_GROUP:
                return "QQ_RECV_IM_CREATE_GROUP";
        case QQ_RECV_IM_SYS_NOTIFICATION:
                return "QQ_RECV_IM_SYS_NOTIFICATION";
        case QQ_RECV_IM_APPROVE_APPLY_ADD_TO_GROUP:
                return "QQ_RECV_IM_APPROVE_APPLY_ADD_TO_GROUP";
        case QQ_RECV_IM_REJCT_APPLY_ADD_TO_GROUP:
                return "QQ_RECV_IM_REJCT_APPLY_ADD_TO_GROUP";
        case QQ_RECV_IM_TEMP_GROUP_IM:
                return "QQ_RECV_IM_TEMP_GROUP_IM";
        case QQ_RECV_IM_GROUP_IM:
                return "QQ_RECV_IM_GROUP_IM";
        default:
                return "QQ_RECV_IM_UNKNOWN";
        }                       // switch type
}                               // qq_get_recv_im_type_str

/*****************************************************************************/
// generate a md5 key using uid and session_key
gchar *_gen_session_md5(gint uid, gchar * session_key)
{
        gchar *src, md5_str[QQ_KEY_LENGTH];
        guint8 *cursor;
        md5_state_t ctx;

        src = g_newa(gchar, 20);
        cursor = src;
        create_packet_dw(src, &cursor, uid);
        create_packet_data(src, &cursor, session_key, QQ_KEY_LENGTH);

        md5_init(&ctx);
        md5_append(&ctx, src, 20);
        md5_finish(&ctx, (md5_byte_t *) md5_str);

        return g_memdup(md5_str, QQ_KEY_LENGTH);
}                               // _gen_session_md5

/*****************************************************************************/
// when we receive a message,
// we send an ACK which is the first 16 bytes of incoming packet
void _qq_send_packet_recv_im_ack(GaimConnection * gc, guint16 seq, guint8 * data) {
        qq_send_cmd(gc, QQ_CMD_RECV_IM, FALSE, seq, FALSE, data, 16);
}                               // _qq_send_packet_recv_im_ack

/*****************************************************************************/
// read the common parts of the normal_im,
// returns the bytes read if succeed, or -1 if there is any error
gint _qq_normal_im_common_read(guint8 * data, guint8 ** cursor, gint len, qq_recv_normal_im_common * common) {

        gint bytes;
        g_return_val_if_fail(data != NULL && len != 0 && common != NULL, -1);

        bytes = 0;
        // now push data into common header
        bytes += read_packet_w(data, cursor, len, &(common->sender_ver));
        bytes += read_packet_dw(data, cursor, len, &(common->sender_uid));
        bytes += read_packet_dw(data, cursor, len, &(common->receiver_uid));

        common->session_md5 = g_memdup(*cursor, QQ_KEY_LENGTH);
        bytes += QQ_KEY_LENGTH;
        *cursor += QQ_KEY_LENGTH;

        bytes += read_packet_w(data, cursor, len, &(common->normal_im_type));

        if (bytes != 28) {      // read common place fail
                gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Expect 28 bytes, read %d bytes\n", bytes);
                return -1;
        }                       // if bytes

        return bytes;
}                               // _qq_normal_im_common_read

/*****************************************************************************/
// process received normal text IM
void _qq_process_recv_normal_im_text
    (guint8 * data, guint8 ** cursor, gint len, qq_recv_normal_im_common * common, GaimConnection * gc) {
        guint16 gaim_msg_type;
        gchar *name;
        gchar *msg_with_gaim_smiley;
        gchar *msg_utf8_encoded;
        qq_data *qd;
        qq_recv_normal_im_text *im_text;

        g_return_if_fail(gc != NULL && gc->proto_data != NULL && common != NULL);
        qd = (qq_data *) gc->proto_data;

        // now it is QQ_NORMAL_IM_TEXT
        if (*cursor >= (data + len - 1)) {
                gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received normal IM text is empty\n");
                return;
        } else
                im_text = g_newa(qq_recv_normal_im_text, 1);

        im_text->common = common;

        // push data into im_text
        read_packet_w(data, cursor, len, &(im_text->msg_seq));
        read_packet_dw(data, cursor, len, &(im_text->send_time));
        read_packet_b(data, cursor, len, &(im_text->unknown1));
        read_packet_b(data, cursor, len, &(im_text->sender_icon));
        read_packet_data(data, cursor, len, (guint8 *) & (im_text->unknown2), 3);
        read_packet_b(data, cursor, len, &(im_text->is_there_font_attr));
        read_packet_data(data, cursor, len, (guint8 *) & (im_text->unknown3), 4);
        read_packet_b(data, cursor, len, &(im_text->msg_type));

        // we need to check if this is auto-reply
        // QQ2003iii build 0304, returns the msg without font_attr
        // even the is_there_font_attr shows 0x01, and msg does not ends with 0x00
        if (im_text->msg_type == QQ_IM_AUTO_REPLY) {
                im_text->is_there_font_attr = 0x00;     // indeed there is no this flag
                im_text->msg = g_strndup(*cursor, data + len - *cursor);
        } else {                // it is normal mesasge
                if (im_text->is_there_font_attr) {
                        im_text->msg = g_strdup(*cursor);
                        *cursor += strlen(im_text->msg) + 1;
                        im_text->font_attr_len = data + len - *cursor;
                        im_text->font_attr = g_memdup(*cursor, im_text->font_attr_len);
                } else          // not im_text->is_there_font_attr
                        im_text->msg = g_strndup(*cursor, data + len - *cursor);
        }                       // if im_text->msg_type
        _qq_show_packet("QQ_MESG recv", data, *cursor - data);

        name = uid_to_gaim_name(common->sender_uid);
        if (gaim_find_buddy(gc->account, name) == NULL)
                qq_add_buddy_by_recv_packet(gc, common->sender_uid, FALSE, TRUE);

        gaim_msg_type = (im_text->msg_type == QQ_IM_AUTO_REPLY) ? GAIM_CONV_IM_AUTO_RESP : 0;

        msg_with_gaim_smiley = qq_smiley_to_gaim(im_text->msg);
        msg_utf8_encoded = im_text->is_there_font_attr ?
            qq_encode_to_gaim(im_text->font_attr,
                              im_text->font_attr_len,
                              msg_with_gaim_smiley) : qq_to_utf8(msg_with_gaim_smiley, QQ_CHARSET_DEFAULT);

        // send encoded to gaim, note that we use im_text->send_time,
        // not the time we receive the message
        // as it may have been dealyed when I am not online.
        serv_got_im(gc, name, msg_utf8_encoded, gaim_msg_type, (time_t) im_text->send_time);

        g_free(msg_utf8_encoded);
        g_free(msg_with_gaim_smiley);
        g_free(name);
        g_free(im_text->msg);
        if (im_text->is_there_font_attr)
                g_free(im_text->font_attr);
}                               // _qq_process_recv_normal_im_text

/*****************************************************************************/
// it is a normal IM, maybe text or video request
void _qq_process_recv_normal_im(guint8 * data, guint8 ** cursor, gint len, GaimConnection * gc)
{
        gint bytes;
        qq_recv_normal_im_common *common;
        qq_recv_normal_im_unprocessed *im_unprocessed;

        g_return_if_fail (data != NULL && len != 0);

        if (*cursor >= (data + len - 1)) {
                gaim_debug (GAIM_DEBUG_WARNING, "QQ",
                            "Received normal IM is empty\n");
                return;
        }
        else
                common = g_newa (qq_recv_normal_im_common, 1);

        bytes = _qq_normal_im_common_read (data, cursor, len, common);
        if (bytes < 0) {
                gaim_debug (GAIM_DEBUG_ERROR, "QQ",
                            "Fail read the common part of normal IM\n");
                return;
        }                       // if bytes

        switch (common->normal_im_type) {
        case QQ_NORMAL_IM_TEXT:
                gaim_debug (GAIM_DEBUG_INFO,
                            "QQ",
                            "Normal IM, text type:\n [%d] => [%d], src: %s\n",
                            common->sender_uid, common->receiver_uid,
                            qq_get_source_str (common->sender_ver));
                _qq_process_recv_normal_im_text (data, cursor, len, common,
                                                 gc);
                break;
        case QQ_NORMAL_IM_FILE_REJECT_UDP:
                qq_process_recv_file_reject (data, cursor, len,
                                             common->sender_uid, gc);
                break;
        case QQ_NORMAL_IM_FILE_APPROVE_UDP:
                qq_process_recv_file_accept (data, cursor, len,
                                             common->sender_uid, gc);
                break;
        case QQ_NORMAL_IM_FILE_REQUEST:
                qq_process_recv_file_request (data, cursor, len,
                                              common->sender_uid, gc);
                break;
        case QQ_NORMAL_IM_FILE_CANCEL:
                qq_process_recv_file_cancel (data, cursor, len,
                                             common->sender_uid, gc);
                break;
        case QQ_NORMAL_IM_FILE_NOTIFY:
                qq_process_recv_file_notify (data, cursor, len,
                                common->sender_uid, gc);
                break;
        default:
                im_unprocessed = g_newa (qq_recv_normal_im_unprocessed, 1);
                im_unprocessed->common = common;
                im_unprocessed->unknown = *cursor;
                im_unprocessed->length = data + len - *cursor;
                // 　a simple process here, maybe more later
                gaim_debug (GAIM_DEBUG_WARNING, "QQ",
                            "Normal IM, unprocessed type [0x%04x]\n",
                            common->normal_im_type);
                gaim_debug (GAIM_DEBUG_WARNING, "QQ",
                            "Dump unknown part.\n%s",
                            hex_dump_to_str (im_unprocessed->unknown,
                                             im_unprocessed->length));
                g_free (common->session_md5);
                return;
        }                       // normal_im_type

        g_free (common->session_md5);
}                               // qq_process_recv_normal_im


/*
void _qq_process_recv_normal_im(guint8 * data, guint8 ** cursor, gint len, GaimConnection * gc) {
        gint bytes;
        qq_recv_normal_im_common *common;
        qq_recv_normal_im_unprocessed *im_unprocessed;

        g_return_if_fail(data != NULL && len != 0);

        if (*cursor >= (data + len - 1)) {
                gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received normal IM is empty\n");
                return;
        } else
                common = g_newa(qq_recv_normal_im_common, 1);

        bytes = _qq_normal_im_common_read(data, cursor, len, common);
        if (bytes < 0) {
                gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Fail read the common part of normal IM\n");
                return;
        }                       // if bytes

        if (common->normal_im_type != QQ_NORMAL_IM_TEXT) {
                im_unprocessed = g_newa(qq_recv_normal_im_unprocessed, 1);
                im_unprocessed->common = common;
                im_unprocessed->unknown = *cursor;
                im_unprocessed->length = data + len - *cursor;
                //　a simple process here, maybe more later
                gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Normal IM, unprocessed type [0x%04x]\n", common->normal_im_type);
                gaim_debug(GAIM_DEBUG_WARNING, "QQ",
                           "Dump unknown part.\n%s", hex_dump_to_str(im_unprocessed->unknown, im_unprocessed->length));
                g_free(common->session_md5);
                return;
        } else {                // normal_im_type ==  QQ_NORMAL_IM_TEXT
                gaim_debug(GAIM_DEBUG_INFO,
                           "QQ",
                           "Normal IM, text type:\n [%d] => [%d], src: %s\n",
                           common->sender_uid, common->receiver_uid, qq_get_source_str(common->sender_ver));
                _qq_process_recv_normal_im_text(data, cursor, len, common, gc);
        }                       // normal_im_type

        g_free(common->session_md5);
}                               // qq_process_recv_normal_im
*/

/*****************************************************************************/
// process im from system administrator
void _qq_process_recv_sys_im(guint8 * data, guint8 ** cursor, gint data_len, GaimConnection * gc) {
        gint len;
        guint8 reply;
        gchar **segments, *msg_utf8;

        g_return_if_fail(gc != NULL && data != NULL && data_len != 0);

        if (*cursor >= (data + data_len - 1)) {
                gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received sys IM is empty\n");
                return;
        }

        len = data + data_len - *cursor;

        if (NULL == (segments = split_data(*cursor, len, "\x2f", 2)))
                return;

        reply = strtol(segments[0], NULL, 10);
        if (reply == QQ_RECV_SYS_IM_KICK_OUT)
                gaim_debug(GAIM_DEBUG_WARNING, "QQ", "We are kicked out by QQ server\n");
        msg_utf8 = qq_to_utf8(segments[1], QQ_CHARSET_DEFAULT);
        gaim_notify_warning(gc, NULL, _("System Message"), msg_utf8);

}                               // _qq_process_recv_sys_im

/*****************************************************************************/
// send an IM to to_uid
void qq_send_packet_im(GaimConnection * gc, guint32 to_uid, gchar * msg, gint type) {
        qq_data *qd;
        guint8 *cursor, *raw_data;
        guint16 client_tag, normal_im_type;
        gint msg_len, raw_len, bytes;
        time_t now;
        gchar *md5, *msg_filtered;
        GData *attribs;
        gchar *font_size = NULL, *font_color = NULL, *font_name = NULL, *tmp;
        gboolean is_bold = FALSE, is_italic = FALSE, is_underline = FALSE;
        const gchar *start, *end, *last;

        g_return_if_fail(gc != NULL && gc->proto_data != NULL);

        qd = (qq_data *) gc->proto_data;
        client_tag = QQ_CLIENT;
        normal_im_type = QQ_NORMAL_IM_TEXT;

        last = msg;
        while (gaim_markup_find_tag("font", last, &start, &end, &attribs)) {
                tmp = g_datalist_get_data(&attribs, "size");
                if (tmp) {
                        if (font_size)
                                g_free(font_size);
                        font_size = g_strdup(tmp);
                }
                tmp = g_datalist_get_data(&attribs, "color");
                if (tmp) {
                        if (font_color)
                                g_free(font_color);
                        font_color = g_strdup(tmp);
                }
                tmp = g_datalist_get_data(&attribs, "face");
                if (tmp) {
                        if (font_name)
                                g_free(font_name);
                        font_name = g_strdup(tmp);
                }

                g_datalist_clear(&attribs);
                last = end + 1;
        }

        if (gaim_markup_find_tag("b", msg, &start, &end, &attribs)) {
                is_bold = TRUE;
                g_datalist_clear(&attribs);
        }

        if (gaim_markup_find_tag("i", msg, &start, &end, &attribs)) {
                is_italic = TRUE;
                g_datalist_clear(&attribs);
        }

        if (gaim_markup_find_tag("u", msg, &start, &end, &attribs)) {
                is_underline = TRUE;
                g_datalist_clear(&attribs);
        }

        gaim_debug(GAIM_DEBUG_INFO, "QQ_MESG", "send mesg: %s\n", msg);
        msg_filtered = gaim_markup_strip_html(msg);
        msg_len = strlen(msg_filtered);
        now = time(NULL);
        md5 = _gen_session_md5(qd->uid, qd->session_key);

        guint font_name_len, tail_len;
        font_name_len = (font_name) ? strlen(font_name) : DEFAULT_FONT_NAME_LEN;
        tail_len = font_name_len + QQ_SEND_IM_AFTER_MSG_HEADER_LEN + 1;

        raw_len = QQ_SEND_IM_BEFORE_MSG_LEN + msg_len + tail_len;
        raw_data = g_newa(guint8, raw_len);
        cursor = raw_data;
        bytes = 0;

        //000-003: receiver uid
        bytes += create_packet_dw(raw_data, &cursor, qd->uid);
        //004-007: sender uid
        bytes += create_packet_dw(raw_data, &cursor, to_uid);
        //008-009: sender client version
        bytes += create_packet_w(raw_data, &cursor, client_tag);
        //010-013: receiver uid
        bytes += create_packet_dw(raw_data, &cursor, qd->uid);
        //014-017: sender uid
        bytes += create_packet_dw(raw_data, &cursor, to_uid);
        //018-033: md5 of (uid+session_key)
        bytes += create_packet_data(raw_data, &cursor, md5, 16);
        //034-035: message type
        bytes += create_packet_w(raw_data, &cursor, normal_im_type);
        //036-037: sequence number
        bytes += create_packet_w(raw_data, &cursor, qd->send_seq);
        //038-041: send time
        bytes += create_packet_dw(raw_data, &cursor, (guint32) now);
        //042-042: always 0x00
        bytes += create_packet_b(raw_data, &cursor, 0x00);
        //043-043: sender icon
        bytes += create_packet_b(raw_data, &cursor, qd->my_icon);
        //044-046: always 0x00
        bytes += create_packet_w(raw_data, &cursor, 0x0000);
        bytes += create_packet_b(raw_data, &cursor, 0x00);
        //047-047: we use font attr
        bytes += create_packet_b(raw_data, &cursor, 0x01);
        //048-051: always 0x00
        bytes += create_packet_dw(raw_data, &cursor, 0x00000000);
        //052-052: text message type (normal/auto-reply)
        bytes += create_packet_b(raw_data, &cursor, type);
        //053-   : msg ends with 0x00
        bytes += create_packet_data(raw_data, &cursor, msg_filtered, msg_len);
        guint8 *send_im_tail = qq_get_send_im_tail(font_color, font_size, font_name, is_bold,
                                                   is_italic, is_underline, tail_len);
        _qq_show_packet("QQ_MESG debug", send_im_tail, tail_len);
        bytes += create_packet_data(raw_data, &cursor, (gchar *) send_im_tail, tail_len);

        _qq_show_packet("QQ_MESG raw", raw_data, cursor - raw_data);

        if (bytes == raw_len)   // create packet OK
                qq_send_cmd(gc, QQ_CMD_SEND_IM, TRUE, 0, TRUE, raw_data, cursor - raw_data);
        else
                gaim_debug(GAIM_DEBUG_ERROR, "QQ",
                           "Fail creating send_im packet, expect %d bytes, build %d bytes\n", raw_len, bytes);

        if (font_color)
                g_free(font_color);
        if (font_size)
                g_free(font_size);
        g_free(send_im_tail);
        g_free(msg_filtered);
}                               // qq_send_packet_im

/*****************************************************************************/
// parse the reply to send_im
void qq_process_send_im_reply(guint8 * buf, gint buf_len, GaimConnection * gc)
{
        qq_data *qd;
        gint len;
        guint8 *data, *cursor, reply;

        g_return_if_fail(gc != NULL && gc->proto_data != NULL);
        g_return_if_fail(buf != NULL && buf_len != 0);

        qd = gc->proto_data;
        len = buf_len;
        data = g_newa(guint8, len);

        if (qq_crypt(DECRYPT, buf, buf_len, qd->session_key, data, &len)) {
                cursor = data;
                read_packet_b(data, &cursor, len, &reply);
                if (reply != QQ_SEND_IM_REPLY_OK)
                        gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Send IM fail\n");
                else
                        gaim_debug(GAIM_DEBUG_INFO, "QQ", "IM ACK OK\n");
        } else
                gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Error decrypt send im reply\n");

}                               // qq_process_send_im_reply

/*****************************************************************************/
// I receive a message, mainly it is text msg,
// but we need to proess other types (group etc)
void qq_process_recv_im(guint8 * buf, gint buf_len, guint16 seq, GaimConnection * gc) {
        qq_data *qd;
        gint len, bytes;
        guint8 *data, *cursor;
        qq_recv_im_header *im_header;

        g_return_if_fail(gc != NULL && gc->proto_data != NULL);
        g_return_if_fail(buf != NULL && buf_len != 0);

        qd = (qq_data *) gc->proto_data;
        len = buf_len;
        data = g_newa(guint8, len);

        if (qq_crypt(DECRYPT, buf, buf_len, qd->session_key, data, &len)) {
                if (len < 16) { // we need to ack with the first 16 bytes
                        gaim_debug(GAIM_DEBUG_ERROR, "QQ", "IM is too short\n");
                        return;
                } else
                        _qq_send_packet_recv_im_ack(gc, seq, data);

                cursor = data;
                bytes = 0;
                im_header = g_newa(qq_recv_im_header, 1);
                bytes += read_packet_dw(data, &cursor, len, &(im_header->sender_uid));
                bytes += read_packet_dw(data, &cursor, len, &(im_header->receiver_uid));
                bytes += read_packet_dw(data, &cursor, len, &(im_header->server_im_seq));
                // if the message is delivered via server, it is server IP/port
                bytes += read_packet_data(data, &cursor, len, (guint8 *) & (im_header->sender_ip), 4);
                bytes += read_packet_w(data, &cursor, len, &(im_header->sender_port));
                bytes += read_packet_w(data, &cursor, len, &(im_header->im_type));

                if (bytes != 20) {      // length of im_header
                        gaim_debug(GAIM_DEBUG_ERROR, "QQ",
                                   "Fail read recv IM header, expect 20 bytes, read %d bytes\n", bytes);
                        return;
                }               // if bytes

                if (im_header->receiver_uid != qd->uid) {       // should not happen
                        gaim_debug(GAIM_DEBUG_ERROR, "QQ", "IM to [%d], NOT me\n", im_header->receiver_uid);
                        return;
                }               // if im_header->receiver_uid

                switch (im_header->im_type) {
                case QQ_RECV_IM_TO_BUDDY:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM from buddy [%d], I am in his/her buddy list\n", im_header->sender_uid);
                        _qq_process_recv_normal_im(data, &cursor, len, gc);
                        break;
                case QQ_RECV_IM_TO_UNKNOWN:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM from buddy [%d], I am a stranger to him/her\n", im_header->sender_uid);
                        _qq_process_recv_normal_im(data, &cursor, len, gc);
                        break;
                case QQ_RECV_IM_UNKNOWN_GROUP_IM:
                case QQ_RECV_IM_TEMP_GROUP_IM:
                case QQ_RECV_IM_GROUP_IM:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ", "IM from group, internal_id [%d]\n", im_header->sender_uid);
                        // sender_uid is in fact internal_group_id
                        qq_process_recv_group_im(data, &cursor, len, im_header->sender_uid, gc, im_header->im_type);
                        break;
                case QQ_RECV_IM_ADD_TO_GROUP:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM from group, added by group internal_id [%d]\n", im_header->sender_uid);
                        // sender_uid is in fact internal_group_id
                        // we need this to create a dummy group and add to blist
                        qq_process_recv_group_im_been_added(data, &cursor, len, im_header->sender_uid, gc);
                        break;
                case QQ_RECV_IM_DEL_FROM_GROUP:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM from group, removed by group internal_ID [%d]\n", im_header->sender_uid);
                        // sender_uid is in fact internal_group_id
                        qq_process_recv_group_im_been_removed(data, &cursor, len, im_header->sender_uid, gc);
                        break;
                case QQ_RECV_IM_APPLY_ADD_TO_GROUP:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM from group, apply to join group internal_ID [%d]\n", im_header->sender_uid);
                        // sender_uid is in fact internal_group_id
                        qq_process_recv_group_im_apply_join(data, &cursor, len, im_header->sender_uid, gc);
                        break;
                case QQ_RECV_IM_APPROVE_APPLY_ADD_TO_GROUP:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM for group system info, approved by group internal_id [%d]\n",
                                   im_header->sender_uid);
                        // sender_uid is in fact internal_group_id
                        qq_process_recv_group_im_been_approved(data, &cursor, len, im_header->sender_uid, gc);
                        break;
                case QQ_RECV_IM_REJCT_APPLY_ADD_TO_GROUP:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM for group system info, rejected by group internal_id [%d]\n",
                                   im_header->sender_uid);
                        // sender_uid is in fact internal_group_id
                        qq_process_recv_group_im_been_rejected(data, &cursor, len, im_header->sender_uid, gc);
                        break;
                case QQ_RECV_IM_SYS_NOTIFICATION:
                        gaim_debug(GAIM_DEBUG_INFO, "QQ",
                                   "IM from [%d], should be a system administrator\n", im_header->sender_uid);
                        _qq_process_recv_sys_im(data, &cursor, len, gc);
                        break;
                default:
                        gaim_debug(GAIM_DEBUG_WARNING, "QQ",
                                   "IM from [%d], [0x%02x] %s is not processed\n",
                                   im_header->sender_uid,
                                   im_header->im_type, qq_get_recv_im_type_str(im_header->im_type));
                }               // switch
        } else
                gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Error decrypt rev im\n");

}                               // qq_process_recv_im

/*****************************************************************************/
// END OF FILE

---