Mercurial > pidgin
annotate src/protocols/msn/slplink.c @ 11595:ecd49b9a48b7
[gaim-migrate @ 13865]
Fix a msn ft crash that I introduced.
committer: Tailor Script <tailor@pidgin.im>
author | Daniel Atallah <daniel.atallah@gmail.com> |
---|---|
date | Mon, 03 Oct 2005 02:59:17 +0000 |
parents | 2cb95478ef9c |
children | cdab645d1ad6 |
rev | line source |
---|---|
9198
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
1 /** |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
2 * @file slplink.c MSNSLP Link support |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
3 * |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
4 * gaim |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
5 * |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
6 * Gaim is the legal property of its developers, whose names are too numerous |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
7 * to list here. Please refer to the COPYRIGHT file distributed with this |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
8 * source distribution. |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
9 * |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
10 * This program is free software; you can redistribute it and/or modify |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
11 * it under the terms of the GNU General Public License as published by |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
12 * the Free Software Foundation; either version 2 of the License, or |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
13 * (at your option) any later version. |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
14 * |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
15 * This program is distributed in the hope that it will be useful, |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
18 * GNU General Public License for more details. |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
19 * |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
20 * You should have received a copy of the GNU General Public License |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
21 * along with this program; if not, write to the Free Software |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
23 */ |
9193 | 24 #include "msn.h" |
25 #include "slplink.h" | |
26 | |
27 #include "switchboard.h" | |
28 #include "slp.h" | |
29 | |
30 void msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg); | |
31 | |
10345 | 32 #ifdef MSN_DEBUG_SLP_FILES |
9193 | 33 static int m_sc = 0; |
34 static int m_rc = 0; | |
35 | |
36 static void | |
37 debug_msg_to_file(MsnMessage *msg, gboolean send) | |
38 { | |
39 char *tmp; | |
40 char *dir; | |
41 char *pload; | |
42 FILE *tf; | |
43 int c; | |
44 gsize pload_size; | |
45 | |
46 dir = send ? "send" : "recv"; | |
47 c = send ? m_sc++ : m_rc++; | |
48 tmp = g_strdup_printf("%s/msntest/%s/%03d", g_get_home_dir(), dir, c); | |
10589
0f7452b1f777
[gaim-migrate @ 11994]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
10481
diff
changeset
|
49 tf = g_fopen(tmp, "wb"); |
9193 | 50 pload = msn_message_gen_payload(msg, &pload_size); |
51 fwrite(pload, 1, pload_size, tf); | |
52 fclose(tf); | |
53 g_free(tmp); | |
54 } | |
55 #endif | |
56 | |
10602 | 57 /************************************************************************** |
58 * Main | |
59 **************************************************************************/ | |
60 | |
9193 | 61 MsnSlpLink * |
62 msn_slplink_new(MsnSession *session, const char *username) | |
63 { | |
64 MsnSlpLink *slplink; | |
65 | |
10296 | 66 g_return_val_if_fail(session != NULL, NULL); |
67 | |
9193 | 68 slplink = g_new0(MsnSlpLink, 1); |
69 | |
10773 | 70 #ifdef MSN_DEBUG_SLPLINK |
71 gaim_debug_info("msn", "slplink_new: slplink(%p)\n", slplink); | |
72 #endif | |
73 | |
9193 | 74 slplink->session = session; |
75 slplink->slp_seq_id = rand() % 0xFFFFFF00 + 4; | |
76 | |
77 slplink->local_user = g_strdup(msn_user_get_passport(session->user)); | |
78 slplink->remote_user = g_strdup(username); | |
79 | |
80 slplink->slp_msg_queue = g_queue_new(); | |
81 | |
82 session->slplinks = | |
83 g_list_append(session->slplinks, slplink); | |
84 | |
85 return slplink; | |
86 } | |
87 | |
88 void | |
89 msn_slplink_destroy(MsnSlpLink *slplink) | |
90 { | |
91 MsnSession *session; | |
92 | |
10773 | 93 #ifdef MSN_DEBUG_SLPLINK |
94 gaim_debug_info("msn", "slplink_destroy: slplink(%p)\n", slplink); | |
95 #endif | |
96 | |
10296 | 97 g_return_if_fail(slplink != NULL); |
98 | |
10345 | 99 if (slplink->swboard != NULL) |
100 slplink->swboard->slplink = NULL; | |
101 | |
9193 | 102 session = slplink->session; |
103 | |
104 if (slplink->local_user != NULL) | |
105 g_free(slplink->local_user); | |
106 | |
107 if (slplink->remote_user != NULL) | |
108 g_free(slplink->remote_user); | |
109 | |
110 if (slplink->directconn != NULL) | |
111 msn_directconn_destroy(slplink->directconn); | |
112 | |
10296 | 113 while (slplink->slp_calls != NULL) |
114 msn_slp_call_destroy(slplink->slp_calls->data); | |
115 | |
9193 | 116 session->slplinks = |
117 g_list_remove(session->slplinks, slplink); | |
118 | |
119 g_free(slplink); | |
120 } | |
121 | |
122 MsnSlpLink * | |
123 msn_session_find_slplink(MsnSession *session, const char *who) | |
124 { | |
125 GList *l; | |
126 | |
127 for (l = session->slplinks; l != NULL; l = l->next) | |
128 { | |
10225 | 129 MsnSlpLink *slplink; |
130 | |
9193 | 131 slplink = l->data; |
132 | |
133 if (!strcmp(slplink->remote_user, who)) | |
134 return slplink; | |
135 } | |
136 | |
137 return NULL; | |
138 } | |
139 | |
140 MsnSlpLink * | |
141 msn_session_get_slplink(MsnSession *session, const char *username) | |
142 { | |
143 MsnSlpLink *slplink; | |
144 | |
145 slplink = msn_session_find_slplink(session, username); | |
146 | |
147 if (slplink == NULL) | |
148 slplink = msn_slplink_new(session, username); | |
149 | |
150 return slplink; | |
151 } | |
152 | |
153 MsnSlpSession * | |
154 msn_slplink_find_slp_session(MsnSlpLink *slplink, long session_id) | |
155 { | |
156 GList *l; | |
157 MsnSlpSession *slpsession; | |
158 | |
159 for (l = slplink->slp_sessions; l != NULL; l = l->next) | |
160 { | |
161 slpsession = l->data; | |
162 | |
163 if (slpsession->id == session_id) | |
164 return slpsession; | |
165 } | |
166 | |
167 return NULL; | |
168 } | |
169 | |
10602 | 170 void |
171 msn_slplink_add_slpcall(MsnSlpLink *slplink, MsnSlpCall *slpcall) | |
172 { | |
10621 | 173 if (slplink->swboard != NULL) |
174 slplink->swboard->flag |= MSN_SB_FLAG_FT; | |
10602 | 175 |
176 slplink->slp_calls = g_list_append(slplink->slp_calls, slpcall); | |
177 } | |
178 | |
179 void | |
180 msn_slplink_remove_slpcall(MsnSlpLink *slplink, MsnSlpCall *slpcall) | |
181 { | |
182 slplink->slp_calls = g_list_remove(slplink->slp_calls, slpcall); | |
183 | |
10773 | 184 /* The slplink has no slpcalls in it. If no one is using it, we might |
185 * destroy the switchboard, but we should be careful not to use the slplink | |
186 * again. */ | |
10602 | 187 if (slplink->slp_calls == NULL) |
188 { | |
189 if (slplink->swboard != NULL) | |
10773 | 190 { |
191 if (msn_switchboard_release(slplink->swboard, MSN_SB_FLAG_FT)) | |
192 /* I'm not sure this is the best thing to do, but it's better | |
193 * than nothing. */ | |
194 slpcall->slplink = NULL; | |
195 } | |
10602 | 196 } |
197 } | |
198 | |
9193 | 199 MsnSlpCall * |
200 msn_slplink_find_slp_call(MsnSlpLink *slplink, const char *id) | |
201 { | |
202 GList *l; | |
203 MsnSlpCall *slpcall; | |
204 | |
10107
65e7df286076
[gaim-migrate @ 11139]
Luke Schierer <lschiere@pidgin.im>
parents:
10092
diff
changeset
|
205 if (!id) |
65e7df286076
[gaim-migrate @ 11139]
Luke Schierer <lschiere@pidgin.im>
parents:
10092
diff
changeset
|
206 return NULL; |
65e7df286076
[gaim-migrate @ 11139]
Luke Schierer <lschiere@pidgin.im>
parents:
10092
diff
changeset
|
207 |
9193 | 208 for (l = slplink->slp_calls; l != NULL; l = l->next) |
209 { | |
210 slpcall = l->data; | |
211 | |
10107
65e7df286076
[gaim-migrate @ 11139]
Luke Schierer <lschiere@pidgin.im>
parents:
10092
diff
changeset
|
212 if (slpcall->id && !strcmp(slpcall->id, id)) |
9193 | 213 return slpcall; |
214 } | |
215 | |
216 return NULL; | |
217 } | |
218 | |
219 MsnSlpCall * | |
220 msn_slplink_find_slp_call_with_session_id(MsnSlpLink *slplink, long id) | |
221 { | |
222 GList *l; | |
223 MsnSlpCall *slpcall; | |
224 | |
225 for (l = slplink->slp_calls; l != NULL; l = l->next) | |
226 { | |
227 slpcall = l->data; | |
228 | |
229 if (slpcall->session_id == id) | |
230 return slpcall; | |
231 } | |
232 | |
233 return NULL; | |
234 } | |
235 | |
236 void | |
237 msn_slplink_send_msg(MsnSlpLink *slplink, MsnMessage *msg) | |
238 { | |
239 if (slplink->directconn != NULL) | |
240 { | |
241 msn_directconn_send_msg(slplink->directconn, msg); | |
242 } | |
243 else | |
244 { | |
10345 | 245 if (slplink->swboard == NULL) |
246 { | |
247 slplink->swboard = msn_session_get_swboard(slplink->session, | |
10773 | 248 slplink->remote_user, MSN_SB_FLAG_FT); |
9193 | 249 |
10345 | 250 if (slplink->swboard == NULL) |
251 return; | |
9193 | 252 |
10346 | 253 /* If swboard is destroyed we will be too */ |
10345 | 254 slplink->swboard->slplink = slplink; |
255 } | |
9193 | 256 |
10481 | 257 msn_switchboard_send_msg(slplink->swboard, msg, TRUE); |
9193 | 258 } |
259 } | |
260 | |
10345 | 261 /* We have received the message ack */ |
9571 | 262 static void |
10345 | 263 msg_ack(MsnMessage *msg, void *data) |
9193 | 264 { |
265 MsnSlpMessage *slpmsg; | |
266 long long real_size; | |
267 | |
10225 | 268 slpmsg = data; |
9193 | 269 |
270 real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size; | |
271 | |
10345 | 272 slpmsg->offset += msg->msnslp_header.length; |
273 | |
9193 | 274 if (slpmsg->offset < real_size) |
275 { | |
276 msn_slplink_send_msgpart(slpmsg->slplink, slpmsg); | |
277 } | |
278 else | |
279 { | |
280 /* The whole message has been sent */ | |
9246
e20af87d8721
[gaim-migrate @ 10045]
Christian Hammond <chipx86@chipx86.com>
parents:
9231
diff
changeset
|
281 if (slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) |
9193 | 282 { |
11595
ecd49b9a48b7
[gaim-migrate @ 13865]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
11367
diff
changeset
|
283 if (slpmsg->slpcall != NULL) |
9246
e20af87d8721
[gaim-migrate @ 10045]
Christian Hammond <chipx86@chipx86.com>
parents:
9231
diff
changeset
|
284 { |
11595
ecd49b9a48b7
[gaim-migrate @ 13865]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
11367
diff
changeset
|
285 if (slpmsg->slpcall->cb) |
ecd49b9a48b7
[gaim-migrate @ 13865]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
11367
diff
changeset
|
286 slpmsg->slpcall->cb(slpmsg->slpcall, |
ecd49b9a48b7
[gaim-migrate @ 13865]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
11367
diff
changeset
|
287 NULL, 0); |
ecd49b9a48b7
[gaim-migrate @ 13865]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
11367
diff
changeset
|
288 |
ecd49b9a48b7
[gaim-migrate @ 13865]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
11367
diff
changeset
|
289 msn_slp_call_destroy(slpmsg->slpcall); |
9246
e20af87d8721
[gaim-migrate @ 10045]
Christian Hammond <chipx86@chipx86.com>
parents:
9231
diff
changeset
|
290 } |
9193 | 291 } |
10345 | 292 } |
9193 | 293 |
10345 | 294 slpmsg->msgs = g_list_remove(slpmsg->msgs, msg); |
295 } | |
296 | |
297 /* We have received the message nak. */ | |
298 static void | |
299 msg_nak(MsnMessage *msg, void *data) | |
300 { | |
301 MsnSlpMessage *slpmsg; | |
302 | |
303 slpmsg = data; | |
304 | |
305 msn_slplink_send_msgpart(slpmsg->slplink, slpmsg); | |
306 | |
307 slpmsg->msgs = g_list_remove(slpmsg->msgs, msg); | |
9193 | 308 } |
309 | |
310 void | |
311 msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) | |
312 { | |
313 MsnMessage *msg; | |
314 long long real_size; | |
315 size_t len = 0; | |
316 | |
10345 | 317 /* Maybe we will want to create a new msg for this slpmsg instead of |
318 * reusing the same one all the time. */ | |
9193 | 319 msg = slpmsg->msg; |
320 | |
321 real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size; | |
322 | |
323 if (slpmsg->offset < real_size) | |
324 { | |
325 if (slpmsg->fp) | |
326 { | |
327 char data[1202]; | |
328 len = fread(data, 1, sizeof(data), slpmsg->fp); | |
329 msn_message_set_bin_data(msg, data, len); | |
330 } | |
331 else | |
332 { | |
333 len = slpmsg->size - slpmsg->offset; | |
334 | |
335 if (len > 1202) | |
336 len = 1202; | |
337 | |
338 msn_message_set_bin_data(msg, slpmsg->buffer + slpmsg->offset, len); | |
339 } | |
340 | |
341 msg->msnslp_header.offset = slpmsg->offset; | |
342 msg->msnslp_header.length = len; | |
343 } | |
344 | |
10345 | 345 #ifdef MSN_DEBUG_SLP |
9193 | 346 msn_message_show_readable(msg, slpmsg->info, slpmsg->text_body); |
347 #endif | |
348 | |
10345 | 349 #ifdef MSN_DEBUG_SLP_FILES |
9193 | 350 debug_msg_to_file(msg, TRUE); |
351 #endif | |
352 | |
10345 | 353 slpmsg->msgs = |
354 g_list_append(slpmsg->msgs, msg); | |
9193 | 355 msn_slplink_send_msg(slplink, msg); |
356 | |
10345 | 357 if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) && |
358 (slpmsg->slpcall != NULL)) | |
9193 | 359 { |
10296 | 360 slpmsg->slpcall->progress = TRUE; |
10225 | 361 |
362 if (slpmsg->slpcall->progress_cb != NULL) | |
9226
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
363 { |
9231
ac8790437abe
[gaim-migrate @ 10027]
Christian Hammond <chipx86@chipx86.com>
parents:
9226
diff
changeset
|
364 slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size, |
ac8790437abe
[gaim-migrate @ 10027]
Christian Hammond <chipx86@chipx86.com>
parents:
9226
diff
changeset
|
365 len, slpmsg->offset); |
9226
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
366 } |
9193 | 367 } |
368 | |
10345 | 369 /* slpmsg->offset += len; */ |
9193 | 370 } |
371 | |
372 void | |
10345 | 373 msn_slplink_release_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) |
9193 | 374 { |
375 MsnMessage *msg; | |
376 | |
377 slpmsg->msg = msg = msn_message_new_msnslp(); | |
9198
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
378 |
9193 | 379 if (slpmsg->flags == 0x0) |
380 { | |
381 msg->msnslp_header.session_id = slpmsg->session_id; | |
382 msg->msnslp_header.ack_id = rand() % 0xFFFFFF00; | |
383 } | |
384 else if (slpmsg->flags == 0x2) | |
385 { | |
386 msg->msnslp_header.session_id = slpmsg->session_id; | |
387 msg->msnslp_header.ack_id = slpmsg->ack_id; | |
388 msg->msnslp_header.ack_size = slpmsg->ack_size; | |
11321 | 389 msg->msnslp_header.ack_sub_id = slpmsg->ack_sub_id; |
9193 | 390 } |
391 else if (slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) | |
392 { | |
393 MsnSlpSession *slpsession; | |
9198
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
394 slpsession = slpmsg->slpsession; |
9193 | 395 |
396 g_return_if_fail(slpsession != NULL); | |
397 msg->msnslp_header.session_id = slpsession->id; | |
398 msg->msnslp_footer.value = slpsession->app_id; | |
399 msg->msnslp_header.ack_id = rand() % 0xFFFFFF00; | |
400 } | |
401 else if (slpmsg->flags == 0x100) | |
402 { | |
403 msg->msnslp_header.ack_id = slpmsg->ack_id; | |
404 msg->msnslp_header.ack_sub_id = slpmsg->ack_sub_id; | |
405 msg->msnslp_header.ack_size = slpmsg->ack_size; | |
406 } | |
407 | |
408 msg->msnslp_header.id = slpmsg->id; | |
409 msg->msnslp_header.flags = slpmsg->flags; | |
410 | |
411 msg->msnslp_header.total_size = slpmsg->size; | |
412 | |
413 msn_message_set_attr(msg, "P2P-Dest", slplink->remote_user); | |
414 | |
10225 | 415 msg->ack_cb = msg_ack; |
10345 | 416 msg->nak_cb = msg_nak; |
9193 | 417 msg->ack_data = slpmsg; |
418 | |
419 msn_slplink_send_msgpart(slplink, slpmsg); | |
10284 | 420 |
421 msn_message_destroy(msg); | |
9193 | 422 } |
423 | |
424 void | |
425 msn_slplink_queue_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) | |
426 { | |
427 slpmsg->id = slplink->slp_seq_id++; | |
428 | |
429 g_queue_push_head(slplink->slp_msg_queue, slpmsg); | |
430 } | |
431 | |
432 void | |
433 msn_slplink_send_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) | |
434 { | |
435 slpmsg->id = slplink->slp_seq_id++; | |
436 | |
10345 | 437 msn_slplink_release_slpmsg(slplink, slpmsg); |
9193 | 438 } |
439 | |
440 void | |
441 msn_slplink_unleash(MsnSlpLink *slplink) | |
442 { | |
443 MsnSlpMessage *slpmsg; | |
444 | |
445 /* Send the queued msgs in the order they came. */ | |
446 | |
447 while ((slpmsg = g_queue_pop_tail(slplink->slp_msg_queue)) != NULL) | |
10345 | 448 { |
449 msn_slplink_release_slpmsg(slplink, slpmsg); | |
450 } | |
9193 | 451 } |
452 | |
453 void | |
454 msn_slplink_send_ack(MsnSlpLink *slplink, MsnMessage *msg) | |
455 { | |
456 MsnSlpMessage *slpmsg; | |
457 | |
458 slpmsg = msn_slpmsg_new(slplink); | |
459 | |
460 slpmsg->session_id = msg->msnslp_header.session_id; | |
461 slpmsg->size = msg->msnslp_header.total_size; | |
462 slpmsg->flags = 0x02; | |
463 slpmsg->ack_id = msg->msnslp_header.id; | |
464 slpmsg->ack_sub_id = msg->msnslp_header.ack_id; | |
465 slpmsg->ack_size = msg->msnslp_header.total_size; | |
466 | |
10345 | 467 #ifdef MSN_DEBUG_SLP |
9193 | 468 slpmsg->info = "SLP ACK"; |
469 #endif | |
470 | |
471 msn_slplink_send_slpmsg(slplink, slpmsg); | |
472 } | |
473 | |
9571 | 474 static void |
475 send_file_cb(MsnSlpSession *slpsession) | |
9193 | 476 { |
477 MsnSlpCall *slpcall; | |
478 MsnSlpMessage *slpmsg; | |
479 | |
480 slpcall = slpsession->slpcall; | |
481 slpmsg = msn_slpmsg_new(slpcall->slplink); | |
10345 | 482 slpmsg->slpcall = slpcall; |
9193 | 483 slpmsg->flags = 0x1000030; |
484 slpmsg->slpsession = slpsession; | |
10345 | 485 #ifdef MSN_DEBUG_SLP |
9193 | 486 slpmsg->info = "SLP FILE"; |
487 #endif | |
488 msn_slpmsg_open_file(slpmsg, gaim_xfer_get_local_filename(slpcall->xfer)); | |
489 | |
490 msn_slplink_send_slpmsg(slpcall->slplink, slpmsg); | |
491 } | |
492 | |
493 void | |
494 msn_slplink_process_msg(MsnSlpLink *slplink, MsnMessage *msg) | |
495 { | |
496 MsnSlpMessage *slpmsg; | |
497 const char *data; | |
498 gsize offset; | |
499 gsize len; | |
500 | |
10345 | 501 #ifdef MSN_DEBUG_SLP |
9193 | 502 msn_slpmsg_show(msg); |
503 #endif | |
504 | |
10345 | 505 #ifdef MSN_DEBUG_SLP_FILES |
9193 | 506 debug_msg_to_file(msg, FALSE); |
507 #endif | |
508 | |
509 if (msg->msnslp_header.total_size < msg->msnslp_header.length) | |
510 { | |
511 gaim_debug_error("msn", "This can't be good\n"); | |
512 g_return_if_reached(); | |
513 } | |
514 | |
515 slpmsg = NULL; | |
516 data = msn_message_get_bin_data(msg, &len); | |
517 | |
518 /* | |
519 OVERHEAD! | |
520 if (msg->msnslp_header.length < msg->msnslp_header.total_size) | |
521 */ | |
522 | |
523 offset = msg->msnslp_header.offset; | |
524 | |
525 if (offset == 0) | |
526 { | |
527 slpmsg = msn_slpmsg_new(slplink); | |
528 slpmsg->id = msg->msnslp_header.id; | |
529 slpmsg->session_id = msg->msnslp_header.session_id; | |
530 slpmsg->size = msg->msnslp_header.total_size; | |
531 slpmsg->flags = msg->msnslp_header.flags; | |
532 | |
533 if (slpmsg->session_id) | |
534 { | |
535 if (slpmsg->slpcall == NULL) | |
536 slpmsg->slpcall = msn_slplink_find_slp_call_with_session_id(slplink, slpmsg->session_id); | |
537 | |
538 if (slpmsg->slpcall != NULL) | |
539 { | |
9226
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
540 if (slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) |
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
541 { |
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
542 GaimXfer *xfer; |
9193 | 543 |
9226
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
544 xfer = slpmsg->slpcall->xfer; |
9193 | 545 |
9226
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
546 if (xfer != NULL) |
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
547 { |
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
548 slpmsg->fp = |
10589
0f7452b1f777
[gaim-migrate @ 11994]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
10481
diff
changeset
|
549 g_fopen(gaim_xfer_get_local_filename(slpmsg->slpcall->xfer), |
9226
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
550 "wb"); |
7a00289f2ef1
[gaim-migrate @ 10022]
Christian Hammond <chipx86@chipx86.com>
parents:
9219
diff
changeset
|
551 } |
9193 | 552 } |
553 } | |
554 } | |
10225 | 555 if (!slpmsg->fp && slpmsg->size) |
10092 | 556 { |
557 slpmsg->buffer = g_try_malloc(slpmsg->size); | |
558 if (slpmsg->buffer == NULL) | |
559 { | |
560 gaim_debug_error("msn", "Failed to allocate buffer for slpmsg\n"); | |
561 return; | |
562 } | |
563 } | |
9193 | 564 } |
565 else | |
566 { | |
10092 | 567 slpmsg = msn_slplink_message_find(slplink, msg->msnslp_header.session_id, msg->msnslp_header.id); |
9193 | 568 } |
569 | |
10345 | 570 if (slpmsg == NULL) |
9193 | 571 { |
10345 | 572 /* Probably the transfer was canceled */ |
9193 | 573 gaim_debug_error("msn", "Couldn't find slpmsg\n"); |
10345 | 574 return; |
9193 | 575 } |
576 | |
10345 | 577 if (slpmsg->fp) |
578 { | |
579 /* fseek(slpmsg->fp, offset, SEEK_SET); */ | |
580 len = fwrite(data, 1, len, slpmsg->fp); | |
581 } | |
582 else if (slpmsg->size) | |
583 { | |
584 if ((offset + len) > slpmsg->size) | |
585 { | |
586 gaim_debug_error("msn", "Oversized slpmsg\n"); | |
587 g_return_if_reached(); | |
588 } | |
589 else | |
590 memcpy(slpmsg->buffer + offset, data, len); | |
591 } | |
592 | |
593 if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) && | |
594 (slpmsg->slpcall != NULL)) | |
9193 | 595 { |
10296 | 596 slpmsg->slpcall->progress = TRUE; |
10225 | 597 |
598 if (slpmsg->slpcall->progress_cb != NULL) | |
9231
ac8790437abe
[gaim-migrate @ 10027]
Christian Hammond <chipx86@chipx86.com>
parents:
9226
diff
changeset
|
599 { |
ac8790437abe
[gaim-migrate @ 10027]
Christian Hammond <chipx86@chipx86.com>
parents:
9226
diff
changeset
|
600 slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size, |
ac8790437abe
[gaim-migrate @ 10027]
Christian Hammond <chipx86@chipx86.com>
parents:
9226
diff
changeset
|
601 len, offset); |
ac8790437abe
[gaim-migrate @ 10027]
Christian Hammond <chipx86@chipx86.com>
parents:
9226
diff
changeset
|
602 } |
9193 | 603 } |
604 | |
605 #if 0 | |
606 if (slpmsg->buffer == NULL) | |
607 return; | |
608 #endif | |
609 | |
610 if (msg->msnslp_header.offset + msg->msnslp_header.length | |
611 >= msg->msnslp_header.total_size) | |
612 { | |
613 /* All the pieces of the slpmsg have been received */ | |
614 MsnSlpCall *slpcall; | |
615 | |
616 slpcall = msn_slp_process_msg(slplink, slpmsg); | |
617 | |
618 if (slpmsg->flags == 0x100) | |
619 { | |
620 MsnDirectConn *directconn; | |
621 | |
622 directconn = slplink->directconn; | |
623 | |
624 if (!directconn->acked) | |
625 msn_directconn_send_handshake(directconn); | |
626 } | |
627 else if (slpmsg->flags == 0x0 || slpmsg->flags == 0x20 || | |
628 slpmsg->flags == 0x1000030) | |
629 { | |
630 /* Release all the messages and send the ACK */ | |
631 | |
632 msn_slplink_send_ack(slplink, msg); | |
633 msn_slplink_unleash(slplink); | |
634 } | |
635 | |
636 msn_slpmsg_destroy(slpmsg); | |
637 | |
638 if (slpcall != NULL && slpcall->wasted) | |
639 msn_slp_call_destroy(slpcall); | |
640 } | |
641 } | |
642 | |
643 MsnSlpMessage * | |
10092 | 644 msn_slplink_message_find(MsnSlpLink *slplink, long session_id, long id) |
9193 | 645 { |
646 GList *e; | |
647 | |
648 for (e = slplink->slp_msgs; e != NULL; e = e->next) | |
649 { | |
650 MsnSlpMessage *slpmsg = e->data; | |
651 | |
10092 | 652 if ((slpmsg->session_id == session_id) && (slpmsg->id == id)) |
9193 | 653 return slpmsg; |
654 } | |
655 | |
656 return NULL; | |
657 } | |
658 | |
9198
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
659 typedef struct |
9193 | 660 { |
661 guint32 length; | |
662 guint32 unk1; | |
663 guint32 file_size; | |
664 guint32 unk2; | |
665 guint32 unk3; | |
666 } MsnContextHeader; | |
667 | |
668 #define MAX_FILE_NAME_LEN 0x226 | |
669 | |
11367
2cb95478ef9c
[gaim-migrate @ 13591]
Richard Laager <rlaager@wiktel.com>
parents:
11321
diff
changeset
|
670 static gchar * |
10047 | 671 gen_context(const char *file_name, const char *file_path) |
9193 | 672 { |
673 struct stat st; | |
674 gsize size = 0; | |
675 MsnContextHeader header; | |
10047 | 676 gchar *u8 = NULL; |
11367
2cb95478ef9c
[gaim-migrate @ 13591]
Richard Laager <rlaager@wiktel.com>
parents:
11321
diff
changeset
|
677 guchar *base; |
2cb95478ef9c
[gaim-migrate @ 13591]
Richard Laager <rlaager@wiktel.com>
parents:
11321
diff
changeset
|
678 guchar *n; |
2cb95478ef9c
[gaim-migrate @ 13591]
Richard Laager <rlaager@wiktel.com>
parents:
11321
diff
changeset
|
679 gchar *ret; |
10047 | 680 gunichar2 *uni = NULL; |
681 glong currentChar = 0; | |
682 glong uni_len = 0; | |
9193 | 683 gsize len; |
684 | |
10589
0f7452b1f777
[gaim-migrate @ 11994]
Daniel Atallah <daniel.atallah@gmail.com>
parents:
10481
diff
changeset
|
685 if (g_stat(file_path, &st) == 0) |
9193 | 686 size = st.st_size; |
687 | |
10047 | 688 if(!file_name) { |
689 u8 = gaim_utf8_try_convert(g_basename(file_path)); | |
690 file_name = u8; | |
691 } | |
692 | |
693 uni = g_utf8_to_utf16(file_name, -1, NULL, &uni_len, NULL); | |
694 | |
695 if(u8) { | |
696 g_free(u8); | |
697 file_name = NULL; | |
698 u8 = NULL; | |
699 } | |
9193 | 700 |
701 len = sizeof(MsnContextHeader) + MAX_FILE_NAME_LEN + 4; | |
702 | |
703 header.length = GUINT32_TO_LE(len); | |
704 header.unk1 = GUINT32_TO_LE(2); | |
705 header.file_size = GUINT32_TO_LE(size); | |
706 header.unk2 = GUINT32_TO_LE(0); | |
707 header.unk3 = GUINT32_TO_LE(0); | |
10225 | 708 |
10047 | 709 base = g_malloc(len + 1); |
710 n = base; | |
9193 | 711 |
712 memcpy(n, &header, sizeof(MsnContextHeader)); | |
713 n += sizeof(MsnContextHeader); | |
714 | |
715 memset(n, 0x00, MAX_FILE_NAME_LEN); | |
10047 | 716 for(currentChar = 0; currentChar < uni_len; currentChar++) { |
717 *((gunichar2 *)n + currentChar) = GUINT16_TO_LE(uni[currentChar]); | |
718 } | |
9193 | 719 n += MAX_FILE_NAME_LEN; |
720 | |
721 memset(n, 0xFF, 4); | |
722 n += 4; | |
10225 | 723 |
9193 | 724 g_free(uni); |
11321 | 725 ret = gaim_base64_encode(base, len); |
726 g_free(base); | |
727 return ret; | |
9193 | 728 } |
729 | |
730 void | |
731 msn_slplink_request_ft(MsnSlpLink *slplink, GaimXfer *xfer) | |
732 { | |
733 MsnSlpCall *slpcall; | |
734 char *context; | |
735 const char *fn; | |
10047 | 736 const char *fp; |
9193 | 737 |
10047 | 738 fn = gaim_xfer_get_filename(xfer); |
739 fp = gaim_xfer_get_local_filename(xfer); | |
9193 | 740 |
741 g_return_if_fail(slplink != NULL); | |
10047 | 742 g_return_if_fail(fp != NULL); |
9193 | 743 |
744 slpcall = msn_slp_call_new(slplink); | |
745 msn_slp_call_init(slpcall, MSN_SLPCALL_DC); | |
746 | |
9571 | 747 slpcall->session_init_cb = send_file_cb; |
9715
b030f83693da
[gaim-migrate @ 10576]
Christian Hammond <chipx86@chipx86.com>
parents:
9571
diff
changeset
|
748 slpcall->end_cb = msn_xfer_end_cb; |
9193 | 749 slpcall->progress_cb = msn_xfer_progress_cb; |
9259
f5f7482678d2
[gaim-migrate @ 10058]
Christian Hammond <chipx86@chipx86.com>
parents:
9246
diff
changeset
|
750 slpcall->cb = msn_xfer_completed_cb; |
9193 | 751 slpcall->xfer = xfer; |
752 | |
10296 | 753 slpcall->pending = TRUE; |
754 | |
9193 | 755 gaim_xfer_set_cancel_send_fnc(xfer, msn_xfer_cancel); |
756 | |
757 xfer->data = slpcall; | |
758 | |
10047 | 759 context = gen_context(fn, fp); |
9193 | 760 |
761 msn_slp_call_invite(slpcall, "5D3E02AB-6190-11D3-BBBB-00C04F795683", 2, | |
762 context); | |
763 | |
764 g_free(context); | |
765 } | |
766 | |
767 void | |
768 msn_slplink_request_object(MsnSlpLink *slplink, | |
769 const char *info, | |
770 MsnSlpCb cb, | |
10225 | 771 MsnSlpEndCb end_cb, |
9193 | 772 const MsnObject *obj) |
773 { | |
774 MsnSlpCall *slpcall; | |
11164 | 775 char *msnobj_data; |
776 char *msnobj_base64; | |
9193 | 777 |
778 g_return_if_fail(slplink != NULL); | |
9861 | 779 g_return_if_fail(obj != NULL); |
9198
ab6636c5a136
[gaim-migrate @ 9993]
Christian Hammond <chipx86@chipx86.com>
parents:
9193
diff
changeset
|
780 |
9193 | 781 msnobj_data = msn_object_to_string(obj); |
11164 | 782 msnobj_base64 = gaim_base64_encode((const guchar *)msnobj_data, strlen(msnobj_data)); |
9193 | 783 g_free(msnobj_data); |
784 | |
785 slpcall = msn_slp_call_new(slplink); | |
786 msn_slp_call_init(slpcall, MSN_SLPCALL_ANY); | |
787 | |
788 slpcall->data_info = g_strdup(info); | |
789 slpcall->cb = cb; | |
10225 | 790 slpcall->end_cb = end_cb; |
9193 | 791 |
792 msn_slp_call_invite(slpcall, "A4268EEC-FEC5-49E5-95C3-F126696BDBF6", 1, | |
793 msnobj_base64); | |
794 | |
795 g_free(msnobj_base64); | |
796 } |