QQ源代码

QQ源代码

// : implementation of the MyQQ class.

//////////////////////////////////////////////////////////////////////

#include

#include

#include "winsock2.h"

#include "MyQQ.h"

#include "md5.h"

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

MyQQ::MyQQ()

{

s = NULL;

LoginToken = NULL;

LoginTokenLength = 0;

Status = 0; //下线

IsLogin = false;

LastID = 0;

MessageText = NULL;

FriendListHead = NULL;

FriendListTail = NULL;

send_seq = random() & 0x0000ffff;

LastOnline = time(NULL);

UDPServerNum = 0;

//服务器地址

LoginServer = (char *)malloc(16*sizeof(char));

//QQ号

UserID = 0;

//密码

Password = NULL;

//得到初始化密钥，按2004版

InitKey = (unsigned char*)malloc(QQ_KEY_LENGTH);

int i;

for(i = 0; i < 16; i++)

InitKey = rand();

SessionKey = (unsigned char*)malloc(QQ_KEY_LENGTH);

}

MyQQ::~MyQQ()

{

if(LoginServer != NULL)

free(LoginServer);

if(MyIP != NULL)

free(MyIP);

if(MessageText != NULL)

free(MessageText);

if(Password != NULL)

free(Password);

if(InitKey != NULL)

free(InitKey);

if(PwdKey != NULL)

free(PwdKey);

if(SessionKey != NULL)

free(SessionKey);

if(FriendListHead != NULL)

{

QQFriend *p = FriendListHead->next;

while(p != NULL)

{

free(FriendListHead);

FriendListHead = p;

p = p->next;

}

if(FriendListTail != NULL)

free(FriendListTail);

}

}

void MyQQ::Login(int pMode)

{

unsigned char *buf, *cursor, *raw_data, *encrypted_data;

int seq_ret;

int encrypted_len, bytes;

//登录模式：1 为正常登录，2为隐身登录 ,3登录即离开

LoginMode = pMode;

if(LoginToken == NULL)

{

//发送获取登录令牌的包

qq_get_logintoken();

}

else

{

//2004登录包

buf = (unsigned char*)malloc(MAX_PACKAGE_LENGTH); //包长65535

raw_data = (unsigned char*)malloc(QQ_LOGIN_DATA_LENGTH); //数据长

encrypted_data = (unsigned char*)malloc(QQ_LOGIN_DATA_LENGTH + 16); //加密数据长度多16

// 产生密文

// 000-015 用PwdKey加密空串

_crypt(ENCRYPT, (unsigned char*)"", 0, PwdKey, raw_data,

&encrypted_len);

//016-051 36字节的固定内容

memmove(raw_data + 16, login_16_51, 36);

//052-052 登录方式

raw_data[52] = (unsigned char)LoginMode;

//053-068 16字节固定内容

memmove(raw_data + 53, login_53_68, 16);

//069 登录令牌长度

int pos = 69;

raw_data[pos++] = (unsigned char)LoginTokenLength;

//070-? 登录令牌

memmove(raw_data + pos, LoginToken, LoginTokenLength);

pos += LoginTokenLength;

//未知字节0x40

raw_data[pos++] = 0x40;

//固定字节

memmove(raw_data + pos, LOGIN_SEGMENTS, 100);

pos += 100;

//剩下的字节填零

for(; pos < QQ_LOGIN_DATA_LENGTH; pos++)

raw_data[pos] = 0x00;

//加密

_crypt(ENCRYPT, raw_data, QQ_LOGIN_DATA_LENGTH, InitKey,

encrypted_data, &encrypted_len);

cursor = buf;

bytes = 0;

bytes += create_packet_head_seq(buf, &cursor, QQ_CMD_LOGIN, true,

&seq_ret);

bytes += create_packet_dw(buf, &cursor, UserID);

bytes += create_packet_data(buf, &cursor, InitKey, QQ_KEY_LENGTH);

bytes += create_packet_data(buf, &cursor, encrypted_data, encrypted_len);

bytes += create_packet_b(buf, &cursor, QQ_PACKET_TAIL);

if (bytes == (cursor - buf)) //包被无误创建

{

qq_send_packet(buf, bytes, QQ_CMD_LOGIN);

}

free(buf);

free(raw_data);

free(encrypted_data);

}

}

//从包中读取一个字节

int MyQQ::read_packet_b(unsigned char * buf, unsigned char ** cursor, int buflen,

unsigned char * b)

