54ceb28106ab226ac91e34d9fb8f652e80c7c770
[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 int total_written = 0;
28 static int total_read = 0;
29
30 extern int verbose;
31 extern int sparse_files;
32
33 int write_total(void)
34 {
35   return total_written;
36 }
37
38 int 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 = NULL;
53 static char *read_buffer_p = NULL;
54 static int read_buffer_len = 0;
55 static int read_buffer_size = 0;
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 void read_buf(int f,char *buf,int len)
149 {
150   int ret;
151   if ((ret=readfd(f,buf,len)) != len) {
152     if (verbose > 1) 
153       fprintf(FERROR,"(%d) Error reading %d bytes : %s\n",
154               getpid(),len,ret==-1?strerror(errno):"EOF");
155     exit_cleanup(1);
156   }
157   total_read += len;
158 }
159
160 unsigned char read_byte(int f)
161 {
162   unsigned char c;
163   read_buf(f,(char *)&c,1);
164   return c;
165 }
166
167
168 static char last_byte=0;
169 static int last_sparse = 0;
170
171 int sparse_end(int f)
172 {
173   if (last_sparse) {
174     lseek(f,-1,SEEK_CUR);
175     return (write(f,&last_byte,1) == 1 ? 0 : -1);
176   }
177   last_sparse = 0;
178   return 0;
179 }
180
181 int write_sparse(int f,char *buf,int len)
182 {
183   int l1=0,l2=0;
184   int ret;
185
186   if (!sparse_files) 
187     return write(f,buf,len);
188
189   for (l1=0;l1<len && buf[l1]==0;l1++) ;
190   for (l2=0;l2<(len-l1) && buf[len-(l2+1)]==0;l2++) ;
191
192   last_byte = buf[len-1];
193
194   if (l1 == len || l2 > 0)
195     last_sparse=1;
196
197   if (l1 > 0)
198     lseek(f,l1,SEEK_CUR);  
199
200   if (l1 == len) 
201     return len;
202
203   if ((ret=write(f,buf+l1,len-(l1+l2))) != len-(l1+l2)) {
204     if (ret == -1 || ret == 0) return ret;
205     return (l1+ret);
206   }
207
208   if (l2 > 0)
209     lseek(f,l2,SEEK_CUR);
210
211   return len;
212 }
213
214
215 static int writefd(int fd,char *buf,int len)
216 {
217   int total = 0;
218   fd_set w_fds, r_fds;
219   int fd_count, count, got_select=0;
220   struct timeval tv;
221
222   if (buffer_f_in == -1) 
223     return write(fd,buf,len);
224
225   while (total < len) {
226     int ret = write(fd,buf+total,len-total);
227
228     if (ret == 0) return total;
229
230     if (ret == -1 && !(errno == EWOULDBLOCK || errno == EAGAIN)) 
231       return -1;
232
233     if (ret == -1 && got_select) {
234             /* hmmm, we got a write select on the fd and then failed to write.
235                Why doesn't that mean that the fd is dead? It doesn't on some
236                systems it seems (eg. IRIX) */
237             u_sleep(1000);
238 #if 0
239             fprintf(FERROR,"write exception\n");
240             exit_cleanup(1);
241 #endif
242     }
243
244     got_select = 0;
245
246
247     if (ret == -1) {
248       read_check(buffer_f_in);
249
250       fd_count = fd+1;
251       FD_ZERO(&w_fds);
252       FD_ZERO(&r_fds);
253       FD_SET(fd,&w_fds);
254       if (buffer_f_in != -1) {
255               FD_SET(buffer_f_in,&r_fds);
256               if (buffer_f_in > fd) 
257                       fd_count = buffer_f_in+1;
258       }
259
260       tv.tv_sec = BLOCKING_TIMEOUT;
261       tv.tv_usec = 0;
262       count = select(fd_count,buffer_f_in == -1? NULL: &r_fds,
263                      &w_fds,NULL,&tv);
264       if (count == -1 && errno != EINTR) {
265               if (verbose > 1) 
266                       fprintf(FERROR,"select error: %s\n", strerror(errno));
267               exit_cleanup(1);
268       }
269
270       if (count == 0) continue;
271       
272       if (FD_ISSET(fd, &w_fds)) {
273               got_select = 1;
274       }
275     } else {
276       total += ret;
277     }
278   }
279
280   return total;
281 }
282
283
284
285 void write_int(int f,int x)
286 {
287   int ret;
288   char b[4];
289   SIVAL(b,0,x);
290   if ((ret=writefd(f,b,4)) != 4) {
291     fprintf(FERROR,"write_int failed : %s\n",
292             ret==-1?strerror(errno):"EOF");
293     exit_cleanup(1);
294   }
295   total_written += 4;
296 }
297
298 void write_buf(int f,char *buf,int len)
299 {
300   int ret;
301   if ((ret=writefd(f,buf,len)) != len) {
302     fprintf(FERROR,"write_buf failed : %s\n",
303             ret==-1?strerror(errno):"EOF");
304     exit_cleanup(1);
305   }
306   total_written += len;
307 }
308
309
310 void write_byte(int f,unsigned char c)
311 {
312   write_buf(f,(char *)&c,1);
313 }
314
315 void write_flush(int f)
316 {
317 }
318
319