- Updated the address for the FSF in the opening comment.
[rsync.git] / backup.c
1 /*
2  * Backup handling code.
3  *
4  * Copyright (C) 1999 Andrew Tridgell
5  * Copyright (C) 2003, 2004, 2005, 2006 Wayne Davison
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include "rsync.h"
23
24 extern int verbose;
25 extern int backup_dir_len;
26 extern unsigned int backup_dir_remainder;
27 extern char backup_dir_buf[MAXPATHLEN];
28 extern char *backup_suffix;
29 extern char *backup_dir;
30
31 extern int am_root;
32 extern int preserve_devices;
33 extern int preserve_specials;
34 extern int preserve_links;
35 extern int safe_symlinks;
36
37 /* make a complete pathname for backup file */
38 char *get_backup_name(char *fname)
39 {
40         if (backup_dir) {
41                 if (stringjoin(backup_dir_buf + backup_dir_len, backup_dir_remainder,
42                                fname, backup_suffix, NULL) < backup_dir_remainder)
43                         return backup_dir_buf;
44         } else {
45                 if (stringjoin(backup_dir_buf, MAXPATHLEN,
46                                fname, backup_suffix, NULL) < MAXPATHLEN)
47                         return backup_dir_buf;
48         }
49
50         rprintf(FERROR, "backup filename too long\n");
51         return NULL;
52 }
53
54 /* simple backup creates a backup with a suffix in the same directory */
55 static int make_simple_backup(char *fname)
56 {
57         int rename_errno;
58         char *fnamebak = get_backup_name(fname);
59
60         if (!fnamebak)
61                 return 0;
62
63         while (1) {
64                 if (do_rename(fname, fnamebak) == 0) {
65                         if (verbose > 1) {
66                                 rprintf(FINFO, "backed up %s to %s\n",
67                                         fname, fnamebak);
68                         }
69                         break;
70                 }
71                 /* cygwin (at least version b19) reports EINVAL */
72                 if (errno == ENOENT || errno == EINVAL)
73                         break;
74
75                 rename_errno = errno;
76                 if (errno == EISDIR && do_rmdir(fnamebak) == 0)
77                         continue;
78                 if (errno == ENOTDIR && do_unlink(fnamebak) == 0)
79                         continue;
80
81                 rsyserr(FERROR, rename_errno, "rename %s to backup %s",
82                         fname, fnamebak);
83                 errno = rename_errno;
84                 return 0;
85         }
86
87         return 1;
88 }
89
90
91 /****************************************************************************
92 Create a directory given an absolute path, perms based upon another directory
93 path
94 ****************************************************************************/
95 static int make_bak_dir(char *fullpath)
96 {
97         STRUCT_STAT st;
98         char *rel = fullpath + backup_dir_len;
99         char *end = rel + strlen(rel);
100         char *p = end;
101
102         while (strncmp(fullpath, "./", 2) == 0)
103                 fullpath += 2;
104
105         /* Try to find an existing dir, starting from the deepest dir. */
106         while (1) {
107                 if (--p == fullpath) {
108                         p += strlen(p);
109                         goto failure;
110                 }
111                 if (*p == '/') {
112                         *p = '\0';
113                         if (mkdir_defmode(fullpath) == 0)
114                                 break;
115                         if (errno != ENOENT) {
116                                 rsyserr(FERROR, errno,
117                                         "make_bak_dir mkdir %s failed",
118                                         full_fname(fullpath));
119                                 goto failure;
120                         }
121                 }
122         }
123
124         /* Make all the dirs that we didn't find on the way here. */
125         while (1) {
126                 if (p >= rel) {
127                         /* Try to transfer the directory settings of the
128                          * actual dir that the files are coming from. */
129                         if (do_stat(rel, &st) < 0) {
130                                 rsyserr(FERROR, errno,
131                                         "make_bak_dir stat %s failed",
132                                         full_fname(rel));
133                         } else {
134                                 do_lchown(fullpath, st.st_uid, st.st_gid);
135                                 do_chmod(fullpath, st.st_mode);
136                         }
137                 }
138                 *p = '/';
139                 p += strlen(p);
140                 if (p == end)
141                         break;
142                 if (mkdir_defmode(fullpath) < 0) {
143                         rsyserr(FERROR, errno, "make_bak_dir mkdir %s failed",
144                                 full_fname(fullpath));
145                         goto failure;
146                 }
147         }
148         return 0;
149
150   failure:
151         while (p != end) {
152                 *p = '/';
153                 p += strlen(p);
154         }
155         return -1;
156 }
157
158 /* robustly move a file, creating new directory structures if necessary */
159 static int robust_move(char *src, char *dst)
160 {
161         if (robust_rename(src, dst, NULL, 0755) < 0
162          && (errno != ENOENT || make_bak_dir(dst) < 0
163           || robust_rename(src, dst, NULL, 0755) < 0))
164                 return -1;
165         return 0;
166 }
167
168
169 /* If we have a --backup-dir, then we get here from make_backup().
170  * We will move the file to be deleted into a parallel directory tree. */
171 static int keep_backup(char *fname)
172 {
173         STRUCT_STAT st;
174         struct file_struct *file;
175         char *buf;
176         int kept = 0;
177         int ret_code;
178
179         /* return if no file to keep */
180         if (do_lstat(fname, &st) < 0)
181                 return 1;
182
183         if (!(file = make_file(fname, NULL, NULL, 0, NO_FILTERS)))
184                 return 1; /* the file could have disappeared */
185
186         if (!(buf = get_backup_name(fname)))
187                 return 0;
188
189         /* Check to see if this is a device file, or link */
190         if ((am_root && preserve_devices && IS_DEVICE(file->mode))
191          || (preserve_specials && IS_SPECIAL(file->mode))) {
192                 do_unlink(buf);
193                 if (do_mknod(buf, file->mode, file->u.rdev) < 0
194                     && (errno != ENOENT || make_bak_dir(buf) < 0
195                      || do_mknod(buf, file->mode, file->u.rdev) < 0)) {
196                         rsyserr(FERROR, errno, "mknod %s failed",
197                                 full_fname(buf));
198                 } else if (verbose > 2) {
199                         rprintf(FINFO, "make_backup: DEVICE %s successful.\n",
200                                 fname);
201                 }
202                 kept = 1;
203                 do_unlink(fname);
204         }
205
206         if (!kept && S_ISDIR(file->mode)) {
207                 /* make an empty directory */
208                 if (do_mkdir(buf, file->mode) < 0
209                     && (errno != ENOENT || make_bak_dir(buf) < 0
210                      || do_mkdir(buf, file->mode) < 0)) {
211                         rsyserr(FINFO, errno, "mkdir %s failed",
212                                 full_fname(buf));
213                 }
214
215                 ret_code = do_rmdir(fname);
216                 if (verbose > 2) {
217                         rprintf(FINFO, "make_backup: RMDIR %s returns %i\n",
218                                 full_fname(fname), ret_code);
219                 }
220                 kept = 1;
221         }
222
223 #ifdef SUPPORT_LINKS
224         if (!kept && preserve_links && S_ISLNK(file->mode)) {
225                 if (safe_symlinks && unsafe_symlink(file->u.link, buf)) {
226                         if (verbose) {
227                                 rprintf(FINFO, "ignoring unsafe symlink %s -> %s\n",
228                                         full_fname(buf), file->u.link);
229                         }
230                         kept = 1;
231                 } else {
232                         do_unlink(buf);
233                         if (do_symlink(file->u.link, buf) < 0
234                             && (errno != ENOENT || make_bak_dir(buf) < 0
235                              || do_symlink(file->u.link, buf) < 0)) {
236                                 rsyserr(FERROR, errno, "link %s -> \"%s\"",
237                                         full_fname(buf),
238                                         file->u.link);
239                         }
240                         do_unlink(fname);
241                         kept = 1;
242                 }
243         }
244 #endif
245
246         if (!kept && !S_ISREG(file->mode)) {
247                 rprintf(FINFO, "make_bak: skipping non-regular file %s\n",
248                         fname);
249                 return 1;
250         }
251
252         /* move to keep tree if a file */
253         if (!kept) {
254                 if (robust_move(fname, buf) != 0) {
255                         rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"",
256                                 full_fname(fname), buf);
257                 } else if (st.st_nlink > 1) {
258                         /* If someone has hard-linked the file into the backup
259                          * dir, rename() might return success but do nothing! */
260                         robust_unlink(fname); /* Just in case... */
261                 }
262         }
263         set_file_attrs(buf, file, NULL, 0);
264         free(file);
265
266         if (verbose > 1) {
267                 rprintf(FINFO, "backed up %s to %s\n",
268                         fname, buf);
269         }
270         return 1;
271 }
272
273
274 /* main backup switch routine */
275 int make_backup(char *fname)
276 {
277         if (backup_dir)
278                 return keep_backup(fname);
279         return make_simple_backup(fname);
280 }