ZOL博客
ZOL首页 | 博客首页
登录  |   注册  |   帮助
我的主页 日志 好友 相册
论坛
视频装备圈子 网摘
ZOL博客 > 叛逆々太子 的主页 > 日志

QQ雏形源码


2006-11-14 23:58:26   浏览(159)

// MyQQ.cpp: 非完全版本
//////////////////////////////////////////////////////////////////////
#include "QQdef.h"
#include "QQcrypt.h"
#include "winsock2.h"
#include "md5.h"
#include "MyQQ.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加密空串
    MCrypter.qq_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;

    //加密
    MCrypter.qq_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 (MCrypter.qq_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 (MCrypter.qq_crypt(DECRYPT, buf, buf_len, PwdKey, data, &len)) {

if (data[0] == QQ_LOGIN_REPLY_OK) {
ret = qq_process_login_ok(data, len);
} els

/n-->
e {
ret = QQ_LOGIN_REPLY_MISC_ERROR;
}
} else {
len = buf_len;
if (MCrypter.qq_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(MCrypter.qq_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, &lrop.result);
// 001-016: session key
lrop.session_key = (unsigned char*)malloc(QQ_KEY_LENGTH);
memcpy(lrop.session_key,cursor,QQ_KEY_LENGTH);

cursor += QQ_KEY_LENGTH;
bytes += QQ_KEY_LENGTH;

// 017-020: login uid
bytes += read_packet_dw(data, &cursor, len, &lrop.uid);
// 021-024: server detected user public IP
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.client_ip, 4);
// 025-026: server detected user port
bytes += read_packet_w(data, &cursor, len, &lrop.client_port);
// 027-030: server detected itself ip 127.0.0.1 ?
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.server_ip, 4);
// 031-032: server listening port
bytes += read_packet_w(data, &cursor, len, &lrop.server_port);
// 033-036: login time for current session
bytes += read_packet_dw(data, &cursor, len, (DWORD *) & lrop.login_time);
// 037-062: 26 bytes, unknown
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.unknown1, 26);
// 063-066: unknown server1 ip address
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.unknown_server1_ip, 4);
// 067-068: unknown server1 port
bytes += read_packet_w(data, &cursor, len, &lrop.unknown_server1_port);
// 069-072: unknown server2 ip address
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.unknown_server2_ip, 4);
// 073-074: unknown server2 port
bytes += read_packet_w(data, &cursor, len, &lrop.unknown_server2_port);
// 075-076: 2 bytes unknown
bytes += read_packet_w(data, &cursor, len, &lrop.unknown2);
// 077-078: 2 bytes unknown
bytes += read_packet_w(data, &cursor, len, &lrop.unknown3);
// 079-110: 32 bytes unknown
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.unknown4, 32);
// 111-122: 12 bytes unknown
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.unknown5, 12);
// 123-126: login IP of last session
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.last_client_ip, 4);
// 127-130: login time of last session
bytes += read_packet_dw(data, &cursor, len, (DWORD *) & lrop.last_login_time);
// 131-138: 8 bytes unknown
bytes += read_packet_data(data, &cursor, len, (unsigned char *) & lrop.unknown6, 8);

memcpy(SessionKey,lrop.session_key, QQ_KEY_LENGTH);

sprintf(MyIP,"%d.%d.%d.%d",lrop.client_ip[0],lrop.client_ip[1],lrop.client_ip[2],lrop.client_ip[3]);
MyPort = lrop.client_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, &lrrp.result);

// 001-004: login uid
bytes += read_packet_dw(data, &cursor, len, &lrrp.uid);

// 005-008: redirected new server IP
bytes += read_packet_data(data, &cursor, len, lrrp.new_server_ip, 4);

// 009-010: redirected new server port
bytes += read_packet_w(data, &cursor, len, &lrrp.new_server_port);

if (bytes != QQ_LOGIN_REPLY_REDIRECT_PACKET_LEN) {
ret = QQ_LOGIN_REPLY_MISC_ERROR;
} else {
sprintf(LoginServer,"%d.%d.%d.%d",lrrp.new_server_ip[0],lrrp.new_server_ip[1],lrrp.new_server_ip[2],lrrp.new_server_ip[3]);

//服务器端口
LoginPort = lrrp.new_server_port;

ServerAddr.sin_family = AF_INET;
ServerAddr.sin_addr.s_addr = inet_addr(LoginServer);
ServerAddr.sin_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);

//0

38-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;
}

