14192
|
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 #include "debug.h"
|
|
24 #include "internal.h"
|
|
25 #include "server.h"
|
|
26
|
|
27 #include "buddy_info.h"
|
|
28 #include "buddy_list.h"
|
|
29 #include "buddy_status.h"
|
|
30 #include "char_conv.h"
|
|
31 #include "crypt.h"
|
|
32 #include "group.h"
|
|
33 #include "header_info.h"
|
|
34 #include "login_logout.h"
|
|
35 #include "packet_parse.h"
|
|
36 #include "qq.h"
|
|
37 #include "qq_proxy.h"
|
|
38 #include "send_core.h"
|
|
39 #include "utils.h"
|
|
40
|
|
41 #define QQ_LOGIN_DATA_LENGTH 416
|
|
42 #define QQ_LOGIN_REPLY_OK_PACKET_LEN 139
|
|
43 #define QQ_LOGIN_REPLY_REDIRECT_PACKET_LEN 11
|
|
44
|
|
45 #define QQ_REQUEST_LOGIN_TOKEN_REPLY_OK 0x00
|
|
46
|
|
47 #define QQ_LOGIN_REPLY_OK 0x00
|
|
48 #define QQ_LOGIN_REPLY_REDIRECT 0x01
|
|
49 #define QQ_LOGIN_REPLY_PWD_ERROR 0x05
|
|
50 #define QQ_LOGIN_REPLY_MISC_ERROR 0xff /* defined by myself */
|
|
51
|
|
52 /* for QQ 2003iii 0117, fixed value */
|
|
53 /* static const guint8 login_23_51[29] = {
|
|
54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
55 0x00, 0x00, 0x00, 0x00, 0xbf, 0x14, 0x11, 0x20,
|
|
56 0x03, 0x9d, 0xb2, 0xe6, 0xb3, 0x11, 0xb7, 0x13,
|
|
57 0x95, 0x67, 0xda, 0x2c, 0x01
|
|
58 }; */
|
|
59
|
|
60 /* for QQ 2003iii 0304, fixed value */
|
|
61 /*
|
|
62 static const guint8 login_23_51[29] = {
|
|
63 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
64 0x00, 0x00, 0x00, 0x00, 0x9a, 0x93, 0xfe, 0x85,
|
|
65 0xd3, 0xd9, 0x2a, 0x41, 0xc8, 0x0d, 0xff, 0xb6,
|
|
66 0x40, 0xb8, 0xac, 0x32, 0x01
|
|
67 };
|
|
68 */
|
|
69
|
|
70 /* for QQ 2005? copy from lumaqq */
|
|
71 static const gint8 login_23_51[29] = {
|
|
72 0, 0, 0,
|
|
73 0, 0, 0, 0, 0, 0, 0, 0, 0, -122,
|
|
74 -52, 76, 53, 44, -45, 115, 108, 20, -10, -10,
|
|
75 -81, -61, -6, 51, -92, 1
|
|
76 };
|
|
77
|
|
78 static const gint8 login_53_68[16] = {
|
|
79 -115, -117, -6, -20, -43, 82, 23, 74, -122, -7,
|
|
80 -89, 117, -26, 50, -47, 109
|
|
81 };
|
|
82
|
|
83 static const gint8 login_100_bytes[100] = {
|
|
84 64,
|
|
85 11, 4, 2, 0, 1, 0, 0, 0, 0, 0,
|
|
86 3, 9, 0, 0, 0, 0, 0, 0, 0, 1,
|
|
87 -23, 3, 1, 0, 0, 0, 0, 0, 1, -13,
|
|
88 3, 0, 0, 0, 0, 0, 0, 1, -19, 3,
|
|
89 0, 0, 0, 0, 0, 0, 1, -20, 3, 0,
|
|
90 0, 0, 0, 0, 0, 3, 5, 0, 0, 0,
|
|
91 0, 0, 0, 0, 3, 7, 0, 0, 0, 0,
|
|
92 0, 0, 0, 1, -18, 3, 0, 0, 0, 0,
|
|
93 0, 0, 1, -17, 3, 0, 0, 0, 0, 0,
|
|
94 0, 1, -21, 3, 0, 0, 0, 0, 0
|
|
95 };
|
|
96
|
|
97 /* fixed value, not affected by version, or mac address */
|
|
98 /*
|
|
99 static const guint8 login_53_68[16] = {
|
|
100 0x82, 0x2a, 0x91, 0xfd, 0xa5, 0xca, 0x67, 0x4c,
|
|
101 0xac, 0x81, 0x1f, 0x6f, 0x52, 0x05, 0xa7, 0xbf
|
|
102 };
|
|
103 */
|
|
104
|
|
105
|
|
106 typedef struct _qq_login_reply_ok qq_login_reply_ok_packet;
|
|
107 typedef struct _qq_login_reply_redirect qq_login_reply_redirect_packet;
|
|
108
|
|
109 struct _qq_login_reply_ok {
|
|
110 guint8 result;
|
|
111 guint8 *session_key;
|
|
112 guint32 uid;
|
|
113 guint8 client_ip[4]; /* those detected by server */
|
|
114 guint16 client_port;
|
|
115 guint8 server_ip[4];
|
|
116 guint16 server_port;
|
|
117 time_t login_time;
|
|
118 guint8 unknown1[26];
|
|
119 guint8 unknown_server1_ip[4];
|
|
120 guint16 unknown_server1_port;
|
|
121 guint8 unknown_server2_ip[4];
|
|
122 guint16 unknown_server2_port;
|
|
123 guint16 unknown2; /* 0x0001 */
|
|
124 guint16 unknown3; /* 0x0000 */
|
|
125 guint8 unknown4[32];
|
|
126 guint8 unknown5[12];
|
|
127 guint8 last_client_ip[4];
|
|
128 time_t last_login_time;
|
|
129 guint8 unknown6[8];
|
|
130 };
|
|
131
|
|
132 struct _qq_login_reply_redirect {
|
|
133 guint8 result;
|
|
134 guint32 uid;
|
|
135 guint8 new_server_ip[4];
|
|
136 guint16 new_server_port;
|
|
137 };
|
|
138
|
|
139 extern gint /* defined in send_core.c */
|
|
140 _create_packet_head_seq(guint8 *buf,
|
|
141 guint8 **cursor, GaimConnection *gc, guint16 cmd, gboolean is_auto_seq, guint16 *seq);
|
|
142 extern gint /* defined in send_core.c */
|
|
143 _qq_send_packet(GaimConnection *gc, guint8 *buf, gint len, guint16 cmd);
|
|
144
|
|
145 /* It is fixed to 16 bytes 0x01 for QQ2003,
|
|
146 * Any value works (or a random 16 bytes string) */
|
|
147 static guint8 *_gen_login_key(void)
|
|
148 {
|
|
149 return (guint8 *) g_strnfill(QQ_KEY_LENGTH, 0x01);
|
|
150 }
|
|
151
|
|
152 /* process login reply which says OK */
|
|
153 static gint _qq_process_login_ok(GaimConnection *gc, guint8 *data, gint len)
|
|
154 {
|
|
155 gint bytes;
|
|
156 guint8 *cursor;
|
|
157 qq_data *qd;
|
|
158 qq_login_reply_ok_packet lrop;
|
|
159
|
|
160 qd = (qq_data *) gc->proto_data;
|
|
161 cursor = data;
|
|
162 bytes = 0;
|
|
163
|
|
164 /* 000-000: reply code */
|
|
165 bytes += read_packet_b(data, &cursor, len, &lrop.result);
|
|
166 /* 001-016: session key */
|
|
167 lrop.session_key = g_memdup(cursor, QQ_KEY_LENGTH);
|
|
168 cursor += QQ_KEY_LENGTH;
|
|
169 bytes += QQ_KEY_LENGTH;
|
|
170 gaim_debug(GAIM_DEBUG_INFO, "QQ", "Get session_key done\n");
|
|
171 /* 017-020: login uid */
|
|
172 bytes += read_packet_dw(data, &cursor, len, &lrop.uid);
|
|
173 /* 021-024: server detected user public IP */
|
|
174 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.client_ip, 4);
|
|
175 /* 025-026: server detected user port */
|
|
176 bytes += read_packet_w(data, &cursor, len, &lrop.client_port);
|
|
177 /* 027-030: server detected itself ip 127.0.0.1 ? */
|
|
178 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.server_ip, 4);
|
|
179 /* 031-032: server listening port */
|
|
180 bytes += read_packet_w(data, &cursor, len, &lrop.server_port);
|
|
181 /* 033-036: login time for current session */
|
|
182 bytes += read_packet_dw(data, &cursor, len, (guint32 *) & lrop.login_time);
|
|
183 /* 037-062: 26 bytes, unknown */
|
|
184 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.unknown1, 26);
|
|
185 /* 063-066: unknown server1 ip address */
|
|
186 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.unknown_server1_ip, 4);
|
|
187 /* 067-068: unknown server1 port */
|
|
188 bytes += read_packet_w(data, &cursor, len, &lrop.unknown_server1_port);
|
|
189 /* 069-072: unknown server2 ip address */
|
|
190 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.unknown_server2_ip, 4);
|
|
191 /* 073-074: unknown server2 port */
|
|
192 bytes += read_packet_w(data, &cursor, len, &lrop.unknown_server2_port);
|
|
193 /* 075-076: 2 bytes unknown */
|
|
194 bytes += read_packet_w(data, &cursor, len, &lrop.unknown2);
|
|
195 /* 077-078: 2 bytes unknown */
|
|
196 bytes += read_packet_w(data, &cursor, len, &lrop.unknown3);
|
|
197 /* 079-110: 32 bytes unknown */
|
|
198 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.unknown4, 32);
|
|
199 /* 111-122: 12 bytes unknown */
|
|
200 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.unknown5, 12);
|
|
201 /* 123-126: login IP of last session */
|
|
202 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.last_client_ip, 4);
|
|
203 /* 127-130: login time of last session */
|
|
204 bytes += read_packet_dw(data, &cursor, len, (guint32 *) & lrop.last_login_time);
|
|
205 /* 131-138: 8 bytes unknown */
|
|
206 bytes += read_packet_data(data, &cursor, len, (guint8 *) & lrop.unknown6, 8);
|
|
207
|
|
208 if (bytes != QQ_LOGIN_REPLY_OK_PACKET_LEN) { /* fail parsing login info */
|
|
209 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
210 "Fail parsing login info, expect %d bytes, read %d bytes\n",
|
|
211 QQ_LOGIN_REPLY_OK_PACKET_LEN, bytes);
|
|
212 } /* but we still go on as login OK */
|
|
213
|
|
214 qd->session_key = g_memdup(lrop.session_key, QQ_KEY_LENGTH);
|
|
215 qd->my_ip = gen_ip_str(lrop.client_ip);
|
|
216 qd->my_port = lrop.client_port;
|
|
217 qd->login_time = lrop.login_time;
|
|
218 qd->last_login_time = lrop.last_login_time;
|
|
219 qd->last_login_ip = gen_ip_str(lrop.last_client_ip);
|
|
220
|
|
221 g_free(lrop.session_key);
|
|
222
|
|
223 gaim_connection_set_state(gc, GAIM_CONNECTED);
|
|
224 qd->logged_in = TRUE; /* must be defined after sev_finish_login */
|
|
225
|
|
226 /* now initiate QQ Qun, do it first as it may take longer to finish */
|
|
227 qq_group_init(gc);
|
|
228
|
|
229 /* Now goes on updating my icon/nickname, not showing info_window */
|
14265
|
230 qd->modifying_face = FALSE;
|
14192
|
231 qq_send_packet_get_info(gc, qd->uid, FALSE);
|
14318
|
232
|
14192
|
233 qq_send_packet_change_status(gc);
|
14318
|
234
|
14404
|
235 /* refresh buddies */
|
14192
|
236 qq_send_packet_get_buddies_list(gc, QQ_FRIENDS_LIST_POSITION_START);
|
14404
|
237 /* refresh groups */
|
|
238 qq_send_packet_get_all_list_with_group(gc, QQ_FRIENDS_LIST_POSITION_START);
|
14192
|
239
|
|
240 return QQ_LOGIN_REPLY_OK;
|
|
241 }
|
|
242
|
|
243 /* process login reply packet which includes redirected new server address */
|
|
244 static gint _qq_process_login_redirect(GaimConnection *gc, guint8 *data, gint len)
|
|
245 {
|
|
246 gint bytes, ret;
|
|
247 guint8 *cursor;
|
|
248 gchar *new_server_str;
|
|
249 qq_data *qd;
|
|
250 qq_login_reply_redirect_packet lrrp;
|
|
251
|
|
252 qd = (qq_data *) gc->proto_data;
|
|
253 cursor = data;
|
|
254 bytes = 0;
|
|
255 /* 000-000: reply code */
|
|
256 bytes += read_packet_b(data, &cursor, len, &lrrp.result);
|
|
257 /* 001-004: login uid */
|
|
258 bytes += read_packet_dw(data, &cursor, len, &lrrp.uid);
|
|
259 /* 005-008: redirected new server IP */
|
|
260 bytes += read_packet_data(data, &cursor, len, lrrp.new_server_ip, 4);
|
|
261 /* 009-010: redirected new server port */
|
|
262 bytes += read_packet_w(data, &cursor, len, &lrrp.new_server_port);
|
|
263
|
|
264 if (bytes != QQ_LOGIN_REPLY_REDIRECT_PACKET_LEN) {
|
|
265 gaim_debug(GAIM_DEBUG_ERROR, "QQ",
|
|
266 "Fail parsing login redirect packet, expect %d bytes, read %d bytes\n",
|
|
267 QQ_LOGIN_REPLY_REDIRECT_PACKET_LEN, bytes);
|
|
268 ret = QQ_LOGIN_REPLY_MISC_ERROR;
|
|
269 } else { /* start new connection */
|
|
270 new_server_str = gen_ip_str(lrrp.new_server_ip);
|
|
271 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
272 "Redirected to new server: %s:%d\n", new_server_str, lrrp.new_server_port);
|
|
273 qq_connect(gc->account, new_server_str, lrrp.new_server_port, qd->use_tcp, TRUE);
|
|
274 g_free(new_server_str);
|
|
275 ret = QQ_LOGIN_REPLY_REDIRECT;
|
|
276 }
|
|
277
|
|
278 return ret;
|
|
279 }
|
|
280
|
|
281 /* process login reply which says wrong password */
|
|
282 static gint _qq_process_login_wrong_pwd(GaimConnection * gc, guint8 * data, gint len)
|
|
283 {
|
|
284 gchar *server_reply, *server_reply_utf8;
|
|
285 server_reply = g_new0(gchar, len);
|
|
286 g_memmove(server_reply, data + 1, len - 1);
|
|
287 server_reply_utf8 = qq_to_utf8(server_reply, QQ_CHARSET_DEFAULT);
|
|
288 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Wrong password, server msg in UTF8: %s\n", server_reply_utf8);
|
|
289 g_free(server_reply);
|
|
290 g_free(server_reply_utf8);
|
|
291
|
|
292 return QQ_LOGIN_REPLY_PWD_ERROR;
|
|
293 }
|
|
294
|
|
295 /* request before login */
|
|
296 void qq_send_packet_request_login_token(GaimConnection *gc)
|
|
297 {
|
|
298 qq_data *qd;
|
|
299 guint8 *buf, *cursor;
|
|
300 guint16 seq_ret;
|
|
301 gint bytes;
|
|
302
|
|
303 qd = (qq_data *) gc->proto_data;
|
|
304 buf = g_newa(guint8, MAX_PACKET_SIZE);
|
|
305
|
|
306 cursor = buf;
|
|
307 bytes = 0;
|
|
308 bytes += _create_packet_head_seq(buf, &cursor, gc, QQ_CMD_REQUEST_LOGIN_TOKEN, TRUE, &seq_ret);
|
|
309 bytes += create_packet_dw(buf, &cursor, qd->uid);
|
|
310 bytes += create_packet_b(buf, &cursor, 0);
|
|
311 bytes += create_packet_b(buf, &cursor, QQ_PACKET_TAIL);
|
|
312
|
|
313 if (bytes == (cursor - buf)) /* packet creation OK */
|
|
314 _qq_send_packet(gc, buf, bytes, QQ_CMD_REQUEST_LOGIN_TOKEN);
|
|
315 else
|
|
316 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Fail create request login token packet\n");
|
|
317 }
|
|
318
|
|
319 /* TODO: The login packet and its response have changed by QQ2006 Beta2. In that version,
|
|
320 * the login OK response packet does not appear to be decryptable with qd->pwkey or qd->inikey.
|
|
321 * Fortunately, this older system still works. */
|
|
322
|
|
323 /* send login packet to QQ server */
|
|
324 static void qq_send_packet_login(GaimConnection *gc, guint8 token_length, guint8 *token)
|
|
325 {
|
|
326 qq_data *qd;
|
|
327 guint8 *buf, *cursor, *raw_data, *encrypted_data;
|
|
328 guint16 seq_ret;
|
|
329 gint encrypted_len, bytes;
|
|
330 gint pos;
|
|
331
|
|
332 qd = (qq_data *) gc->proto_data;
|
|
333 buf = g_newa(guint8, MAX_PACKET_SIZE);
|
|
334 raw_data = g_newa(guint8, QQ_LOGIN_DATA_LENGTH);
|
|
335 encrypted_data = g_newa(guint8, QQ_LOGIN_DATA_LENGTH + 16); /* 16 bytes more */
|
|
336 qd->inikey = _gen_login_key();
|
|
337
|
|
338 /* now generate the encrypted data
|
|
339 * 000-015 use pwkey as key to encrypt empty string */
|
|
340 qq_crypt(ENCRYPT, (guint8 *) "", 0, qd->pwkey, raw_data, &encrypted_len);
|
|
341 /* 016-016 */
|
|
342 raw_data[16] = 0x00;
|
|
343 /* 017-020, used to be IP, now zero */
|
|
344 *((guint32 *) (raw_data + 17)) = 0x00000000;
|
|
345 /* 021-022, used to be port, now zero */
|
|
346 *((guint16 *) (raw_data + 21)) = 0x0000;
|
|
347 /* 023-051, fixed value, unknown */
|
|
348 g_memmove(raw_data + 23, login_23_51, 29);
|
|
349 /* 052-052, login mode */
|
|
350 raw_data[52] = qd->login_mode;
|
|
351 /* 053-068, fixed value, maybe related to per machine */
|
|
352 g_memmove(raw_data + 53, login_53_68, 16);
|
|
353
|
|
354 /* 069, login token length */
|
|
355 raw_data[69] = token_length;
|
|
356 pos = 70;
|
|
357 /* 070-093, login token, normally 24 bytes */
|
|
358 g_memmove(raw_data + pos, token, token_length);
|
|
359 pos += token_length;
|
|
360 /* 100 bytes unknown */
|
|
361 g_memmove(raw_data + pos, login_100_bytes, 100);
|
|
362 pos += 100;
|
|
363 /* all zero left */
|
|
364 memset(raw_data+pos, 0, QQ_LOGIN_DATA_LENGTH - pos);
|
|
365
|
|
366 qq_crypt(ENCRYPT, raw_data, QQ_LOGIN_DATA_LENGTH, qd->inikey, encrypted_data, &encrypted_len);
|
|
367
|
|
368 cursor = buf;
|
|
369 bytes = 0;
|
|
370 bytes += _create_packet_head_seq(buf, &cursor, gc, QQ_CMD_LOGIN, TRUE, &seq_ret);
|
|
371 bytes += create_packet_dw(buf, &cursor, qd->uid);
|
|
372 bytes += create_packet_data(buf, &cursor, qd->inikey, QQ_KEY_LENGTH);
|
|
373 bytes += create_packet_data(buf, &cursor, encrypted_data, encrypted_len);
|
|
374 bytes += create_packet_b(buf, &cursor, QQ_PACKET_TAIL);
|
|
375
|
|
376 if (bytes == (cursor - buf)) /* packet creation OK */
|
|
377 _qq_send_packet(gc, buf, bytes, QQ_CMD_LOGIN);
|
|
378 else
|
|
379 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Fail create login packet\n");
|
|
380 }
|
|
381
|
|
382 void qq_process_request_login_token_reply(guint8 *buf, gint buf_len, GaimConnection *gc)
|
|
383 {
|
|
384 qq_data *qd;
|
|
385
|
|
386 g_return_if_fail(buf != NULL && buf_len != 0);
|
|
387
|
|
388 qd = (qq_data *) gc->proto_data;
|
|
389
|
|
390 if (buf[0] == QQ_REQUEST_LOGIN_TOKEN_REPLY_OK) {
|
|
391 if (buf[1] != buf_len-2) {
|
|
392 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
393 "Malformed login token reply packet. Packet specifies length of %d, actual length is %d\n", buf[1], buf_len-2);
|
|
394 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
395 "Attempting to proceed with the actual packet length.\n");
|
|
396 }
|
|
397 gaim_debug(GAIM_DEBUG_INFO, "QQ",
|
|
398 "<<< got a token with %d bytes -> [default] decrypt and dump\n%s",buf_len-2, hex_dump_to_str(buf+2, buf_len-2));
|
|
399 qq_send_packet_login(gc, buf_len-2, buf+2);
|
|
400 } else {
|
|
401 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Unknown request login token reply code : %d\n", buf[0]);
|
|
402 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
403 ">>> %d bytes -> [default] decrypt and dump\n%s",
|
|
404 buf_len, hex_dump_to_str(buf, buf_len));
|
|
405 try_dump_as_gbk(buf, buf_len);
|
|
406 gaim_connection_error(gc, _("Request login token error!"));
|
|
407 }
|
|
408 }
|
|
409
|
|
410 /* send logout packets to QQ server */
|
|
411 void qq_send_packet_logout(GaimConnection *gc)
|
|
412 {
|
|
413 gint i;
|
|
414 qq_data *qd;
|
|
415
|
|
416 qd = (qq_data *) gc->proto_data;
|
|
417 for (i = 0; i < 4; i++)
|
|
418 qq_send_cmd(gc, QQ_CMD_LOGOUT, FALSE, 0xffff, FALSE, qd->pwkey, QQ_KEY_LENGTH);
|
|
419
|
|
420 qd->logged_in = FALSE; /* update login status AFTER sending logout packets */
|
|
421 }
|
|
422
|
|
423 /* process the login reply packet */
|
|
424 void qq_process_login_reply(guint8 *buf, gint buf_len, GaimConnection *gc)
|
|
425 {
|
|
426 gint len, ret, bytes;
|
|
427 guint8 *data;
|
|
428 qq_data *qd;
|
|
429
|
|
430 g_return_if_fail(buf != NULL && buf_len != 0);
|
|
431
|
|
432 qd = (qq_data *) gc->proto_data;
|
|
433 len = buf_len;
|
|
434 data = g_newa(guint8, len);
|
|
435
|
|
436 if (qq_crypt(DECRYPT, buf, buf_len, qd->pwkey, data, &len)) {
|
|
437 /* should be able to decrypt with pwkey */
|
|
438 gaim_debug(GAIM_DEBUG_INFO, "QQ", "Decrypt login reply packet with pwkey, %d bytes\n", len);
|
|
439 if (data[0] == QQ_LOGIN_REPLY_OK) {
|
|
440 ret = _qq_process_login_ok(gc, data, len);
|
|
441 } else {
|
|
442 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Unknown login reply code : %d\n", data[0]);
|
|
443 ret = QQ_LOGIN_REPLY_MISC_ERROR;
|
|
444 }
|
|
445 } else { /* decrypt with pwkey error */
|
|
446 len = buf_len; /* reset len, decrypt will fail if len is too short */
|
|
447 if (qq_crypt(DECRYPT, buf, buf_len, qd->inikey, data, &len)) {
|
|
448 /* decrypt ok with inipwd, it might be password error */
|
|
449 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
450 "Decrypt login reply packet with inikey, %d bytes\n", len);
|
|
451 bytes = 0;
|
|
452 switch (data[0]) {
|
|
453 case QQ_LOGIN_REPLY_REDIRECT:
|
|
454 ret = _qq_process_login_redirect(gc, data, len);
|
|
455 break;
|
|
456 case QQ_LOGIN_REPLY_PWD_ERROR:
|
|
457 ret = _qq_process_login_wrong_pwd(gc, data, len);
|
|
458 break;
|
|
459 default:
|
|
460 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "Unknown reply code: %d\n", data[0]);
|
|
461 gaim_debug(GAIM_DEBUG_WARNING, "QQ",
|
|
462 ">>> %d bytes -> [default] decrypt and dump\n%s",
|
|
463 buf_len, hex_dump_to_str(data, len));
|
|
464 try_dump_as_gbk(data, len);
|
|
465
|
|
466 ret = QQ_LOGIN_REPLY_MISC_ERROR;
|
|
467 }
|
|
468 } else { /* no idea how to decrypt */
|
|
469 gaim_debug(GAIM_DEBUG_ERROR, "QQ", "No idea how to decrypt login reply\n");
|
|
470 ret = QQ_LOGIN_REPLY_MISC_ERROR;
|
|
471 }
|
|
472 }
|
|
473
|
|
474 switch (ret) {
|
|
475 case QQ_LOGIN_REPLY_PWD_ERROR:
|
|
476 gc->wants_to_die = TRUE;
|
|
477 gaim_connection_error(gc, _("Wrong password!"));
|
|
478 break;
|
|
479 case QQ_LOGIN_REPLY_MISC_ERROR:
|
|
480 gaim_connection_error(gc, _("Unable to login, check debug log"));
|
|
481 break;
|
|
482 case QQ_LOGIN_REPLY_OK:
|
|
483 gaim_debug(GAIM_DEBUG_INFO, "QQ", "Login replys OK, everything is fine\n");
|
|
484 break;
|
|
485 case QQ_LOGIN_REPLY_REDIRECT:
|
|
486 /* the redirect has been done in _qq_process_login_reply */
|
|
487 break;
|
|
488 default:{;
|
|
489 }
|
|
490 }
|
|
491 }
|