home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 35 Internet / 35-Internet.zip / rsync221.zip / sender.c < prev    next >
C/C++ Source or Header  |  1999-03-04  |  5KB  |  231 lines
  1. /* 
  2.    Copyright (C) Andrew Tridgell 1996
  3.    Copyright (C) Paul Mackerras 1996
  4.    
  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 2 of the License, or
  8.    (at your option) any later version.
  9.    
  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.    GNU General Public License for more details.
  14.    
  15.    You should have received a copy of the GNU General Public License
  16.    along with this program; if not, write to the Free Software
  17.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #include "rsync.h"
  21.  
  22. extern int verbose;
  23. extern int remote_version;
  24. extern int csum_length;
  25. extern struct stats stats;
  26. extern int io_error;
  27. extern int dry_run;
  28. extern int am_server;
  29.  
  30.  
  31. /*
  32.   receive the checksums for a buffer
  33.   */
  34. static struct sum_struct *receive_sums(int f)
  35. {
  36.     struct sum_struct *s;
  37.     int i;
  38.     OFF_T offset = 0;
  39.  
  40.     s = (struct sum_struct *)malloc(sizeof(*s));
  41.     if (!s) out_of_memory("receive_sums");
  42.  
  43.     s->count = read_int(f);
  44.     s->n = read_int(f);
  45.     s->remainder = read_int(f);  
  46.     s->sums = NULL;
  47.  
  48.     if (verbose > 3)
  49.         rprintf(FINFO,"count=%d n=%d rem=%d\n",
  50.             s->count,s->n,s->remainder);
  51.  
  52.     if (s->count == 0) 
  53.         return(s);
  54.  
  55.     s->sums = (struct sum_buf *)malloc(sizeof(s->sums[0])*s->count);
  56.     if (!s->sums) out_of_memory("receive_sums");
  57.  
  58.     for (i=0;i<s->count;i++) {
  59.         s->sums[i].sum1 = read_int(f);
  60.         read_buf(f,s->sums[i].sum2,csum_length);
  61.  
  62.         s->sums[i].offset = offset;
  63.         s->sums[i].i = i;
  64.  
  65.         if (i == s->count-1 && s->remainder != 0) {
  66.             s->sums[i].len = s->remainder;
  67.         } else {
  68.             s->sums[i].len = s->n;
  69.         }
  70.         offset += s->sums[i].len;
  71.  
  72.         if (verbose > 3)
  73.             rprintf(FINFO,"chunk[%d] len=%d offset=%d sum1=%08x\n",
  74.                 i,s->sums[i].len,(int)s->sums[i].offset,s->sums[i].sum1);
  75.     }
  76.  
  77.     s->flength = offset;
  78.  
  79.     return s;
  80. }
  81.  
  82.  
  83.  
  84. void send_files(struct file_list *flist,int f_out,int f_in)
  85. { 
  86.     int fd;
  87.     struct sum_struct *s;
  88.     struct map_struct *buf;
  89.     STRUCT_STAT st;
  90.     char fname[MAXPATHLEN];  
  91.     int i;
  92.     struct file_struct *file;
  93.     int phase = 0;
  94.     extern struct stats stats;        
  95.     struct stats initial_stats;
  96.  
  97.     if (verbose > 2)
  98.         rprintf(FINFO,"send_files starting\n");
  99.  
  100.     setup_readbuffer(f_in);
  101.  
  102.     while (1) {
  103.         int offset=0;
  104.  
  105.         i = read_int(f_in);
  106.         if (i == -1) {
  107.             if (phase==0 && remote_version >= 13) {
  108.                 phase++;
  109.                 csum_length = SUM_LENGTH;
  110.                 write_int(f_out,-1);
  111.                 if (verbose > 2)
  112.                     rprintf(FINFO,"send_files phase=%d\n",phase);
  113.                 continue;
  114.             }
  115.             break;
  116.         }
  117.  
  118.         if (i < 0 || i >= flist->count) {
  119.             rprintf(FERROR,"Invalid file index %d (count=%d)\n", 
  120.                 i, flist->count);
  121.             exit_cleanup(RERR_PROTOCOL);
  122.         }
  123.  
  124.         file = flist->files[i];
  125.  
  126.         stats.num_transferred_files++;
  127.         stats.total_transferred_size += file->length;
  128.  
  129.         fname[0] = 0;
  130.         if (file->basedir) {
  131.             strlcpy(fname,file->basedir,MAXPATHLEN);
  132.             if (strlen(fname) == MAXPATHLEN-1) {
  133.                 io_error = 1;
  134.                 rprintf(FERROR, "send_files failed on long-named directory %s\n",
  135.                     fname);
  136.                 return;
  137.             }
  138.             strlcat(fname,"/",MAXPATHLEN);
  139.             offset = strlen(file->basedir)+1;
  140.         }
  141.         strlcat(fname,f_name(file),MAXPATHLEN);
  142.       
  143.         if (verbose > 2) 
  144.             rprintf(FINFO,"send_files(%d,%s)\n",i,fname);
  145.       
  146.         if (dry_run) {    
  147.             if (!am_server) {
  148.                 log_transfer(file, fname+offset);
  149.             }
  150.             write_int(f_out,i);
  151.             continue;
  152.         }
  153.  
  154.         initial_stats = stats;
  155.  
  156.         s = receive_sums(f_in);
  157.         if (!s) {
  158.             io_error = 1;
  159.             rprintf(FERROR,"receive_sums failed\n");
  160.             return;
  161.         }
  162.       
  163.         fd = open(fname,O_RDONLY);
  164.         if (fd == -1) {
  165.             io_error = 1;
  166.             rprintf(FERROR,"send_files failed to open %s: %s\n",
  167.                 fname,strerror(errno));
  168.             free_sums(s);
  169.             continue;
  170.         }
  171.       
  172.         /* map the local file */
  173.         if (do_fstat(fd,&st) != 0) {
  174.             io_error = 1;
  175.             rprintf(FERROR,"fstat failed : %s\n",strerror(errno));
  176.             free_sums(s);
  177.             close(fd);
  178.             return;
  179.         }
  180.       
  181.         if (st.st_size > 0) {
  182.             buf = map_file(fd,st.st_size);
  183.         } else {
  184.             buf = NULL;
  185.         }
  186.       
  187.         if (verbose > 2)
  188.             rprintf(FINFO,"send_files mapped %s of size %d\n",
  189.                 fname,(int)st.st_size);
  190.  
  191.         write_int(f_out,i);
  192.       
  193.         write_int(f_out,s->count);
  194.         write_int(f_out,s->n);
  195.         write_int(f_out,s->remainder);
  196.       
  197.         if (verbose > 2)
  198.             rprintf(FINFO,"calling match_sums %s\n",fname);
  199.       
  200.         if (!am_server) {
  201.             log_transfer(file, fname+offset);
  202.         }
  203.  
  204.         set_compression(fname);
  205.       
  206.         match_sums(f_out,s,buf,st.st_size);
  207.  
  208.         log_send(file, &initial_stats);
  209.             
  210.         if (buf) unmap_file(buf);
  211.         close(fd);
  212.       
  213.         free_sums(s);
  214.       
  215.         if (verbose > 2)
  216.             rprintf(FINFO,"sender finished %s\n",fname);
  217.     }
  218.  
  219.     if (verbose > 2)
  220.         rprintf(FINFO,"send files finished\n");
  221.  
  222.     match_report();
  223.  
  224.     write_int(f_out,-1);
  225. }
  226.  
  227.  
  228.  
  229.  
  230.  
  231.