//请求获得在线好友列表
void MyQQ::qq_send_packet_get_buddies_online(unsigned char position)
{

unsigned char *raw_data, *cursor;

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

create_packet_b(raw_data, &cursor, QQ_GET_ONLINE_BUDDY_02);
// 001-001 seems it supports 255 online buddies at most
create_packet_b(raw_data, &cursor, position);
// 002-002
create_packet_b(raw_data, &cursor, 0x00);
// 003-004
create_packet_w(raw_data, &cursor, 0x0000);

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

}

//处理在线好友列表消息
void MyQQ::qq_process_get_buddies_online_reply(unsigned char * buf, int buf_len)
{
int len, bytes;
unsigned char *data, *cursor, position;
qq_buddy *q_bud;
qq_friends_online_entry *fe;
QQFriend *p;

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

if (MCrypter.qq_crypt(DECRYPT, buf, buf_len, SessionKey, data, &len))
{
read_packet_b(data, &cursor, len, &position);

fe = (qq_friends_online_entry *)malloc(sizeof(qq_friends_online_entry));
qq_buddy_status * s = (qq_buddy_status *)malloc(sizeof(qq_buddy_status));

while (cursor < (data + len))
{

bytes = 0;

// 000-003: uid
bytes += read_packet_dw(data, &cursor, len, &s->uid);
// 004-004: 0x01
bytes += read_packet_b(data, &cursor, len, &s->unknown1);
// 005-008: ip
s->ip = (unsigned char*)malloc(4);
bytes += read_packet_data(data, &cursor, len, s->ip, 4);
// 009-010: port
bytes += read_packet_w(data, &cursor, len, &s->port);
// 011-011: 0x00
bytes += read_packet_b(data, &cursor, len, &s->unknown2);
// 012-012: status
bytes += read_packet_b(data, &cursor, len, &s->status);
// 013-014:
bytes += read_packet_w(data, &cursor, len, &s->unknown3);
// 015-030: unknown key
s->unknown_key = (unsigned char*)malloc(QQ_KEY_LENGTH);
bytes += read_packet_data(data, &cursor, len, s->unknown_key, QQ_KEY_LENGTH);

// 031-032: unknown4
bytes += read_packet_w(data, &cursor, len, &fe->unknown1);
// 033-033: flag1
bytes += read_packet_b(data, &cursor, len, &fe->flag1);
// 034-034: comm_flag
bytes += read_packet_b(data, &cursor, len, &fe->comm_flag);
// 035-036:
bytes += read_packet_w(data, &cursor, len, &fe->unknown2);
// 037-037:
bytes += read_packet_b(data, &cursor, len, &fe->ending); // 0x00

p = FriendListHead;
while(p != NULL)
{
if(p->Buddy->uid == s->uid)
{
p->Buddy->status = s->status;
break;
}
p = p->next;
}
} // while cursor

if(position != 0xFF)
{
//如

果类表为接收完，继续发消息请求
qq_send_packet_get_buddies_online(position);
}
else
{
//更新好友的状态
p = FriendListHead;
while(p != NULL)
{
if(p->Buddy->status != QQ_BUDDY_ONLINE_OFFLINE)
{
//I_QQChangeBuddyStatus(p->Buddy->uid, p->Buddy->status);
}
p = p->next;
}
}
}
}

//请求获得好友列表
void MyQQ::qq_send_packet_get_buddies_list(short position)
{
unsigned char *raw_data, *cursor;
int data_len;

data_len = 3;
raw_data = (unsigned char*)malloc(data_len);
cursor = raw_data;
// 000-001 starting position, can manually specify
create_packet_w(raw_data, &cursor, position);

create_packet_b(raw_data, &cursor, 0x00);

qq_send_cmd(QQ_CMD_GET_FRIENDS_LIST, TRUE, 0, TRUE, raw_data, data_len);
}