{

if(*cursor <= buf + buflen - sizeof(*b))

{

*b = **(unsigned char **) cursor;

*cursor += sizeof(*b);

return sizeof(*b);

}

else

return -1;

}

//从包中读取一个字

int MyQQ::read_packet_w(unsigned char * buf, unsigned char ** cursor, int buflen, short *

w)

{

if(*cursor <= buf + buflen - sizeof(*w))

{

*w = ntohs(**(short **) cursor);

*cursor += sizeof(*w);

return sizeof(*w);

} else

return -1;

}

//处理收到的消息

void MyQQ::qq_process_recv_im(unsigned char* buf, int buf_len, short seq)

{

int len, bytes;

unsigned char *data, *cursor;

qq_recv_im_header *im_header;

len = buf_len;

data = (unsigned char *)malloc(len);

if (_crypt(DECRYPT, buf, buf_len, SessionKey, data, &len))

{

if(len < 16)

return;

else

qq_send_packet_recv_im_ack(seq, data);

cursor = data;

bytes = 0;

im_header = (qq_recv_im_header *)malloc(sizeof(qq_recv_im_header));

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));

bytes += read_packet_data(data, &cursor, len, (unsigned char *)

(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) { // im_header的长度

return;

&

}

if (im_header->receiver_uid != UserID)

{

return;

}

LastID = im_header->sender_uid;

switch (im_header->im_type)

{

case QQ_RECV_IM_TO_BUDDY:

qq_process_recv_normal_im(data, &cursor, len);

break;

case QQ_RECV_IM_TO_UNKNOWN:

qq_process_recv_normal_im(data, &cursor, len);

break;

case QQ_RECV_IM_GROUP_IM:

//qq_process_recv_group_im(data, &cursor, len, im_header->sender_uid, gc);

break;

case QQ_RECV_IM_ADD_TO_GROUP:

//qq_process_recv_group_im_been_added(data, &cursor, len,

im_header->sender_uid, gc);

break;

case QQ_RECV_IM_DEL_FROM_GROUP:

//qq_process_recv_group_im_been_removed(data, &cursor, len,

im_header->sender_uid, gc);

break;

case QQ_RECV_IM_APPLY_ADD_TO_GROUP:

//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:

//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:

//qq_process_recv_group_im_been_rejected(data, &cursor, len,

im_header->sender_uid, gc);

break;

case QQ_RECV_IM_SYS_NOTIFICATION:

//_qq_process_recv_sys_im(data, &cursor, len, gc);

break;

default:

break;

}// switch

}

}

//处理登录Reply的消息

void MyQQ::qq_process_login_reply(unsigned char* buf, int buf_len)

{

if(IsLogin == true)

return;

int len, ret, bytes;

unsigned char *data;

len = buf_len;

data = (unsigned char*)malloc(len);

if (_crypt(DECRYPT, buf, buf_len, PwdKey, data, &len)) {

if (data[0] == QQ_LOGIN_REPLY_OK) {

ret = qq_process_login_ok(data, len);

} else {

ret = QQ_LOGIN_REPLY_MISC_ERROR;

}

} else {

len = buf_len;

if (_crypt(DECRYPT, buf, buf_len, InitKey, data, &len)) {

bytes = 0;

switch (data[0]) {

case QQ_LOGIN_REPLY_REDIRECT:

ret = qq_process_login_redirect(data, len);

break;

case QQ_LOGIN_REPLY_PWD_ERROR:

ret = qq_process_login_wrong_pwd(data, len);

break;

default:

ret = QQ_LOGIN_REPLY_MISC_ERROR;

}

} else {

ret = QQ_LOGIN_REPLY_MISC_ERROR;

}

}

switch (ret) {

case QQ_LOGIN_REPLY_PWD_ERROR:

MessageBox(NULL,"QQ密码错误!","错误",MB_OK);

break;

case QQ_LOGIN_REPLY_MISC_ERROR:

MessageBox(NULL,"QQ登录出错，请重试!","错误",MB_OK);

break;

case QQ_LOGIN_REPLY_OK:

break;

case QQ_LOGIN_REPLY_REDIRECT:

break;

default:

break;

} // switch ret

}

void MyQQ::qq_process_group_cmd_reply(unsigned char* cursor, int len, short seq){}

void MyQQ::qq_process_msg_sys(unsigned char* cursor, int len, short seq){}

