Mercurial > pidgin3 / file comparison

comparison: src/protocols/msn/slplink.c

src/protocols/msn/slplink.c

changeset 10345
7d7f8cfa2b4f
parent 10296
9badf1cedc6e
child 10346
9c65a007b4a5
equal deleted inserted replaced
10344:09d0502090b3 10345:7d7f8cfa2b4f
27 #include "switchboard.h" 27 #include "switchboard.h"
28 #include "slp.h" 28 #include "slp.h"
29 29
30 void msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg); 30 void msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg);
31 31
32 #ifdef DEBUG_SLP_FILES 32 #ifdef MSN_DEBUG_SLP_FILES
33 static int m_sc = 0; 33 static int m_sc = 0;
34 static int m_rc = 0; 34 static int m_rc = 0;
35 35
36 static void 36 static void
37 debug_msg_to_file(MsnMessage *msg, gboolean send) 37 debug_msg_to_file(MsnMessage *msg, gboolean send)
82 { 82 {
83 MsnSession *session; 83 MsnSession *session;
84 84
85 g_return_if_fail(slplink != NULL); 85 g_return_if_fail(slplink != NULL);
86 86
87 if (slplink->swboard != NULL)
88 slplink->swboard->slplink = NULL;
89
87 session = slplink->session; 90 session = slplink->session;
88 91
89 if (slplink->local_user != NULL) 92 if (slplink->local_user != NULL)
90 g_free(slplink->local_user); 93 g_free(slplink->local_user);
91 94
196 { 199 {
197 msn_directconn_send_msg(slplink->directconn, msg); 200 msn_directconn_send_msg(slplink->directconn, msg);
198 } 201 }
199 else 202 else
200 { 203 {
201 MsnSwitchBoard *swboard; 204 if (slplink->swboard == NULL)
202 205 {
203 swboard = msn_session_get_swboard(slplink->session, 206 slplink->swboard = msn_session_get_swboard(slplink->session,
204 slplink->remote_user); 207 slplink->remote_user);
205 208
206 if (swboard == NULL) 209 if (slplink->swboard == NULL)
207 return; 210 return;
208 211
209 if (!g_queue_is_empty(swboard->im_queue) || 212 /* If swboard is destroyed we will too */
210 !swboard->user_joined) 213 slplink->swboard->slplink = slplink;
211 { 214 }
212 msn_switchboard_queue_msg(swboard, msg); 215
216 if (!g_queue_is_empty(slplink->swboard->im_queue) ||
217 slplink->swboard->empty)
218 {
219 msn_switchboard_queue_msg(slplink->swboard, msg);
213 } 220 }
214 else 221 else
215 { 222 {
216 msn_switchboard_send_msg(swboard, msg); 223 msn_switchboard_send_msg(slplink->swboard, msg);
217 } 224 }
218 } 225 }
219 } 226 }
220 227
221 /* We have received the message receive ack */ 228 /* We have received the message ack */
222 static void 229 static void
223 msg_ack(void *data) 230 msg_ack(MsnMessage *msg, void *data)
224 { 231 {
225 MsnSlpMessage *slpmsg; 232 MsnSlpMessage *slpmsg;
226 long long real_size; 233 long long real_size;
227 234
228 slpmsg = data; 235 slpmsg = data;
229 236
230 real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size; 237 real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size;
238
239 slpmsg->offset += msg->msnslp_header.length;
231 240
232 if (slpmsg->offset < real_size) 241 if (slpmsg->offset < real_size)
233 { 242 {
234 msn_slplink_send_msgpart(slpmsg->slplink, slpmsg); 243 msn_slplink_send_msgpart(slpmsg->slplink, slpmsg);
235 } 244 }
243 (slpmsg->slpcall->cb != NULL)) 252 (slpmsg->slpcall->cb != NULL))
244 { 253 {
245 slpmsg->slpcall->cb(slpmsg->slpcall, NULL, 0); 254 slpmsg->slpcall->cb(slpmsg->slpcall, NULL, 0);
246 } 255 }
247 } 256 }
248 257 }
249 msn_slpmsg_destroy(slpmsg); 258
250 } 259 slpmsg->msgs = g_list_remove(slpmsg->msgs, msg);
260 }
261
262 /* We have received the message nak. */
263 static void
264 msg_nak(MsnMessage *msg, void *data)
265 {
266 MsnSlpMessage *slpmsg;
267
268 slpmsg = data;
269
270 msn_slplink_send_msgpart(slpmsg->slplink, slpmsg);
271
272 slpmsg->msgs = g_list_remove(slpmsg->msgs, msg);
251 } 273 }
252 274
253 void 275 void
254 msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) 276 msn_slplink_send_msgpart(MsnSlpLink *slplink, MsnSlpMessage *slpmsg)
255 { 277 {
256 MsnMessage *msg; 278 MsnMessage *msg;
257 long long real_size; 279 long long real_size;
258 size_t len = 0; 280 size_t len = 0;
259 281
282 /* Maybe we will want to create a new msg for this slpmsg instead of
283 * reusing the same one all the time. */
260 msg = slpmsg->msg; 284 msg = slpmsg->msg;
261 285
262 real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size; 286 real_size = (slpmsg->flags == 0x2) ? 0 : slpmsg->size;
263 287
264 if (slpmsg->offset < real_size) 288 if (slpmsg->offset < real_size)
281 305
282 msg->msnslp_header.offset = slpmsg->offset; 306 msg->msnslp_header.offset = slpmsg->offset;
283 msg->msnslp_header.length = len; 307 msg->msnslp_header.length = len;
284 } 308 }
285 309
286 #ifdef DEBUG_SLP 310 #ifdef MSN_DEBUG_SLP
287 msn_message_show_readable(msg, slpmsg->info, slpmsg->text_body); 311 msn_message_show_readable(msg, slpmsg->info, slpmsg->text_body);
288 #endif 312 #endif
289 313
290 #ifdef DEBUG_SLP_FILES 314 #ifdef MSN_DEBUG_SLP_FILES
291 debug_msg_to_file(msg, TRUE); 315 debug_msg_to_file(msg, TRUE);
292 #endif 316 #endif
293 317
318 slpmsg->msgs =
319 g_list_append(slpmsg->msgs, msg);
294 msn_slplink_send_msg(slplink, msg); 320 msn_slplink_send_msg(slplink, msg);
295 321
296 if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) && (slpmsg->slpcall != NULL)) 322 if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) &&
323 (slpmsg->slpcall != NULL))
297 { 324 {
298 slpmsg->slpcall->progress = TRUE; 325 slpmsg->slpcall->progress = TRUE;
299 326
300 if (slpmsg->slpcall->progress_cb != NULL) 327 if (slpmsg->slpcall->progress_cb != NULL)
301 { 328 {
302 slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size, 329 slpmsg->slpcall->progress_cb(slpmsg->slpcall, slpmsg->size,
303 len, slpmsg->offset); 330 len, slpmsg->offset);
304 } 331 }
305 } 332 }
306 333
307 slpmsg->offset += len; 334 /* slpmsg->offset += len; */
308 } 335 }
309 336
310 void 337 void
311 msn_slplink_release_msg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) 338 msn_slplink_release_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg)
312 { 339 {
313 MsnMessage *msg; 340 MsnMessage *msg;
314 341
315 slpmsg->msg = msg = msn_message_new_msnslp(); 342 slpmsg->msg = msg = msn_message_new_msnslp();
316 343
348 msg->msnslp_header.total_size = slpmsg->size; 375 msg->msnslp_header.total_size = slpmsg->size;
349 376
350 msn_message_set_attr(msg, "P2P-Dest", slplink->remote_user); 377 msn_message_set_attr(msg, "P2P-Dest", slplink->remote_user);
351 378
352 msg->ack_cb = msg_ack; 379 msg->ack_cb = msg_ack;
380 msg->nak_cb = msg_nak;
353 msg->ack_data = slpmsg; 381 msg->ack_data = slpmsg;
354 382
355 msn_slplink_send_msgpart(slplink, slpmsg); 383 msn_slplink_send_msgpart(slplink, slpmsg);
356 384
357 msn_message_destroy(msg); 385 msn_message_destroy(msg);
368 void 396 void
369 msn_slplink_send_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg) 397 msn_slplink_send_slpmsg(MsnSlpLink *slplink, MsnSlpMessage *slpmsg)
370 { 398 {
371 slpmsg->id = slplink->slp_seq_id++; 399 slpmsg->id = slplink->slp_seq_id++;
372 400
373 msn_slplink_release_msg(slplink, slpmsg); 401 msn_slplink_release_slpmsg(slplink, slpmsg);
374 } 402 }
375 403
376 void 404 void
377 msn_slplink_unleash(MsnSlpLink *slplink) 405 msn_slplink_unleash(MsnSlpLink *slplink)
378 { 406 {
379 MsnSlpMessage *slpmsg; 407 MsnSlpMessage *slpmsg;
380 408
381 /* Send the queued msgs in the order they came. */ 409 /* Send the queued msgs in the order they came. */
382 410
383 while ((slpmsg = g_queue_pop_tail(slplink->slp_msg_queue)) != NULL) 411 while ((slpmsg = g_queue_pop_tail(slplink->slp_msg_queue)) != NULL)
384 msn_slplink_release_msg(slplink, slpmsg); 412 {
413 msn_slplink_release_slpmsg(slplink, slpmsg);
414 }
385 } 415 }
386 416
387 void 417 void
388 msn_slplink_send_ack(MsnSlpLink *slplink, MsnMessage *msg) 418 msn_slplink_send_ack(MsnSlpLink *slplink, MsnMessage *msg)
389 { 419 {
396 slpmsg->flags = 0x02; 426 slpmsg->flags = 0x02;
397 slpmsg->ack_id = msg->msnslp_header.id; 427 slpmsg->ack_id = msg->msnslp_header.id;
398 slpmsg->ack_sub_id = msg->msnslp_header.ack_id; 428 slpmsg->ack_sub_id = msg->msnslp_header.ack_id;
399 slpmsg->ack_size = msg->msnslp_header.total_size; 429 slpmsg->ack_size = msg->msnslp_header.total_size;
400 430
401 #ifdef DEBUG_SLP 431 #ifdef MSN_DEBUG_SLP
402 slpmsg->info = "SLP ACK"; 432 slpmsg->info = "SLP ACK";
403 #endif 433 #endif
404 434
405 msn_slplink_send_slpmsg(slplink, slpmsg); 435 msn_slplink_send_slpmsg(slplink, slpmsg);
406 } 436 }
411 MsnSlpCall *slpcall; 441 MsnSlpCall *slpcall;
412 MsnSlpMessage *slpmsg; 442 MsnSlpMessage *slpmsg;
413 443
414 slpcall = slpsession->slpcall; 444 slpcall = slpsession->slpcall;
415 slpmsg = msn_slpmsg_new(slpcall->slplink); 445 slpmsg = msn_slpmsg_new(slpcall->slplink);
446 slpmsg->slpcall = slpcall;
416 slpmsg->flags = 0x1000030; 447 slpmsg->flags = 0x1000030;
417 slpmsg->slpsession = slpsession; 448 slpmsg->slpsession = slpsession;
418 #ifdef DEBUG_SLP 449 #ifdef MSN_DEBUG_SLP
419 slpmsg->info = "SLP FILE"; 450 slpmsg->info = "SLP FILE";
420 #endif 451 #endif
421 slpmsg->slpcall = slpcall;
422 msn_slpmsg_open_file(slpmsg, gaim_xfer_get_local_filename(slpcall->xfer)); 452 msn_slpmsg_open_file(slpmsg, gaim_xfer_get_local_filename(slpcall->xfer));
423 453
424 msn_slplink_send_slpmsg(slpcall->slplink, slpmsg); 454 msn_slplink_send_slpmsg(slpcall->slplink, slpmsg);
425 } 455 }
426 456
430 MsnSlpMessage *slpmsg; 460 MsnSlpMessage *slpmsg;
431 const char *data; 461 const char *data;
432 gsize offset; 462 gsize offset;
433 gsize len; 463 gsize len;
434 464
435 #ifdef DEBUG_SLP 465 #ifdef MSN_DEBUG_SLP
436 msn_slpmsg_show(msg); 466 msn_slpmsg_show(msg);
437 #endif 467 #endif
438 468
439 #ifdef DEBUG_SLP_FILES 469 #ifdef MSN_DEBUG_SLP_FILES
440 debug_msg_to_file(msg, FALSE); 470 debug_msg_to_file(msg, FALSE);
441 #endif 471 #endif
442 472
443 if (msg->msnslp_header.total_size < msg->msnslp_header.length) 473 if (msg->msnslp_header.total_size < msg->msnslp_header.length)
444 { 474 {
499 else 529 else
500 { 530 {
501 slpmsg = msn_slplink_message_find(slplink, msg->msnslp_header.session_id, msg->msnslp_header.id); 531 slpmsg = msn_slplink_message_find(slplink, msg->msnslp_header.session_id, msg->msnslp_header.id);
502 } 532 }
503 533
504 if (slpmsg != NULL) 534 if (slpmsg == NULL)
505 { 535 {
506 if (slpmsg->fp) 536 /* Probably the transfer was canceled */
507 {
508 /* fseek(slpmsg->fp, offset, SEEK_SET); */
509 len = fwrite(data, 1, len, slpmsg->fp);
510 }
511 else if (slpmsg->size)
512 {
513 if ((offset + len) > slpmsg->size)
514 {
515 gaim_debug_error("msn", "Oversized slpmsg\n");
516 g_return_if_reached();
517 }
518 else
519 memcpy(slpmsg->buffer + offset, data, len);
520 }
521 }
522 else
523 {
524 gaim_debug_error("msn", "Couldn't find slpmsg\n"); 537 gaim_debug_error("msn", "Couldn't find slpmsg\n");
525 g_return_if_reached(); 538 return;
526 } 539 }
527 540
528 if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) && (slpmsg->slpcall != NULL)) 541 if (slpmsg->fp)
542 {
543 /* fseek(slpmsg->fp, offset, SEEK_SET); */
544 len = fwrite(data, 1, len, slpmsg->fp);
545 }
546 else if (slpmsg->size)
547 {
548 if ((offset + len) > slpmsg->size)
549 {
550 gaim_debug_error("msn", "Oversized slpmsg\n");
551 g_return_if_reached();
552 }
553 else
554 memcpy(slpmsg->buffer + offset, data, len);
555 }
556
557 if ((slpmsg->flags == 0x20 || slpmsg->flags == 0x1000030) &&
558 (slpmsg->slpcall != NULL))
529 { 559 {
530 slpmsg->slpcall->progress = TRUE; 560 slpmsg->slpcall->progress = TRUE;
531 561
532 if (slpmsg->slpcall->progress_cb != NULL) 562 if (slpmsg->slpcall->progress_cb != NULL)
533 { 563 {

Mercurial Repository: pidgin3

mercurial