//处理好友列表消息
void MyQQ::qq_process_get_buddies_list_reply(unsigned char * buf, int buf_len)
{
qq_buddy *q_bud;
int len, bytes, bytes_expected, i;
short position = 0, unknown;
unsigned char *data, *cursor, bar;//, pascal_len;
unsigned short pascal_len;
char *name;


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

if (MCrypter.qq_crypt(DECRYPT, buf, buf_len, SessionKey, data, &len)) {
read_packet_w(data, &cursor, len, &position);
i = 0;
while (cursor < (data + len)) {
q_bud = (qq_buddy *)malloc(sizeof(qq_buddy));
bytes = 0;
// 000-003: uid
bytes += read_packet_dw(data, &cursor, len, &q_bud->uid);
// 004-004: 0xff if buddy is self, 0x00 otherwise
bytes += read_packet_b(data, &cursor, len, &bar);
// 005-005: icon index (1-255)
bytes += read_packet_b(data, &cursor, len, &q_bud->icon);
// 006-006: age
bytes += read_packet_b(data, &cursor, len, &q_bud->age);
// 007-007: gender
bytes += read_packet_b(data, &cursor, len, &q_bud->gender);

//这里如果字符集不同还要进行转换
pascal_len = cursor[0];
q_bud->nickname = (unsigned char*)malloc(pascal_len+1);
memcpy(q_bud->nickname,cursor+1,pascal_len);
q_bud->nickname[pascal_len] = 0;
pascal_len++;


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

bytes += read_packet_b(data, &cursor, len, &q_bud->flag1);
bytes += read_packet_b(data, &cursor, len, &q_bud->comm_flag);

bytes_expected = 12 + pascal_len;

if (q_bud->uid == 0 || bytes != bytes_expected) {

continue;
} else
i++;

//这里应是将好友信息写入本地好友列表
AddBuddyToList(q_bud);
} // while cursor

if (position == 0xFFFFFFFF) {
//在主界面上显示好友列表
//I_QQUpdateBuddyList();

//若接收完毕，则请求在线好友列表
qq_send_packet_get_buddies_online(QQ_FRIENDS_ONLINE_POSITION_START);
} else //继续请求好友列表
qq_send_packet_get_buddies_list(position);
}
}


//读取好友状态
int MyQQ::qq_buddy_status_read(unsigned char * data, unsigned char ** cursor, int len, qq_buddy_status * s)
{
int bytes;

bytes = 0;

// 000-003: uid
bytes += read_packet_dw(data, cursor, len, &s->uid);
// 004-004: 0x01
bytes += read_packet_b(data, cursor, len, &s->unknown1);
// 005-008: ip
s->ip = (unsigned char *)malloc(4);
bytes += read_packet_data(data, cursor, len, s->ip, 4);
// 009-010: port
bytes += read_packet_w(data, cursor, len, &s->port);
// 011-011: 0x00
bytes += read_packet_b(data, cursor, len, &s->unknown2);
// 012-012: status
bytes += read_packet_b(data, cursor, len, &s->status);
// 013-014:
bytes += read_packet_w(data, cursor, len, &s->unknown3);
// 015-030: unknown key
s->unknown_key = (unsigned char *)malloc(QQ_KEY_LENGTH);
bytes += read_packet_data(data, cursor, len, s->unknown_key, QQ_KEY_LENGTH);

if (s->uid == 0 || bytes != 31)
return -1;

return bytes;
}


void MyQQ::AddBuddyToList(qq_buddy * pBuddy)
{
qq_buddy * temp = (qq_buddy*)malloc(sizeof(qq_buddy));
memcpy(temp,pBuddy,sizeof(qq_buddy));

QQFriend * p = (QQFriend*)malloc(sizeof(QQFriend));
p->Buddy = temp;
p->next = NULL;

if(FriendListHead == NULL)
{
FriendListHead = p;
FriendListTail = p;
}
else
{
FriendListTail->next = p;
FriendListTail = p;
}
}


void MyQQ::GetFriendList()
{
  qq_send_packet_get_buddies_list(QQ_FRIENDS_LIST_POSITION_START);
}

void MyQQ::GetOnlineFriendList()
{
  qq_send_packet_get_buddies_online(QQ_FRIENDS_ONLINE_POSITION_START);
}


void MyQQ::ListFriend()
{
  char Num[15];
  char Name[256];
  QQFriend * p = FriendListHead;
  while(p != NULL)
  {
    sprintf(Num,"%d",(p->Buddy)->uid);
    sprintf(Name,"%s%c",(char*)((p->Buddy)->nickname),'

投稿：情感
评论(0) | 浏览(159) | 收藏到我的网摘 | 邀请好友阅读
谁顶了这篇日志>>  还有谁对该日志投票? 最近读者>>
0
票
好文，顶
0
票
烂文，踩
 
网友评论>>
发表评论：  
 
内　容：
插入表情 文采分大于5可以使用表情
   *Ctrl+Enter快速回复

针对ZOL博客您有任何使用问题和建议 您可以 联系博客管理员 或 查看帮助
ZOL简介 | 用户注册 | 广告服务 | 人员招聘(月) | ZOL历程 | 互动营销中心 | 站点地图 | 联系方式 | 欢迎投稿 | RSS订阅 | 友情链接
Copyright ©1999 - 2008 ZOL. All rights reserved. 中关村在线 版权所有.