void MyQQ::qq_process_friend_change_status(unsigned char* buf, int buf_len)

{

int len, bytes;

unsigned char *data, *cursor;

len = buf_len;

data = (unsigned char*)malloc(len);

cursor = data;

qq_buddy_status * ss;

if(_crypt(DECRYPT, buf, buf_len, SessionKey, data, &len))

{

ss = (qq_buddy_status *)malloc(sizeof(qq_buddy_status));

bytes = 0;

// 000-003: uid

bytes += read_packet_dw(data, &cursor, len, &ss->uid);

// 004-004: 0x01

bytes += read_packet_b(data, &cursor, len, &ss->unknown1);

// 005-008: ip

ss->ip = (unsigned char*)malloc(4);

bytes += read_packet_data(data, &cursor, len, ss->ip, 4);

// 009-010: port

bytes += read_packet_w(data, &cursor, len, &ss->port);

// 011-011: 0x00

bytes += read_packet_b(data, &cursor, len, &ss->unknown2);

// 012-012: status

bytes += read_packet_b(data, &cursor, len, &ss->status);

// 013-014:

bytes += read_packet_w(data, &cursor, len, &ss->unknown3);

// 015-030: unknown key

ss->unknown_key = (unsigned char*)malloc(QQ_KEY_LENGTH);

bytes += read_packet_data(data, &cursor, len, ss->unknown_key, QQ_KEY_LENGTH);

}

//这里是更新好友的状态，可自己实现接口

//I_QQChangeBuddyStatus(ss->uid, ss->status);

}

int MyQQ::qq_process_login_ok(unsigned char * data, int len)

{

qq_login_reply_ok lrop;

int bytes;

unsigned char* cursor;

cursor = data;

bytes = 0;

// 000-000: reply code

bytes += read_packet_b(data, &cursor, len, &);

// 001-016: session key

n_key = (unsigned char*)malloc(QQ_KEY_LENGTH);

memcpy(n_key,cursor,QQ_KEY_LENGTH);

cursor += QQ_KEY_LENGTH;

bytes += QQ_KEY_LENGTH;

// 017-020: login uid

bytes += read_packet_dw(data, &cursor, len, &);

// 021-024: server detected user public IP

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & _ip, 4);

// 025-026: server detected user port

bytes += read_packet_w(data, &cursor, len, &_port);

// 027-030: server detected itself ip 127.0.0.1 ?

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & _ip, 4);

// 031-032: server listening port

bytes += read_packet_w(data, &cursor, len, &_port);

// 033-036: login time for current session

bytes += read_packet_dw(data, &cursor, len, (DWORD *) & _time);

// 037-062: 26 bytes, unknown

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & n1, 26);

// 063-066: unknown server1 ip address

bytes += read_packet_data(data, &cursor, len, (unsigned char *) &

n_server1_ip, 4);

// 067-068: unknown server1 port

bytes += read_packet_w(data, &cursor, len, &n_server1_port);

// 069-072: unknown server2 ip address

bytes += read_packet_data(data, &cursor, len, (unsigned char *) &

n_server2_ip, 4);

// 073-074: unknown server2 port

bytes += read_packet_w(data, &cursor, len, &n_server2_port);

// 075-076: 2 bytes unknown

bytes += read_packet_w(data, &cursor, len, &n2);

// 077-078: 2 bytes unknown

bytes += read_packet_w(data, &cursor, len, &n3);

// 079-110: 32 bytes unknown

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & n4, 32);

// 111-122: 12 bytes unknown

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & n5, 12);

// 123-126: login IP of last session

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & _client_ip, 4);

// 127-130: login time of last session

bytes += read_packet_dw(data, &cursor, len, (DWORD *) & _login_time);

// 131-138: 8 bytes unknown

bytes += read_packet_data(data, &cursor, len, (unsigned char *) & n6, 8);

memcpy(SessionKey,n_key, QQ_KEY_LENGTH);

sprintf(MyIP,"%d.%d.%d.%d",_ip[0],_ip[1],_ip[2],_ip[3]);

MyPort = _port;

IsLogin = true;

qq_send_packet_get_info(UserID);

switch(LoginMode)

{

case 1:

Status = 1;

break;

case 2:

Status = 3;

break;

default:

break;

}

qq_send_packet_change_status();

GetFriendList();

return QQ_LOGIN_REPLY_OK;

}

