finished 64 bit file offset support. Hopefully rsync can now transfer
[rsync.git] / io.c
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 /*
21   Utilities used in rsync 
22
23   tridge, June 1996
24   */
25 #include "rsync.h"
26
27 static off_t total_written;
28 static off_t total_read;
29
30 extern int verbose;
31 extern int sparse_files;
32
33 off_t write_total(void)
34 {
35   return total_written;
36 }
37
38 off_t read_total(void)
39 {
40   return total_read;
41 }
42
43 static int buffer_f_in = -1;
44
45 void setup_nonblocking(int f_in,int f_out)
46 {
47   set_blocking(f_out,0);
48   buffer_f_in = f_in;
49 }
50
51
52 static char *read_buffer;
53 static char *read_buffer_p;
54 static int read_buffer_len;
55 static int read_buffer_size;
56
57
58 /* This function was added to overcome a deadlock problem when using
59  * ssh.  It looks like we can't allow our receive queue to get full or
60  * ssh will clag up. Uggh.  */
61 static void read_check(int f)
62 {
63   int n;
64
65   if (f == -1) return;
66
67   if (read_buffer_len == 0) {
68     read_buffer_p = read_buffer;
69   }
70
71   if ((n=num_waiting(f)) <= 0)
72     return;
73
74   /* things could deteriorate if we read in really small chunks */
75   if (n < 10) n = 1024;
76
77   if (read_buffer_p != read_buffer) {
78     memmove(read_buffer,read_buffer_p,read_buffer_len);
79     read_buffer_p = read_buffer;
80   }
81
82   if (n > (read_buffer_size - read_buffer_len)) {
83     read_buffer_size += n;
84     if (!read_buffer)
85       read_buffer = (char *)malloc(read_buffer_size);
86     else
87       read_buffer = (char *)realloc(read_buffer,read_buffer_size);
88     if (!read_buffer) out_of_memory("read check");      
89     read_buffer_p = read_buffer;      
90   }
91
92   n = read(f,read_buffer+read_buffer_len,n);
93   if (n > 0) {
94     read_buffer_len += n;
95   }
96 }
97
98
99 static int readfd(int fd,char *buffer,int N)
100 {
101   int  ret;
102   int total=0;  
103
104   if (read_buffer_len < N)
105           read_check(buffer_f_in);
106  
107   while (total < N)
108     {
109       if (read_buffer_len > 0 && buffer_f_in == fd) {
110         ret = MIN(read_buffer_len,N-total);
111         memcpy(buffer+total,read_buffer_p,ret);
112         read_buffer_p += ret;
113         read_buffer_len -= ret;
114       } else {
115         while ((ret = read(fd,buffer + total,N - total)) == -1) {
116           fd_set fds;
117
118           if (errno != EAGAIN && errno != EWOULDBLOCK)
119             return -1;
120           FD_ZERO(&fds);
121           FD_SET(fd, &fds);
122           select(fd+1, &fds, NULL, NULL, NULL);
123         }
124       }
125
126       if (ret <= 0)
127         return total;
128       total += ret;
129     }
130   return total;
131 }
132
133
134 int read_int(int f)
135 {
136   int ret;
137   char b[4];
138   if ((ret=readfd(f,b,4)) != 4) {
139     if (verbose > 1) 
140       fprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
141               getpid(),4,ret==-1?strerror(errno):"EOF");
142     exit_cleanup(1);
143   }
144   total_read += 4;
145   return IVAL(b,0);
146 }
147
148 off_t read_longint(int f)
149 {
150         extern int remote_version;
151         off_t ret;
152         char b[8];
153         ret = read_int(f);
154         if (ret == -1 && remote_version >= 16) {
155                 if (sizeof(off_t) <= 4) {
156                         fprintf(FERROR,"Integer overflow - attempted 64 bit offset\n");
157                         exit_cleanup(1);
158                 }
159                 if ((ret=readfd(f,b,8)) != 8) {
160                         if (verbose > 1) 
161                                 fprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
162                                         getpid(),8,ret==-1?strerror(errno):"EOF");
163                         exit_cleanup(1);
164                 }
165                 total_read += 8;
166                 ret = IVAL(b,0) | (((off_t)IVAL(b,4))<<32);
167         }
168         return ret;
169 }
170
171 void read_buf(int f,char *buf,int len)
172 {
173   int ret;
174   if ((ret=readfd(f,buf,len)) != len) {
175     if (verbose > 1) 
176       fprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
177               getpid(),len,ret==-1?strerror(errno):"EOF");
178     exit_cleanup(1);
179   }
180   total_read += len;
181 }
182
183 unsigned char read_byte(int f)
184 {
185   unsigned char c;
186   read_buf(f,(char *)&c,1);
187   return c;
188 }
189
190
191 static char last_byte;
192 static int last_sparse;
193
194 int sparse_end(int f)
195 {
196   if (last_sparse) {
197     lseek(f,-1,SEEK_CUR);
198     return (write(f,&last_byte,1) == 1 ? 0 : -1);
199   }
200   last_sparse = 0;
201   return 0;
202 }
203
204 int write_sparse(int f,char *buf,int len)
205 {
206   int l1=0,l2=0;
207   int ret;
208
209   if (!sparse_files) 
210     return write(f,buf,len);
211
212   for (l1=0;l1<len && buf[l1]==0;l1++) ;
213   for (l2=0;l2<(len-l1) && buf[len-(l2+1)]==0;l2++) ;
214
215   last_byte = buf[len-1];
216
217   if (l1 == len || l2 > 0)
218     last_sparse=1;
219
220   if (l1 > 0)
221     lseek(f,l1,SEEK_CUR);  
222
223   if (l1 == len) 
224     return len;
225
226   if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) {
227     if (ret == -1 || ret == 0) return ret;
228     return (l1+ret);
229   }
230
231   if (l2 > 0)
232     lseek(f,l2,SEEK_CUR);
233
234   return len;
235 }
236
237
238 static int writefd(int fd,char *buf,int len)
239 {
240   int total = 0;
241   fd_set w_fds, r_fds;
242   int fd_count, count, got_select=0;
243   struct timeval tv;
244
245   if (buffer_f_in == -1) 
246     return write(fd,buf,len);
247
248   while (total < len) {
249     int ret = write(fd,buf+total,len-total);
250
251     if (ret == 0) return total;
252
253     if (ret == -1 && !(errno == EWOULDBLOCK || errno == EAGAIN)) 
254       return -1;
255
256     if (ret == -1 && got_select) {
257             /* hmmm, we got a write select on the fd and then failed to write.
258                Why doesn't that mean that the fd is dead? It doesn't on some
259                systems it seems (eg. IRIX) */
260             u_sleep(1000);
261 #if 0
262             fprintf(FERROR,"write exception\n");
263             exit_cleanup(1);
264 #endif
265     }
266
267     got_select = 0;
268
269
270     if (ret == -1) {
271       read_check(buffer_f_in);
272
273       fd_count = fd+1;
274       FD_ZERO(&w_fds);
275       FD_ZERO(&r_fds);
276       FD_SET(fd,&w_fds);
277       if (buffer_f_in != -1) {
278               FD_SET(buffer_f_in,&r_fds);
279               if (buffer_f_in > fd) 
280                       fd_count = buffer_f_in+1;
281       }
282
283       tv.tv_sec = BLOCKING_TIMEOUT;
284       tv.tv_usec = 0;
285       count = select(fd_count,buffer_f_in == -1? NULL: &r_fds,
286                      &w_fds,NULL,&tv);
287       if (count == -1 && errno != EINTR) {
288               if (verbose > 1) 
289                       fprintf(FERROR,"select error: %s\n", strerror(errno));
290               exit_cleanup(1);
291       }
292
293       if (count == 0) continue;
294       
295       if (FD_ISSET(fd, &w_fds)) {
296               got_select = 1;
297       }
298     } else {
299       total += ret;
300     }
301   }
302
303   return total;
304 }
305
306
307
308 void write_int(int f,int x)
309 {
310   int ret;
311   char b[4];
312   SIVAL(b,0,x);
313   if ((ret=writefd(f,b,4)) != 4) {
314     fprintf(FERROR,"write_int failed : %s\n",
315             ret==-1?strerror(errno):"EOF");
316     exit_cleanup(1);
317   }
318   total_written += 4;
319 }
320
321 void write_longint(int f, off_t x)
322 {
323         extern int remote_version;
324         char b[8];
325         int ret;
326
327         if (remote_version < 16 || x <= 0x7FFFFFFF) {
328                 write_int(f, (int)x);
329                 return;
330         }
331
332         write_int(f, -1);
333         SIVAL(b,0,(x&0xFFFFFFFF));
334         SIVAL(b,4,((x>>32)&0xFFFFFFFF));
335
336         if ((ret=writefd(f,b,8)) != 8) {
337                 fprintf(FERROR,"write_longint failed : %s\n",
338                         ret==-1?strerror(errno):"EOF");
339                 exit_cleanup(1);
340         }
341         total_written += 8;
342 }
343
344 void write_buf(int f,char *buf,int len)
345 {
346   int ret;
347   if ((ret=writefd(f,buf,len)) != len) {
348     fprintf(FERROR,"write_buf failed : %s\n",
349             ret==-1?strerror(errno):"EOF");
350     exit_cleanup(1);
351   }
352   total_written += len;
353 }
354
355
356 void write_byte(int f,unsigned char c)
357 {
358   write_buf(f,(char *)&c,1);
359 }
360
361 void write_flush(int f)
362 {
363 }
364
365