Mercurial > gftp.yaz
comparison lib/sshv2.c @ 84:7ef60ce2bdb2
2002-12-29 Brian Masney <masneyb@gftp.org>
* lib/ssh.c lib/config_file.c lib/Makefile.am lib/gftp.h lib/options.h - removed old legacy SSH protocol and option to enable this protocol
* lib/gftp.h - added GFTP_ERETRYABLE and GFTP_EFATAL error codes
* lib/bookmark.c lib/local.c lib/protocols.c lib/rfc959.c lib/rfc2068.c
lib/sshv2.c - return new error codes instead of -1 or -2
* lib/misc.c (gftp_*_sort_function_ds) - changed return values
* src/gtk/transfer.c (connect_thread) - if return value of
gftp_connect() is GFTP_EFATAL, don't attempt to retry the connection
author | masneyb |
---|---|
date | Sun, 29 Dec 2002 15:16:27 +0000 |
parents | 29128554eb86 |
children | 8c37d73d3f1f |
comparison
equal
deleted
inserted
replaced
83:462de7034797 | 84:7ef60ce2bdb2 |
---|---|
279 sshv2_send_command (gftp_request * request, char type, char *command, | 279 sshv2_send_command (gftp_request * request, char type, char *command, |
280 gint32 len) | 280 gint32 len) |
281 { | 281 { |
282 char buf[34000]; | 282 char buf[34000]; |
283 gint32 clen; | 283 gint32 clen; |
284 int ret; | |
284 | 285 |
285 if (len > 33995) | 286 if (len > 33995) |
286 { | 287 { |
287 request->logging_function (gftp_logging_error, request->user_data, | 288 request->logging_function (gftp_logging_error, request->user_data, |
288 _("Error: Message size %d too big\n"), len); | 289 _("Error: Message size %d too big\n"), len); |
289 gftp_disconnect (request); | 290 gftp_disconnect (request); |
290 return (-1); | 291 return (GFTP_EFATAL); |
291 } | 292 } |
292 | 293 |
293 clen = htonl (len + 1); | 294 clen = htonl (len + 1); |
294 memcpy (buf, &clen, 4); | 295 memcpy (buf, &clen, 4); |
295 buf[4] = type; | 296 buf[4] = type; |
303 printf ("\n"); | 304 printf ("\n"); |
304 #endif | 305 #endif |
305 | 306 |
306 sshv2_log_command (request, gftp_logging_send, type, buf + 5, len); | 307 sshv2_log_command (request, gftp_logging_send, type, buf + 5, len); |
307 | 308 |
308 if (gftp_write (request, buf, len + 5, request->sockfd) < 0) | 309 if ((ret = gftp_write (request, buf, len + 5, request->sockfd)) < 0) |
309 return (-2); | 310 return (ret); |
310 | 311 |
311 return 0; | 312 return (0); |
312 } | 313 } |
313 | 314 |
314 | 315 |
315 static int | 316 static int |
316 sshv2_read_response (gftp_request * request, sshv2_message * message, | 317 sshv2_read_response (gftp_request * request, sshv2_message * message, |
325 pos = buf; | 326 pos = buf; |
326 rem = 5; | 327 rem = 5; |
327 while (rem > 0) | 328 while (rem > 0) |
328 { | 329 { |
329 if ((numread = gftp_read (request, pos, rem, fd)) < 0) | 330 if ((numread = gftp_read (request, pos, rem, fd)) < 0) |
330 return (-2); | 331 return ((int) numread); |
331 rem -= numread; | 332 rem -= numread; |
332 pos += numread; | 333 pos += numread; |
333 } | 334 } |
334 | 335 |
335 memcpy (&message->length, buf, 4); | 336 memcpy (&message->length, buf, 4); |
339 request->logging_function (gftp_logging_error, request->user_data, | 340 request->logging_function (gftp_logging_error, request->user_data, |
340 _("Error: Message size %d too big from server\n"), | 341 _("Error: Message size %d too big from server\n"), |
341 message->length); | 342 message->length); |
342 memset (message, 0, sizeof (*message)); | 343 memset (message, 0, sizeof (*message)); |
343 gftp_disconnect (request); | 344 gftp_disconnect (request); |
344 return (-1); | 345 return (GFTP_EFATAL); |
345 } | 346 } |
346 | 347 |
347 message->command = buf[4]; | 348 message->command = buf[4]; |
348 message->buffer = g_malloc (message->length + 1); | 349 message->buffer = g_malloc (message->length + 1); |
349 | 350 |
353 pos = message->buffer; | 354 pos = message->buffer; |
354 rem = message->length - 1; | 355 rem = message->length - 1; |
355 while (rem > 0) | 356 while (rem > 0) |
356 { | 357 { |
357 if ((numread = gftp_read (request, pos, rem, fd)) < 0) | 358 if ((numread = gftp_read (request, pos, rem, fd)) < 0) |
358 return (-2); | 359 return ((int) numread); |
359 rem -= numread; | 360 rem -= numread; |
360 pos += numread; | 361 pos += numread; |
361 } | 362 } |
362 | 363 |
363 message->buffer[message->length] = '\0'; | 364 message->buffer[message->length] = '\0'; |
399 { | 400 { |
400 request->logging_function (gftp_logging_error, request->user_data, | 401 request->logging_function (gftp_logging_error, request->user_data, |
401 _("Received wrong response from server, disconnecting\n")); | 402 _("Received wrong response from server, disconnecting\n")); |
402 sshv2_message_free (message); | 403 sshv2_message_free (message); |
403 gftp_disconnect (request); | 404 gftp_disconnect (request); |
404 return (-2); | 405 return (GFTP_EFATAL); |
405 } | 406 } |
406 | 407 |
407 memcpy (&ret, message->pos, 4); | 408 memcpy (&ret, message->pos, 4); |
408 ret = ntohl (ret); | 409 ret = ntohl (ret); |
409 message->pos += 4; | 410 message->pos += 4; |
412 { | 413 { |
413 request->logging_function (gftp_logging_error, request->user_data, | 414 request->logging_function (gftp_logging_error, request->user_data, |
414 _("Received wrong response from server, disconnecting\n")); | 415 _("Received wrong response from server, disconnecting\n")); |
415 sshv2_message_free (message); | 416 sshv2_message_free (message); |
416 gftp_disconnect (request); | 417 gftp_disconnect (request); |
417 return (-2); | 418 return (GFTP_EFATAL); |
418 } | 419 } |
419 | 420 |
420 return (ret); | 421 return (ret); |
421 } | 422 } |
422 | 423 |
455 char *tempstr, *dir; | 456 char *tempstr, *dir; |
456 gint32 num; | 457 gint32 num; |
457 size_t len; | 458 size_t len; |
458 int ret; | 459 int ret; |
459 | 460 |
460 g_return_val_if_fail (request != NULL, -2); | 461 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
461 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 462 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
462 | 463 |
463 if (request->directory == NULL || *request->directory == '\0') | 464 if (request->directory == NULL || *request->directory == '\0') |
464 dir = "."; | 465 dir = "."; |
465 else | 466 else |
466 dir = request->directory; | 467 dir = request->directory; |
473 num = htonl (params->id++); | 474 num = htonl (params->id++); |
474 memcpy (tempstr, &num, 4); | 475 memcpy (tempstr, &num, 4); |
475 | 476 |
476 num = htonl (len); | 477 num = htonl (len); |
477 memcpy (tempstr + 4, &num, 4); | 478 memcpy (tempstr + 4, &num, 4); |
478 if (sshv2_send_command (request, SSH_FXP_REALPATH, tempstr, len + 8) < 0) | 479 if ((ret = sshv2_send_command (request, SSH_FXP_REALPATH, tempstr, |
480 len + 8)) < 0) | |
479 { | 481 { |
480 g_free (tempstr); | 482 g_free (tempstr); |
481 return (-2); | 483 return (ret); |
482 } | 484 } |
483 | 485 |
484 g_free (tempstr); | 486 g_free (tempstr); |
485 if (request->directory) | 487 if (request->directory) |
486 { | 488 { |
488 request->directory = NULL; | 490 request->directory = NULL; |
489 } | 491 } |
490 | 492 |
491 memset (&message, 0, sizeof (message)); | 493 memset (&message, 0, sizeof (message)); |
492 ret = sshv2_read_response (request, &message, -1); | 494 ret = sshv2_read_response (request, &message, -1); |
493 if (ret == SSH_FXP_STATUS) | 495 if (ret < 0) |
496 return (ret); | |
497 else if (ret == SSH_FXP_STATUS) | |
494 { | 498 { |
495 sshv2_message_free (&message); | 499 sshv2_message_free (&message); |
496 return (-2); | 500 return (GFTP_ERETRYABLE); |
497 } | 501 } |
498 else if (ret != SSH_FXP_NAME) | 502 else if (ret != SSH_FXP_NAME) |
499 { | 503 { |
500 request->logging_function (gftp_logging_error, request->user_data, | 504 request->logging_function (gftp_logging_error, request->user_data, |
501 _("Received wrong response from server, disconnecting\n")); | 505 _("Received wrong response from server, disconnecting\n")); |
502 sshv2_message_free (&message); | 506 sshv2_message_free (&message); |
503 gftp_disconnect (request); | 507 gftp_disconnect (request); |
504 return (-2); | 508 return (GFTP_EFATAL); |
505 } | 509 } |
506 | 510 |
507 message.pos += 4; | 511 message.pos += 4; |
508 if (sshv2_buffer_get_int32 (request, &message, 1) < 0) | 512 if ((ret = sshv2_buffer_get_int32 (request, &message, 1)) < 0) |
509 return (-2); | 513 return (ret); |
510 | 514 |
511 if ((request->directory = sshv2_buffer_get_string (request, &message)) == NULL) | 515 if ((request->directory = sshv2_buffer_get_string (request, &message)) == NULL) |
512 return (-2); | 516 return (GFTP_EFATAL); |
513 | 517 |
514 sshv2_message_free (&message); | 518 sshv2_message_free (&message); |
515 return (0); | 519 return (0); |
516 } | 520 } |
517 | 521 |
518 | 522 |
519 static int | 523 static int |
520 sshv2_connect (gftp_request * request) | 524 sshv2_connect (gftp_request * request) |
521 { | 525 { |
522 char **args, *tempstr, pts_name[20], *p1, p2, *exepath, port[6]; | 526 char **args, *tempstr, pts_name[20], *p1, p2, *exepath, port[6]; |
523 int version, fdm, fds, s[2]; | 527 int version, fdm, fds, s[2], ret; |
524 sshv2_message message; | 528 sshv2_message message; |
525 pid_t child; | 529 pid_t child; |
526 | 530 |
527 g_return_val_if_fail (request != NULL, -2); | 531 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
528 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 532 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
529 g_return_val_if_fail (request->hostname != NULL, -2); | 533 g_return_val_if_fail (request->hostname != NULL, GFTP_EFATAL); |
530 | 534 |
531 if (request->sockfd > 0) | 535 if (request->sockfd > 0) |
532 return (0); | 536 return (0); |
533 | 537 |
534 request->logging_function (gftp_logging_misc, request->user_data, | 538 request->logging_function (gftp_logging_misc, request->user_data, |
562 if (socketpair (AF_LOCAL, SOCK_STREAM, 0, s) < 0) | 566 if (socketpair (AF_LOCAL, SOCK_STREAM, 0, s) < 0) |
563 { | 567 { |
564 request->logging_function (gftp_logging_error, request->user_data, | 568 request->logging_function (gftp_logging_error, request->user_data, |
565 _("Cannot create a socket pair: %s\n"), | 569 _("Cannot create a socket pair: %s\n"), |
566 g_strerror (errno)); | 570 g_strerror (errno)); |
567 return (-2); | 571 return (GFTP_ERETRYABLE); |
568 } | 572 } |
569 } | 573 } |
570 else | 574 else |
571 { | 575 { |
572 s[0] = s[1] = 0; | 576 s[0] = s[1] = 0; |
573 if ((fdm = ptym_open (pts_name)) < 0) | 577 if ((fdm = ptym_open (pts_name)) < 0) |
574 { | 578 { |
575 request->logging_function (gftp_logging_error, request->user_data, | 579 request->logging_function (gftp_logging_error, request->user_data, |
576 _("Cannot open master pty %s: %s\n"), pts_name, | 580 _("Cannot open master pty %s: %s\n"), pts_name, |
577 g_strerror (errno)); | 581 g_strerror (errno)); |
578 return (-2); | 582 return (GFTP_ERETRYABLE); |
579 } | 583 } |
580 } | 584 } |
581 | 585 |
582 if ((child = fork ()) == 0) | 586 if ((child = fork ()) == 0) |
583 { | 587 { |
591 { | 595 { |
592 if ((fds = ptys_open (fdm, pts_name)) < 0) | 596 if ((fds = ptys_open (fdm, pts_name)) < 0) |
593 { | 597 { |
594 printf ("Cannot open slave pts %s: %s\n", pts_name, | 598 printf ("Cannot open slave pts %s: %s\n", pts_name, |
595 g_strerror (errno)); | 599 g_strerror (errno)); |
596 return (-1); | 600 return (GFTP_ERETRYABLE); |
597 } | 601 } |
598 close (fdm); | 602 close (fdm); |
599 } | 603 } |
600 | 604 |
601 tty_raw (fds); | 605 tty_raw (fds); |
606 close (fds); | 610 close (fds); |
607 execvp (ssh_prog_name != NULL && *ssh_prog_name != '\0' ? | 611 execvp (ssh_prog_name != NULL && *ssh_prog_name != '\0' ? |
608 ssh_prog_name : "ssh", args); | 612 ssh_prog_name : "ssh", args); |
609 | 613 |
610 printf (_("Error: Cannot execute ssh: %s\n"), g_strerror (errno)); | 614 printf (_("Error: Cannot execute ssh: %s\n"), g_strerror (errno)); |
611 return (-1); | 615 exit (1); |
612 } | 616 } |
613 else if (child > 0) | 617 else if (child > 0) |
614 { | 618 { |
615 if (ssh_use_askpass || sshv2_use_sftp_subsys) | 619 if (ssh_use_askpass || sshv2_use_sftp_subsys) |
616 { | 620 { |
625 !(strlen (tempstr) > 4 && strcmp (tempstr + strlen (tempstr) - 5, | 629 !(strlen (tempstr) > 4 && strcmp (tempstr + strlen (tempstr) - 5, |
626 "xsftp") == 0)) | 630 "xsftp") == 0)) |
627 { | 631 { |
628 g_free (args); | 632 g_free (args); |
629 g_free (exepath); | 633 g_free (exepath); |
630 return (-2); | 634 return (GFTP_EFATAL); |
631 } | 635 } |
632 g_free (tempstr); | 636 g_free (tempstr); |
633 } | 637 } |
634 g_free (args); | 638 g_free (args); |
635 g_free (exepath); | 639 g_free (exepath); |
636 | 640 |
637 request->sockfd = fdm; | 641 request->sockfd = fdm; |
638 | 642 |
639 version = htonl (SSH_MY_VERSION); | 643 version = htonl (SSH_MY_VERSION); |
640 if (sshv2_send_command (request, SSH_FXP_INIT, (char *) &version, 4) < 0) | 644 if ((ret = sshv2_send_command (request, SSH_FXP_INIT, (char *) |
641 return (-2); | 645 &version, 4)) < 0) |
646 return (ret); | |
642 | 647 |
643 memset (&message, 0, sizeof (message)); | 648 memset (&message, 0, sizeof (message)); |
644 if (sshv2_read_response (request, &message, -1) != SSH_FXP_VERSION) | 649 if ((ret = sshv2_read_response (request, &message, -1)) != SSH_FXP_VERSION) |
645 { | 650 { |
646 request->logging_function (gftp_logging_error, request->user_data, | 651 request->logging_function (gftp_logging_error, request->user_data, |
647 _("Received wrong response from server, disconnecting\n")); | 652 _("Received wrong response from server, disconnecting\n")); |
648 sshv2_message_free (&message); | 653 sshv2_message_free (&message); |
649 gftp_disconnect (request); | 654 gftp_disconnect (request); |
650 return (-2); | 655 |
656 if (ret < 0) | |
657 return (ret); | |
658 else | |
659 return (GFTP_ERETRYABLE); | |
651 } | 660 } |
652 sshv2_message_free (&message); | 661 sshv2_message_free (&message); |
653 | 662 |
654 request->logging_function (gftp_logging_misc, request->user_data, | 663 request->logging_function (gftp_logging_misc, request->user_data, |
655 _("Successfully logged into SSH server %s\n"), | 664 _("Successfully logged into SSH server %s\n"), |
659 { | 668 { |
660 request->logging_function (gftp_logging_error, request->user_data, | 669 request->logging_function (gftp_logging_error, request->user_data, |
661 _("Cannot fork another process: %s\n"), | 670 _("Cannot fork another process: %s\n"), |
662 g_strerror (errno)); | 671 g_strerror (errno)); |
663 g_free (args); | 672 g_free (args); |
664 return (-1); | 673 return (GFTP_ERETRYABLE); |
665 } | 674 } |
666 | 675 |
667 if (sshv2_getcwd (request) < 0) | 676 if (sshv2_getcwd (request) < 0) |
668 { | 677 { |
669 if (request->directory) | 678 if (request->directory) |
670 g_free (request->directory); | 679 g_free (request->directory); |
671 | 680 |
672 request->directory = g_strdup ("."); | 681 request->directory = g_strdup ("."); |
673 if (sshv2_getcwd (request) < 0) | 682 if ((ret = sshv2_getcwd (request)) < 0) |
674 { | 683 { |
675 gftp_disconnect (request); | 684 gftp_disconnect (request); |
676 return (-2); | 685 return (ret); |
677 } | 686 } |
678 } | 687 } |
679 | 688 |
680 return (0); | 689 return (0); |
681 } | 690 } |
714 sshv2_end_transfer (gftp_request * request) | 723 sshv2_end_transfer (gftp_request * request) |
715 { | 724 { |
716 sshv2_params * params; | 725 sshv2_params * params; |
717 sshv2_message message; | 726 sshv2_message message; |
718 gint32 len; | 727 gint32 len; |
719 | 728 int ret; |
720 g_return_val_if_fail (request != NULL, -2); | 729 |
721 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 730 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
731 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); | |
722 | 732 |
723 params = request->protocol_data; | 733 params = request->protocol_data; |
724 if (params->message.buffer != NULL) | 734 if (params->message.buffer != NULL) |
725 { | 735 { |
726 sshv2_message_free (¶ms->message); | 736 sshv2_message_free (¶ms->message); |
730 if (params->handle_len > 0) | 740 if (params->handle_len > 0) |
731 { | 741 { |
732 len = htonl (params->id++); | 742 len = htonl (params->id++); |
733 memcpy (params->handle, &len, 4); | 743 memcpy (params->handle, &len, 4); |
734 | 744 |
735 if (sshv2_send_command (request, SSH_FXP_CLOSE, params->handle, | 745 if ((ret = sshv2_send_command (request, SSH_FXP_CLOSE, params->handle, |
736 params->handle_len) < 0) | 746 params->handle_len)) < 0) |
737 return (-2); | 747 return (ret); |
738 | 748 |
739 memset (&message, 0, sizeof (message)); | 749 memset (&message, 0, sizeof (message)); |
740 if (sshv2_read_response (request, &message, -1) != SSH_FXP_STATUS) | 750 if ((ret = sshv2_read_response (request, &message, -1)) != SSH_FXP_STATUS) |
741 { | 751 { |
742 request->logging_function (gftp_logging_error, request->user_data, | 752 request->logging_function (gftp_logging_error, request->user_data, |
743 _("Received wrong response from server, disconnecting\n")); | 753 _("Received wrong response from server, disconnecting\n")); |
744 sshv2_message_free (&message); | 754 sshv2_message_free (&message); |
745 gftp_disconnect (request); | 755 gftp_disconnect (request); |
746 return (-2); | 756 if (ret < 0) |
757 return (ret); | |
758 else | |
759 return (GFTP_ERETRYABLE); | |
747 } | 760 } |
748 sshv2_message_free (&message); | 761 sshv2_message_free (&message); |
749 params->handle_len = 0; | 762 params->handle_len = 0; |
750 } | 763 } |
751 | 764 |
766 sshv2_message message; | 779 sshv2_message message; |
767 char *tempstr; | 780 char *tempstr; |
768 gint32 len; | 781 gint32 len; |
769 int ret; | 782 int ret; |
770 | 783 |
771 g_return_val_if_fail (request != NULL, -2); | 784 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
772 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 785 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
773 g_return_val_if_fail (request->sockfd > 0, -2); | 786 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); |
774 | 787 |
775 params = request->protocol_data; | 788 params = request->protocol_data; |
776 | 789 |
777 request->logging_function (gftp_logging_misc, request->user_data, | 790 request->logging_function (gftp_logging_misc, request->user_data, |
778 _("Retrieving directory listing...\n")); | 791 _("Retrieving directory listing...\n")); |
783 memcpy (tempstr, &len, 4); | 796 memcpy (tempstr, &len, 4); |
784 | 797 |
785 len = htonl (strlen (request->directory)); | 798 len = htonl (strlen (request->directory)); |
786 memcpy (tempstr + 4, &len, 4); | 799 memcpy (tempstr + 4, &len, 4); |
787 strcpy (tempstr + 8, request->directory); | 800 strcpy (tempstr + 8, request->directory); |
788 if (sshv2_send_command (request, SSH_FXP_OPENDIR, tempstr, | 801 if ((ret = sshv2_send_command (request, SSH_FXP_OPENDIR, tempstr, |
789 strlen (request->directory) + 8) < 0) | 802 strlen (request->directory) + 8)) < 0) |
790 { | 803 { |
791 g_free (tempstr); | 804 g_free (tempstr); |
792 return (-2); | 805 return (ret); |
793 } | 806 } |
794 g_free (tempstr); | 807 g_free (tempstr); |
795 | 808 |
796 memset (&message, 0, sizeof (message)); | 809 memset (&message, 0, sizeof (message)); |
797 ret = sshv2_read_response (request, &message, -1); | 810 ret = sshv2_read_response (request, &message, -1); |
798 if (ret == SSH_FXP_STATUS) | 811 if (ret < 0) |
812 return (ret); | |
813 else if (ret == SSH_FXP_STATUS) | |
799 { | 814 { |
800 sshv2_message_free (&message); | 815 sshv2_message_free (&message); |
801 return (-2); | 816 return (GFTP_ERETRYABLE); |
802 } | 817 } |
803 else if (ret != SSH_FXP_HANDLE) | 818 else if (ret != SSH_FXP_HANDLE) |
804 { | 819 { |
805 request->logging_function (gftp_logging_error, request->user_data, | 820 request->logging_function (gftp_logging_error, request->user_data, |
806 _("Received wrong response from server, disconnecting\n")); | 821 _("Received wrong response from server, disconnecting\n")); |
807 sshv2_message_free (&message); | 822 sshv2_message_free (&message); |
808 gftp_disconnect (request); | 823 gftp_disconnect (request); |
809 return (-2); | 824 return (GFTP_EFATAL); |
810 } | 825 } |
811 | 826 |
812 if (message.length - 4 > SSH_MAX_HANDLE_SIZE) | 827 if (message.length - 4 > SSH_MAX_HANDLE_SIZE) |
813 { | 828 { |
814 request->logging_function (gftp_logging_error, request->user_data, | 829 request->logging_function (gftp_logging_error, request->user_data, |
815 _("Error: Message size %d too big from server\n"), | 830 _("Error: Message size %d too big from server\n"), |
816 message.length - 4); | 831 message.length - 4); |
817 sshv2_message_free (&message); | 832 sshv2_message_free (&message); |
818 gftp_disconnect (request); | 833 gftp_disconnect (request); |
819 return (-1); | 834 return (GFTP_EFATAL); |
820 | 835 |
821 } | 836 } |
822 | 837 |
823 memset (params->handle, 0, 4); | 838 memset (params->handle, 0, 4); |
824 memcpy (params->handle + 4, message.buffer + 4, message.length - 5); | 839 memcpy (params->handle + 4, message.buffer + 4, message.length - 5); |
835 gint32 len, attrs, longnamelen; | 850 gint32 len, attrs, longnamelen; |
836 int ret, i, count, retsize; | 851 int ret, i, count, retsize; |
837 sshv2_params *params; | 852 sshv2_params *params; |
838 char *longname; | 853 char *longname; |
839 | 854 |
840 g_return_val_if_fail (request != NULL, -2); | 855 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
841 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 856 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
842 g_return_val_if_fail (fle != NULL, -2); | 857 g_return_val_if_fail (fle != NULL, GFTP_EFATAL); |
843 | 858 |
844 params = request->protocol_data; | 859 params = request->protocol_data; |
845 | 860 |
846 if (request->last_dir_entry) | 861 if (request->last_dir_entry) |
847 { | 862 { |
861 sshv2_message_free (¶ms->message); | 876 sshv2_message_free (¶ms->message); |
862 | 877 |
863 len = htonl (params->id++); | 878 len = htonl (params->id++); |
864 memcpy (params->handle, &len, 4); | 879 memcpy (params->handle, &len, 4); |
865 | 880 |
866 if (sshv2_send_command (request, SSH_FXP_READDIR, params->handle, | 881 if ((ret = sshv2_send_command (request, SSH_FXP_READDIR, |
867 params->handle_len) < 0) | 882 params->handle, |
868 return (-2); | 883 params->handle_len)) < 0) |
884 return (ret); | |
869 } | 885 } |
870 | 886 |
871 if ((ret = sshv2_read_response (request, ¶ms->message, fd)) < 0) | 887 if ((ret = sshv2_read_response (request, ¶ms->message, fd)) < 0) |
872 return (-2); | 888 return (ret); |
873 | 889 |
874 if (!request->cached) | 890 if (!request->cached) |
875 { | 891 { |
876 request->last_dir_entry = g_malloc (params->message.length + 4); | 892 request->last_dir_entry = g_malloc (params->message.length + 4); |
877 len = htonl (params->message.length); | 893 len = htonl (params->message.length); |
885 if (ret == SSH_FXP_NAME) | 901 if (ret == SSH_FXP_NAME) |
886 { | 902 { |
887 params->message.pos = params->message.buffer + 4; | 903 params->message.pos = params->message.buffer + 4; |
888 if ((params->count = sshv2_buffer_get_int32 (request, | 904 if ((params->count = sshv2_buffer_get_int32 (request, |
889 ¶ms->message, -1)) < 0) | 905 ¶ms->message, -1)) < 0) |
890 return (-2); | 906 return (params->count); |
891 } | 907 } |
892 } | 908 } |
893 | 909 |
894 if (ret == SSH_FXP_NAME) | 910 if (ret == SSH_FXP_NAME) |
895 { | 911 { |
896 if ((len = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0 || | 912 if ((len = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0 || |
897 params->message.pos + len > params->message.end) | 913 params->message.pos + len > params->message.end) |
898 return (-2); | 914 return (GFTP_EFATAL); |
899 | 915 |
900 params->message.pos += len; | 916 params->message.pos += len; |
901 | 917 |
902 if ((longnamelen = sshv2_buffer_get_int32 (request, | 918 if ((longnamelen = sshv2_buffer_get_int32 (request, |
903 ¶ms->message, -1)) < 0 || | 919 ¶ms->message, -1)) < 0 || |
904 params->message.pos + longnamelen > params->message.end) | 920 params->message.pos + longnamelen > params->message.end) |
905 return (-2); | 921 return (GFTP_EFATAL); |
906 | 922 |
907 longname = params->message.pos; | 923 longname = params->message.pos; |
908 params->message.pos += longnamelen; | 924 params->message.pos += longnamelen; |
909 | 925 |
910 if ((attrs = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) | 926 if ((attrs = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) |
911 return (-2); | 927 return (attrs); |
912 | 928 |
913 if (attrs & SSH_FILEXFER_ATTR_SIZE) | 929 if (attrs & SSH_FILEXFER_ATTR_SIZE) |
914 { | 930 { |
915 params->message.pos += 8; | 931 params->message.pos += 8; |
916 if (params->message.pos > params->message.end) | 932 if (params->message.pos > params->message.end) |
917 { | 933 { |
918 request->logging_function (gftp_logging_error, request->user_data, | 934 request->logging_function (gftp_logging_error, request->user_data, |
919 _("Received wrong response from server, disconnecting\n")); | 935 _("Received wrong response from server, disconnecting\n")); |
920 sshv2_message_free (¶ms->message); | 936 sshv2_message_free (¶ms->message); |
921 gftp_disconnect (request); | 937 gftp_disconnect (request); |
922 return (-2); | 938 return (GFTP_EFATAL); |
923 } | 939 } |
924 } | 940 } |
925 | 941 |
926 if (attrs & SSH_FILEXFER_ATTR_UIDGID) | 942 if (attrs & SSH_FILEXFER_ATTR_UIDGID) |
927 { | 943 { |
930 { | 946 { |
931 request->logging_function (gftp_logging_error, request->user_data, | 947 request->logging_function (gftp_logging_error, request->user_data, |
932 _("Received wrong response from server, disconnecting\n")); | 948 _("Received wrong response from server, disconnecting\n")); |
933 sshv2_message_free (¶ms->message); | 949 sshv2_message_free (¶ms->message); |
934 gftp_disconnect (request); | 950 gftp_disconnect (request); |
935 return (-2); | 951 return (GFTP_EFATAL); |
936 } | 952 } |
937 } | 953 } |
938 | 954 |
939 if (attrs & SSH_FILEXFER_ATTR_PERMISSIONS) | 955 if (attrs & SSH_FILEXFER_ATTR_PERMISSIONS) |
940 { | 956 { |
943 { | 959 { |
944 request->logging_function (gftp_logging_error, request->user_data, | 960 request->logging_function (gftp_logging_error, request->user_data, |
945 _("Received wrong response from server, disconnecting\n")); | 961 _("Received wrong response from server, disconnecting\n")); |
946 sshv2_message_free (¶ms->message); | 962 sshv2_message_free (¶ms->message); |
947 gftp_disconnect (request); | 963 gftp_disconnect (request); |
948 return (-2); | 964 return (GFTP_EFATAL); |
949 } | 965 } |
950 } | 966 } |
951 | 967 |
952 if (attrs & SSH_FILEXFER_ATTR_ACMODTIME) | 968 if (attrs & SSH_FILEXFER_ATTR_ACMODTIME) |
953 { | 969 { |
956 { | 972 { |
957 request->logging_function (gftp_logging_error, request->user_data, | 973 request->logging_function (gftp_logging_error, request->user_data, |
958 _("Received wrong response from server, disconnecting\n")); | 974 _("Received wrong response from server, disconnecting\n")); |
959 sshv2_message_free (¶ms->message); | 975 sshv2_message_free (¶ms->message); |
960 gftp_disconnect (request); | 976 gftp_disconnect (request); |
961 return (-2); | 977 return (GFTP_EFATAL); |
962 } | 978 } |
963 } | 979 } |
964 | 980 |
965 if (attrs & SSH_FILEXFER_ATTR_EXTENDED) | 981 if (attrs & SSH_FILEXFER_ATTR_EXTENDED) |
966 { | 982 { |
967 if ((count = sshv2_buffer_get_int32 (request, | 983 if ((count = sshv2_buffer_get_int32 (request, |
968 ¶ms->message, -1)) < 0) | 984 ¶ms->message, -1)) < 0) |
969 return (-2); | 985 return (GFTP_EFATAL); |
970 | 986 |
971 for (i=0; i<count; i++) | 987 for (i=0; i<count; i++) |
972 { | 988 { |
973 if ((len = sshv2_buffer_get_int32 (request, | 989 if ((len = sshv2_buffer_get_int32 (request, |
974 ¶ms->message, -1)) < 0 || | 990 ¶ms->message, -1)) < 0 || |
975 params->message.pos + len + 4 > params->message.end) | 991 params->message.pos + len + 4 > params->message.end) |
976 return (-2); | 992 return (GFTP_EFATAL); |
977 | 993 |
978 params->message.pos += len + 4; | 994 params->message.pos += len + 4; |
979 | 995 |
980 if ((len = sshv2_buffer_get_int32 (request, | 996 if ((len = sshv2_buffer_get_int32 (request, |
981 ¶ms->message, -1)) < 0 || | 997 ¶ms->message, -1)) < 0 || |
982 params->message.pos + len + 4 > params->message.end) | 998 params->message.pos + len + 4 > params->message.end) |
983 return (-2); | 999 return (GFTP_EFATAL); |
984 | 1000 |
985 params->message.pos += len + 4; | 1001 params->message.pos += len + 4; |
986 } | 1002 } |
987 } | 1003 } |
988 | 1004 |
992 if (longname[longnamelen - 1] == '*') | 1008 if (longname[longnamelen - 1] == '*') |
993 longname[--longnamelen] = '\0'; | 1009 longname[--longnamelen] = '\0'; |
994 if (longname[longnamelen - 1] == '/') | 1010 if (longname[longnamelen - 1] == '/') |
995 longname[--longnamelen] = '\0'; | 1011 longname[--longnamelen] = '\0'; |
996 | 1012 |
997 if (gftp_parse_ls (longname, fle) != 0) | 1013 if ((ret = gftp_parse_ls (longname, fle)) < 0) |
998 { | 1014 { |
999 gftp_file_destroy (fle); | 1015 gftp_file_destroy (fle); |
1000 return (-2); | 1016 return (ret); |
1001 } | 1017 } |
1002 retsize = strlen (longname); | 1018 retsize = strlen (longname); |
1003 | 1019 |
1004 params->count--; | 1020 params->count--; |
1005 } | 1021 } |
1012 { | 1028 { |
1013 request->logging_function (gftp_logging_error, request->user_data, | 1029 request->logging_function (gftp_logging_error, request->user_data, |
1014 _("Received wrong response from server, disconnecting\n")); | 1030 _("Received wrong response from server, disconnecting\n")); |
1015 sshv2_message_free (¶ms->message); | 1031 sshv2_message_free (¶ms->message); |
1016 gftp_disconnect (request); | 1032 gftp_disconnect (request); |
1017 return (-2); | 1033 return (GFTP_EFATAL); |
1018 } | 1034 } |
1019 | 1035 |
1020 return (retsize); | 1036 return (retsize); |
1021 } | 1037 } |
1022 | 1038 |
1029 char *tempstr, *dir; | 1045 char *tempstr, *dir; |
1030 gint32 num; | 1046 gint32 num; |
1031 size_t len; | 1047 size_t len; |
1032 int ret; | 1048 int ret; |
1033 | 1049 |
1034 g_return_val_if_fail (request != NULL, -2); | 1050 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1035 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1051 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1036 | 1052 |
1037 params = request->protocol_data; | 1053 params = request->protocol_data; |
1038 if (request->directory != directory) | 1054 if (request->directory != directory) |
1039 { | 1055 { |
1040 if (*directory == '/') | 1056 if (*directory == '/') |
1055 num = htonl (params->id++); | 1071 num = htonl (params->id++); |
1056 memcpy (tempstr, &num, 4); | 1072 memcpy (tempstr, &num, 4); |
1057 | 1073 |
1058 num = htonl (len - 8); | 1074 num = htonl (len - 8); |
1059 memcpy (tempstr + 4, &num, 4); | 1075 memcpy (tempstr + 4, &num, 4); |
1060 if (sshv2_send_command (request, SSH_FXP_REALPATH, tempstr, len) < 0) | 1076 if ((ret = sshv2_send_command (request, SSH_FXP_REALPATH, tempstr, len)) < 0) |
1061 { | 1077 { |
1062 g_free (tempstr); | 1078 g_free (tempstr); |
1063 return (-2); | 1079 return (ret); |
1064 } | 1080 } |
1065 g_free (tempstr); | 1081 g_free (tempstr); |
1066 | 1082 |
1067 memset (&message, 0, sizeof (message)); | 1083 memset (&message, 0, sizeof (message)); |
1068 ret = sshv2_read_response (request, &message, -1); | 1084 ret = sshv2_read_response (request, &message, -1); |
1069 if (ret == SSH_FXP_STATUS) | 1085 if (ret < 0) |
1086 return (ret); | |
1087 else if (ret == SSH_FXP_STATUS) | |
1070 { | 1088 { |
1071 sshv2_message_free (&message); | 1089 sshv2_message_free (&message); |
1072 return (-2); | 1090 return (GFTP_ERETRYABLE); |
1073 } | 1091 } |
1074 else if (ret != SSH_FXP_NAME) | 1092 else if (ret != SSH_FXP_NAME) |
1075 { | 1093 { |
1076 request->logging_function (gftp_logging_error, request->user_data, | 1094 request->logging_function (gftp_logging_error, request->user_data, |
1077 _("Received wrong response from server, disconnecting\n")); | 1095 _("Received wrong response from server, disconnecting\n")); |
1078 sshv2_message_free (&message); | 1096 sshv2_message_free (&message); |
1079 gftp_disconnect (request); | 1097 gftp_disconnect (request); |
1080 return (-2); | 1098 return (GFTP_EFATAL); |
1081 } | 1099 } |
1082 | 1100 |
1083 message.pos += 4; | 1101 message.pos += 4; |
1084 if (sshv2_buffer_get_int32 (request, &message, 1) != 1) | 1102 if (sshv2_buffer_get_int32 (request, &message, 1) != 1) |
1085 return (-2); | 1103 return (GFTP_EFATAL); |
1086 | 1104 |
1087 if ((dir = sshv2_buffer_get_string (request, &message)) == NULL) | 1105 if ((dir = sshv2_buffer_get_string (request, &message)) == NULL) |
1088 return (-2); | 1106 return (GFTP_EFATAL); |
1089 | 1107 |
1090 if (request->directory) | 1108 if (request->directory) |
1091 g_free (request->directory); | 1109 g_free (request->directory); |
1092 request->directory = dir; | 1110 request->directory = dir; |
1093 sshv2_message_free (&message); | 1111 sshv2_message_free (&message); |
1104 sshv2_params * params; | 1122 sshv2_params * params; |
1105 sshv2_message message; | 1123 sshv2_message message; |
1106 char *tempstr; | 1124 char *tempstr; |
1107 gint32 num; | 1125 gint32 num; |
1108 size_t len; | 1126 size_t len; |
1109 | 1127 int ret; |
1110 g_return_val_if_fail (request != NULL, -2); | 1128 |
1111 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1129 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1112 g_return_val_if_fail (directory != NULL, -2); | 1130 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1131 g_return_val_if_fail (directory != NULL, GFTP_EFATAL); | |
1113 | 1132 |
1114 params = request->protocol_data; | 1133 params = request->protocol_data; |
1115 | 1134 |
1116 if (*directory == '/') | 1135 if (*directory == '/') |
1117 { | 1136 { |
1135 memcpy (tempstr + 4, &num, 4); | 1154 memcpy (tempstr + 4, &num, 4); |
1136 | 1155 |
1137 if (sshv2_send_command (request, SSH_FXP_RMDIR, tempstr, len) < 0) | 1156 if (sshv2_send_command (request, SSH_FXP_RMDIR, tempstr, len) < 0) |
1138 { | 1157 { |
1139 g_free (tempstr); | 1158 g_free (tempstr); |
1140 return (-2); | 1159 return (GFTP_ERETRYABLE); |
1141 } | 1160 } |
1142 g_free (tempstr); | 1161 g_free (tempstr); |
1143 | 1162 |
1144 memset (&message, 0, sizeof (message)); | 1163 memset (&message, 0, sizeof (message)); |
1145 if (sshv2_read_response (request, &message, -1) < 0) | 1164 if ((ret = sshv2_read_response (request, &message, -1)) < 0) |
1146 return (-2); | 1165 return (ret); |
1147 | 1166 |
1148 message.pos += 4; | 1167 message.pos += 4; |
1149 if (sshv2_buffer_get_int32 (request, &message, SSH_FX_OK) < 0) | 1168 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1150 return (-2); | 1169 return (ret); |
1151 | 1170 |
1152 sshv2_message_free (&message); | 1171 sshv2_message_free (&message); |
1153 | 1172 |
1154 return (0); | 1173 return (0); |
1155 } | 1174 } |
1161 sshv2_params * params; | 1180 sshv2_params * params; |
1162 sshv2_message message; | 1181 sshv2_message message; |
1163 char *tempstr; | 1182 char *tempstr; |
1164 gint32 num; | 1183 gint32 num; |
1165 size_t len; | 1184 size_t len; |
1166 | 1185 int ret; |
1167 g_return_val_if_fail (request != NULL, -2); | 1186 |
1168 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1187 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1169 g_return_val_if_fail (file != NULL, -2); | 1188 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1189 g_return_val_if_fail (file != NULL, GFTP_EFATAL); | |
1170 | 1190 |
1171 params = request->protocol_data; | 1191 params = request->protocol_data; |
1172 | 1192 |
1173 if (*file == '/') | 1193 if (*file == '/') |
1174 { | 1194 { |
1192 memcpy (tempstr + 4, &num, 4); | 1212 memcpy (tempstr + 4, &num, 4); |
1193 | 1213 |
1194 if (sshv2_send_command (request, SSH_FXP_REMOVE, tempstr, len) < 0) | 1214 if (sshv2_send_command (request, SSH_FXP_REMOVE, tempstr, len) < 0) |
1195 { | 1215 { |
1196 g_free (tempstr); | 1216 g_free (tempstr); |
1197 return (-2); | 1217 return (GFTP_ERETRYABLE); |
1198 } | 1218 } |
1199 g_free (tempstr); | 1219 g_free (tempstr); |
1200 | 1220 |
1201 memset (&message, 0, sizeof (message)); | 1221 memset (&message, 0, sizeof (message)); |
1202 if (sshv2_read_response (request, &message, -1) < 0) | 1222 if ((ret = sshv2_read_response (request, &message, -1)) < 0) |
1203 return (-2); | 1223 return (ret); |
1204 | 1224 |
1205 message.pos += 4; | 1225 message.pos += 4; |
1206 if (sshv2_buffer_get_int32 (request, &message, SSH_FX_OK) < 0) | 1226 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1207 return (-2); | 1227 return (ret); |
1208 | 1228 |
1209 sshv2_message_free (&message); | 1229 sshv2_message_free (&message); |
1210 | 1230 |
1211 return (0); | 1231 return (0); |
1212 } | 1232 } |
1218 char *tempstr, buf[10]; | 1238 char *tempstr, buf[10]; |
1219 sshv2_params * params; | 1239 sshv2_params * params; |
1220 sshv2_message message; | 1240 sshv2_message message; |
1221 gint32 num; | 1241 gint32 num; |
1222 size_t len; | 1242 size_t len; |
1223 | 1243 int ret; |
1224 g_return_val_if_fail (request != NULL, -2); | 1244 |
1225 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1245 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1226 g_return_val_if_fail (file != NULL, -2); | 1246 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1247 g_return_val_if_fail (file != NULL, GFTP_EFATAL); | |
1227 | 1248 |
1228 params = request->protocol_data; | 1249 params = request->protocol_data; |
1229 | 1250 |
1230 if (*file == '/') | 1251 if (*file == '/') |
1231 { | 1252 { |
1256 memcpy (tempstr + len - 4, &num, 4); | 1277 memcpy (tempstr + len - 4, &num, 4); |
1257 | 1278 |
1258 if (sshv2_send_command (request, SSH_FXP_SETSTAT, tempstr, len) < 0) | 1279 if (sshv2_send_command (request, SSH_FXP_SETSTAT, tempstr, len) < 0) |
1259 { | 1280 { |
1260 g_free (tempstr); | 1281 g_free (tempstr); |
1261 return (-2); | 1282 return (GFTP_ERETRYABLE); |
1262 } | 1283 } |
1263 g_free (tempstr); | 1284 g_free (tempstr); |
1264 | 1285 |
1265 memset (&message, 0, sizeof (message)); | 1286 memset (&message, 0, sizeof (message)); |
1266 if (sshv2_read_response (request, &message, -1) < 0) | 1287 if ((ret = sshv2_read_response (request, &message, -1)) < 0) |
1267 return (-2); | 1288 return (ret); |
1268 | 1289 |
1269 message.pos += 4; | 1290 message.pos += 4; |
1270 if (sshv2_buffer_get_int32 (request, &message, SSH_FX_OK) < 0) | 1291 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1271 return (-2); | 1292 return (ret); |
1272 | 1293 |
1273 sshv2_message_free (&message); | 1294 sshv2_message_free (&message); |
1274 | 1295 |
1275 return (0); | 1296 return (0); |
1276 } | 1297 } |
1282 sshv2_params * params; | 1303 sshv2_params * params; |
1283 sshv2_message message; | 1304 sshv2_message message; |
1284 char *tempstr; | 1305 char *tempstr; |
1285 gint32 num; | 1306 gint32 num; |
1286 size_t len; | 1307 size_t len; |
1287 | 1308 int ret; |
1288 g_return_val_if_fail (request != NULL, -2); | 1309 |
1289 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1310 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1290 g_return_val_if_fail (newdir != NULL, -2); | 1311 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1312 g_return_val_if_fail (newdir != NULL, GFTP_EFATAL); | |
1291 | 1313 |
1292 params = request->protocol_data; | 1314 params = request->protocol_data; |
1293 | 1315 |
1294 if (*newdir == '/') | 1316 if (*newdir == '/') |
1295 { | 1317 { |
1314 memset (tempstr + len - 4, 0, 4); /* attributes */ | 1336 memset (tempstr + len - 4, 0, 4); /* attributes */ |
1315 | 1337 |
1316 if (sshv2_send_command (request, SSH_FXP_MKDIR, tempstr, len) < 0) | 1338 if (sshv2_send_command (request, SSH_FXP_MKDIR, tempstr, len) < 0) |
1317 { | 1339 { |
1318 g_free (tempstr); | 1340 g_free (tempstr); |
1319 return (-2); | 1341 return (GFTP_ERETRYABLE); |
1320 } | 1342 } |
1321 g_free (tempstr); | 1343 g_free (tempstr); |
1322 | 1344 |
1323 memset (&message, 0, sizeof (message)); | 1345 memset (&message, 0, sizeof (message)); |
1324 if (sshv2_read_response (request, &message, -1) < 0) | 1346 if ((ret = sshv2_read_response (request, &message, -1)) < 0) |
1325 return (-2); | 1347 return (ret); |
1326 | 1348 |
1327 message.pos += 4; | 1349 message.pos += 4; |
1328 if (sshv2_buffer_get_int32 (request, &message, SSH_FX_OK) < 0) | 1350 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1329 return (-2); | 1351 return (ret); |
1330 | 1352 |
1331 sshv2_message_free (&message); | 1353 sshv2_message_free (&message); |
1332 | 1354 |
1333 return (0); | 1355 return (0); |
1334 } | 1356 } |
1338 sshv2_rename (gftp_request * request, const char *oldname, const char *newname) | 1360 sshv2_rename (gftp_request * request, const char *oldname, const char *newname) |
1339 { | 1361 { |
1340 char *tempstr, *oldstr, *newstr; | 1362 char *tempstr, *oldstr, *newstr; |
1341 sshv2_params * params; | 1363 sshv2_params * params; |
1342 sshv2_message message; | 1364 sshv2_message message; |
1365 size_t oldlen, newlen; | |
1343 gint32 num; | 1366 gint32 num; |
1344 size_t oldlen, newlen; | 1367 int ret; |
1345 | 1368 |
1346 g_return_val_if_fail (request != NULL, -2); | 1369 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1347 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1370 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1348 g_return_val_if_fail (oldname != NULL, -2); | 1371 g_return_val_if_fail (oldname != NULL, GFTP_EFATAL); |
1349 g_return_val_if_fail (newname != NULL, -2); | 1372 g_return_val_if_fail (newname != NULL, GFTP_EFATAL); |
1350 | 1373 |
1351 params = request->protocol_data; | 1374 params = request->protocol_data; |
1352 | 1375 |
1353 if (*oldname == '/') | 1376 if (*oldname == '/') |
1354 { | 1377 { |
1385 strcpy (tempstr + 12 + oldlen, newstr); | 1408 strcpy (tempstr + 12 + oldlen, newstr); |
1386 | 1409 |
1387 if (sshv2_send_command (request, SSH_FXP_RENAME, tempstr, oldlen + newlen + 12) < 0) | 1410 if (sshv2_send_command (request, SSH_FXP_RENAME, tempstr, oldlen + newlen + 12) < 0) |
1388 { | 1411 { |
1389 g_free (tempstr); | 1412 g_free (tempstr); |
1390 return (-2); | 1413 return (GFTP_ERETRYABLE); |
1391 } | 1414 } |
1392 g_free (tempstr); | 1415 g_free (tempstr); |
1393 | 1416 |
1394 memset (&message, 0, sizeof (message)); | 1417 memset (&message, 0, sizeof (message)); |
1395 if (sshv2_read_response (request, &message, -1) < 0) | 1418 if ((ret = sshv2_read_response (request, &message, -1)) < 0) |
1396 return (-2); | 1419 return (ret); |
1397 | 1420 |
1398 message.pos += 4; | 1421 message.pos += 4; |
1399 if (sshv2_buffer_get_int32 (request, &message, SSH_FX_OK) < 0) | 1422 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1400 return (-2); | 1423 return (ret); |
1401 | 1424 |
1402 sshv2_message_free (&message); | 1425 sshv2_message_free (&message); |
1403 | 1426 |
1404 return (0); | 1427 return (0); |
1405 } | 1428 } |
1411 sshv2_params * params; | 1434 sshv2_params * params; |
1412 sshv2_message message; | 1435 sshv2_message message; |
1413 char *tempstr; | 1436 char *tempstr; |
1414 gint32 num; | 1437 gint32 num; |
1415 size_t len; | 1438 size_t len; |
1416 | 1439 int ret; |
1417 g_return_val_if_fail (request != NULL, -2); | 1440 |
1418 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1441 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1419 g_return_val_if_fail (file != NULL, -2); | 1442 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1443 g_return_val_if_fail (file != NULL, GFTP_EFATAL); | |
1420 | 1444 |
1421 params = request->protocol_data; | 1445 params = request->protocol_data; |
1422 | 1446 |
1423 if (*file == '/') | 1447 if (*file == '/') |
1424 { | 1448 { |
1451 memcpy (tempstr + len - 4, &num, 4); | 1475 memcpy (tempstr + len - 4, &num, 4); |
1452 | 1476 |
1453 if (sshv2_send_command (request, SSH_FXP_SETSTAT, tempstr, len) < 0) | 1477 if (sshv2_send_command (request, SSH_FXP_SETSTAT, tempstr, len) < 0) |
1454 { | 1478 { |
1455 g_free (tempstr); | 1479 g_free (tempstr); |
1456 return (-2); | 1480 return (GFTP_ERETRYABLE); |
1457 } | 1481 } |
1458 g_free (tempstr); | 1482 g_free (tempstr); |
1459 | 1483 |
1460 memset (&message, 0, sizeof (message)); | 1484 memset (&message, 0, sizeof (message)); |
1461 if (sshv2_read_response (request, &message, -1) < 0) | 1485 if ((ret = sshv2_read_response (request, &message, -1)) < 0) |
1462 return (-2); | 1486 return (ret); |
1463 | 1487 |
1464 message.pos += 4; | 1488 message.pos += 4; |
1465 if (sshv2_buffer_get_int32 (request, &message, SSH_FX_OK) < 0) | 1489 if ((ret = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1466 return (-2); | 1490 return (ret); |
1467 | 1491 |
1468 sshv2_message_free (&message); | 1492 sshv2_message_free (&message); |
1469 | 1493 |
1470 return (0); | 1494 return (0); |
1471 } | 1495 } |
1480 int serv_ret; | 1504 int serv_ret; |
1481 #ifdef G_HAVE_GINT64 | 1505 #ifdef G_HAVE_GINT64 |
1482 gint64 ret; | 1506 gint64 ret; |
1483 #endif | 1507 #endif |
1484 | 1508 |
1485 g_return_val_if_fail (request != NULL, -2); | 1509 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1486 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1510 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1487 g_return_val_if_fail (file != NULL, -2); | 1511 g_return_val_if_fail (file != NULL, GFTP_EFATAL); |
1488 | 1512 |
1489 params = request->protocol_data; | 1513 params = request->protocol_data; |
1490 | 1514 |
1491 if (*file == '/') | 1515 if (*file == '/') |
1492 { | 1516 { |
1510 memcpy (tempstr + 4, &num, 4); | 1534 memcpy (tempstr + 4, &num, 4); |
1511 | 1535 |
1512 if (sshv2_send_command (request, SSH_FXP_STAT, tempstr, len + 8) < 0) | 1536 if (sshv2_send_command (request, SSH_FXP_STAT, tempstr, len + 8) < 0) |
1513 { | 1537 { |
1514 g_free (tempstr); | 1538 g_free (tempstr); |
1515 return (-2); | 1539 return (GFTP_ERETRYABLE); |
1516 } | 1540 } |
1517 g_free (tempstr); | 1541 g_free (tempstr); |
1518 | 1542 |
1519 memset (¶ms->message, 0, sizeof (params->message)); | 1543 memset (¶ms->message, 0, sizeof (params->message)); |
1520 serv_ret = sshv2_read_response (request, ¶ms->message, -1); | 1544 serv_ret = sshv2_read_response (request, ¶ms->message, -1); |
1521 if (serv_ret == SSH_FXP_STATUS) | 1545 if (serv_ret < 0) |
1546 return (serv_ret); | |
1547 else if (serv_ret == SSH_FXP_STATUS) | |
1522 { | 1548 { |
1523 sshv2_message_free (¶ms->message); | 1549 sshv2_message_free (¶ms->message); |
1524 return (-2); | 1550 return (GFTP_ERETRYABLE); |
1525 } | 1551 } |
1526 else if (serv_ret != SSH_FXP_ATTRS) | 1552 else if (serv_ret != SSH_FXP_ATTRS) |
1527 { | 1553 { |
1528 request->logging_function (gftp_logging_error, request->user_data, | 1554 request->logging_function (gftp_logging_error, request->user_data, |
1529 _("Received wrong response from server, disconnecting\n")); | 1555 _("Received wrong response from server, disconnecting\n")); |
1530 sshv2_message_free (¶ms->message); | 1556 sshv2_message_free (¶ms->message); |
1531 gftp_disconnect (request); | 1557 gftp_disconnect (request); |
1532 return (-2); | 1558 return (GFTP_ERETRYABLE); |
1533 } | 1559 } |
1534 | 1560 |
1535 if (params->message.length < 5) | 1561 if (params->message.length < 5) |
1536 return (-2); | 1562 return (GFTP_ERETRYABLE); |
1537 params->message.pos += 4; | 1563 params->message.pos += 4; |
1538 | 1564 |
1539 if ((attrs = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) | 1565 if ((attrs = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) |
1540 return (-2); | 1566 return (GFTP_ERETRYABLE); |
1541 | 1567 |
1542 if (attrs & SSH_FILEXFER_ATTR_SIZE) | 1568 if (attrs & SSH_FILEXFER_ATTR_SIZE) |
1543 { | 1569 { |
1544 if ((highnum = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) | 1570 if ((highnum = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) |
1545 return (-2); | 1571 return (GFTP_ERETRYABLE); |
1546 | 1572 |
1547 if ((lownum = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) | 1573 if ((lownum = sshv2_buffer_get_int32 (request, ¶ms->message, -1)) < 0) |
1548 return (-2); | 1574 return (GFTP_ERETRYABLE); |
1549 | 1575 |
1550 sshv2_message_free (¶ms->message); | 1576 sshv2_message_free (¶ms->message); |
1551 | 1577 |
1552 #if G_HAVE_GINT64 | 1578 #if G_HAVE_GINT64 |
1553 ret = (gint64) lownum | ((gint64) highnum >> 32); | 1579 ret = (gint64) lownum | ((gint64) highnum >> 32); |
1573 char *tempstr; | 1599 char *tempstr; |
1574 size_t stlen; | 1600 size_t stlen; |
1575 gint32 num; | 1601 gint32 num; |
1576 int ret; | 1602 int ret; |
1577 | 1603 |
1578 g_return_val_if_fail (request != NULL, -2); | 1604 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1579 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1605 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1580 g_return_val_if_fail (request->sockfd > 0, -2); | 1606 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); |
1581 /* fd ignored for this protocol */ | 1607 /* fd ignored for this protocol */ |
1582 | 1608 |
1583 params = request->protocol_data; | 1609 params = request->protocol_data; |
1584 params->offset = startsize; | 1610 params->offset = startsize; |
1585 | 1611 |
1610 memset (tempstr + 12 + stlen, 0, 4); | 1636 memset (tempstr + 12 + stlen, 0, 4); |
1611 | 1637 |
1612 if (sshv2_send_command (request, SSH_FXP_OPEN, tempstr, stlen + 16) < 0) | 1638 if (sshv2_send_command (request, SSH_FXP_OPEN, tempstr, stlen + 16) < 0) |
1613 { | 1639 { |
1614 g_free (tempstr); | 1640 g_free (tempstr); |
1615 return (-2); | 1641 return (GFTP_ERETRYABLE); |
1616 } | 1642 } |
1617 | 1643 |
1618 g_free (tempstr); | 1644 g_free (tempstr); |
1619 memset (&message, 0, sizeof (message)); | 1645 memset (&message, 0, sizeof (message)); |
1620 ret = sshv2_read_response (request, &message, -1); | 1646 ret = sshv2_read_response (request, &message, -1); |
1621 if (ret == SSH_FXP_STATUS) | 1647 if (ret < 0) |
1648 return (ret); | |
1649 else if (ret == SSH_FXP_STATUS) | |
1622 { | 1650 { |
1623 sshv2_message_free (&message); | 1651 sshv2_message_free (&message); |
1624 return (-2); | 1652 return (GFTP_ERETRYABLE); |
1625 } | 1653 } |
1626 else if (ret != SSH_FXP_HANDLE) | 1654 else if (ret != SSH_FXP_HANDLE) |
1627 { | 1655 { |
1628 request->logging_function (gftp_logging_error, request->user_data, | 1656 request->logging_function (gftp_logging_error, request->user_data, |
1629 _("Received wrong response from server, disconnecting\n")); | 1657 _("Received wrong response from server, disconnecting\n")); |
1630 sshv2_message_free (&message); | 1658 sshv2_message_free (&message); |
1631 gftp_disconnect (request); | 1659 gftp_disconnect (request); |
1632 return (-2); | 1660 return (GFTP_ERETRYABLE); |
1633 } | 1661 } |
1634 | 1662 |
1635 if (message.length - 4 > SSH_MAX_HANDLE_SIZE) | 1663 if (message.length - 4 > SSH_MAX_HANDLE_SIZE) |
1636 { | 1664 { |
1637 request->logging_function (gftp_logging_error, request->user_data, | 1665 request->logging_function (gftp_logging_error, request->user_data, |
1638 _("Error: Message size %d too big from server\n"), | 1666 _("Error: Message size %d too big from server\n"), |
1639 message.length - 4); | 1667 message.length - 4); |
1640 sshv2_message_free (&message); | 1668 sshv2_message_free (&message); |
1641 gftp_disconnect (request); | 1669 gftp_disconnect (request); |
1642 return (-1); | 1670 return (GFTP_ERETRYABLE); |
1643 | 1671 |
1644 } | 1672 } |
1645 | 1673 |
1646 memset (params->handle, 0, 4); | 1674 memset (params->handle, 0, 4); |
1647 memcpy (params->handle + 4, message.buffer+ 4, message.length - 5); | 1675 memcpy (params->handle + 4, message.buffer+ 4, message.length - 5); |
1661 char *tempstr; | 1689 char *tempstr; |
1662 size_t stlen; | 1690 size_t stlen; |
1663 gint32 num; | 1691 gint32 num; |
1664 int ret; | 1692 int ret; |
1665 | 1693 |
1666 g_return_val_if_fail (request != NULL, -2); | 1694 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1667 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1695 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1668 g_return_val_if_fail (request->sockfd > 0, -2); | 1696 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); |
1669 /* fd ignored for this protocol */ | 1697 /* fd ignored for this protocol */ |
1670 | 1698 |
1671 params = request->protocol_data; | 1699 params = request->protocol_data; |
1672 params->offset = 0; | 1700 params->offset = 0; |
1673 | 1701 |
1701 memset (tempstr + 12 + stlen, 0, 4); | 1729 memset (tempstr + 12 + stlen, 0, 4); |
1702 | 1730 |
1703 if (sshv2_send_command (request, SSH_FXP_OPEN, tempstr, stlen + 16) < 0) | 1731 if (sshv2_send_command (request, SSH_FXP_OPEN, tempstr, stlen + 16) < 0) |
1704 { | 1732 { |
1705 g_free (tempstr); | 1733 g_free (tempstr); |
1706 return (-2); | 1734 return (GFTP_ERETRYABLE); |
1707 } | 1735 } |
1708 | 1736 |
1709 g_free (tempstr); | 1737 g_free (tempstr); |
1710 memset (&message, 0, sizeof (message)); | 1738 memset (&message, 0, sizeof (message)); |
1711 ret = sshv2_read_response (request, &message, -1); | 1739 ret = sshv2_read_response (request, &message, -1); |
1712 if (ret == SSH_FXP_STATUS) | 1740 if (ret < 0) |
1741 return (ret); | |
1742 else if (ret == SSH_FXP_STATUS) | |
1713 { | 1743 { |
1714 sshv2_message_free (&message); | 1744 sshv2_message_free (&message); |
1715 return (-2); | 1745 return (GFTP_ERETRYABLE); |
1716 } | 1746 } |
1717 else if (ret != SSH_FXP_HANDLE) | 1747 else if (ret != SSH_FXP_HANDLE) |
1718 { | 1748 { |
1719 request->logging_function (gftp_logging_error, request->user_data, | 1749 request->logging_function (gftp_logging_error, request->user_data, |
1720 _("Received wrong response from server, disconnecting\n")); | 1750 _("Received wrong response from server, disconnecting\n")); |
1721 sshv2_message_free (&message); | 1751 sshv2_message_free (&message); |
1722 gftp_disconnect (request); | 1752 gftp_disconnect (request); |
1723 return (-2); | 1753 return (GFTP_ERETRYABLE); |
1724 } | 1754 } |
1725 | 1755 |
1726 if (message.length - 4 > SSH_MAX_HANDLE_SIZE) | 1756 if (message.length - 4 > SSH_MAX_HANDLE_SIZE) |
1727 { | 1757 { |
1728 request->logging_function (gftp_logging_error, request->user_data, | 1758 request->logging_function (gftp_logging_error, request->user_data, |
1729 _("Error: Message size %d too big from server\n"), | 1759 _("Error: Message size %d too big from server\n"), |
1730 message.length - 4); | 1760 message.length - 4); |
1731 sshv2_message_free (&message); | 1761 sshv2_message_free (&message); |
1732 gftp_disconnect (request); | 1762 gftp_disconnect (request); |
1733 return (-1); | 1763 return (GFTP_ERETRYABLE); |
1734 | 1764 |
1735 } | 1765 } |
1736 | 1766 |
1737 memset (params->handle, 0, 4); | 1767 memset (params->handle, 0, 4); |
1738 memcpy (params->handle + 4, message.buffer+ 4, message.length - 5); | 1768 memcpy (params->handle + 4, message.buffer+ 4, message.length - 5); |
1747 sshv2_get_next_file_chunk (gftp_request * request, char *buf, size_t size) | 1777 sshv2_get_next_file_chunk (gftp_request * request, char *buf, size_t size) |
1748 { | 1778 { |
1749 sshv2_params * params; | 1779 sshv2_params * params; |
1750 sshv2_message message; | 1780 sshv2_message message; |
1751 gint32 num; | 1781 gint32 num; |
1782 int ret; | |
1752 | 1783 |
1753 #ifdef G_HAVE_GINT64 | 1784 #ifdef G_HAVE_GINT64 |
1754 gint64 offset; | 1785 gint64 offset; |
1755 #else | 1786 #else |
1756 gint32 offset; | 1787 gint32 offset; |
1757 #endif | 1788 #endif |
1758 | 1789 |
1759 g_return_val_if_fail (request != NULL, -2); | 1790 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1760 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1791 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1761 g_return_val_if_fail (request->sockfd > 0, -2); | 1792 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); |
1762 g_return_val_if_fail (buf != NULL, -2); | 1793 g_return_val_if_fail (buf != NULL, GFTP_EFATAL); |
1763 | 1794 |
1764 params = request->protocol_data; | 1795 params = request->protocol_data; |
1765 | 1796 |
1766 if (params->read_buffer == NULL) | 1797 if (params->read_buffer == NULL) |
1767 { | 1798 { |
1784 | 1815 |
1785 num = htonl (size); | 1816 num = htonl (size); |
1786 memcpy (params->read_buffer + params->handle_len + 8, &num, 4); | 1817 memcpy (params->read_buffer + params->handle_len + 8, &num, 4); |
1787 | 1818 |
1788 if (sshv2_send_command (request, SSH_FXP_READ, params->read_buffer, params->handle_len + 12) < 0) | 1819 if (sshv2_send_command (request, SSH_FXP_READ, params->read_buffer, params->handle_len + 12) < 0) |
1789 return (-2); | 1820 return (GFTP_ERETRYABLE); |
1790 | 1821 |
1791 memset (&message, 0, sizeof (message)); | 1822 memset (&message, 0, sizeof (message)); |
1792 if (sshv2_read_response (request, &message, -1) != SSH_FXP_DATA) | 1823 if ((ret = sshv2_read_response (request, &message, -1)) != SSH_FXP_DATA) |
1793 { | 1824 { |
1825 if (ret < 0) | |
1826 return (ret); | |
1827 | |
1794 message.pos += 4; | 1828 message.pos += 4; |
1795 if ((num = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) | 1829 if ((num = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1796 return (-2); | 1830 return (num); |
1797 sshv2_message_free (&message); | 1831 sshv2_message_free (&message); |
1798 if (num != SSH_FX_EOF) | 1832 if (num != SSH_FX_EOF) |
1799 { | 1833 { |
1800 request->logging_function (gftp_logging_error, request->user_data, | 1834 request->logging_function (gftp_logging_error, request->user_data, |
1801 _("Received wrong response from server, disconnecting\n")); | 1835 _("Received wrong response from server, disconnecting\n")); |
1802 gftp_disconnect (request); | 1836 gftp_disconnect (request); |
1803 return (-2); | 1837 return (GFTP_ERETRYABLE); |
1804 } | 1838 } |
1805 return (0); | 1839 return (0); |
1806 } | 1840 } |
1807 | 1841 |
1808 memcpy (&num, message.buffer + 4, 4); | 1842 memcpy (&num, message.buffer + 4, 4); |
1812 request->logging_function (gftp_logging_error, request->user_data, | 1846 request->logging_function (gftp_logging_error, request->user_data, |
1813 _("Error: Message size %d too big from server\n"), | 1847 _("Error: Message size %d too big from server\n"), |
1814 num); | 1848 num); |
1815 sshv2_message_free (&message); | 1849 sshv2_message_free (&message); |
1816 gftp_disconnect (request); | 1850 gftp_disconnect (request); |
1817 return (-1); | 1851 return (GFTP_ERETRYABLE); |
1818 | 1852 |
1819 } | 1853 } |
1820 | 1854 |
1821 memcpy (buf, message.buffer + 8, num); | 1855 memcpy (buf, message.buffer + 8, num); |
1822 sshv2_message_free (&message); | 1856 sshv2_message_free (&message); |
1838 gint64 offset; | 1872 gint64 offset; |
1839 #else | 1873 #else |
1840 gint32 offset; | 1874 gint32 offset; |
1841 #endif | 1875 #endif |
1842 | 1876 |
1843 g_return_val_if_fail (request != NULL, -2); | 1877 g_return_val_if_fail (request != NULL, GFTP_EFATAL); |
1844 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, -2); | 1878 g_return_val_if_fail (request->protonum == GFTP_SSHV2_NUM, GFTP_EFATAL); |
1845 g_return_val_if_fail (request->sockfd > 0, -2); | 1879 g_return_val_if_fail (request->sockfd > 0, GFTP_EFATAL); |
1846 g_return_val_if_fail (buf != NULL, -2); | 1880 g_return_val_if_fail (buf != NULL, GFTP_EFATAL); |
1847 g_return_val_if_fail (size <= 32500, -2); | 1881 g_return_val_if_fail (size <= 32500, GFTP_EFATAL); |
1848 | 1882 |
1849 params = request->protocol_data; | 1883 params = request->protocol_data; |
1850 | 1884 |
1851 num = htonl (params->handle_len); | 1885 num = htonl (params->handle_len); |
1852 memcpy (tempstr, params->handle, params->handle_len); | 1886 memcpy (tempstr, params->handle, params->handle_len); |
1868 memcpy (tempstr + params->handle_len + 12, buf, size); | 1902 memcpy (tempstr + params->handle_len + 12, buf, size); |
1869 | 1903 |
1870 if (sshv2_send_command (request, SSH_FXP_WRITE, tempstr, params->handle_len + size + 12) < 0) | 1904 if (sshv2_send_command (request, SSH_FXP_WRITE, tempstr, params->handle_len + size + 12) < 0) |
1871 { | 1905 { |
1872 g_free (tempstr); | 1906 g_free (tempstr); |
1873 return (-2); | 1907 return (GFTP_ERETRYABLE); |
1874 } | 1908 } |
1875 | 1909 |
1876 memset (&message, 0, sizeof (message)); | 1910 memset (&message, 0, sizeof (message)); |
1877 params->dont_log_status = 1; | 1911 params->dont_log_status = 1; |
1878 ret = sshv2_read_response (request, &message, -1); | 1912 ret = sshv2_read_response (request, &message, -1); |
1913 if (ret < 0) | |
1914 return (ret); | |
1915 | |
1879 params->dont_log_status = 0; | 1916 params->dont_log_status = 0; |
1880 if (ret != SSH_FXP_STATUS) | 1917 if (ret != SSH_FXP_STATUS) |
1881 { | 1918 { |
1882 request->logging_function (gftp_logging_error, request->user_data, | 1919 request->logging_function (gftp_logging_error, request->user_data, |
1883 _("Received wrong response from server, disconnecting\n")); | 1920 _("Received wrong response from server, disconnecting\n")); |
1884 sshv2_message_free (&message); | 1921 sshv2_message_free (&message); |
1885 gftp_disconnect (request); | 1922 gftp_disconnect (request); |
1886 return (-2); | 1923 return (GFTP_ERETRYABLE); |
1887 } | 1924 } |
1888 | 1925 |
1889 message.pos += 4; | 1926 message.pos += 4; |
1890 if ((num = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) | 1927 if ((num = sshv2_buffer_get_int32 (request, &message, SSH_FX_OK)) < 0) |
1891 return (-2); | 1928 return (GFTP_ERETRYABLE); |
1892 sshv2_message_free (&message); | 1929 sshv2_message_free (&message); |
1893 | 1930 |
1894 if (num == SSH_FX_EOF) | 1931 if (num == SSH_FX_EOF) |
1895 return (0); | 1932 return (0); |
1896 else if (num != SSH_FX_OK) | 1933 else if (num != SSH_FX_OK) |
1897 return (-1); | 1934 return (GFTP_ERETRYABLE); |
1898 | 1935 |
1899 params->offset += size; | 1936 params->offset += size; |
1900 return (size); | 1937 return (size); |
1901 } | 1938 } |
1902 | 1939 |