int MyQQ::qq_process_login_redirect(unsigned char * data, int len)

{

int bytes, ret;

unsigned char *cursor;

qq_login_reply_redirect_packet lrrp;

cursor = data;

bytes = 0;

// 000-000: reply code

bytes += read_packet_b(data, &cursor, len, &);

// 001-004: login uid

bytes += read_packet_dw(data, &cursor, len, &);

// 005-008: redirected new server IP

bytes += read_packet_data(data, &cursor, len, _server_ip, 4);

// 009-010: redirected new server port

bytes += read_packet_w(data, &cursor, len, &_server_port);

if (bytes != QQ_LOGIN_REPLY_REDIRECT_PACKET_LEN) {

ret = QQ_LOGIN_REPLY_MISC_ERROR;

} else {

sprintf(LoginServer,"%d.%d.%d.%d",_server_ip[0],_server_ip[1],_server_ip[2],_server_ip[3]);

//服务器端口

LoginPort = _server_port;

_family = AF_INET;

_addr.s_addr = inet_addr(LoginServer);

_port = htons(LoginPort);

//向新的服务器地址发送登录请求

Login(LoginMode);

ret = QQ_LOGIN_REPLY_REDIRECT;

}

return ret;

}

int MyQQ::qq_process_login_wrong_pwd(unsigned char * data, int len)

{

return QQ_LOGIN_REPLY_PWD_ERROR;

}

void MyQQ::qq_send_packet_change_status()

{

unsigned char *raw_data, *cursor, away_cmd;

DWORD misc_status;

if (IsLogin == false)

return;

switch (Status) {

case 1:

away_cmd = QQ_BUDDY_ONLINE_NORMAL;

break;

case 2:

away_cmd = QQ_BUDDY_ONLINE_INVISIBLE;

break;

case 3:

away_cmd = QQ_BUDDY_ONLINE_AWAY;

break;

default:

away_cmd = QQ_BUDDY_ONLINE_NORMAL;

} // switch

raw_data = (unsigned char*)malloc(5);

cursor = raw_data;

misc_status = 0x00000000;

create_packet_b(raw_data, &cursor, away_cmd);

create_packet_dw(raw_data, &cursor, misc_status);

qq_send_cmd(QQ_CMD_CHANGE_ONLINE_STATUS, TRUE, 0, TRUE, raw_data, 5);

}

void MyQQ::TurnInvisible()

{

Status = 2;

qq_send_packet_change_status();

}

void MyQQ::TurnVisible()

{

Status = 1;

qq_send_packet_change_status();

}

void MyQQ::TurnAway()

{

Status = 3;

qq_send_packet_change_status();

}

void MyQQ::Logout()

{

int i;

for (i = 0; i < 4; i++)

qq_send_cmd(QQ_CMD_LOGOUT, FALSE, 0xffff, FALSE, PwdKey, QQ_KEY_LENGTH);

IsLogin = false;

Status = 0;

}

void MyQQ::QQSendTextMessage(DWORD to_uid, char * msg, int type)

{

unsigned char *cursor, *raw_data;

short client_tag, normal_im_type;

int msg_len, raw_len, bytes;

time_t now;

unsigned char *md5;

char *msg_filtered;

char *font_size = NULL, *font_color = NULL, *font_name = NULL, *tmp;

bool is_bold = FALSE, is_italic = FALSE, is_underline = FALSE;

const char *start, *end, *last;

client_tag = QQ_CLIENT;

normal_im_type = QQ_NORMAL_IM_TEXT;

last = msg;

msg_filtered = msg;

msg_len = strlen(msg_filtered);

now = time(NULL);

md5 = gen_session_md5(UserID, SessionKey);

int font_name_len, tail_len;

font_name_len = 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 = (unsigned char*)malloc(raw_len);

cursor = raw_data;

bytes = 0;

//000-003: receiver uid

bytes += create_packet_dw(raw_data, &cursor, UserID);

//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, UserID);

//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);

bytes += create_packet_w(raw_data, &cursor, send_seq);

//038-041: send time

bytes += create_packet_dw(raw_data, &cursor, (DWORD)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);

bytes += create_packet_b(raw_data, &cursor, MyIcon);

//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, (unsigned char *)msg_filtered, msg_len);

unsigned char *send_im_tail = qq_get_send_im_tail(font_color, font_size, font_name, false,false, false, tail_len);

bytes += create_packet_data(raw_data, &cursor, send_im_tail, tail_len);

if (bytes == raw_len) // create packet OK

{

qq_send_cmd(QQ_CMD_SEND_IM, TRUE, 0, TRUE, raw_data, cursor - raw_data);

}

}

