diff options
Diffstat (limited to '')
| -rw-r--r-- | backup.c | 355 |
1 files changed, 355 insertions, 0 deletions
diff --git a/backup.c b/backup.c new file mode 100644 index 0000000..686cb29 --- /dev/null +++ b/backup.c @@ -0,0 +1,355 @@ +/* + * Backup handling code. + * + * Copyright (C) 1999 Andrew Tridgell + * Copyright (C) 2003-2022 Wayne Davison + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, visit the http://fsf.org website. + */ + +#include "rsync.h" +#include "ifuncs.h" + +extern int am_root; +extern int preserve_acls; +extern int preserve_xattrs; +extern int preserve_devices; +extern int preserve_specials; +extern int preserve_links; +extern int safe_symlinks; +extern int backup_dir_len; +extern unsigned int backup_dir_remainder; +extern char backup_dir_buf[MAXPATHLEN]; +extern char *backup_suffix; +extern char *backup_dir; + +/* Returns -1 on error, 0 on missing dir, and 1 on present dir. */ +static int validate_backup_dir(void) +{ + STRUCT_STAT st; + + if (do_lstat(backup_dir_buf, &st) < 0) { + if (errno == ENOENT) + return 0; + rsyserr(FERROR, errno, "backup lstat %s failed", backup_dir_buf); + return -1; + } + if (!S_ISDIR(st.st_mode)) { + int flags = get_del_for_flag(st.st_mode) | DEL_FOR_BACKUP | DEL_RECURSE; + if (delete_item(backup_dir_buf, st.st_mode, flags) == 0) + return 0; + return -1; + } + return 1; +} + +/* Create a backup path from the given fname, putting the result into + * backup_dir_buf. Any new directories (compared to the prior backup + * path) are ensured to exist as directories, replacing anything else + * that may be in the way (e.g. a symlink). */ +static BOOL copy_valid_path(const char *fname) +{ + const char *f; + int val; + BOOL ret = True; + stat_x sx; + char *b, *rel = backup_dir_buf + backup_dir_len, *name = rel; + + for (f = fname, b = rel; *f && *f == *b; f++, b++) { + if (*b == '/') + name = b + 1; + } + + if (stringjoin(rel, backup_dir_remainder, fname, backup_suffix, NULL) >= backup_dir_remainder) { + rprintf(FERROR, "backup filename too long\n"); + *name = '\0'; + return False; + } + + for ( ; ; name = b + 1) { + if ((b = strchr(name, '/')) == NULL) + return True; + *b = '\0'; + + val = validate_backup_dir(); + if (val == 0) + break; + if (val < 0) { + *name = '\0'; + return False; + } + + *b = '/'; + } + + init_stat_x(&sx); + + for ( ; b; name = b + 1, b = strchr(name, '/')) { + *b = '\0'; + + while (do_mkdir(backup_dir_buf, ACCESSPERMS) < 0) { + if (errno == EEXIST) { + val = validate_backup_dir(); + if (val > 0) + break; + if (val == 0) + continue; + } else + rsyserr(FERROR, errno, "backup mkdir %s failed", backup_dir_buf); + *name = '\0'; + ret = False; + goto cleanup; + } + + /* Try to transfer the directory settings of the actual dir + * that the files are coming from. */ + if (x_stat(rel, &sx.st, NULL) < 0) + rsyserr(FERROR, errno, "backup stat %s failed", full_fname(rel)); + else { + struct file_struct *file; + if (!(file = make_file(rel, NULL, NULL, 0, NO_FILTERS))) + continue; +#ifdef SUPPORT_ACLS + if (preserve_acls && !S_ISLNK(file->mode)) { + get_acl(rel, &sx); + cache_tmp_acl(file, &sx); + free_acl(&sx); + } +#endif +#ifdef SUPPORT_XATTRS + if (preserve_xattrs) { + get_xattr(rel, &sx); + cache_tmp_xattr(file, &sx); + free_xattr(&sx); + } +#endif + set_file_attrs(backup_dir_buf, file, NULL, NULL, 0); + unmake_file(file); + } + + *b = '/'; + } + + cleanup: + +#ifdef SUPPORT_ACLS + uncache_tmp_acls(); +#endif +#ifdef SUPPORT_XATTRS + uncache_tmp_xattrs(); +#endif + + return ret; +} + +/* Make a complete pathname for backup file and verify any new path elements. */ +char *get_backup_name(const char *fname) +{ + if (backup_dir) { + static int initialized = 0; + if (!initialized) { + int ret; + if (backup_dir_len > 1) + backup_dir_buf[backup_dir_len-1] = '\0'; + ret = make_path(backup_dir_buf, 0); + if (backup_dir_len > 1) + backup_dir_buf[backup_dir_len-1] = '/'; + if (ret < 0) + return NULL; + initialized = 1; + } + /* copy fname into backup_dir_buf while validating the dirs. */ + if (copy_valid_path(fname)) + return backup_dir_buf; + /* copy_valid_path() has printed an error message. */ + return NULL; + } + + if (stringjoin(backup_dir_buf, MAXPATHLEN, fname, backup_suffix, NULL) < MAXPATHLEN) + return backup_dir_buf; + + rprintf(FERROR, "backup filename too long\n"); + return NULL; +} + +/* Has same return codes as make_backup(). */ +static inline int link_or_rename(const char *from, const char *to, + BOOL prefer_rename, STRUCT_STAT *stp) +{ +#ifdef SUPPORT_HARD_LINKS + if (!prefer_rename) { +#ifndef CAN_HARDLINK_SYMLINK + if (S_ISLNK(stp->st_mode)) + return 0; /* Use copy code. */ +#endif +#ifndef CAN_HARDLINK_SPECIAL + if (IS_SPECIAL(stp->st_mode) || IS_DEVICE(stp->st_mode)) + return 0; /* Use copy code. */ +#endif + if (do_link(from, to) == 0) { + if (DEBUG_GTE(BACKUP, 1)) + rprintf(FINFO, "make_backup: HLINK %s successful.\n", from); + return 2; + } + /* We prefer to rename a regular file rather than copy it. */ + if (!S_ISREG(stp->st_mode) || errno == EEXIST || errno == EISDIR) + return 0; + } +#endif + if (do_rename(from, to) == 0) { + if (stp->st_nlink > 1 && !S_ISDIR(stp->st_mode)) { + /* If someone has hard-linked the file into the backup + * dir, rename() might return success but do nothing! */ + robust_unlink(from); /* Just in case... */ + } + if (DEBUG_GTE(BACKUP, 1)) + rprintf(FINFO, "make_backup: RENAME %s successful.\n", from); + return 1; + } + return 0; +} + +/* Hard-link, rename, or copy an item to the backup name. Returns 0 for + * failure, 1 if item was moved, 2 if item was duplicated or hard linked + * into backup area, or 3 if item doesn't exist or isn't a regular file. */ +int make_backup(const char *fname, BOOL prefer_rename) +{ + stat_x sx; + struct file_struct *file; + int save_preserve_xattrs; + char *buf; + int ret = 0; + + init_stat_x(&sx); + /* Return success if no file to keep. */ + if (x_lstat(fname, &sx.st, NULL) < 0) + return 3; + + if (!(buf = get_backup_name(fname))) + return 0; + + /* Try a hard-link or a rename first. Using rename is not atomic, but + * is more efficient than forcing a copy for larger files when no hard- + * linking is possible. */ + if ((ret = link_or_rename(fname, buf, prefer_rename, &sx.st)) != 0) + goto success; + if (errno == EEXIST || errno == EISDIR) { + STRUCT_STAT bakst; + if (do_lstat(buf, &bakst) == 0) { + int flags = get_del_for_flag(bakst.st_mode) | DEL_FOR_BACKUP | DEL_RECURSE; + if (delete_item(buf, bakst.st_mode, flags) != 0) + return 0; + } + if ((ret = link_or_rename(fname, buf, prefer_rename, &sx.st)) != 0) + goto success; + } + + /* Fall back to making a copy. */ + if (!(file = make_file(fname, NULL, &sx.st, 0, NO_FILTERS))) + return 3; /* the file could have disappeared */ + +#ifdef SUPPORT_ACLS + if (preserve_acls && !S_ISLNK(file->mode)) { + get_acl(fname, &sx); + cache_tmp_acl(file, &sx); + free_acl(&sx); + } +#endif +#ifdef SUPPORT_XATTRS + if (preserve_xattrs) { + get_xattr(fname, &sx); + cache_tmp_xattr(file, &sx); + free_xattr(&sx); + } +#endif + + /* Check to see if this is a device file, or link */ + if ((am_root && preserve_devices && IS_DEVICE(file->mode)) + || (preserve_specials && IS_SPECIAL(file->mode))) { + if (do_mknod(buf, file->mode, sx.st.st_rdev) < 0) + rsyserr(FERROR, errno, "mknod %s failed", full_fname(buf)); + else if (DEBUG_GTE(BACKUP, 1)) + rprintf(FINFO, "make_backup: DEVICE %s successful.\n", fname); + ret = 2; + } + +#ifdef SUPPORT_LINKS + if (!ret && preserve_links && S_ISLNK(file->mode)) { + const char *sl = F_SYMLINK(file); + if (safe_symlinks && unsafe_symlink(sl, fname)) { + if (INFO_GTE(SYMSAFE, 1)) { + rprintf(FINFO, "not backing up unsafe symlink \"%s\" -> \"%s\"\n", + fname, sl); + } + ret = 2; + } else { + if (do_symlink(sl, buf) < 0) + rsyserr(FERROR, errno, "link %s -> \"%s\"", full_fname(buf), sl); + else if (DEBUG_GTE(BACKUP, 1)) + rprintf(FINFO, "make_backup: SYMLINK %s successful.\n", fname); + ret = 2; + } + } +#endif + + if (!ret && !S_ISREG(file->mode)) { + if (INFO_GTE(NONREG, 1)) + rprintf(FINFO, "make_bak: skipping non-regular file %s\n", fname); + unmake_file(file); +#ifdef SUPPORT_ACLS + uncache_tmp_acls(); +#endif +#ifdef SUPPORT_XATTRS + uncache_tmp_xattrs(); +#endif + return 3; + } + + /* Copy to backup tree if a file. */ + if (!ret) { + if (copy_file(fname, buf, -1, file->mode) < 0) { + rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"", + full_fname(fname), buf); + unmake_file(file); +#ifdef SUPPORT_ACLS + uncache_tmp_acls(); +#endif +#ifdef SUPPORT_XATTRS + uncache_tmp_xattrs(); +#endif + return 0; + } + if (DEBUG_GTE(BACKUP, 1)) + rprintf(FINFO, "make_backup: COPY %s successful.\n", fname); + ret = 2; + } + + save_preserve_xattrs = preserve_xattrs; + preserve_xattrs = 0; + set_file_attrs(buf, file, NULL, fname, ATTRS_ACCURATE_TIME); + preserve_xattrs = save_preserve_xattrs; + + unmake_file(file); +#ifdef SUPPORT_ACLS + uncache_tmp_acls(); +#endif +#ifdef SUPPORT_XATTRS + uncache_tmp_xattrs(); +#endif + + success: + if (INFO_GTE(BACKUP, 1)) + rprintf(FINFO, "backed up %s to %s\n", fname, buf); + return ret; +} |