13870
|
1 /**
|
|
2 * The QQ2003C protocol plugin
|
|
3 *
|
|
4 * for gaim
|
|
5 *
|
|
6 * Copyright (C) 2004 Puzzlebird
|
|
7 *
|
|
8 * This program is free software; you can redistribute it and/or modify
|
|
9 * it under the terms of the GNU General Public License as published by
|
|
10 * the Free Software Foundation; either version 2 of the License, or
|
|
11 * (at your option) any later version.
|
|
12 *
|
|
13 * This program is distributed in the hope that it will be useful,
|
|
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
16 * GNU General Public License for more details.
|
|
17 *
|
|
18 * You should have received a copy of the GNU General Public License
|
|
19 * along with this program; if not, write to the Free Software
|
|
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
21 */
|
|
22
|
|
23 // START OF FILE
|
|
24 /*****************************************************************************/
|
|
25 #include "conversation.h" // GaimConeversation
|
|
26 #include "debug.h" // gaim_debug
|
|
27 #include "internal.h" // strlen, _("get_text")
|
|
28 #include "cipher.h" // md5 functions //md5.h gfhuang
|
|
29 #include "notify.h" // gaim_notify_warning
|
|
30 #include "server.h" // serv_got_im
|
|
31 #include "util.h" // gaim_markup_find_tag, gaim_base16_decode
|
|
32
|
|
33 #include "utils.h" // gen_ip_str
|
|
34 #include "packet_parse.h" // create_packet
|
|
35 #include "buddy_info.h" // qq_send_packet_get_info
|
|
36 #include "buddy_list.h" // qq_send_packet_get_buddies_online
|
|
37 #include "buddy_opt.h" // qq_add_buddy_by_recv_packet
|
|
38 #include "char_conv.h" // qq_to_utf8, qq_encode_to_gaim
|
|
39 #include "crypt.h" // qq_crypt
|
|
40 #include "group_im.h" // qq_send_packet_group_im
|
|
41 #include "header_info.h" // cmd alias
|
|
42 #include "im.h"
|
|
43 #include "send_core.h" // qq_send_cmd
|
|
44 #include "send_core.h" // qq_data
|
|
45 #include "send_file.h"
|
|
46
|
|
47 #define QQ_SEND_IM_REPLY_OK 0x00
|
|
48 #define DEFAULT_FONT_NAME_LEN 4
|
|
49
|
|
50 // a debug function
|
13871
|
51 void _qq_show_packet(gchar * desc, gchar * buf, gint len);
|
13870
|
52
|
|
53 enum
|
|
54 {
|
|
55 QQ_NORMAL_IM_TEXT = 0x000b,
|
|
56 QQ_NORMAL_IM_FILE_REQUEST_TCP = 0x0001, //gfhuang
|
|
57 QQ_NORMAL_IM_FILE_APPROVE_TCP = 0x0003,
|
|
58 QQ_NORMAL_IM_FILE_REJECT_TCP = 0x0005,
|
|
59 QQ_NORMAL_IM_FILE_REQUEST_UDP = 0x0035,
|
|
60 QQ_NORMAL_IM_FILE_APPROVE_UDP = 0x0037,
|
|
61 QQ_NORMAL_IM_FILE_REJECT_UDP = 0x0039,
|
|
62 QQ_NORMAL_IM_FILE_NOTIFY = 0x003b,
|
|
63 QQ_NORMAL_IM_FILE_PASV = 0x003f, // are you behind a firewall, gfhuang
|
|
64 QQ_NORMAL_IM_FILE_CANCEL = 0x0049,
|
|
65 QQ_NORMAL_IM_FILE_EX_REQUEST_UDP = 0x81, //gfhuang
|
|
66 QQ_NORMAL_IM_FILE_EX_REQUEST_ACCEPT = 0x83, //gfhuang
|
|
67 QQ_NORMAL_IM_FILE_EX_REQUEST_CANCEL = 0x85, //gfhuang
|
|
68 QQ_NORMAL_IM_FILE_EX_NOTIFY_IP = 0x87 //gfhuang
|
|
69 };
|
|
70
|
|
71
|
|
72 enum {
|
|
73 QQ_RECV_SYS_IM_KICK_OUT = 0x01,
|
|
74 };
|
|
75
|
|
76 /*
|
|
77 guint8 send_im_tail[QQ_SEND_IM_AFTER_MSG_LEN] = {
|
|
78 0x00, // end of msg
|
|
79 0x0a, // font attr, size=10, no bold, no italic, no underline
|
|
80 0x00, // font color red 00-ff
|
|
81 0x00, // font color green
|
|
82 0x00, // font color blue
|
|
83 0x00, // unknown
|
|
84 0x86, 0x22, // encoding, 0x8622=GB, 0x0000=EN, define BIG5 support here
|
|
85 0xcb, 0xce, 0xcc, 0xe5, 0x0d // font name, related, not fix length
|
|
86 };
|
|
87 */
|
|
88
|
|
89 typedef struct _qq_recv_im_header qq_recv_im_header;
|
|
90 typedef struct _qq_recv_normal_im_text qq_recv_normal_im_text;
|
|
91 typedef struct _qq_recv_normal_im_common qq_recv_normal_im_common;
|
|
92 typedef struct _qq_recv_normal_im_unprocessed qq_recv_normal_im_unprocessed;
|
|
93
|
|
94 struct _qq_recv_normal_im_common {
|
|
95 // this is the common part of normal_text
|
|
96 guint16 sender_ver;
|
|
97 guint32 sender_uid;
|
|
98 guint32 receiver_uid;
|
|
99 guint8 *session_md5;
|
|
100 guint16 normal_im_type;
|
|
101 };
|
|
102
|
|
103 struct _qq_recv_normal_im_text {
|
|
104 qq_recv_normal_im_common *common;
|
|
105 // now comes the part fo text only
|
|
106 guint16 msg_seq;
|
|
107 guint32 send_time;
|
|
108 guint8 unknown1;
|
|
109 guint8 sender_icon;
|
|
110 guint8 unknown2[3];
|
|
111 guint8 is_there_font_attr;
|
|
112 guint8 unknown3[4];
|
|
113 guint8 msg_type;
|
|
114 guint8 *msg; // no fixed length, ends with 0x00
|
|
115 guint8 *font_attr;
|
|
116 gint font_attr_len;
|
|
117 };
|
|
118
|
|
119 struct _qq_recv_normal_im_unprocessed {
|
|
120 qq_recv_normal_im_common *common;
|
|
121 // now comes the part of unprocessed
|
|
122 guint8 *unknown; // no fixed length
|
|
123 gint length;
|
|
124 };
|
|
125
|
|
126 struct _qq_recv_im_header {
|
|
127 guint32 sender_uid;
|
|
128 guint32 receiver_uid;
|
|
129 guint32 server_im_seq;
|
|
130 guint8 sender_ip[4];
|
|
131 guint16 sender_port;
|
|
132 guint16 im_type;
|
|
133 };
|
|
134
|
|
135 #define QQ_SEND_IM_AFTER_MSG_HEADER_LEN 8
|
|
136 #define DEFAULT_FONT_NAME "\0xcb\0xce\0xcc\0xe5"
|
|
137
|
|
138 guint8 *qq_get_send_im_tail(const gchar * font_color,
|
|
139 const gchar * font_size,
|
|
140 const gchar * font_name,
|
|
141 gboolean is_bold, gboolean is_italic, gboolean is_underline, guint tail_len)
|
|
142 {
|
|
143 gchar *s1, *s2;
|
|
144 unsigned char *rgb;
|
|
145 guint font_name_len;
|
|
146 guint8 *send_im_tail;
|
|
147 const guint8 simsun[] = { 0xcb, 0xce, 0xcc, 0xe5 };
|
|
148
|
|
149 if (font_name) {
|
|
150 font_name_len = strlen(font_name);
|
|
151 } else {
|
|
152 font_name_len = DEFAULT_FONT_NAME_LEN;
|
|
153 font_name = simsun;
|
|
154 }
|
|
155
|
|
156 send_im_tail = g_new0(guint8, tail_len);
|
|
157
|
|
158 g_strlcpy(send_im_tail + QQ_SEND_IM_AFTER_MSG_HEADER_LEN,
|
|
159 font_name, tail_len - QQ_SEND_IM_AFTER_MSG_HEADER_LEN);
|
|
160 send_im_tail[tail_len - 1] = tail_len;
|
|
161
|
|
162 send_im_tail[0] = 0x00;
|
|
163 if (font_size) {
|
|
164 send_im_tail[1] = (guint8) (atoi(font_size) * 3 + 1);
|
|
165 } else {
|
|
166 send_im_tail[1] = 10;
|
|
167 }
|
|
168 if (is_bold)
|
|
169 send_im_tail[1] |= 0x20;
|
|
170 if (is_italic)
|
|
171 send_im_tail[1] |= 0x40;
|
|
172 if (is_underline)
|
|
173 send_im_tail[1] |= 0x80;
|
|
174
|
|
175 if (font_color) {
|
|
176 s1 = g_strndup(font_color + 1, 6);
|
|
177 /* Henry: maybe this is a bug of gaim, the string should have
|
|
178 * the length of odd number @_@
|
|
179 */
|
|
180 s2 = g_strdup_printf("%sH", s1);
|
|
181 // gaim_base16_decode(s2, &rgb); by gfhuang
|
|
182 rgb = gaim_base16_decode(s2, NULL);
|
|
183 g_free(s1);
|
|
184 g_free(s2);
|
|
185 memcpy(send_im_tail + 2, rgb, 3);
|
|
186 g_free(rgb);
|
|
187 } else {
|
|
188 send_im_tail[2] = send_im_tail[3] = send_im_tail[4] = 0;
|
|
189 }
|
|
190
|
|
191 send_im_tail[5] = 0x00;
|
|
192 send_im_tail[6] = 0x86;
|
|
193 send_im_tail[7] = 0x22; // encoding, 0x8622=GB, 0x0000=EN, define BIG5 support here
|
|
194 _qq_show_packet("QQ_MESG", send_im_tail, tail_len);
|
|
195 return (guint8 *) send_im_tail;
|
|
196 } // qq_get_send_im_tail
|
|
197
|
|
198 /*****************************************************************************/
|
|
199 static const gchar *qq_get_recv_im_type_str(gint type)
|
|
200 {
|
|
201 switch (type) {
|
|
202 case QQ_RECV_IM_TO_BUDDY:
|
|
203 return "QQ_RECV_IM_TO_BUDDY";
|
|
204 case QQ_RECV_IM_TO_UNKNOWN:
|
|
205 return "QQ_RECV_IM_TO_UNKNOWN";
|
|
206 case QQ_RECV_IM_UNKNOWN_QUN_IM:
|
|
207 return "QQ_RECV_IM_UNKNOWN_QUN_IM";
|
|
208 case QQ_RECV_IM_ADD_TO_QUN:
|
|
209 return "QQ_RECV_IM_ADD_TO_QUN";
|
|
210 case QQ_RECV_IM_DEL_FROM_QUN:
|
|
211 return "QQ_RECV_IM_DEL_FROM_QUN";
|
|
212 case QQ_RECV_IM_APPLY_ADD_TO_QUN:
|
|
213 return "QQ_RECV_IM_APPLY_ADD_TO_QUN";
|
|
214 case QQ_RECV_IM_CREATE_QUN:
|
|
215 return "QQ_RECV_IM_CREATE_QUN";
|
|
216 case QQ_RECV_IM_SYS_NOTIFICATION:
|
|
217 return "QQ_RECV_IM_SYS_NOTIFICATION";
|
|
218 case QQ_RECV_IM_APPROVE_APPLY_ADD_TO_QUN:
|
|
219 return "QQ_RECV_IM_APPROVE_APPLY_ADD_TO_QUN";
|
|
220 case QQ_RECV_IM_REJCT_APPLY_ADD_TO_QUN:
|
|
221 return "QQ_RECV_IM_REJCT_APPLY_ADD_TO_QUN";
|
|
222 case QQ_RECV_IM_TEMP_QUN_IM:
|
|
223 return "QQ_RECV_IM_TEMP_QUN_IM"; //gfhuang
|
|
224 case QQ_RECV_IM_QUN_IM:
|
|
225 return "QQ_RECV_IM_QUN_IM"; //gfhuang
|
|
226 default:
|
|
227 return "QQ_RECV_IM_UNKNOWN";
|
|
228 } // switch type
|
|
229 } // qq_get_recv_im_type_str
|
|
230
|
|
231 /*****************************************************************************/
|
|
232 // generate a md5 key using uid and session_key
|
13871
|
233 gchar *_gen_session_md5(gint uid, gchar * session_key)
|
13870
|
234 {
|
|
235 gchar *src, md5_str[QQ_KEY_LENGTH];
|
|
236 guint8 *cursor;
|
|
237 // md5_state_t ctx; //gfhuang
|
|
238 GaimCipher *cipher;
|
|
239 GaimCipherContext *context;
|
|
240
|
|
241
|
|
242 src = g_newa(gchar, 20);
|
|
243 cursor = src;
|
|
244 create_packet_dw(src, &cursor, uid);
|
|
245 create_packet_data(src, &cursor, session_key, QQ_KEY_LENGTH);
|
|
246
|
|
247 /* gfhuang
|
|
248 md5_init(&ctx);
|
|
249 md5_append(&ctx, src, 20);
|
|
250 md5_finish(&ctx, (md5_byte_t *) md5_str);
|
|
251 */
|
|
252 cipher = gaim_ciphers_find_cipher("md5");
|
|
253 context = gaim_cipher_context_new(cipher, NULL);
|
|
254 gaim_cipher_context_append(context, src, 20);
|
|
255 gaim_cipher_context_digest(context, sizeof(md5_str), md5_str, NULL);
|
|
256 gaim_cipher_context_destroy(context);
|
|
257
|
|
258 return g_memdup(md5_str, QQ_KEY_LENGTH);
|
|
259 } // _gen_session_md5
|
|
260
|
|
261 /*****************************************************************************/
|
|
262 // when we receive a message,
|
|
263 // we send an ACK which is the first 16 bytes of incoming packet
|
|
264 static void _qq_send_packet_recv_im_ack(GaimConnection * gc, guint16 seq, guint8 * data) {
|
|
265 qq_send_cmd(gc, QQ_CMD_RECV_IM, FALSE, seq, FALSE, data, 16);
|
|
266 } // _qq_send_packet_recv_im_ack
|
|
267
|
|
268 /*****************************************************************************/
|
|
269 // read the common parts of the normal_im,
|
|
270 // returns the bytes read if succeed, or -1 if there is any error
|
|
271 static gint _qq_normal_im_common_read(guint8 * data, guint8 ** cursor, gint len, qq_recv_normal_im_common * common) {
|
|
272
|
|
273 gint bytes;
|
|
274 g_return_val_if_fail(data != NULL && len != 0 && common != NULL, -1);
|
|
275
|
|
276 bytes = 0;
|
|
277 // now push data into common header
|
|
278 bytes += read_packet_w(data, cursor, len, &(common->sender_ver));
|
|
279 bytes += read_packet_dw(data, cursor, len, &(common->sender_uid));
|
|
280 bytes += read_packet_dw(data, cursor, len, &(common->receiver_uid));
|
|
281
|
|
282 common->session_md5 = g_memdup(*cursor, QQ_KEY_LENGTH);
|
|
283 bytes += QQ_KEY_LENGTH;
|
|
284 *cursor += QQ_KEY_LENGTH;
|
|
285
|
|
286 bytes += read_packet_w(data, cursor, len, &(common->normal_im_type));
|
|
287
|
|
288 if (bytes != 28) { // read common place fail
|
|
289 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Expect 28 bytes, read %d bytes\n", bytes);
|
|
290 return -1;
|
|
291 } // if bytes
|
|
292
|
|
293 return bytes;
|
|
294 } // _qq_normal_im_common_read
|
|
295
|
|
296 /*****************************************************************************/
|
|
297 // process received normal text IM
|
|
298 static void _qq_process_recv_normal_im_text
|
|
299 (guint8 * data, guint8 ** cursor, gint len, qq_recv_normal_im_common * common, GaimConnection * gc) {
|
|
300 guint16 gaim_msg_type;
|
|
301 gchar *name;
|
|
302 gchar *msg_with_gaim_smiley;
|
|
303 gchar *msg_utf8_encoded;
|
|
304 qq_data *qd;
|
|
305 qq_recv_normal_im_text *im_text;
|
|
306
|
|
307 g_return_if_fail(gc != NULL && gc->proto_data != NULL && common != NULL);
|
|
308 qd = (qq_data *) gc->proto_data;
|
|
309
|
|
310 // now it is QQ_NORMAL_IM_TEXT
|
|
311 if (*cursor >= (data + len - 1)) {
|
|
312 gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received normal IM text is empty\n");
|
|
313 return;
|
|
314 } else
|
|
315 im_text = g_newa(qq_recv_normal_im_text, 1);
|
|
316
|
|
317 im_text->common = common;
|
|
318
|
|
319 // push data into im_text
|
|
320 read_packet_w(data, cursor, len, &(im_text->msg_seq));
|
|
321 read_packet_dw(data, cursor, len, &(im_text->send_time));
|
|
322 read_packet_b(data, cursor, len, &(im_text->unknown1));
|
|
323 read_packet_b(data, cursor, len, &(im_text->sender_icon));
|
|
324 read_packet_data(data, cursor, len, (guint8 *) & (im_text->unknown2), 3);
|
|
325 read_packet_b(data, cursor, len, &(im_text->is_there_font_attr));
|
|
326 //////////////////////
|
|
327 // from lumaqq for unknown3, gfhuang
|
|
328 // totalFragments = buf.get() & 255;
|
|
329 // fragmentSequence = buf.get() & 255;
|
|
330 // messageId = buf.getChar();
|
|
331 read_packet_data(data, cursor, len, (guint8 *) & (im_text->unknown3), 4);
|
|
332 read_packet_b(data, cursor, len, &(im_text->msg_type));
|
|
333
|
|
334 // we need to check if this is auto-reply
|
|
335 // QQ2003iii build 0304, returns the msg without font_attr
|
|
336 // even the is_there_font_attr shows 0x01, and msg does not ends with 0x00
|
|
337 if (im_text->msg_type == QQ_IM_AUTO_REPLY) {
|
|
338 im_text->is_there_font_attr = 0x00; // indeed there is no this flag
|
|
339 im_text->msg = g_strndup(*cursor, data + len - *cursor);
|
|
340 } else { // it is normal mesasge
|
|
341 if (im_text->is_there_font_attr) {
|
|
342 im_text->msg = g_strdup(*cursor);
|
|
343 *cursor += strlen(im_text->msg) + 1;
|
|
344 im_text->font_attr_len = data + len - *cursor;
|
|
345 im_text->font_attr = g_memdup(*cursor, im_text->font_attr_len);
|
|
346 } else // not im_text->is_there_font_attr
|
|
347 im_text->msg = g_strndup(*cursor, data + len - *cursor);
|
|
348 } // if im_text->msg_type
|
|
349 _qq_show_packet("QQ_MESG recv", data, *cursor - data);
|
|
350
|
|
351 name = uid_to_gaim_name(common->sender_uid);
|
|
352 if (gaim_find_buddy(gc->account, name) == NULL)
|
|
353 qq_add_buddy_by_recv_packet(gc, common->sender_uid, FALSE, TRUE);
|
|
354
|
|
355 gaim_msg_type = (im_text->msg_type == QQ_IM_AUTO_REPLY) ? GAIM_MESSAGE_AUTO_RESP : 0;
|
|
356
|
|
357 msg_with_gaim_smiley = qq_smiley_to_gaim(im_text->msg);
|
|
358 msg_utf8_encoded = im_text->is_there_font_attr ?
|
|
359 qq_encode_to_gaim(im_text->font_attr,
|
|
360 im_text->font_attr_len,
|
|
361 msg_with_gaim_smiley) : qq_to_utf8(msg_with_gaim_smiley, QQ_CHARSET_DEFAULT);
|
|
362
|
|
363 // send encoded to gaim, note that we use im_text->send_time,
|
|
364 // not the time we receive the message
|
|
365 // as it may have been dealyed when I am not online.
|
|
366 serv_got_im(gc, name, msg_utf8_encoded, gaim_msg_type, (time_t) im_text->send_time);
|
|
367
|
|
368 g_free(msg_utf8_encoded);
|
|
369 g_free(msg_with_gaim_smiley);
|
|
370 g_free(name);
|
|
371 g_free(im_text->msg);
|
|
372 if (im_text->is_there_font_attr)
|
|
373 g_free(im_text->font_attr);
|
|
374 } // _qq_process_recv_normal_im_text
|
|
375
|
|
376 /*****************************************************************************/
|
|
377 // it is a normal IM, maybe text or video request
|
|
378 static void _qq_process_recv_normal_im(guint8 * data, guint8 ** cursor, gint len, GaimConnection * gc)
|
|
379 {
|
|
380 gint bytes;
|
|
381 qq_recv_normal_im_common *common;
|
|
382 qq_recv_normal_im_unprocessed *im_unprocessed;
|
|
383
|
|
384 g_return_if_fail (data != NULL && len != 0);
|
|
385
|
|
386 if (*cursor >= (data + len - 1)) {
|
|
387 gaim_debug (GAIM_DEBUG_WARNING, "QQ",
|
|
388 "Received normal IM is empty\n");
|
|
389 return;
|
|
390 }
|
|
391 else
|
|
392 common = g_newa (qq_recv_normal_im_common, 1);
|
|
393
|
|
394 bytes = _qq_normal_im_common_read (data, cursor, len, common);
|
|
395 if (bytes < 0) {
|
|
396 gaim_debug (GAIM_DEBUG_ERROR, "QQ",
|
|
397 "Fail read the common part of normal IM\n");
|
|
398 return;
|
|
399 } // if bytes
|
|
400
|
|
401 switch (common->normal_im_type) {
|
|
402 case QQ_NORMAL_IM_TEXT:
|
|
403 gaim_debug (GAIM_DEBUG_INFO,
|
|
404 "QQ",
|
|
405 "Normal IM, text type:\n [%d] => [%d], src: %s\n",
|
|
406 common->sender_uid, common->receiver_uid,
|
|
407 qq_get_source_str (common->sender_ver));
|
|
408 _qq_process_recv_normal_im_text (data, cursor, len, common,
|
|
409 gc);
|
|
410 break;
|
|
411 case QQ_NORMAL_IM_FILE_REJECT_UDP:
|
|
412 qq_process_recv_file_reject (data, cursor, len,
|
|
413 common->sender_uid, gc);
|
|
414 break;
|
|
415 case QQ_NORMAL_IM_FILE_APPROVE_UDP:
|
|
416 qq_process_recv_file_accept (data, cursor, len,
|
|
417 common->sender_uid, gc);
|
|
418 break;
|
|
419 case QQ_NORMAL_IM_FILE_REQUEST_UDP:
|
|
420 qq_process_recv_file_request (data, cursor, len,
|
|
421 common->sender_uid, gc);
|
|
422 break;
|
|
423 case QQ_NORMAL_IM_FILE_CANCEL:
|
|
424 qq_process_recv_file_cancel (data, cursor, len,
|
|
425 common->sender_uid, gc);
|
|
426 break;
|
|
427 case QQ_NORMAL_IM_FILE_NOTIFY:
|
|
428 qq_process_recv_file_notify (data, cursor, len,
|
|
429 common->sender_uid, gc);
|
|
430 break;
|
|
431 default:
|
|
432 im_unprocessed = g_newa (qq_recv_normal_im_unprocessed, 1);
|
|
433 im_unprocessed->common = common;
|
|
434 im_unprocessed->unknown = *cursor;
|
|
435 im_unprocessed->length = data + len - *cursor;
|
|
436 //  a simple process here, maybe more later
|
|
437 gaim_debug (GAIM_DEBUG_WARNING, "QQ",
|
|
438 "Normal IM, unprocessed type [0x%04x]\n",
|
|
439 common->normal_im_type);
|
|
440 gaim_debug (GAIM_DEBUG_WARNING, "QQ",
|
|
441 "Dump unknown part.\n%s",
|
|
442 hex_dump_to_str (im_unprocessed->unknown,
|
|
443 im_unprocessed->length));
|
|
444 g_free (common->session_md5);
|
|
445 return;
|
|
446 } // normal_im_type
|
|
447
|
|
448 g_free (common->session_md5);
|
|
449 } // qq_process_recv_normal_im
|
|
450
|
|
451
|
|
452 /*
|
|
453 static void _qq_process_recv_normal_im(guint8 * data, guint8 ** cursor, gint len, GaimConnection * gc) {
|
|
454 gint bytes;
|
|
455 qq_recv_normal_im_common *common;
|
|
456 qq_recv_normal_im_unprocessed *im_unprocessed;
|
|
457
|
|
458 g_return_if_fail(data != NULL && len != 0);
|
|
459
|
|
460 if (*cursor >= (data + len - 1)) {
|
|
461 gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received normal IM is empty\n");
|
|
462 return;
|
|
463 } else
|
|
464 common = g_newa(qq_recv_normal_im_common, 1);
|
|
465
|
|
466 bytes = _qq_normal_im_common_read(data, cursor, len, common);
|
|
467 if (bytes < 0) {
|
|
468 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Fail read the common part of normal IM\n");
|
|
469 return;
|
|
470 } // if bytes
|
|
471
|
|
472 if (common->normal_im_type != QQ_NORMAL_IM_TEXT) {
|
|
473 im_unprocessed = g_newa(qq_recv_normal_im_unprocessed, 1);
|
|
474 im_unprocessed->common = common;
|
|
475 im_unprocessed->unknown = *cursor;
|
|
476 im_unprocessed->length = data + len - *cursor;
|
|
477 // a simple process here, maybe more later
|
|
478 gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Normal IM, unprocessed type [0x%04x]\n", common->normal_im_type);
|
|
479 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
480 "Dump unknown part.\n%s", hex_dump_to_str(im_unprocessed->unknown, im_unprocessed->length));
|
|
481 g_free(common->session_md5);
|
|
482 return;
|
|
483 } else { // normal_im_type == QQ_NORMAL_IM_TEXT
|
|
484 gaim_debug(GAIM_DEBUG_INFO,
|
|
485 "QQ",
|
|
486 "Normal IM, text type:\n [%d] => [%d], src: %s\n",
|
|
487 common->sender_uid, common->receiver_uid, qq_get_source_str(common->sender_ver));
|
|
488 _qq_process_recv_normal_im_text(data, cursor, len, common, gc);
|
|
489 } // normal_im_type
|
|
490
|
|
491 g_free(common->session_md5);
|
|
492 } // qq_process_recv_normal_im
|
|
493 */
|
|
494
|
|
495 /*****************************************************************************/
|
|
496 // process im from system administrator
|
|
497 static void _qq_process_recv_sys_im(guint8 * data, guint8 ** cursor, gint data_len, GaimConnection * gc) {
|
|
498 gint len;
|
|
499 guint8 reply;
|
|
500 gchar **segments, *msg_utf8;
|
|
501
|
|
502 g_return_if_fail(gc != NULL && data != NULL && data_len != 0);
|
|
503
|
|
504 if (*cursor >= (data + data_len - 1)) {
|
|
505 gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Received sys IM is empty\n");
|
|
506 return;
|
|
507 }
|
|
508
|
|
509 len = data + data_len - *cursor;
|
|
510
|
|
511 if (NULL == (segments = split_data(*cursor, len, "\x2f", 2)))
|
|
512 return;
|
|
513
|
|
514 reply = strtol(segments[0], NULL, 10);
|
|
515 if (reply == QQ_RECV_SYS_IM_KICK_OUT)
|
|
516 gaim_debug(GAIM_DEBUG_WARNING, "QQ", "We are kicked out by QQ server\n");
|
|
517 msg_utf8 = qq_to_utf8(segments[1], QQ_CHARSET_DEFAULT);
|
|
518 gaim_notify_warning(gc, NULL, _("System Message"), msg_utf8);
|
|
519
|
|
520 } // _qq_process_recv_sys_im
|
|
521
|
|
522 /*****************************************************************************/
|
|
523 // send an IM to to_uid
|
|
524 void qq_send_packet_im(GaimConnection * gc, guint32 to_uid, gchar * msg, gint type) {
|
|
525 qq_data *qd;
|
|
526 guint8 *cursor, *raw_data;
|
|
527 guint16 client_tag, normal_im_type;
|
|
528 gint msg_len, raw_len, bytes;
|
|
529 time_t now;
|
|
530 gchar *md5, *msg_filtered;
|
|
531 GData *attribs;
|
|
532 gchar *font_size = NULL, *font_color = NULL, *font_name = NULL, *tmp;
|
|
533 gboolean is_bold = FALSE, is_italic = FALSE, is_underline = FALSE;
|
|
534 const gchar *start, *end, *last;
|
|
535
|
|
536 g_return_if_fail(gc != NULL && gc->proto_data != NULL);
|
|
537
|
|
538 qd = (qq_data *) gc->proto_data;
|
|
539 client_tag = QQ_CLIENT;
|
|
540 normal_im_type = QQ_NORMAL_IM_TEXT;
|
|
541
|
|
542 last = msg;
|
|
543 while (gaim_markup_find_tag("font", last, &start, &end, &attribs)) {
|
|
544 tmp = g_datalist_get_data(&attribs, "size");
|
|
545 if (tmp) {
|
|
546 if (font_size)
|
|
547 g_free(font_size);
|
|
548 font_size = g_strdup(tmp);
|
|
549 }
|
|
550 tmp = g_datalist_get_data(&attribs, "color");
|
|
551 if (tmp) {
|
|
552 if (font_color)
|
|
553 g_free(font_color);
|
|
554 font_color = g_strdup(tmp);
|
|
555 }
|
|
556 tmp = g_datalist_get_data(&attribs, "face");
|
|
557 if (tmp) {
|
|
558 if (font_name)
|
|
559 g_free(font_name);
|
|
560 font_name = g_strdup(tmp);
|
|
561 }
|
|
562
|
|
563 g_datalist_clear(&attribs);
|
|
564 last = end + 1;
|
|
565 }
|
|
566
|
|
567 if (gaim_markup_find_tag("b", msg, &start, &end, &attribs)) {
|
|
568 is_bold = TRUE;
|
|
569 g_datalist_clear(&attribs);
|
|
570 }
|
|
571
|
|
572 if (gaim_markup_find_tag("i", msg, &start, &end, &attribs)) {
|
|
573 is_italic = TRUE;
|
|
574 g_datalist_clear(&attribs);
|
|
575 }
|
|
576
|
|
577 if (gaim_markup_find_tag("u", msg, &start, &end, &attribs)) {
|
|
578 is_underline = TRUE;
|
|
579 g_datalist_clear(&attribs);
|
|
580 }
|
|
581
|
|
582 gaim_debug(GAIM_DEBUG_INFO, "QQ_MESG", "send mesg: %s\n", msg);
|
|
583 msg_filtered = gaim_markup_strip_html(msg);
|
|
584 msg_len = strlen(msg_filtered);
|
|
585 now = time(NULL);
|
|
586 md5 = _gen_session_md5(qd->uid, qd->session_key);
|
|
587
|
|
588 guint font_name_len, tail_len;
|
|
589 font_name_len = (font_name) ? strlen(font_name) : DEFAULT_FONT_NAME_LEN;
|
|
590 tail_len = font_name_len + QQ_SEND_IM_AFTER_MSG_HEADER_LEN + 1;
|
|
591
|
|
592 raw_len = QQ_SEND_IM_BEFORE_MSG_LEN + msg_len + tail_len;
|
|
593 raw_data = g_newa(guint8, raw_len);
|
|
594 cursor = raw_data;
|
|
595 bytes = 0;
|
|
596
|
|
597 //000-003: receiver uid
|
|
598 bytes += create_packet_dw(raw_data, &cursor, qd->uid);
|
|
599 //004-007: sender uid
|
|
600 bytes += create_packet_dw(raw_data, &cursor, to_uid);
|
|
601 //008-009: sender client version
|
|
602 bytes += create_packet_w(raw_data, &cursor, client_tag);
|
|
603 //010-013: receiver uid
|
|
604 bytes += create_packet_dw(raw_data, &cursor, qd->uid);
|
|
605 //014-017: sender uid
|
|
606 bytes += create_packet_dw(raw_data, &cursor, to_uid);
|
|
607 //018-033: md5 of (uid+session_key)
|
|
608 bytes += create_packet_data(raw_data, &cursor, md5, 16);
|
|
609 //034-035: message type
|
|
610 bytes += create_packet_w(raw_data, &cursor, normal_im_type);
|
|
611 //036-037: sequence number
|
|
612 bytes += create_packet_w(raw_data, &cursor, qd->send_seq);
|
|
613 //038-041: send time
|
|
614 bytes += create_packet_dw(raw_data, &cursor, (guint32) now);
|
|
615 //042-042: always 0x00
|
|
616 bytes += create_packet_b(raw_data, &cursor, 0x00);
|
|
617 //043-043: sender icon
|
|
618 bytes += create_packet_b(raw_data, &cursor, qd->my_icon);
|
|
619 //044-046: always 0x00
|
|
620 bytes += create_packet_w(raw_data, &cursor, 0x0000);
|
|
621 bytes += create_packet_b(raw_data, &cursor, 0x00);
|
|
622 //047-047: we use font attr
|
|
623 bytes += create_packet_b(raw_data, &cursor, 0x01);
|
|
624 //048-051: always 0x00
|
|
625 bytes += create_packet_dw(raw_data, &cursor, 0x00000000);
|
|
626 //052-052: text message type (normal/auto-reply)
|
|
627 bytes += create_packet_b(raw_data, &cursor, type);
|
|
628 //053- : msg ends with 0x00
|
|
629 bytes += create_packet_data(raw_data, &cursor, msg_filtered, msg_len);
|
|
630 guint8 *send_im_tail = qq_get_send_im_tail(font_color, font_size, font_name, is_bold,
|
|
631 is_italic, is_underline, tail_len);
|
|
632 _qq_show_packet("QQ_MESG debug", send_im_tail, tail_len);
|
|
633 bytes += create_packet_data(raw_data, &cursor, (gchar *) send_im_tail, tail_len);
|
|
634
|
|
635 _qq_show_packet("QQ_MESG raw", raw_data, cursor - raw_data);
|
|
636
|
|
637 if (bytes == raw_len) // create packet OK
|
|
638 qq_send_cmd(gc, QQ_CMD_SEND_IM, TRUE, 0, TRUE, raw_data, cursor - raw_data);
|
|
639 else
|
|
640 gaim_debug(GAIM_DEBUG_ERROR, "QQ",
|
|
641 "Fail creating send_im packet, expect %d bytes, build %d bytes\n", raw_len, bytes);
|
|
642
|
|
643 if (font_color)
|
|
644 g_free(font_color);
|
|
645 if (font_size)
|
|
646 g_free(font_size);
|
|
647 g_free(send_im_tail);
|
|
648 g_free(msg_filtered);
|
|
649 } // qq_send_packet_im
|
|
650
|
|
651 /*****************************************************************************/
|
|
652 // parse the reply to send_im
|
|
653 void qq_process_send_im_reply(guint8 * buf, gint buf_len, GaimConnection * gc)
|
|
654 {
|
|
655 qq_data *qd;
|
|
656 gint len;
|
|
657 guint8 *data, *cursor, reply;
|
|
658
|
|
659 g_return_if_fail(gc != NULL && gc->proto_data != NULL);
|
|
660 g_return_if_fail(buf != NULL && buf_len != 0);
|
|
661
|
|
662 qd = gc->proto_data;
|
|
663 len = buf_len;
|
|
664 data = g_newa(guint8, len);
|
|
665
|
|
666 if (qq_crypt(DECRYPT, buf, buf_len, qd->session_key, data, &len)) {
|
|
667 cursor = data;
|
|
668 read_packet_b(data, &cursor, len, &reply);
|
|
669 if (reply != QQ_SEND_IM_REPLY_OK) {
|
|
670 gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Send IM fail\n");
|
|
671 gaim_notify_error(gc, _("Server ACK"), _("Send IM fail\n"), NULL);
|
|
672 // serv_got_im(gc, name, "Server ACK: Send IM fail\n", GAIM_MESSAGE_ERROR, time(NULL));
|
|
673 }
|
|
674 else
|
|
675 gaim_debug(GAIM_DEBUG_INFO, "QQ", "IM ACK OK\n");
|
|
676 } else {
|
|
677 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Error decrypt send im reply\n");
|
|
678 }
|
|
679
|
|
680 } // qq_process_send_im_reply
|
|
681
|
|
682 /*****************************************************************************/
|
|
683 // I receive a message, mainly it is text msg,
|
|
684 // but we need to proess other types (group etc)
|
|
685 void qq_process_recv_im(guint8 * buf, gint buf_len, guint16 seq, GaimConnection * gc) {
|
|
686 qq_data *qd;
|
|
687 gint len, bytes;
|
|
688 guint8 *data, *cursor;
|
|
689 qq_recv_im_header *im_header;
|
|
690
|
|
691 g_return_if_fail(gc != NULL && gc->proto_data != NULL);
|
|
692 g_return_if_fail(buf != NULL && buf_len != 0);
|
|
693
|
|
694 qd = (qq_data *) gc->proto_data;
|
|
695 len = buf_len;
|
|
696 data = g_newa(guint8, len);
|
|
697
|
|
698 if (qq_crypt(DECRYPT, buf, buf_len, qd->session_key, data, &len)) {
|
|
699 if (len < 16) { // we need to ack with the first 16 bytes
|
|
700 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "IM is too short\n");
|
|
701 return;
|
|
702 } else
|
|
703 _qq_send_packet_recv_im_ack(gc, seq, data);
|
|
704
|
|
705 cursor = data;
|
|
706 bytes = 0;
|
|
707 im_header = g_newa(qq_recv_im_header, 1);
|
|
708 bytes += read_packet_dw(data, &cursor, len, &(im_header->sender_uid));
|
|
709 bytes += read_packet_dw(data, &cursor, len, &(im_header->receiver_uid));
|
|
710 bytes += read_packet_dw(data, &cursor, len, &(im_header->server_im_seq));
|
|
711 // if the message is delivered via server, it is server IP/port
|
|
712 bytes += read_packet_data(data, &cursor, len, (guint8 *) & (im_header->sender_ip), 4);
|
|
713 bytes += read_packet_w(data, &cursor, len, &(im_header->sender_port));
|
|
714 bytes += read_packet_w(data, &cursor, len, &(im_header->im_type));
|
|
715
|
|
716 if (bytes != 20) { // length of im_header
|
|
717 gaim_debug(GAIM_DEBUG_ERROR, "QQ",
|
|
718 "Fail read recv IM header, expect 20 bytes, read %d bytes\n", bytes);
|
|
719 return;
|
|
720 } // if bytes
|
|
721
|
|
722 if (im_header->receiver_uid != qd->uid) { // should not happen
|
|
723 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "IM to [%d], NOT me\n", im_header->receiver_uid);
|
|
724 return;
|
|
725 } // if im_header->receiver_uid
|
|
726
|
|
727 switch (im_header->im_type) {
|
|
728 case QQ_RECV_IM_TO_BUDDY:
|
|
729 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
730 "IM from buddy [%d], I am in his/her buddy list\n", im_header->sender_uid);
|
|
731 _qq_process_recv_normal_im(data, &cursor, len, gc);
|
|
732 break;
|
|
733 case QQ_RECV_IM_TO_UNKNOWN:
|
|
734 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
735 "IM from buddy [%d], I am a stranger to him/her\n", im_header->sender_uid);
|
|
736 _qq_process_recv_normal_im(data, &cursor, len, gc);
|
|
737 break;
|
|
738 case QQ_RECV_IM_UNKNOWN_QUN_IM:
|
|
739 case QQ_RECV_IM_TEMP_QUN_IM:
|
|
740 case QQ_RECV_IM_QUN_IM:
|
|
741 gaim_debug(GAIM_DEBUG_INFO, "QQ", "IM from group, internal_id [%d]\n", im_header->sender_uid);
|
|
742 // sender_uid is in fact internal_group_id
|
|
743 qq_process_recv_group_im(data, &cursor, len, im_header->sender_uid, gc, im_header->im_type);
|
|
744 break;
|
|
745 case QQ_RECV_IM_ADD_TO_QUN:
|
|
746 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
747 "IM from group, added by group internal_id [%d]\n", im_header->sender_uid);
|
|
748 // sender_uid is in fact internal_group_id
|
|
749 // we need this to create a dummy group and add to blist
|
|
750 qq_process_recv_group_im_been_added(data, &cursor, len, im_header->sender_uid, gc);
|
|
751 break;
|
|
752 case QQ_RECV_IM_DEL_FROM_QUN:
|
|
753 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
754 "IM from group, removed by group internal_ID [%d]\n", im_header->sender_uid);
|
|
755 // sender_uid is in fact internal_group_id
|
|
756 qq_process_recv_group_im_been_removed(data, &cursor, len, im_header->sender_uid, gc);
|
|
757 break;
|
|
758 case QQ_RECV_IM_APPLY_ADD_TO_QUN:
|
|
759 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
760 "IM from group, apply to join group internal_ID [%d]\n", im_header->sender_uid);
|
|
761 // sender_uid is in fact internal_group_id
|
|
762 qq_process_recv_group_im_apply_join(data, &cursor, len, im_header->sender_uid, gc);
|
|
763 break;
|
|
764 case QQ_RECV_IM_APPROVE_APPLY_ADD_TO_QUN:
|
|
765 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
766 "IM for group system info, approved by group internal_id [%d]\n",
|
|
767 im_header->sender_uid);
|
|
768 // sender_uid is in fact internal_group_id
|
|
769 qq_process_recv_group_im_been_approved(data, &cursor, len, im_header->sender_uid, gc);
|
|
770 break;
|
|
771 case QQ_RECV_IM_REJCT_APPLY_ADD_TO_QUN:
|
|
772 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
773 "IM for group system info, rejected by group internal_id [%d]\n",
|
|
774 im_header->sender_uid);
|
|
775 // sender_uid is in fact internal_group_id
|
|
776 qq_process_recv_group_im_been_rejected(data, &cursor, len, im_header->sender_uid, gc);
|
|
777 break;
|
|
778 case QQ_RECV_IM_SYS_NOTIFICATION:
|
|
779 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
780 "IM from [%d], should be a system administrator\n", im_header->sender_uid);
|
|
781 _qq_process_recv_sys_im(data, &cursor, len, gc);
|
|
782 break;
|
|
783 default:
|
|
784 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
785 "IM from [%d], [0x%02x] %s is not processed\n",
|
|
786 im_header->sender_uid,
|
|
787 im_header->im_type, qq_get_recv_im_type_str(im_header->im_type));
|
|
788 } // switch
|
|
789 } else
|
|
790 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Error decrypt rev im\n");
|
|
791
|
|
792 } // qq_process_recv_im
|
|
793
|
|
794 /*****************************************************************************/
|
|
795 // END OF FILE
|