diff src/protocols/qq/im.c @ 13870:983fd420e86b

[gaim-migrate @ 16340] Performed minor cleanup of the OpenQ codebase and patched it into the Gaim trunk as a prpl, providing basic QQ functionality. committer: Tailor Script <[e-mail]>

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/protocols/qq/im.c	Mon Jun 26 02:58:54 2006 +0000
@@ -0,0 +1,795 @@
+/**
+ * The QQ2003C protocol plugin
+ *
+ * for gaim
+ *
+ * Copyright (C) 2004 Puzzlebird
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+// START OF FILE
+/*****************************************************************************/
+#include "conversation.h"	// GaimConeversation
+#include "debug.h"		// gaim_debug
+#include "internal.h"		// strlen, _("get_text")
+#include "cipher.h"		// md5 functions    //md5.h gfhuang
+#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 "send_core.h"			// qq_data
+#include "send_file.h"
+
+#define QQ_SEND_IM_REPLY_OK       0x00
+#define DEFAULT_FONT_NAME_LEN 	  4
+
+// a debug function
+static void _qq_show_packet(gchar * desc, gchar * buf, gint len);
+
+enum
+{
+        QQ_NORMAL_IM_TEXT = 0x000b,
+	QQ_NORMAL_IM_FILE_REQUEST_TCP = 0x0001,			//gfhuang
+	QQ_NORMAL_IM_FILE_APPROVE_TCP = 0x0003,
+	QQ_NORMAL_IM_FILE_REJECT_TCP = 0x0005,
+	QQ_NORMAL_IM_FILE_REQUEST_UDP = 0x0035,
+	QQ_NORMAL_IM_FILE_APPROVE_UDP = 0x0037,
+	QQ_NORMAL_IM_FILE_REJECT_UDP = 0x0039,
+	QQ_NORMAL_IM_FILE_NOTIFY = 0x003b,
+	QQ_NORMAL_IM_FILE_PASV = 0x003f,			// are you behind a firewall, gfhuang
+	QQ_NORMAL_IM_FILE_CANCEL = 0x0049,
+	QQ_NORMAL_IM_FILE_EX_REQUEST_UDP = 0x81,		//gfhuang	
+	QQ_NORMAL_IM_FILE_EX_REQUEST_ACCEPT = 0x83,		//gfhuang
+	QQ_NORMAL_IM_FILE_EX_REQUEST_CANCEL = 0x85,		//gfhuang
+	QQ_NORMAL_IM_FILE_EX_NOTIFY_IP = 0x87			//gfhuang
+};
+
+
+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);  by gfhuang
+		rgb = gaim_base16_decode(s2, NULL);
+		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
+
+/*****************************************************************************/
+static 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_QUN_IM:
+		return "QQ_RECV_IM_UNKNOWN_QUN_IM";
+	case QQ_RECV_IM_ADD_TO_QUN:
+		return "QQ_RECV_IM_ADD_TO_QUN";
+	case QQ_RECV_IM_DEL_FROM_QUN:
+		return "QQ_RECV_IM_DEL_FROM_QUN";
+	case QQ_RECV_IM_APPLY_ADD_TO_QUN:
+		return "QQ_RECV_IM_APPLY_ADD_TO_QUN";
+	case QQ_RECV_IM_CREATE_QUN:
+		return "QQ_RECV_IM_CREATE_QUN";
+	case QQ_RECV_IM_SYS_NOTIFICATION:
+		return "QQ_RECV_IM_SYS_NOTIFICATION";
+	case QQ_RECV_IM_APPROVE_APPLY_ADD_TO_QUN:
+		return "QQ_RECV_IM_APPROVE_APPLY_ADD_TO_QUN";
+	case QQ_RECV_IM_REJCT_APPLY_ADD_TO_QUN:
+		return "QQ_RECV_IM_REJCT_APPLY_ADD_TO_QUN";
+	case QQ_RECV_IM_TEMP_QUN_IM:
+		return "QQ_RECV_IM_TEMP_QUN_IM";	//gfhuang
+	case QQ_RECV_IM_QUN_IM:
+		return "QQ_RECV_IM_QUN_IM";		//gfhuang
+	default:
+		return "QQ_RECV_IM_UNKNOWN";
+	}			// switch type
+}				// qq_get_recv_im_type_str
+
+/*****************************************************************************/
+// generate a md5 key using uid and session_key
+static gchar *_gen_session_md5(gint uid, gchar * session_key)
+{
+	gchar *src, md5_str[QQ_KEY_LENGTH];
+	guint8 *cursor;
+//	md5_state_t ctx;             //gfhuang
+	GaimCipher *cipher;
+        GaimCipherContext *context;
+
+
+	src = g_newa(gchar, 20);
+	cursor = src;
+	create_packet_dw(src, &cursor, uid);
+	create_packet_data(src, &cursor, session_key, QQ_KEY_LENGTH);
+
+/*         gfhuang
+	md5_init(&ctx);
+	md5_append(&ctx, src, 20);
+	md5_finish(&ctx, (md5_byte_t *) md5_str);
+*/
+	cipher = gaim_ciphers_find_cipher("md5");
+	context = gaim_cipher_context_new(cipher, NULL);
+	gaim_cipher_context_append(context, src, 20);
+	gaim_cipher_context_digest(context, sizeof(md5_str), md5_str, NULL);
+	gaim_cipher_context_destroy(context);
+
+	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
+static 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
+static 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
+static 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));
+	//////////////////////
+	// from lumaqq	for unknown3, gfhuang
+	//	totalFragments = buf.get() & 255;
+        //	fragmentSequence = buf.get() & 255;
+        //	messageId = buf.getChar();
+	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_MESSAGE_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
+static 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_UDP:
+		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
+
+
+/*
+static 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
+static 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");
+			gaim_notify_error(gc, _("Server ACK"), _("Send IM fail\n"), NULL);
+//			serv_got_im(gc, name, "Server ACK: Send IM fail\n", GAIM_MESSAGE_ERROR, time(NULL));
+		}
+		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_QUN_IM:
+		case QQ_RECV_IM_TEMP_QUN_IM:
+		case QQ_RECV_IM_QUN_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_QUN:
+			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_QUN:
+			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_QUN:
+			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_QUN:
+			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_QUN:
+			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