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