added "created dir" message
[rsync.git] / util.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
32 int write_total(void)
33 {
34   return total_written;
35 }
36
37 int read_total(void)
38 {
39   return total_read;
40 }
41
42 void write_int(int f,int x)
43 {
44   char b[4];
45   SIVAL(b,0,x);
46   if (write(f,b,4) != 4) {
47     fprintf(stderr,"write_int failed : %s\n",strerror(errno));
48     exit(1);
49   }
50   total_written += 4;
51 }
52
53 void write_buf(int f,char *buf,int len)
54 {
55   if (write(f,buf,len) != len) {
56     fprintf(stderr,"write_buf failed : %s\n",strerror(errno));
57     exit(1);
58   }
59   total_written += len;
60 }
61
62 static int num_waiting(int fd)
63 {
64   int len=0;
65 #ifdef FIONREAD
66   ioctl(fd,FIONREAD,&len);
67 #endif
68   return(len);
69 }
70
71 static char *read_buffer = NULL;
72 static char *read_buffer_p = NULL;
73 static int read_buffer_len = 0;
74 static int read_buffer_size = 0;
75
76
77 void write_flush(int f)
78 {
79 }
80
81 void read_check(int f)
82 {
83   int n;
84
85   if (read_buffer_len == 0) {
86     read_buffer_p = read_buffer;
87   }
88
89   if ((n=num_waiting(f)) <= 0)
90     return;
91
92   if (read_buffer_p != read_buffer) {
93     memmove(read_buffer,read_buffer_p,read_buffer_len);
94     read_buffer_p = read_buffer;
95   }
96
97   if (n > (read_buffer_size - read_buffer_len)) {
98     read_buffer_size += n;
99     if (!read_buffer)
100       read_buffer = (char *)malloc(read_buffer_size);
101     else
102       read_buffer = (char *)realloc(read_buffer,read_buffer_size);
103     if (!read_buffer) out_of_memory("read check");      
104     read_buffer_p = read_buffer;      
105   }
106
107   n = read(f,read_buffer+read_buffer_len,n);
108   if (n > 0) {
109     read_buffer_len += n;
110   }
111 }
112
113
114 static int readfd(int fd,char *buffer,int N)
115 {
116   int  ret;
117   int total=0;  
118  
119   while (total < N)
120     {
121       if (read_buffer_len > 0) {
122         ret = MIN(read_buffer_len,N-total);
123         memcpy(buffer+total,read_buffer_p,ret);
124         read_buffer_p += ret;
125         read_buffer_len -= ret;
126       } else {
127         ret = read(fd,buffer + total,N - total);
128       }
129
130       if (ret <= 0)
131         return total;
132       total += ret;
133     }
134   return total;
135 }
136
137
138 int read_int(int f)
139 {
140   char b[4];
141   if (readfd(f,b,4) != 4) {
142     if (verbose > 1) 
143       fprintf(stderr,"Error reading %d bytes : %s\n",4,strerror(errno));
144     exit(1);
145   }
146   total_read += 4;
147   return IVAL(b,0);
148 }
149
150 void read_buf(int f,char *buf,int len)
151 {
152   if (readfd(f,buf,len) != len) {
153     if (verbose > 1) 
154       fprintf(stderr,"Error reading %d bytes : %s\n",len,strerror(errno));
155     exit(1);
156   }
157   total_read += len;
158 }
159
160
161 char *map_file(int fd,off_t len)
162 {
163   char *ret = (char *)mmap(NULL,len,PROT_READ,MAP_SHARED,fd,0);
164   return ret;
165 }
166
167 void unmap_file(char *buf,off_t len)
168 {
169   if (len > 0 && buf)
170     munmap(buf,len);
171 }
172
173
174 int read_write(int fd_in,int fd_out,int size)
175 {
176   static char *buf=NULL;
177   static int bufsize = WRITE_BLOCK_SIZE;
178   int total=0;
179   
180   if (!buf) {
181     buf = (char *)malloc(bufsize);
182     if (!buf) out_of_memory("read_write");
183   }
184
185   while (total < size) {
186     int n = MIN(size-total,bufsize);
187     read_buf(fd_in,buf,n);
188     if (write(fd_out,buf,n) != n)
189       return total;
190     total += n;
191   }
192   return total;
193 }
194
195
196 /* this is taken from CVS */
197 int piped_child(char **command,int *f_in,int *f_out)
198 {
199   int pid;
200   int to_child_pipe[2];
201   int from_child_pipe[2];
202
203   if (pipe(to_child_pipe) < 0 ||
204       pipe(from_child_pipe) < 0) {
205     fprintf(stderr,"pipe: %s\n",strerror(errno));
206     exit(1);
207   }
208
209
210   pid = fork();
211   if (pid < 0) {
212     fprintf(stderr,"fork: %s\n",strerror(errno));
213     exit(1);
214   }
215
216   if (pid == 0)
217     {
218       if (dup2(to_child_pipe[0], STDIN_FILENO) < 0 ||
219           close(to_child_pipe[1]) < 0 ||
220           close(from_child_pipe[0]) < 0 ||
221           dup2(from_child_pipe[1], STDOUT_FILENO) < 0) {
222         fprintf(stderr,"Failed to dup/close : %s\n",strerror(errno));
223         exit(1);
224       }
225       execvp(command[0], command);
226       fprintf(stderr,"Failed to exec %s : %s\n",
227               command[0],strerror(errno));
228       exit(1);
229     }
230
231   if (close(from_child_pipe[1]) < 0 ||
232       close(to_child_pipe[0]) < 0) {
233     fprintf(stderr,"Failed to close : %s\n",strerror(errno));   
234     exit(1);
235   }
236
237   *f_in = from_child_pipe[0];
238   *f_out = to_child_pipe[1];
239   
240   return pid;
241 }
242
243
244 void out_of_memory(char *str)
245 {
246   fprintf(stderr,"out of memory in %s\n",str);
247   exit(1);
248 }
249
250
251 #ifndef HAVE_STRDUP
252  char *strdup(char *s)
253 {
254   int l = strlen(s) + 1;
255   char *ret = (char *)malloc(l);
256   if (ret)
257     strcpy(ret,s);
258   return ret;
259 }
260 #endif
261
262
263 int set_modtime(char *fname,time_t modtime)
264 {
265 #ifdef HAVE_UTIME_H
266   struct utimbuf tbuf;  
267   tbuf.actime = time(NULL);
268   tbuf.modtime = modtime;
269   return utime(fname,&tbuf);
270 #elif defined(HAVE_UTIME)
271   time_t t[2];
272   t[0] = time(NULL);
273   t[1] = modtime;
274   return utime(fname,t);
275 #else
276   struct timeval t[2];
277   t[0].tv_sec = time(NULL);
278   t[0].tv_usec = 0;
279   t[1].tv_sec = modtime;
280   t[1].tv_usec = 0;
281   return utimes(fname,t);
282 #endif
283 }
284