Mercurial > pidgin.yaz

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[gaim-migrate @ 16340] Performed minor cleanup of the OpenQ codebase and patched it into the Gaim trunk as a prpl, providing basic QQ functionality. committer: Tailor Script <tailor@pidgin.im>
author Mark Huetsch <markhuetsch>
date Mon, 26 Jun 2006 02:58:54 +0000
parents
children 2be9dfa9569b
comparison
equal deleted inserted replaced
13869:5642f4658b59 13870:983fd420e86b
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
51 static void _qq_show_packet(gchar * desc, gchar * buf, gint len);
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
233 static gchar *_gen_session_md5(gint uid, gchar * session_key)
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