- Changed the calling args to delete_file() to take an st_mode instead
[rsync.git] / rsync.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 /* this file contains code used by more than one part of the rsync
21    process */
22
23 #include "rsync.h"
24
25 extern int verbose;
26 extern int dry_run;
27 extern int itemize_changes;
28 extern int preserve_times;
29 extern int omit_dir_times;
30 extern int am_root;
31 extern int am_server;
32 extern int am_sender;
33 extern int am_generator;
34 extern int preserve_uid;
35 extern int preserve_gid;
36 extern int force_delete;
37 extern int inplace;
38 extern int recurse;
39 extern int keep_dirlinks;
40 extern int make_backups;
41 extern struct stats stats;
42 extern char *backup_dir;
43 extern char *log_format;
44
45
46 /*
47   free a sums struct
48   */
49 void free_sums(struct sum_struct *s)
50 {
51         if (s->sums) free(s->sums);
52         free(s);
53 }
54
55
56 /*
57  * delete a file or directory. If force_delete is set then delete
58  * recursively
59  */
60 int delete_file(char *fname, int mode, int flags)
61 {
62         DIR *d;
63         struct dirent *di;
64         char buf[MAXPATHLEN];
65         STRUCT_STAT st;
66         int zap_dir;
67
68         if (!S_ISDIR(mode)) {
69                 if (robust_unlink(fname) == 0) {
70                         if ((verbose || log_format) && !(flags & DEL_TERSE))
71                                 log_delete(fname, mode);
72                         return 0;
73                 }
74                 if (errno == ENOENT)
75                         return 0;
76                 rsyserr(FERROR, errno, "delete_file: unlink %s failed",
77                         full_fname(fname));
78                 return -1;
79         }
80
81         zap_dir = (flags & DEL_FORCE_RECURSE || (force_delete && recurse))
82                 && !(flags & DEL_NO_RECURSE);
83         if (dry_run && zap_dir)
84                 errno = ENOTEMPTY;
85         else if (do_rmdir(fname) == 0) {
86                 if ((verbose || log_format) && !(flags & DEL_TERSE))
87                         log_delete(fname, mode);
88                 return 0;
89         }
90         if (errno == ENOENT)
91                 return 0;
92         if (!zap_dir || (errno != ENOTEMPTY && errno != EEXIST)) {
93                 rsyserr(FERROR, errno, "delete_file: rmdir %s failed",
94                         full_fname(fname));
95                 return -1;
96         }
97
98         /* now we do a recsursive delete on the directory ... */
99         if (!(d = opendir(fname))) {
100                 rsyserr(FERROR, errno, "delete_file: opendir %s failed",
101                         full_fname(fname));
102                 return -1;
103         }
104
105         if (!(flags & DEL_TERSE)) {
106                 if (verbose || log_format)
107                         log_delete(fname, mode);
108                 flags |= DEL_TERSE;
109         }
110
111         for (errno = 0, di = readdir(d); di; errno = 0, di = readdir(d)) {
112                 char *dname = d_name(di);
113                 if (dname[0] == '.' && (dname[1] == '\0'
114                     || (dname[1] == '.' && dname[2] == '\0')))
115                         continue;
116                 pathjoin(buf, sizeof buf, fname, dname);
117
118                 if (do_lstat(buf, &st) < 0)
119                         continue;
120                 if (verbose || log_format)
121                         log_delete(buf, st.st_mode);
122                 if (delete_file(buf, st.st_mode, flags) != 0) {
123                         closedir(d);
124                         return -1;
125                 }
126         }
127         if (errno) {
128                 rsyserr(FERROR, errno, "delete_file: readdir %s failed",
129                         full_fname(fname));
130                 closedir(d);
131                 return -1;
132         }
133
134         closedir(d);
135
136         if (do_rmdir(fname) != 0 && errno != ENOENT) {
137                 rsyserr(FERROR, errno, "delete_file: rmdir %s failed",
138                         full_fname(fname));
139                 return -1;
140         }
141
142         return 0;
143 }
144
145 int set_perms(char *fname,struct file_struct *file,STRUCT_STAT *st,
146               int flags)
147 {
148         int updated = 0;
149         STRUCT_STAT st2;
150         int change_uid, change_gid;
151
152         if (!st) {
153                 if (dry_run)
154                         return 1;
155                 if (link_stat(fname, &st2, 0) < 0) {
156                         rsyserr(FERROR, errno, "stat %s failed",
157                                 full_fname(fname));
158                         return 0;
159                 }
160                 st = &st2;
161         }
162
163         if (!preserve_times || S_ISLNK(st->st_mode)
164          || (S_ISDIR(st->st_mode)
165           && (omit_dir_times || (make_backups && !backup_dir))))
166                 flags |= PERMS_SKIP_MTIME;
167         if (!(flags & PERMS_SKIP_MTIME)
168             && cmp_modtime(st->st_mtime, file->modtime) != 0) {
169                 if (set_modtime(fname,file->modtime) != 0) {
170                         rsyserr(FERROR, errno, "failed to set times on %s",
171                                 full_fname(fname));
172                         return 0;
173                 }
174                 updated = 1;
175         }
176
177         change_uid = am_root && preserve_uid && st->st_uid != file->uid;
178         change_gid = preserve_gid && file->gid != GID_NONE
179                 && st->st_gid != file->gid;
180 #if !defined HAVE_LCHOWN && !defined CHOWN_MODIFIES_SYMLINK
181         if (S_ISLNK(st->st_mode))
182                 ;
183         else
184 #endif
185         if (change_uid || change_gid) {
186                 if (verbose > 2) {
187                         if (change_uid) {
188                                 rprintf(FINFO,
189                                         "set uid of %s from %ld to %ld\n",
190                                         safe_fname(fname),
191                                         (long)st->st_uid, (long)file->uid);
192                         }
193                         if (change_gid) {
194                                 rprintf(FINFO,
195                                         "set gid of %s from %ld to %ld\n",
196                                         safe_fname(fname),
197                                         (long)st->st_gid, (long)file->gid);
198                         }
199                 }
200                 if (do_lchown(fname,
201                     change_uid ? file->uid : st->st_uid,
202                     change_gid ? file->gid : st->st_gid) != 0) {
203                         /* shouldn't have attempted to change uid or gid
204                          * unless have the privilege */
205                         rsyserr(FERROR, errno, "%s %s failed",
206                             change_uid ? "chown" : "chgrp",
207                             full_fname(fname));
208                         return 0;
209                 }
210                 /* a lchown had been done - we have to re-stat if the
211                  * destination had the setuid or setgid bits set due
212                  * to the side effect of the chown call */
213                 if (st->st_mode & (S_ISUID | S_ISGID)) {
214                         link_stat(fname, st,
215                                   keep_dirlinks && S_ISDIR(st->st_mode));
216                 }
217                 updated = 1;
218         }
219
220 #ifdef HAVE_CHMOD
221         if (!S_ISLNK(st->st_mode)) {
222                 if ((st->st_mode & CHMOD_BITS) != (file->mode & CHMOD_BITS)) {
223                         updated = 1;
224                         if (do_chmod(fname,(file->mode & CHMOD_BITS)) != 0) {
225                                 rsyserr(FERROR, errno, "failed to set permissions on %s",
226                                         full_fname(fname));
227                                 return 0;
228                         }
229                 }
230         }
231 #endif
232
233         if (verbose > 1 && flags & PERMS_REPORT) {
234                 if (updated)
235                         rprintf(FINFO, "%s\n", safe_fname(fname));
236                 else
237                         rprintf(FINFO, "%s is uptodate\n", safe_fname(fname));
238         }
239         return updated;
240 }
241
242
243 void sig_int(void)
244 {
245         /* KLUGE: if the user hits Ctrl-C while ssh is prompting
246          * for a password, then our cleanup's sending of a SIGUSR1
247          * signal to all our children may kill ssh before it has a
248          * chance to restore the tty settings (i.e. turn echo back
249          * on).  By sleeping for a short time, ssh gets a bigger
250          * chance to do the right thing.  If child processes are
251          * not ssh waiting for a password, then this tiny delay
252          * shouldn't hurt anything. */
253         msleep(400);
254         exit_cleanup(RERR_SIGNAL);
255 }
256
257
258 /* finish off a file transfer, renaming the file and setting the permissions
259    and ownership */
260 void finish_transfer(char *fname, char *fnametmp, struct file_struct *file,
261                      int ok_to_set_time, int overwriting_basis)
262 {
263         int ret;
264
265         if (inplace) {
266                 if (verbose > 2)
267                         rprintf(FINFO, "finishing %s\n", safe_fname(fname));
268                 goto do_set_perms;
269         }
270
271         if (make_backups && overwriting_basis && !make_backup(fname))
272                 return;
273
274         /* Change permissions before putting the file into place. */
275         set_perms(fnametmp, file, NULL, ok_to_set_time ? 0 : PERMS_SKIP_MTIME);
276
277         /* move tmp file over real file */
278         if (verbose > 2) {
279                 rprintf(FINFO, "renaming %s to %s\n",
280                         safe_fname(fnametmp), safe_fname(fname));
281         }
282         ret = robust_rename(fnametmp, fname, file->mode & INITACCESSPERMS);
283         if (ret < 0) {
284                 rsyserr(FERROR, errno, "%s %s -> \"%s\"",
285                     ret == -2 ? "copy" : "rename",
286                     full_fname(fnametmp), safe_fname(fname));
287                 do_unlink(fnametmp);
288                 return;
289         }
290         if (ret == 0) {
291                 /* The file was moved into place (not copied), so it's done. */
292                 return;
293         }
294     do_set_perms:
295         set_perms(fname, file, NULL, ok_to_set_time ? 0 : PERMS_SKIP_MTIME);
296 }
297
298 const char *who_am_i(void)
299 {
300         if (am_sender < 0)
301                 return am_server ? "server" : "client";
302         return am_sender ? "sender" : am_generator ? "generator" : "receiver";
303 }