[BACK]Return to sftp-client.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/sftp-client.c between version 1.44.2.2 and 1.45

version 1.44.2.2, 2004/08/19 22:37:32 version 1.45, 2003/11/21 11:57:03
Line 1 
Line 1 
 /*  /*
  * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>   * Copyright (c) 2001-2003 Damien Miller.  All rights reserved.
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Redistribution and use in source and binary forms, with or without
  * purpose with or without fee is hereby granted, provided that the above   * modification, are permitted provided that the following conditions
  * copyright notice and this permission notice appear in all copies.   * are met:
    * 1. Redistributions of source code must retain the above copyright
    *    notice, this list of conditions and the following disclaimer.
    * 2. Redistributions in binary form must reproduce the above copyright
    *    notice, this list of conditions and the following disclaimer in the
    *    documentation and/or other materials provided with the distribution.
  *   *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN   * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
    * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */   */
   
 /* XXX: memleaks */  /* XXX: memleaks */
Line 36 
Line 44 
 #include "sftp-common.h"  #include "sftp-common.h"
 #include "sftp-client.h"  #include "sftp-client.h"
   
 extern volatile sig_atomic_t interrupted;  
 extern int showprogress;  extern int showprogress;
   
 /* Minimum amount of data to read at at time */  /* Minimum amount of data to read at at time */
Line 331 
Line 338 
                 (*dir)[0] = NULL;                  (*dir)[0] = NULL;
         }          }
   
         for (; !interrupted;) {          for (;;) {
                 int count;                  int count;
   
                 id = expected_id = conn->msg_id++;                  id = expected_id = conn->msg_id++;
Line 408 
Line 415 
         do_close(conn, handle, handle_len);          do_close(conn, handle, handle_len);
         xfree(handle);          xfree(handle);
   
         /* Don't return partial matches on interrupt */  
         if (interrupted && dir != NULL && *dir != NULL) {  
                 free_sftp_dirents(*dir);  
                 *dir = xmalloc(sizeof(**dir));  
                 **dir = NULL;  
         }  
   
         return(0);          return(0);
 }  }
   
Line 651 
Line 651 
   
         buffer_init(&msg);          buffer_init(&msg);
   
         /* Send symlink request */          /* Send rename request */
         id = conn->msg_id++;          id = conn->msg_id++;
         buffer_put_char(&msg, SSH2_FXP_SYMLINK);          buffer_put_char(&msg, SSH2_FXP_SYMLINK);
         buffer_put_int(&msg, id);          buffer_put_int(&msg, id);
Line 813 
Line 813 
         max_req = 1;          max_req = 1;
         progress_counter = 0;          progress_counter = 0;
   
         if (showprogress && size != 0)          if (showprogress) {
                 start_progress_meter(remote_path, size, &progress_counter);                  if (size)
                           start_progress_meter(remote_path, size,
                               &progress_counter);
                   else
                           printf("Fetching %s to %s\n", remote_path, local_path);
           }
   
         while (num_req > 0 || max_req > 0) {          while (num_req > 0 || max_req > 0) {
                 char *data;                  char *data;
                 u_int len;                  u_int len;
   
                 /*  
                  * Simulate EOF on interrupt: stop sending new requests and  
                  * allow outstanding requests to drain gracefully  
                  */  
                 if (interrupted) {  
                         if (num_req == 0) /* If we haven't started yet... */  
                                 break;  
                         max_req = 0;  
                 }  
   
                 /* Send some more requests */                  /* Send some more requests */
                 while (num_req < max_req) {                  while (num_req < max_req) {
                         debug3("Request range %llu -> %llu (%d/%d)",                          debug3("Request range %llu -> %llu (%d/%d)",
Line 917 
Line 912 
                                             (unsigned long long)offset,                                              (unsigned long long)offset,
                                             num_req);                                              num_req);
                                         max_req = 1;                                          max_req = 1;
                                 } else if (max_req <= conn->num_requests) {                                  }
                                   else if (max_req < conn->num_requests + 1) {
                                         ++max_req;                                          ++max_req;
                                 }                                  }
                         }                          }
Line 988 
Line 984 
                 TAILQ_ENTRY(outstanding_ack) tq;                  TAILQ_ENTRY(outstanding_ack) tq;
         };          };
         TAILQ_HEAD(ackhead, outstanding_ack) acks;          TAILQ_HEAD(ackhead, outstanding_ack) acks;
         struct outstanding_ack *ack = NULL;          struct outstanding_ack *ack;
   
         TAILQ_INIT(&acks);          TAILQ_INIT(&acks);
   
Line 1044 
Line 1040 
         offset = 0;          offset = 0;
         if (showprogress)          if (showprogress)
                 start_progress_meter(local_path, sb.st_size, &offset);                  start_progress_meter(local_path, sb.st_size, &offset);
           else
                   printf("Uploading %s to %s\n", local_path, remote_path);
   
         for (;;) {          for (;;) {
                 int len;                  int len;
   
                 /*                  /*
                  * Can't use atomicio here because it returns 0 on EOF,                   * Can't use atomicio here because it returns 0 on EOF, thus losing
                  * thus losing the last block of the file.                   * the last block of the file
                  * Simulate an EOF on interrupt, allowing ACKs from the  
                  * server to drain.  
                  */                   */
                 if (interrupted)                  do
                         len = 0;  
                 else do  
                         len = read(local_fd, data, conn->transfer_buflen);                          len = read(local_fd, data, conn->transfer_buflen);
                 while ((len == -1) && (errno == EINTR || errno == EAGAIN));                  while ((len == -1) && (errno == EINTR || errno == EAGAIN));
   
Legend:
Removed from v.1.44.2.2  
changed lines
  Added in v.1.45