void qq_process_room_cmd_get_qun_list( guint8 *data, gint data_len, PurpleConnection *gc )
{
qq_data *qd;
qq_room_data *rmd;
guint32 id, qun_id;
gint bytes;
guint8 num;
guint8 i;
g_return_if_fail(data != NULL && data_len > 0);
qd = (qq_data *) gc->proto_data;
/* qq_show_packet("Room List", data, data_len); */
bytes = 0;
bytes += qq_get8(&num, data);
for (i=0; i<num; ++i)
{
bytes += qq_get32(&id, data+bytes);
bytes += qq_get32(&qun_id, data+bytes);
bytes ++;
rmd = qq_room_data_find(gc, id);
g_return_if_fail(rmd != NULL);
rmd->qun_id = qun_id;
rmd->my_role = QQ_ROOM_ROLE_YES;
purple_debug_info("QQ", "Qun added id: %u qun_id: %u\n",
rmd->id, rmd->qun_id);
}
}
static void process_level(PurpleConnection *gc, guint8 *data, gint data_len)
{
gint bytes = 0;
guint32 uid, onlineTime;
guint16 level, timeRemainder;
qq_buddy_data *bd;
while (data_len - bytes >= 12) {
bytes += qq_get32(&uid, data + bytes);
bytes += qq_get32(&onlineTime, data + bytes);
bytes += qq_get16(&level, data + bytes);
bytes += qq_get16(&timeRemainder, data + bytes);
purple_debug_info("QQ", "level: %d, uid %u, tmOnline: %d, tmRemainder: %d\n",
level, uid, onlineTime, timeRemainder);
bd = qq_buddy_data_find(gc, uid);
if (bd == NULL) {
purple_debug_error("QQ", "Got levels of %u not in my buddy list\n", uid);
continue;
}
bd->onlineTime = onlineTime;
bd->level = level;
bd->timeRemainder = timeRemainder;
}
if (bytes != data_len) {
purple_debug_error("QQ",
"Wrong format of Get levels. Truncate %d bytes.\n", data_len - bytes);
}
}
static gint _qq_get_file_header(qq_file_header *fh, guint8 *buf)
{
gint bytes = 0;
bytes += qq_get16(&(fh->client_ver), buf + bytes);
bytes += qq_get8(&fh->file_key, buf + bytes);
bytes += qq_get32(&(fh->sender_uid), buf + bytes);
bytes += qq_get32(&(fh->receiver_uid), buf + bytes);
fh->sender_uid = _decrypt_qq_uid(fh->sender_uid, _get_file_key(fh->file_key));
fh->receiver_uid = _decrypt_qq_uid(fh->receiver_uid, _get_file_key(fh->file_key));
return bytes;
}
/* read the common parts of the normal_im,
* returns the bytes read if succeed, or -1 if there is any error */
static gint get_im_header(qq_im_header *im_header, guint8 *data, gint len)
{
gint bytes;
g_return_val_if_fail(data != NULL && len > 0, -1);
bytes = 0;
bytes += qq_get16(&(im_header->version_from), data + bytes);
bytes += qq_get32(&(im_header->uid_from), data + bytes);
bytes += qq_get32(&(im_header->uid_to), data + bytes);
bytes += qq_getdata(im_header->session_md5, QQ_KEY_LENGTH, data + bytes);
bytes += qq_get16(&(im_header->im_type), data + bytes);
return bytes;
}
void qq_process_buddy_check_code(PurpleConnection *gc, guint8 *data, gint data_len)
{
qq_data *qd;
gint bytes;
guint8 cmd;
guint8 reply;
guint32 uid;
guint16 flag1, flag2;
g_return_if_fail(data != NULL && data_len >= 5);
qd = (qq_data *) gc->proto_data;
qq_show_packet("buddy_check_code", data, data_len);
bytes = 0;
bytes += qq_get8(&cmd, data + bytes); /* 0x03 */
bytes += qq_get8(&reply, data + bytes);
if (reply == 0) {
purple_debug_info("QQ", "Failed checking code\n");
return;
}
bytes += qq_get32(&uid, data + bytes);
g_return_if_fail(uid != 0);
bytes += qq_get16(&flag1, data + bytes);
bytes += qq_get16(&flag2, data + bytes);
purple_debug_info("QQ", "Check code reply Ok, uid %u, flag 0x%04X-0x%04X\n",
uid, flag1, flag2);
return;
}
void qq_process_search_uid( PurpleConnection *gc, guint8 *data, gint data_len, qq_buddy_opt_req *opt_req )
{
gint bytes;
guint32 uid;
guint8 status;
gchar * name;
guint16 icon;
g_return_if_fail(data != NULL && data_len != 0);
g_return_if_fail(opt_req && opt_req->uid != 0);
//qq_show_packet("qq_process_search_uid", data, data_len);
bytes = 7;
bytes += qq_get32(&uid, data + bytes);
g_return_if_fail(uid == opt_req->uid);
bytes ++;
bytes += qq_get8(&status, data + bytes);
bytes += 4;
bytes += qq_get_vstr(&name, NULL, sizeof(guint8), data + bytes);
bytes += qq_get16(&icon, data + bytes);
bytes += 13;
bytes += qq_get16(&opt_req->no_auth_len, data + bytes);
if (opt_req->no_auth)
{
opt_req->no_auth = g_new0(guint8, opt_req->no_auth_len);
bytes += qq_getdata(opt_req->no_auth, opt_req->no_auth_len, data + bytes);
}
qq_request_add_buddy_post(gc, opt_req, NULL);
}
/* Process the reply to group_auth subcmd */
void qq_process_group_cmd_join_group_auth(guint8 *data, gint len, PurpleConnection *gc)
{
gint bytes;
guint32 id;
qq_room_data *rmd;
gchar *msg;
g_return_if_fail(data != NULL && len > 0);
if (len < 4) {
purple_debug_error("QQ",
"Invalid join room reply, expect %d bytes, read %d bytes\n", 4, len);
return;
}
bytes = 0;
bytes += qq_get32(&id, data + bytes);
g_return_if_fail(id > 0);
rmd = qq_room_data_find(gc, id);
if (rmd != NULL) {
msg = g_strdup_printf(_("Successfully joined Qun %s (%u)"), rmd->title_utf8, rmd->ext_id);
qq_got_message(gc, msg);
g_free(msg);
} else {
qq_got_message(gc, _("Successfully joined Qun"));
}
}
static void process_level_2007(PurpleConnection *gc, guint8 *data, gint data_len)
{
gint bytes;
guint32 uid, onlineTime;
guint16 level, timeRemainder;
qq_buddy_data *bd;
guint16 str_len;
gchar *str;
gchar *str_utf8;
bytes = 0;
bytes += qq_get32(&uid, data + bytes);
bytes += qq_get32(&onlineTime, data + bytes);
bytes += qq_get16(&level, data + bytes);
bytes += qq_get16(&timeRemainder, data + bytes);
purple_debug_info("QQ", "level: %d, uid %u, tmOnline: %d, tmRemainder: %d\n",
level, uid, onlineTime, timeRemainder);
bd = qq_buddy_data_find(gc, uid);
if (bd == NULL) {
purple_debug_error("QQ", "Got levels of %u not in my buddy list\n", uid);
return;
}
bd->onlineTime = onlineTime;
bd->level = level;
bd->timeRemainder = timeRemainder;
/* extend bytes in qq2007*/
bytes += 4; /* skip 8 bytes */
/* qq_show_packet("Buddies level", data + bytes, data_len - bytes); */
do {
bytes += qq_get16(&str_len, data + bytes);
if (str_len <= 0 || bytes + str_len > data_len) {
purple_debug_error("QQ",
"Wrong format of Get levels. Truncate %d bytes.\n", data_len - bytes);
break;
}
str = g_strndup((gchar *)data + bytes, str_len);
bytes += str_len;
str_utf8 = qq_to_utf8(str, QQ_CHARSET_DEFAULT);
purple_debug_info("QQ", "%s\n", str_utf8);
g_free(str_utf8);
g_free(str);
} while (bytes < data_len);
}
/* process group cmd reply "search group" */
void qq_process_room_search(PurpleConnection *gc, guint8 *data, gint len, guint32 ship32)
{
qq_data *qd;
qq_room_data rmd;
PurpleChat *chat;
gint bytes;
guint8 search_type;
guint16 unknown;
g_return_if_fail(data != NULL && len > 0);
qd = (qq_data *) gc->proto_data;
bytes = 0;
bytes += qq_get8(&search_type, data + bytes);
/* now it starts with group_info_entry */
bytes += qq_get32(&(rmd.id), data + bytes);
bytes += qq_get32(&(rmd.ext_id), data + bytes);
bytes += qq_get8(&(rmd.type8), data + bytes);
bytes += qq_get16(&(unknown), data + bytes);
bytes += qq_get16(&(unknown), data + bytes);
bytes += qq_get32(&(rmd.creator_uid), data + bytes);
bytes += qq_get16(&(unknown), data + bytes);
bytes += qq_get16(&(unknown), data + bytes);
bytes += qq_get16(&(unknown), data + bytes);
bytes += qq_get32(&(rmd.category), data + bytes);
bytes += qq_get_vstr(&(rmd.title_utf8), QQ_CHARSET_DEFAULT, data + bytes);
bytes += qq_get16(&(unknown), data + bytes);
bytes += qq_get8(&(rmd.auth_type), data + bytes);
bytes += qq_get_vstr(&(rmd.desc_utf8), QQ_CHARSET_DEFAULT, data + bytes);
/* end of one qq_group */
if(bytes != len) {
purple_debug_error("QQ",
"group_cmd_search_group: Dangerous error! maybe protocol changed, notify developers!");
}
if (ship32 == QQ_ROOM_SEARCH_FOR_JOIN) {
chat = qq_room_find_or_new(gc, rmd.id, rmd.ext_id);
g_return_if_fail(chat != NULL);
qq_room_update_chat_info(chat, &rmd);
qq_request_room_join(gc, &rmd);
} else {
add_to_roomlist(qd, &rmd);
}
}
void qq_process_add_buddy_touch( PurpleConnection *gc, guint8 *data, gint data_len, qq_buddy_opt_req *opt_req )
{
qq_data *qd;
gint bytes;
guint32 dest_uid;
guint8 reply;
g_return_if_fail(data != NULL && data_len >= 5);
g_return_if_fail(opt_req && opt_req->uid != 0);
qd = (qq_data *) gc->proto_data;
purple_debug_info("QQ", "Process buddy add no auth for id [%u]\n", opt_req->uid);
qq_show_packet("buddy_add_no_auth_ex", data, data_len);
bytes = 0;
bytes += qq_get32(&dest_uid, data + bytes);
bytes += qq_get8(&reply, data + bytes);
g_return_if_fail(dest_uid == opt_req->uid);
if (reply == 0x99) {
purple_debug_info("QQ", "Successfully added buddy %u\n", opt_req->uid);
qq_buddy_find_or_new(gc, opt_req->uid, opt_req->group_id);
qq_request_get_buddy_info(gc, opt_req->uid, 0, 0);
qq_request_get_level(gc, opt_req->uid);
qq_request_get_buddies_online(gc, 0, 0);
return;
}
if (reply != 0) {
purple_debug_info("QQ", "Failed adding buddy %u, Unknown reply 0x%02X\n",
opt_req->uid, reply);
}
/* need auth */
g_return_if_fail(data_len > bytes);
bytes += qq_get8(&opt_req->auth_type, data + bytes);
purple_debug_warning("QQ", "Adding buddy needs authorize 0x%02X\n", opt_req->auth_type);
switch (opt_req->auth_type) {
case 0x00: /* no authorize */
case 0x01: /* authorize */
qq_request_auth_token(gc, QQ_AUTH_INFO_BUDDY, QQ_AUTH_INFO_ADD_BUDDY, 0, opt_req);
break;
case 0x02: /* disable */
break;
case 0x03: /* answer question */
qq_request_question(gc, QQ_QUESTION_REQUEST, opt_req->uid, NULL, NULL);
break;
case 0x04: /* deny! */
break;
default:
g_return_if_reached();
break;
}
return;
}
/* from QQ2010 on, extra info should be taken out */
static gint packet_get_header_ex(UID *uid, guint8 *header_ex_fixed, guint8 *buf)
{
gint bytes = 0;
bytes += qq_get32(uid, buf + bytes);
bytes += qq_getdata(header_ex_fixed, 3, buf + bytes);
qq_show_packet("packet_get_header_ex", header_ex_fixed, 3);
purple_debug_info("QQ", "packet_get_header_ex - UID:%u\n", *uid);
return bytes;
}
void qq_process_room_cmd_get_onlines(guint8 *data, gint len, PurpleConnection *gc)
{
guint32 room_id, member_uid;
guint8 unknown;
gint bytes, num;
qq_room_data *rmd;
qq_buddy_data *bd;
g_return_if_fail(data != NULL && len > 0);
if (len <= 3) {
purple_debug_error("QQ", "Invalid group online member reply, discard it!\n");
return;
}
bytes = 0;
bytes += qq_get32(&room_id, data + bytes);
bytes += qq_get8(&unknown, data + bytes); /* 0x3c ?? */
g_return_if_fail(room_id > 0);
rmd = qq_room_data_find(gc, room_id);
if (rmd == NULL) {
purple_debug_error("QQ", "Can not info of room id [%u]\n", room_id);
return;
}
/* set all offline first, then update those online */
set_all_offline(rmd);
num = 0;
while (bytes < len) {
bytes += qq_get32(&member_uid, data + bytes);
num++;
bd = qq_room_buddy_find_or_new(gc, rmd, member_uid);
if (bd != NULL)
bd->status = QQ_BUDDY_ONLINE_NORMAL;
}
if(bytes > len) {
purple_debug_error("QQ",
"group_cmd_get_online_members: Dangerous error! maybe protocol changed, notify developers!");
}
purple_debug_info("QQ", "Group \"%s\" has %d online members\n", rmd->name, num);
qq_room_conv_set_onlines(gc, rmd);
}
/* process group cmd reply "join group" */
void qq_process_group_cmd_join_group(guint8 *data, gint len, PurpleConnection *gc)
{
gint bytes;
guint32 id;
qq_room_data *rmd;
gchar *msg;
g_return_if_fail(data != NULL && len > 0);
if (len < 4) {
purple_debug_error("QQ",
"Invalid join room reply, expect %d bytes, read %d bytes\n", 5, len);
return;
}
bytes = 0;
bytes += qq_get32(&id, data + bytes);
/* join group OK */
rmd = qq_room_data_find(gc, id);
/* need to check if group is NULL or not. */
g_return_if_fail(rmd != NULL);
purple_debug_info("QQ", "Succeeded in joining group \"%s\"\n", rmd->name);
rmd->my_role = QQ_ROOM_ROLE_YES;
qq_room_conv_open(gc, rmd);
/*
switch (reply) {
case QQ_ROOM_JOIN_OK:
purple_debug_info("QQ", "Succeeded in joining group \"%s\"\n", rmd->name);
rmd->my_role = QQ_ROOM_ROLE_YES;
qq_room_conv_open(gc, rmd);
break;
case QQ_ROOM_JOIN_NEED_AUTH:
purple_debug_info("QQ",
"Failed to join room qun id %u %s, needs authentication\n",
rmd->qun_id, rmd->name);
rmd->my_role = QQ_ROOM_ROLE_NO;
do_room_join_request(gc, rmd);
break;
case QQ_ROOM_JOIN_DENIED:
msg = g_strdup_printf(_("Qun %u denied from joining"), rmd->qun_id);
purple_notify_info(gc, _("QQ Qun Operation"), _("Failed:"), msg);
g_free(msg);
break;
default:
purple_debug_info("QQ",
"Failed to join room qun id %u %s, unknown reply: 0x%02x\n",
rmd->qun_id, rmd->name, reply);
purple_notify_info(gc, _("QQ Qun Operation"), _("Failed:"), _("Join Qun, Unknown Reply"));
} */
}
void qq_process_add_buddy_post( PurpleConnection *gc, guint8 *data, gint data_len, guintptr auth_type )
{
guint32 uid;
g_return_if_fail(data != NULL && data_len != 0);
qq_get32(&uid, data+1);
//qq_show_packet("qq_process_add_buddy_post", data, data_len);
if (auth_type == 0)
{
qq_buddy_find_or_new(gc, uid, 0xFF);
qq_request_get_buddy_info(gc, uid, 0, 0);
qq_request_get_buddies_online(gc, 0, 0);
qq_request_get_level(gc, uid);
}
}
/* If comes here, cmd is OK already */
void qq_process_group_cmd_exit_group(guint8 *data, gint len, PurpleConnection *gc)
{
gint bytes;
guint32 id;
g_return_if_fail(data != NULL && len > 0);
if (len < 4) {
purple_debug_error("QQ", "Invalid exit group reply, expect %d bytes, read %d bytes\n", 4, len);
return;
}
bytes = 0;
bytes += qq_get32(&id, data + bytes);
qq_room_remove(gc, id);
}
/* I receive a message, mainly it is text msg,
* but we need to process other types (group etc) */
static void process_private_msg(guint8 *data, gint data_len, guint16 cmd, guint16 seq, PurpleConnection *gc)
{
qq_data *qd;
gint bytes;
guint16 len;
guint8 tmp8;
struct {
guint32 uid_from;
guint32 uid_to;
guint32 seq;
struct in_addr ip_from;
guint16 port_from;
guint16 msg_type;
} header;
g_return_if_fail(data != NULL && data_len != 0);
qd = (qq_data *) gc->proto_data;
if (data_len < 16) { /* we need to ack with the first 16 bytes */
purple_debug_error("QQ", "MSG is too short\n");
return;
} else {
/* when we receive a message,
* we send an ACK which is the first 16 bytes of incoming packet */
qq_send_server_reply(gc, cmd, seq, data, 16);
}
/* check len first */
if (data_len < 20) { /* length of im_header */
purple_debug_error("QQ", "Invald MSG header, len %d < 20\n", data_len);
return;
}
bytes = 0;
bytes += qq_get32(&(header.uid_from), data + bytes);
bytes += qq_get32(&(header.uid_to), data + bytes);
bytes += qq_get32(&(header.seq), data + bytes);
/* if the message is delivered via server, it is server IP/port */
bytes += qq_getIP(&(header.ip_from), data + bytes);
bytes += qq_get16(&(header.port_from), data + bytes);
bytes += qq_get16(&(header.msg_type), data + bytes);
/* im_header prepared */
if (header.uid_to != qd->uid) { /* should not happen */
purple_debug_error("QQ", "MSG to %u, NOT me\n", header.uid_to);
return;
}
/* check bytes */
if (bytes >= data_len - 1) {
purple_debug_warning("QQ", "Empty MSG\n");
return;
}
switch (header.msg_type) {
case QQ_MSG_BUDDY_84:
case QQ_MSG_BUDDY_85:
purple_debug_info("QQ", "MSG from buddy [%d]\n", header.uid_from);
qq_process_im(gc, data + bytes, data_len - bytes, header.msg_type);
break;
case QQ_MSG_TO_UNKNOWN:
case QQ_MSG_BUDDY_09:
case QQ_MSG_BUDDY_A6:
case QQ_MSG_BUDDY_A7:
case QQ_MSG_BUDDY_78:
purple_debug_info("QQ ", "MSG from buddy [%d]\n", header.uid_from);
bytes += 1;
qq_get8(&tmp8, data+bytes);
while (tmp8 == 0)
{
bytes += 1;
bytes += qq_get16(&len, data+bytes);
bytes += len;
qq_get8(&tmp8, data+bytes);
}
qq_process_im(gc, data + bytes, data_len - bytes, header.msg_type);
break;
case QQ_MSG_TYPING:
qq_process_typing(gc, data+bytes, data_len-bytes, header.uid_from);
break;
case QQ_MSG_NEWS:
do_server_news(gc, data + bytes, data_len - bytes);
break;
case QQ_MSG_SMS:
do_got_sms(gc, data + bytes, data_len - bytes);
break;
case QQ_MSG_ROOM_IM_UNKNOWN:
case QQ_MSG_TEMP_ROOM_IM:
case QQ_MSG_ROOM_IM:
case QQ_MSG_ROOM_IM_52:
purple_debug_info("QQ", "MSG from room [%d]\n", header.uid_from);
qq_process_room_im(data + bytes, data_len - bytes, header.uid_from, gc, header.msg_type);
break;
case QQ_MSG_ADD_TO_ROOM:
purple_debug_info("QQ", "Notice from [%d], Added\n", header.uid_from);
/* uid_from is group id
* we need this to create a dummy group and add to blist */
qq_process_room_buddy_joined(data + bytes, data_len - bytes, header.uid_from, gc);
break;
case QQ_MSG_DEL_FROM_ROOM:
purple_debug_info("QQ", "Notice from room [%d], Removed\n", header.uid_from);
/* uid_from is group id */
qq_process_room_buddy_removed(data + bytes, data_len - bytes, header.uid_from, gc);
break;
case QQ_MSG_APPLY_ADD_TO_ROOM:
purple_debug_info("QQ", "Notice from room [%d], Joined\n", header.uid_from);
/* uid_from is group id */
qq_process_room_buddy_request_join(data + bytes, data_len - bytes, header.uid_from, gc);
break;
case QQ_MSG_APPROVE_APPLY_ADD_TO_ROOM:
purple_debug_info("QQ", "Notice from room [%d], Confirm add in\n",
header.uid_from);
/* uid_from is group id */
qq_process_room_buddy_approved(data + bytes, data_len - bytes, header.uid_from, gc);
break;
case QQ_MSG_REJCT_APPLY_ADD_TO_ROOM:
purple_debug_info("QQ", "Notice from room [%d], Refuse add in\n",
header.uid_from);
/* uid_from is group id */
qq_process_room_buddy_rejected(data + bytes, data_len - bytes, header.uid_from, gc);
break;
case QQ_MSG_SYS:
do_msg_sys(gc, data + bytes, data_len - bytes);
break;
default:
purple_debug_warning("QQ", "MSG from %u, unknown type %s [0x%04X]\n",
header.uid_from, get_im_type_desc(header.msg_type), header.msg_type);
qq_show_packet("MSG header", data, bytes);
if (data_len - bytes > 0) {
qq_show_packet("MSG data", data + bytes, data_len - bytes);
}
break;
}
}
void qq_process_room_cmd_get_info(guint8 *data, gint data_len, guint32 action, PurpleConnection *gc)
{
qq_data *qd;
qq_room_data *rmd;
qq_buddy_data *bd;
PurpleChat *chat;
PurpleConversation *conv;
guint8 organization, role;
guint16 max_members;
guint32 resend_flag, member_uid, id, qun_id, last_uid;
gint bytes;
guint num=0;
guint8 has_more=0;
gchar *topic;
g_return_if_fail(data != NULL && data_len > 0);
qd = (qq_data *) gc->proto_data;
/* qq_show_packet("Room Info", data, data_len); */
bytes = 0;
bytes += qq_get32(&id, data + bytes);
g_return_if_fail(id > 0);
bytes += qq_get32(&qun_id, data + bytes);
g_return_if_fail(qun_id > 0);
chat = qq_room_find_or_new(gc, id, qun_id);
g_return_if_fail(chat != NULL);
rmd = qq_room_data_find(gc, id);
g_return_if_fail(rmd != NULL);
bytes += qq_get32(&resend_flag, data + bytes); //first 00 00 00 03, then 00 00 00 02
if (resend_flag == 0x00000003)
{
bytes += qq_get8(&(rmd->type8), data + bytes);
bytes += 4; //maybe vip sign
bytes += qq_get32(&(rmd->creator_uid), data + bytes);
if (rmd->creator_uid == qd->uid)
rmd->my_role = QQ_ROOM_ROLE_ADMIN;
bytes += qq_get8(&(rmd->auth_type), data + bytes);
bytes += 4 ; /* oldCategory */
bytes += 2; // 00 00
bytes += qq_get32(&(rmd->category), data + bytes);
bytes += qq_get16(&max_members, data + bytes);
bytes += 1;
bytes += 8;
purple_debug_info("QQ", "type: %u creator: %u category: %u max_members: %u\n",
rmd->type8, rmd->creator_uid, rmd->category, max_members);
bytes += qq_get_vstr(&(rmd->name), NULL, sizeof(guint8), data + bytes);
bytes += 2; /* 0x0000 */
bytes += qq_get_vstr(&(rmd->bulletin), NULL, sizeof(guint8), data + bytes);
bytes += qq_get_vstr(&(rmd->intro), NULL, sizeof(guint8), data + bytes);
bytes += qq_get_vstr(&(rmd->token), NULL, sizeof(guint16), data + bytes);
purple_debug_info("QQ", "room [%s] bulletin [%s] intro [%s] \n",
rmd->name, rmd->bulletin, rmd->intro);
bytes += 2; //Unknown
bytes += qq_get32(&last_uid, data + bytes); /* last_uid of this recv, request more with it */
bytes += qq_get8(&has_more, data + bytes); /* if there are more, request again */
/* now comes the member list separated by 0x00 */
} else {
/* resend_flag 00 00 00 02 is special, start with random one only 5 bytes */
bytes += qq_get32(&member_uid, data + bytes);
num++;
bytes += qq_get8(&organization, data + bytes);
bd = qq_room_buddy_find_or_new(gc, rmd, member_uid);
}
while (bytes < data_len) {
bytes += qq_get32(&member_uid, data + bytes);
num++;
bytes += qq_get8(&organization, data + bytes);
bytes += qq_get8(&role, data + bytes);
#if 0
if(organization != 0 || role != 0) {
purple_debug_info("QQ", "%u, organization=%d, role=%d\n", member_uid, organization, role);
}
#endif
bd = qq_room_buddy_find_or_new(gc, rmd, member_uid);
if (bd != NULL)
bd->role = role;
}
purple_debug_info("QQ", "Qun \"%s\" has received %d members\n", rmd->name, num);
if (has_more)
{
qq_send_room_cmd_mess(gc, QQ_ROOM_CMD_GET_INFO, id, NULL, 0,
0, last_uid);
} else {
qq_room_update_chat_info(chat, rmd);
if (action == QQ_ROOM_INFO_DISPLAY) {
room_info_display(gc, rmd);
}
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
rmd->name, purple_connection_get_account(gc));
if(NULL == conv) {
purple_debug_warning("QQ", "Conversation \"%s\" is not opened\n", rmd->name);
return;
}
topic = g_strdup_printf("%u %s", rmd->qun_id, rmd->bulletin);
purple_debug_info("QQ", "Set chat topic to %s\n", topic);
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(conv), NULL, topic);
g_free(topic);
}
}
/* process the reply to get_members_info packet */
void qq_process_room_cmd_get_members_info( guint8 *data, gint len, guint32 index, PurpleConnection *gc )
{
gint bytes;
gint num;
guint32 id, member_uid;
guint16 unknown;
qq_room_data *rmd;
qq_buddy_data *bd;
gchar *nick;
g_return_if_fail(data != NULL && len > 0);
/* qq_show_packet("qq_process_room_cmd_get_members_info", data, len); */
bytes = 0;
bytes += qq_get32(&id, data + bytes);
g_return_if_fail(id > 0);
rmd = qq_room_data_find(gc, id);
g_return_if_fail(rmd != NULL);
num = 0;
while (bytes < len) {
bytes += qq_get32(&member_uid, data + bytes);
g_return_if_fail(member_uid > 0);
bd = qq_room_buddy_find_or_new(gc, rmd, member_uid);
g_return_if_fail(bd != NULL);
num++;
bytes += qq_get16(&(bd->face), data + bytes);
bytes += qq_get8(&(bd->age), data + bytes);
bytes += qq_get8(&(bd->gender), data + bytes);
/* only here use old charset GB18030 */
bytes += qq_get_vstr(&nick, QQ_CHARSET_DEFAULT, sizeof(guint8), data + bytes);
bytes += qq_get16(&unknown, data + bytes);
bytes += qq_get8(&(bd->ext_flag), data + bytes);
bytes += qq_get8(&(bd->comm_flag), data + bytes);
qq_filter_str(nick);
bd->nickname = g_strdup(nick);
g_free(nick);
#if 0
purple_debug_info("QQ",
"member [%d]: ext_flag=0x%02x, comm_flag=0x%02x, nick=%s\n",
member_uid, bd->ext_flag, bd->comm_flag, bd->nickname);
#endif
bd->last_update = time(NULL);
}
if (bytes > len) {
purple_debug_error("QQ",
"group_cmd_get_members_info: Dangerous error! maybe protocol changed, notify developers!");
}
purple_debug_info("QQ", "Group \"%s\" got %d member info\n", rmd->name, num);
if (index)
{
qq_request_room_get_members_info(gc, id, 0, index);
return;
}
rmd->has_got_members_info = TRUE;
qq_room_conv_set_onlines(gc, rmd);
}
static void _qq_process_recv_file_data(PurpleConnection *gc, guint8 *data, gint len)
{
gint bytes ;
qq_file_header fh;
guint16 packet_type;
guint16 packet_seq;
guint8 sub_type;
guint32 fragment_index;
guint16 fragment_len;
guint32 fragment_offset;
qq_data *qd = (qq_data *) gc->proto_data;
ft_info *info = (ft_info *) qd->xfer->data;
bytes = 0;
bytes += _qq_get_file_header(&fh, data + bytes);
bytes += 1; /* skip an unknown byte */
bytes += qq_get16(&packet_type, data + bytes);
switch(packet_type)
{
case QQ_FILE_CMD_FILE_OP:
bytes += qq_get16(&packet_seq, data + bytes);
bytes += qq_get8(&sub_type, data + bytes);
switch (sub_type)
{
case QQ_FILE_BASIC_INFO:
bytes += 4; /* file length, we have already known it from xfer */
bytes += qq_get32(&info->fragment_num, data + bytes);
bytes += qq_get32(&info->fragment_len, data + bytes);
/* FIXME: We must check the md5 here,
* if md5 doesn't match we will ignore
* the packet or send sth as error number */
info->max_fragment_index = 0;
info->window = 0;
purple_debug_info("QQ",
"start receiving data, %d fragments with %d length each\n",
info->fragment_num, info->fragment_len);
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP_ACK, sub_type,
0, 0, NULL, 0);
break;
case QQ_FILE_DATA_INFO:
bytes += qq_get32(&fragment_index, data + bytes);
bytes += qq_get32(&fragment_offset, data + bytes);
bytes += qq_get16(&fragment_len, data + bytes);
purple_debug_info("QQ",
"received %dth fragment with length %d, offset %d\n",
fragment_index, fragment_len, fragment_offset);
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP_ACK, sub_type,
fragment_index, packet_seq, NULL, 0);
_qq_recv_file_progess(gc, data + bytes, fragment_len, fragment_index, fragment_offset);
break;
case QQ_FILE_EOF:
purple_debug_info("QQ", "end of receiving\n");
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP_ACK, sub_type,
0, 0, NULL, 0);
break;
}
break;
case QQ_FILE_CMD_FILE_OP_ACK:
bytes += qq_get16(&packet_seq, data + bytes);
bytes += qq_get8(&sub_type, data + bytes);
switch (sub_type)
{
case QQ_FILE_BASIC_INFO:
info->max_fragment_index = 0;
info->window = 0;
/* It is ready to send file data */
_qq_send_file_progess(gc);
break;
case QQ_FILE_DATA_INFO:
bytes += qq_get32(&fragment_index, data + bytes);
_qq_update_send_progess(gc, fragment_index);
if (purple_xfer_is_completed(qd->xfer))
_qq_send_file_data_packet(gc, QQ_FILE_CMD_FILE_OP, QQ_FILE_EOF, 0, 0, NULL, 0);
/* else
_qq_send_file_progess(gc); */
break;
case QQ_FILE_EOF:
/* FIXME: OK, we can end the connection successfully */
_qq_send_file_data_packet(gc, QQ_FILE_EOF, 0, 0, 0, NULL, 0);
purple_xfer_set_completed(qd->xfer, TRUE);
break;
}
break;
case QQ_FILE_EOF:
_qq_send_file_data_packet(gc, QQ_FILE_EOF, 0, 0, 0, NULL, 0);
purple_xfer_set_completed(qd->xfer, TRUE);
purple_xfer_end(qd->xfer);
break;
case QQ_FILE_BASIC_INFO:
purple_debug_info("QQ", "here\n");
_qq_send_file_data_packet(gc, QQ_FILE_DATA_INFO, 0, 0, 0, NULL, 0);
break;
default:
purple_debug_info("QQ", "_qq_process_recv_file_data: unknown packet type [%d]\n",
packet_type);
break;
}
}
/* process received extended (2007) text IM */
static void process_extend_im_text(PurpleConnection *gc, guint8 *data, gint len, qq_im_header *im_header)
{
qq_data *qd;
guint16 purple_msg_type;
gchar *who;
gchar *msg_smiley, *msg_fmt, *msg_utf8;
PurpleBuddy *buddy;
qq_buddy_data *bd;
gint bytes, tail_len;
qq_im_format *fmt = NULL;
struct {
/* now comes the part for text only */
guint16 msg_seq;
guint32 send_time;
guint16 sender_icon;
guint32 has_font_attr;
guint8 unknown1[8];
guint8 fragment_count;
guint8 fragment_index;
guint8 msg_id;
guint8 unknown2;
guint8 msg_type;
gchar *msg; /* no fixed length, ends with 0x00 */
guint8 fromMobileQQ;
} im_text;
g_return_if_fail (data != NULL && len > 0);
g_return_if_fail(im_header != NULL);
qd = (qq_data *) gc->proto_data;
memset(&im_text, 0, sizeof(im_text));
/* qq_show_packet("Extend IM text", data, len); */
bytes = 0;
bytes += qq_get16(&(im_text.msg_seq), data + bytes);
bytes += qq_get32(&(im_text.send_time), data + bytes);
bytes += qq_get16(&(im_text.sender_icon), data + bytes);
bytes += qq_get32(&(im_text.has_font_attr), data + bytes);
bytes += qq_getdata(im_text.unknown1, sizeof(im_text.unknown1), data + bytes);
bytes += qq_get8(&(im_text.fragment_count), data + bytes);
bytes += qq_get8(&(im_text.fragment_index), data + bytes);
bytes += qq_get8(&(im_text.msg_id), data + bytes);
bytes += 1; /* skip 0x00 */
bytes += qq_get8(&(im_text.msg_type), data + bytes);
purple_debug_info("QQ", "IM Seq %u, id %04X, fragment %d-%d, type %d, %s\n",
im_text.msg_seq, im_text.msg_id,
im_text.fragment_count, im_text.fragment_index,
im_text.msg_type,
im_text.has_font_attr ? "exist font atrr" : "");
if (im_text.has_font_attr) {
fmt = qq_im_fmt_new();
tail_len = qq_get_im_tail(fmt, data + bytes, len - bytes);
im_text.msg = g_strndup((gchar *)(data + bytes), len - tail_len);
} else {
im_text.msg = g_strndup((gchar *)(data + bytes), len - bytes);
}
/* qq_show_packet("IM text", (guint8 *)im_text.msg , strlen(im_text.msg)); */
if(im_text.fragment_count == 0) im_text.fragment_count = 1;
who = uid_to_purple_name(im_header->uid_from);
buddy = purple_find_buddy(gc->account, who);
if (buddy == NULL) {
/* create no-auth buddy */
buddy = qq_buddy_new(gc, im_header->uid_from);
}
bd = (buddy == NULL) ? NULL : purple_buddy_get_protocol_data(buddy);
if (bd != NULL) {
bd->client_tag = im_header->version_from;
bd->face = im_text.sender_icon;
qq_update_buddy_icon(gc->account, who, bd->face);
}
purple_msg_type = 0;
msg_smiley = qq_emoticon_to_purple(im_text.msg);
if (fmt != NULL) {
msg_fmt = qq_im_fmt_to_purple(fmt, msg_smiley);
msg_utf8 = qq_to_utf8(msg_fmt, QQ_CHARSET_DEFAULT);
g_free(msg_fmt);
qq_im_fmt_free(fmt);
} else {
msg_utf8 = qq_to_utf8(msg_smiley, QQ_CHARSET_DEFAULT);
}
g_free(msg_smiley);
/* send encoded to purple, note that we use im_text.send_time,
* not the time we receive the message
* as it may have been delayed when I am not online. */
serv_got_im(gc, who, msg_utf8, purple_msg_type, (time_t) im_text.send_time);
g_free(msg_utf8);
g_free(who);
g_free(im_text.msg);
}
/* process reply to get_memo packet */
void qq_process_get_buddy_memo(PurpleConnection *gc, guint8* data, gint data_len,
guint32 update_class, guint32 action)
{
gchar **segments;
gint bytes;
gint index;
guint8 rcv_cmd;
guint32 rcv_uid;
guint8 unk1_8;
guint8 is_success;
g_return_if_fail(NULL != gc && NULL != data && 0 != data_len);
/*
qq_show_packet("MEMO REACH", data, data_len);
*/
purple_debug_info("QQ", "action=0x%02X\n", action);
bytes = 0;
/* TX looks a bit clever than before... :) */
bytes += qq_get8(&rcv_cmd, data+bytes);
purple_debug_info("QQ", "rcv_cmd=0x%02X\n", rcv_cmd);
/* it's possible that packet contains no buddy uid and no memo!!!
* go to next step according to previous action sent */
if (1 == data_len) { /* only one byte */
purple_debug_info("QQ", "memo packet contains no buddy uid and memo...\n");
if (QQ_BUDDY_MEMO_MODIFY == action) {
qq_create_buddy_memo(gc, (guint32)update_class, QQ_BUDDY_MEMO_MODIFY);
return;
}
return;
}
switch (rcv_cmd) {
case QQ_BUDDY_MEMO_MODIFY:
case QQ_BUDDY_MEMO_REMOVE:
bytes += qq_get8(&is_success, data+bytes);
if (QQ_BUDDY_MEMO_REQUEST_SUCCESS == is_success) {
purple_notify_message(gc, PURPLE_NOTIFY_MSG_INFO,
_("Memo Modify"), _("Server says:"),
_("Your request was accepted."),
NULL, NULL);
purple_debug_info("QQ", "memo change succeessfully!\n");
}
else {
purple_notify_message(gc, PURPLE_NOTIFY_MSG_INFO,
_("Memo Modify"), _("Server says:"),
_("Your request was rejected."),
NULL, NULL);
purple_debug_info("QQ", "memo change failed\n");
}
break;
case QQ_BUDDY_MEMO_GET:
bytes += qq_get32(&rcv_uid, data+bytes);
purple_debug_info("QQ", "rcv_uid=%u\n", rcv_uid);
bytes += qq_get8(&unk1_8, data+bytes);
purple_debug_info("QQ", "unk1_8=0x%02X\n", unk1_8);
segments = g_new0(gchar*, QQ_MEMO_SIZE);
for (index = 0; index < QQ_MEMO_SIZE; index++) {
/* get utf8 string */
bytes += qq_get_vstr(&segments[index], QQ_CHARSET_DEFAULT, data+bytes);
/*
purple_debug_info("QQ", "bytes:%d, seg:%s\n", bytes, segments[index]);
*/
}
/* common action, update buddy memo */
update_buddy_memo(gc, rcv_uid, segments[QQ_MEMO_ALIAS]);
/* memo is thing that we regard our buddy as, so we need one more buddy_uid */
memo_modify_dialogue(gc, rcv_uid, segments, action);
break;
default:
purple_debug_info("QQ", "received an UNKNOWN memo cmd!!!\n");
break;
}
}
void qq_process_add_buddy_no_auth_ex(PurpleConnection *gc,
guint8 *data, gint data_len, guint32 uid)
{
qq_data *qd;
gint bytes;
guint32 dest_uid;
guint8 reply;
guint8 auth_type;
g_return_if_fail(data != NULL && data_len >= 5);
g_return_if_fail(uid != 0);
qd = (qq_data *) gc->proto_data;
purple_debug_info("QQ", "Process buddy add no auth for id [%u]\n", uid);
qq_show_packet("buddy_add_no_auth_ex", data, data_len);
bytes = 0;
bytes += qq_get32(&dest_uid, data + bytes);
bytes += qq_get8(&reply, data + bytes);
g_return_if_fail(dest_uid == uid);
if (reply == 0x99) {
purple_debug_info("QQ", "Successed adding buddy %u\n", uid);
qq_buddy_find_or_new(gc, uid);
qq_request_buddy_info(gc, uid, 0, 0);
if (qd->client_version >= 2007) {
qq_request_get_level_2007(gc, uid);
} else {
qq_request_get_level(gc, uid);
}
qq_request_get_buddies_online(gc, 0, 0);
return;
}
if (reply != 0) {
purple_debug_info("QQ", "Failed adding buddy %u, Unknow reply 0x%02X\n",
uid, reply);
}
/* need auth */
g_return_if_fail(data_len > bytes);
bytes += qq_get8(&auth_type, data + bytes);
purple_debug_warning("QQ", "Adding buddy needs authorize 0x%02X\n", auth_type);
switch (auth_type) {
case 0x00: /* no authorize */
break;
case 0x01: /* authorize */
qq_request_auth_code(gc, QQ_AUTH_INFO_BUDDY, QQ_AUTH_INFO_ADD_BUDDY, uid);
break;
case 0x02: /* disable */
break;
case 0x03: /* answer question */
qq_request_question(gc, QQ_QUESTION_REQUEST, uid, NULL, NULL);
break;
default:
g_return_if_reached();
break;
}
return;
}
/* recv an IM from a group chat */
void qq_process_room_im(guint8 *data, gint data_len, guint32 id, PurpleConnection *gc, guint16 msg_type)
{
qq_data *qd;
gchar *msg_smiley, *msg_fmt, *msg_utf8;
gint bytes, tail_len;
struct {
guint32 ext_id;
guint8 type8;
guint32 member_uid;
guint16 unknown;
guint16 msg_seq;
time_t send_time;
guint32 version;
guint16 msg_len;
gchar *msg;
} im_text;
guint32 temp_id;
guint16 content_type;
guint8 frag_count, frag_index;
guint16 msg_id;
qq_im_format *fmt = NULL;
/* at least include im_text.msg_len */
g_return_if_fail(data != NULL && data_len > 23);
qd = (qq_data *) gc->proto_data;
/* qq_show_packet("ROOM_IM", data, data_len); */
memset(&im_text, 0, sizeof(im_text));
bytes = 0;
bytes += qq_get32(&(im_text.ext_id), data + bytes);
bytes += qq_get8(&(im_text.type8), data + bytes);
if(QQ_MSG_TEMP_QUN_IM == msg_type) {
bytes += qq_get32(&temp_id, data + bytes);
}
bytes += qq_get32(&(im_text.member_uid), bytes + data);
bytes += qq_get16(&im_text.unknown, data + bytes); /* 0x0001? */
bytes += qq_get16(&(im_text.msg_seq), data + bytes);
bytes += qq_getime(&im_text.send_time, data + bytes);
bytes += qq_get32(&im_text.version, data + bytes);
bytes += qq_get16(&(im_text.msg_len), data + bytes);
purple_debug_info("QQ", "Room IM, ext id %u, seq %u, version 0x%04X, len %u\n",
im_text.ext_id, im_text.msg_seq, im_text.version, im_text.msg_len);
if (im_text.msg_len != data_len - bytes) {
purple_debug_warning("QQ", "Room IM length %d should be %d\n",
im_text.msg_len, data_len - bytes);
im_text.msg_len = data_len - bytes;
}
g_return_if_fail(im_text.msg_len > 0 && bytes + im_text.msg_len <= data_len);
if(msg_type != QQ_MSG_QUN_IM_UNKNOWN) {
g_return_if_fail(im_text.msg_len >= 10);
bytes += qq_get16(&content_type, data + bytes);
bytes += qq_get8(&frag_count, data + bytes);
bytes += qq_get8(&frag_index, data + bytes);
bytes += qq_get16(&msg_id, data + bytes);
bytes += 4; /* skip 0x(00 00 00 00) */
purple_debug_info("QQ", "Room IM, content %d, frag %d-%d, msg id %u\n",
content_type, frag_count, frag_index, msg_id);
im_text.msg_len -= 10;
}
g_return_if_fail(im_text.msg_len > 0);
/* qq_show_packet("Message", data + bytes, data_len - bytes); */
if (frag_count <= 1 || frag_count == frag_index + 1) {
fmt = qq_im_fmt_new();
tail_len = qq_get_im_tail(fmt, data + bytes, data_len - bytes);
im_text.msg = g_strndup((gchar *)(data + bytes), data_len - tail_len);
} else {
im_text.msg = g_strndup((gchar *)(data + bytes), data_len - bytes);
}
/* group im_group has no flag to indicate whether it has font_attr or not */
msg_smiley = qq_emoticon_to_purple(im_text.msg);
if (fmt != NULL) {
msg_fmt = qq_im_fmt_to_purple(fmt, msg_smiley);
msg_utf8 = qq_to_utf8(msg_fmt, QQ_CHARSET_DEFAULT);
g_free(msg_fmt);
qq_im_fmt_free(fmt);
} else {
msg_utf8 = qq_to_utf8(msg_smiley, QQ_CHARSET_DEFAULT);
}
g_free(msg_smiley);
purple_debug_info("QQ", "Room (%u) IM from %u: %s\n",
im_text.ext_id, im_text.member_uid, msg_utf8);
qq_room_got_chat_in(gc, id, im_text.member_uid, msg_utf8, im_text.send_time);
g_free(msg_utf8);
g_free(im_text.msg);
}