unsigned char * MyQQ::gen_session_md5(int uid, unsigned char * session_key)

{

unsigned char *src, md5_str[QQ_KEY_LENGTH];

unsigned char *cursor;

md5_state_t ctx;

src = (unsigned char *)malloc(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);

unsigned char * t = (unsigned char *)malloc(QQ_KEY_LENGTH);

memcpy(t,md5_str, QQ_KEY_LENGTH);

return t;

}

unsigned char * MyQQ::qq_get_send_im_tail(const char * font_color,

const char * font_size,

const char * font_name,

bool is_bold, bool is_italic, bool is_underline, int tail_len)

{

char *s1, *s2;

unsigned char *rgb;

int font_name_len;

unsigned char *send_im_tail;

const unsigned char simsun[] = { 0xcb, 0xce, 0xcc, 0xe5 };

font_name_len = DEFAULT_FONT_NAME_LEN;

font_name = (const char*)&(simsun[0]);

send_im_tail = (unsigned char*)malloc(tail_len);

memcpy(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;

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;

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;

return (unsigned char *) send_im_tail;

}

//处理普通的QQ消息

void MyQQ::qq_process_recv_normal_im(unsigned char * data, unsigned char ** cursor, int len)

{

int bytes;

qq_recv_normal_im_common *common;

qq_recv_normal_im_unprocessed *im_unprocessed;

if (*cursor >= (data + len - 1)) {

return;

}

else

common = (qq_recv_normal_im_common *)malloc(sizeof(qq_recv_normal_im_common));

bytes = qq_normal_im_common_read(data, cursor, len, common);

if (bytes < 0) {

return;

}

switch (common->normal_im_type) {

case QQ_NORMAL_IM_TEXT:

qq_process_recv_normal_im_text (data, cursor, len, common);

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:

return;

} // normal_im_type

g_free (common->session_md5);

}

void MyQQ::qq_process_recv_normal_im_text(unsigned char * data, unsigned char ** cursor, int len, qq_recv_normal_im_common * common)

{

short gaim_msg_type;

char *name;

char *msg_with_gaim_smiley;

char *msg_utf8_encoded;

qq_recv_normal_im_text *im_text;

if (*cursor >= (data + len - 1)) {

return;

} else

im_text = (qq_recv_normal_im_text *)malloc(sizeof(qq_recv_normal_im_text));

im_text->common = common;

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, (unsigned char *) & (im_text->unknown2), 3);

read_packet_b(data, cursor, len, &(im_text->is_there_font_attr));

read_packet_data(data, cursor, len, (unsigned char *) & (im_text->unknown3), 4);

read_packet_b(data, cursor, len, &(im_text->msg_type));

if (im_text->msg_type == QQ_IM_AUTO_REPLY) {

im_text->is_there_font_attr = 0x00;

im_text->msg = (unsigned char *)malloc(1024);

memcpy(im_text->msg,*cursor, data + len - *cursor);

} else {

if (im_text->is_there_font_attr) {

im_text->msg = (unsigned char *)malloc(1500);

memcpy(im_text->msg,*cursor, strlen((const char *)*cursor));

im_text->msg[strlen((const char *)*cursor)] = 0;

}

else

{ im_text->msg = (unsigned char *)malloc(1024);

memcpy(im_text->msg,*cursor, data + len - *cursor);

im_text->msg[data + len - *cursor] = 0;

}

}

MessageText = im_text->msg;

//如果需要自动回复

if(Status == 3)

{

//I_QQAutoReply()函数获取预先设置的自动回复消息内容，需自己实现

char* MText = I_QQAutoReply();

QQSendTextMessage(common->sender_uid,MText,0x01);

}

//在主界面中显示消息

//I_QQReceiveMessage((char *)MessageText,common->sender_uid);

}

int MyQQ::qq_normal_im_common_read(unsigned char * data, unsigned char ** cursor, int len, qq_recv_normal_im_common * common)

{

int bytes;

bytes = 0;

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 = (unsigned char *)malloc(QQ_KEY_LENGTH);

memcpy(common->session_md5,*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) {

return -1;

}

return bytes;

}