[BACK]Return to backup.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / rsync

Diff for /embedaddon/rsync/backup.c between versions 1.1.1.1 and 1.1.1.4

version 1.1.1.1, 2012/02/17 15:09:30 version 1.1.1.4, 2021/03/17 00:32:36
Line 2 Line 2
  * Backup handling code.   * Backup handling code.
  *   *
  * Copyright (C) 1999 Andrew Tridgell   * Copyright (C) 1999 Andrew Tridgell
 * Copyright (C) 2003-2009 Wayne Davison * Copyright (C) 2003-2020 Wayne Davison
  *   *
  * This program is free software; you can redistribute it and/or modify   * 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   * it under the terms of the GNU General Public License as published by
Line 19 Line 19
  */   */
   
 #include "rsync.h"  #include "rsync.h"
   #include "ifuncs.h"
   
 extern int verbose;  
 extern int am_root;  extern int am_root;
 extern int preserve_acls;  extern int preserve_acls;
 extern int preserve_xattrs;  extern int preserve_xattrs;
Line 29  extern int preserve_specials; Line 29  extern int preserve_specials;
 extern int preserve_links;  extern int preserve_links;
 extern int safe_symlinks;  extern int safe_symlinks;
 extern int backup_dir_len;  extern int backup_dir_len;
   extern int backup_dir_dels_len;
 extern unsigned int backup_dir_remainder;  extern unsigned int backup_dir_remainder;
   extern unsigned int backup_dir_dels_remainder;
 extern char backup_dir_buf[MAXPATHLEN];  extern char backup_dir_buf[MAXPATHLEN];
   extern char backup_dir_dels_buf[MAXPATHLEN];
 extern char *backup_suffix;  extern char *backup_suffix;
   extern char *backup_suffix_dels;
 extern char *backup_dir;  extern char *backup_dir;
   extern char *backup_dir_dels;
   
/* make a complete pathname for backup file */static BOOL deleting;
char *get_backup_name(const char *fname) 
{ 
        if (backup_dir) { 
                if (stringjoin(backup_dir_buf + backup_dir_len, backup_dir_remainder, 
                               fname, backup_suffix, NULL) < backup_dir_remainder) 
                        return backup_dir_buf; 
        } else { 
                if (stringjoin(backup_dir_buf, MAXPATHLEN, 
                               fname, backup_suffix, NULL) < MAXPATHLEN) 
                        return backup_dir_buf; 
        } 
   
        rprintf(FERROR, "backup filename too long\n");/* Returns -1 on error, 0 on missing dir, and 1 on present dir. */
        return NULL;static int validate_backup_dir(char *buf)
} 
 
/* simple backup creates a backup with a suffix in the same directory */ 
static int make_simple_backup(const char *fname) 
 {  {
        int rename_errno;        STRUCT_STAT st;
        const char *fnamebak = get_backup_name(fname); 
   
        if (!fnamebak)        if (do_lstat(buf, &st) < 0) {
                return 0;                if (errno == ENOENT)
                        return 0;
        while (1) {                rsyserr(FERROR, errno, "backup lstat %s failed", buf);
                if (do_rename(fname, fnamebak) == 0) {                return -1;
                        if (verbose > 1) { 
                                rprintf(FINFO, "backed up %s to %s\n", 
                                        fname, fnamebak); 
                        } 
                        break; 
                } 
                /* cygwin (at least version b19) reports EINVAL */ 
                if (errno == ENOENT || errno == EINVAL) 
                        break; 
 
                rename_errno = errno; 
                if (errno == EISDIR && do_rmdir(fnamebak) == 0) 
                        continue; 
                if (errno == ENOTDIR && do_unlink(fnamebak) == 0) 
                        continue; 
 
                rsyserr(FERROR, rename_errno, "rename %s to backup %s", 
                        fname, fnamebak); 
                errno = rename_errno; 
                return 0; 
         }          }
        if (!S_ISDIR(st.st_mode)) {
                 int flags = get_del_for_flag(st.st_mode) | DEL_FOR_BACKUP | DEL_RECURSE;
                 if (delete_item(buf, st.st_mode, flags) == 0)
                         return 0;
                 return -1;
         }
         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
Create a directory given an absolute path, perms based upon another directory * path) are ensured to exist as directories, replacing anything else
path * that may be in the way (e.g. a symlink). */
****************************************************************************/static BOOL copy_valid_path(const char *fname, char *buf, int prefix_len, unsigned int remainder, const char *suffix)
int make_bak_dir(const char *fullpath) 
 {  {
        char fbuf[MAXPATHLEN], *rel, *end, *p;        const char *f;
        struct file_struct *file;        int val;
        int len = backup_dir_len;        BOOL ret = True;
         stat_x sx;          stat_x sx;
           char *b, *rel = buf + prefix_len, *name = rel;
   
        while (*fullpath == '.' && fullpath[1] == '/') {        for (f = fname, b = rel; *f && *f == *b; f++, b++) {
                fullpath += 2;                if (*b == '/')
                len -= 2;                        name = b + 1;
         }          }
   
        if (strlcpy(fbuf, fullpath, sizeof fbuf) >= sizeof fbuf)        if (stringjoin(rel, remainder, fname, suffix, NULL) >= remainder) {
                return -1;                rprintf(FERROR, "backup filename too long\n");
                 *name = '\0';
                 return False;
         }
   
        rel = fbuf + len;        for ( ; ; name = b + 1) {
        end = p = rel + strlen(rel);                if ((b = strchr(name, '/')) == NULL)
                         return True;
                 *b = '\0';
   
        /* Try to find an existing dir, starting from the deepest dir. */                val = validate_backup_dir(buf);
        while (1) {                if (val == 0)
                if (--p == fbuf)                        break;
                        return -1;                if (val < 0) {
                if (*p == '/') {                        *name = '\0';
                        *p = '\0';                        return False;
                        if (mkdir_defmode(fbuf) == 0) 
                                break; 
                        if (errno != ENOENT) { 
                                rsyserr(FERROR, errno, 
                                        "make_bak_dir mkdir %s failed", 
                                        full_fname(fbuf)); 
                                return -1; 
                        } 
                 }                  }
   
                   *b = '/';
         }          }
   
        /* Make all the dirs that we didn't find on the way here. */        init_stat_x(&sx);
        while (1) {
                if (p >= rel) {        for ( ; b; name = b + 1, b = strchr(name, '/')) {
                        /* Try to transfer the directory settings of the                *b = '\0';
                         * actual dir that the files are coming from. */
                        if (x_stat(rel, &sx.st, NULL) < 0) {                while (do_mkdir(buf, ACCESSPERMS) < 0) {
                                rsyserr(FERROR, errno,                        if (errno == EEXIST) {
                                        "make_bak_dir stat %s failed",                                val = validate_backup_dir(buf);
                                        full_fname(rel));                                if (val > 0)
                        } else {                                        break;
#ifdef SUPPORT_ACLS                                if (val == 0)
                                sx.acc_acl = sx.def_acl = NULL; 
#endif 
#ifdef SUPPORT_XATTRS 
                                sx.xattr = NULL; 
#endif 
                                if (!(file = make_file(rel, NULL, NULL, 0, NO_FILTERS))) 
                                         continue;                                          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  #ifdef SUPPORT_ACLS
                                if (preserve_acls && !S_ISLNK(file->mode)) {                        if (preserve_acls && !S_ISLNK(file->mode)) {
                                        get_acl(rel, &sx);                                get_acl(rel, &sx);
                                        cache_tmp_acl(file, &sx);                                cache_tmp_acl(file, &sx);
                                        free_acl(&sx);                                free_acl(&sx);
                                }                        }
 #endif  #endif
 #ifdef SUPPORT_XATTRS  #ifdef SUPPORT_XATTRS
                                if (preserve_xattrs) {                        if (preserve_xattrs) {
                                        get_xattr(rel, &sx);                                get_xattr(rel, &sx);
                                        cache_tmp_xattr(file, &sx);                                cache_tmp_xattr(file, &sx);
                                        free_xattr(&sx);                                free_xattr(&sx);
                                }                        }
 #endif  #endif
                                set_file_attrs(fbuf, file, NULL, NULL, 0);                        set_file_attrs(buf, file, NULL, NULL, 0);
                                unmake_file(file);                        unmake_file(file);
                 }
 
                 *b = '/';
         }
 
   cleanup:
 
 #ifdef SUPPORT_ACLS  #ifdef SUPPORT_ACLS
                                uncache_tmp_acls();        uncache_tmp_acls();
 #endif  #endif
 #ifdef SUPPORT_XATTRS  #ifdef SUPPORT_XATTRS
                                uncache_tmp_xattrs();        uncache_tmp_xattrs();
 #endif  #endif
                        }
         return ret;
 }
 
 /* Make a complete pathname for backup file and verify any new path elements. */
 char *get_backup_name(const char *fname)
 {
         char *buf = deleting ? backup_dir_dels_buf : backup_dir_buf;
         char *suffix = deleting ? backup_suffix_dels : backup_suffix;
 
         if (backup_dir) {
                 int prefix_len = deleting ? backup_dir_dels_len : backup_dir_len;
                 unsigned int remainder = deleting ? backup_dir_dels_remainder : backup_dir_remainder;
                 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, ACCESSPERMS, 0);
                         if (backup_dir_len > 1)
                                 backup_dir_buf[backup_dir_len-1] = '/';
                         if (ret < 0)
                                 return NULL;
                         initialized = 1;
                 }                  }
                *p = '/';                /* copy fname into backup_dir_buf while validating the dirs. */
                p += strlen(p);                if (copy_valid_path(fname, buf, prefix_len, remainder, suffix))
                if (p == end)                        return buf;
                        break;                /* copy_valid_path() has printed an error message. */
                if (mkdir_defmode(fbuf) < 0) {                return NULL;
                        rsyserr(FERROR, errno, "make_bak_dir mkdir %s failed", 
                                full_fname(fbuf)); 
                        return -1; 
                } 
         }          }
   
        return 0;        if (stringjoin(backup_dir_buf, MAXPATHLEN, fname, suffix, NULL) < MAXPATHLEN)
                 return buf;
 
         rprintf(FERROR, "backup filename too long\n");
         return NULL;
 }  }
   
/* robustly move a file, creating new directory structures if necessary *//* Has same return codes as make_backup(). */
static int robust_move(const char *src, char *dst)static inline int link_or_rename(const char *from, const char *to,
                                  BOOL prefer_rename, STRUCT_STAT *stp)
 {  {
        if (robust_rename(src, dst, NULL, 0755) < 0) {#ifdef SUPPORT_HARD_LINKS
                int save_errno = errno ? errno : EINVAL; /* 0 paranoia */        if (!prefer_rename) {
                if (errno == ENOENT && make_bak_dir(dst) == 0) {#ifndef CAN_HARDLINK_SYMLINK
                        if (robust_rename(src, dst, NULL, 0755) < 0)                if (S_ISLNK(stp->st_mode))
                                save_errno = errno ? errno : save_errno;                        return 0; /* Use copy code. */
                        else#endif
                                save_errno = 0;#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;
                 }                  }
                if (save_errno) {                /* We prefer to rename a regular file rather than copy it. */
                        errno = save_errno;                if (!S_ISREG(stp->st_mode) || errno == EEXIST || errno == EISDIR)
                        return -1;                        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;          return 0;
 }  }
   
/* Hard-link, rename, or copy an item to the backup name.  Returns 0 for
/* If we have a --backup-dir, then we get here from make_backup(). * failure, 1 if item was moved, 2 if item was duplicated or hard linked
 * We will move the file to be deleted into a parallel directory tree. */ * into backup area, or 3 if item doesn't exist or isn't a regular file. */
static int keep_backup(const char *fname)int make_backup(const char *fname, BOOL prefer_rename)
 {  {
         stat_x sx;          stat_x sx;
         struct file_struct *file;          struct file_struct *file;
           int save_preserve_xattrs;
         char *buf;          char *buf;
        int save_preserve_xattrs = preserve_xattrs;        int ret = 0;
        int kept = 0; 
        int ret_code; 
   
        /* return if no file to keep */        init_stat_x(&sx);
         /* Return success if no file to keep. */
         if (x_lstat(fname, &sx.st, NULL) < 0)          if (x_lstat(fname, &sx.st, NULL) < 0)
                return 1;                return 3;
#ifdef SUPPORT_ACLS 
        sx.acc_acl = sx.def_acl = NULL; 
#endif 
#ifdef SUPPORT_XATTRS 
        sx.xattr = NULL; 
#endif 
   
        if (!(file = make_file(fname, NULL, NULL, 0, NO_FILTERS)))        if (!(buf = get_backup_name(fname)))
                return 1; /* the file could have disappeared */ 
 
        if (!(buf = get_backup_name(fname))) { 
                unmake_file(file); 
#ifdef SUPPORT_ACLS 
                uncache_tmp_acls(); 
#endif 
#ifdef SUPPORT_XATTRS 
                uncache_tmp_xattrs(); 
#endif 
                 return 0;                  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  #ifdef SUPPORT_ACLS
         if (preserve_acls && !S_ISLNK(file->mode)) {          if (preserve_acls && !S_ISLNK(file->mode)) {
                 get_acl(fname, &sx);                  get_acl(fname, &sx);
Line 256  static int keep_backup(const char *fname) Line 289  static int keep_backup(const char *fname)
         /* Check to see if this is a device file, or link */          /* Check to see if this is a device file, or link */
         if ((am_root && preserve_devices && IS_DEVICE(file->mode))          if ((am_root && preserve_devices && IS_DEVICE(file->mode))
          || (preserve_specials && IS_SPECIAL(file->mode))) {           || (preserve_specials && IS_SPECIAL(file->mode))) {
                int save_errno;                if (do_mknod(buf, file->mode, sx.st.st_rdev) < 0)
                do_unlink(buf);                        rsyserr(FERROR, errno, "mknod %s failed", full_fname(buf));
                if (do_mknod(buf, file->mode, sx.st.st_rdev) < 0) {                else if (DEBUG_GTE(BACKUP, 1))
                        save_errno = errno ? errno : EINVAL; /* 0 paranoia */                        rprintf(FINFO, "make_backup: DEVICE %s successful.\n", fname);
                        if (errno == ENOENT && make_bak_dir(buf) == 0) {                ret = 2;
                                if (do_mknod(buf, file->mode, sx.st.st_rdev) < 0) 
                                        save_errno = errno ? errno : save_errno; 
                                else 
                                        save_errno = 0; 
                        } 
                        if (save_errno) { 
                                rsyserr(FERROR, save_errno, "mknod %s failed", 
                                        full_fname(buf)); 
                        } 
                } else 
                        save_errno = 0; 
                if (verbose > 2 && save_errno == 0) { 
                        rprintf(FINFO, "make_backup: DEVICE %s successful.\n", 
                                fname); 
                } 
                kept = 1; 
                do_unlink(fname); 
         }          }
   
         if (!kept && S_ISDIR(file->mode)) {  
                 /* make an empty directory */  
                 if (do_mkdir(buf, file->mode) < 0) {  
                         int save_errno = errno ? errno : EINVAL; /* 0 paranoia */  
                         if (errno == ENOENT && make_bak_dir(buf) == 0) {  
                                 if (do_mkdir(buf, file->mode) < 0)  
                                         save_errno = errno ? errno : save_errno;  
                                 else  
                                         save_errno = 0;  
                         }  
                         if (save_errno) {  
                                 rsyserr(FINFO, save_errno, "mkdir %s failed",  
                                         full_fname(buf));  
                         }  
                 }  
   
                 ret_code = do_rmdir(fname);  
                 if (verbose > 2) {  
                         rprintf(FINFO, "make_backup: RMDIR %s returns %i\n",  
                                 full_fname(fname), ret_code);  
                 }  
                 kept = 1;  
         }  
   
 #ifdef SUPPORT_LINKS  #ifdef SUPPORT_LINKS
        if (!kept && preserve_links && S_ISLNK(file->mode)) {        if (!ret && preserve_links && S_ISLNK(file->mode)) {
                 const char *sl = F_SYMLINK(file);                  const char *sl = F_SYMLINK(file);
                 if (safe_symlinks && unsafe_symlink(sl, fname)) {                  if (safe_symlinks && unsafe_symlink(sl, fname)) {
                        if (verbose) {                        if (INFO_GTE(SYMSAFE, 1)) {
                                 rprintf(FINFO, "not backing up unsafe symlink \"%s\" -> \"%s\"\n",                                  rprintf(FINFO, "not backing up unsafe symlink \"%s\" -> \"%s\"\n",
                                         fname, sl);                                          fname, sl);
                         }                          }
                        kept = 1;                        ret = 2;
                 } else {                  } else {
                        do_unlink(buf);                        if (do_symlink(sl, buf) < 0)
                        if (do_symlink(sl, buf) < 0) {                                rsyserr(FERROR, errno, "link %s -> \"%s\"", full_fname(buf), sl);
                                int save_errno = errno ? errno : EINVAL; /* 0 paranoia */                        else if (DEBUG_GTE(BACKUP, 1))
                                if (errno == ENOENT && make_bak_dir(buf) == 0) {                                rprintf(FINFO, "make_backup: SYMLINK %s successful.\n", fname);
                                        if (do_symlink(sl, buf) < 0)                        ret = 2;
                                                save_errno = errno ? errno : save_errno; 
                                        else 
                                                save_errno = 0; 
                                } 
                                if (save_errno) { 
                                        rsyserr(FERROR, save_errno, "link %s -> \"%s\"", 
                                                full_fname(buf), sl); 
                                } 
                        } 
                        do_unlink(fname); 
                        kept = 1; 
                 }                  }
         }          }
 #endif  #endif
   
        if (!kept && !S_ISREG(file->mode)) {        if (!ret && !S_ISREG(file->mode)) {
                rprintf(FINFO, "make_bak: skipping non-regular file %s\n",                rprintf(FINFO, "make_bak: skipping non-regular file %s\n", fname);
                        fname); 
                 unmake_file(file);                  unmake_file(file);
 #ifdef SUPPORT_ACLS  #ifdef SUPPORT_ACLS
                 uncache_tmp_acls();                  uncache_tmp_acls();
Line 344  static int keep_backup(const char *fname) Line 324  static int keep_backup(const char *fname)
 #ifdef SUPPORT_XATTRS  #ifdef SUPPORT_XATTRS
                 uncache_tmp_xattrs();                  uncache_tmp_xattrs();
 #endif  #endif
                return 1;                return 3;
         }          }
   
        /* move to keep tree if a file */        /* Copy to backup tree if a file. */
        if (!kept) {        if (!ret) {
                if (robust_move(fname, buf) != 0) {                if (copy_file(fname, buf, -1, file->mode) < 0) {
                         rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"",                          rsyserr(FERROR, errno, "keep_backup failed: %s -> \"%s\"",
                                 full_fname(fname), buf);                                  full_fname(fname), buf);
                } else if (sx.st.st_nlink > 1) {                        unmake_file(file);
                        /* If someone has hard-linked the file into the backup#ifdef SUPPORT_ACLS
                         * dir, rename() might return success but do nothing! */                        uncache_tmp_acls();
                        robust_unlink(fname); /* Just in case... */#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;          preserve_xattrs = 0;
        set_file_attrs(buf, file, NULL, fname, 0);        set_file_attrs(buf, file, NULL, fname, ATTRS_ACCURATE_TIME);
         preserve_xattrs = save_preserve_xattrs;          preserve_xattrs = save_preserve_xattrs;
   
         unmake_file(file);          unmake_file(file);
 #ifdef SUPPORT_ACLS  #ifdef SUPPORT_ACLS
         uncache_tmp_acls();          uncache_tmp_acls();
Line 369  static int keep_backup(const char *fname) Line 359  static int keep_backup(const char *fname)
         uncache_tmp_xattrs();          uncache_tmp_xattrs();
 #endif  #endif
   
        if (verbose > 1) {  success:
                rprintf(FINFO, "backed up %s to %s\n",        if (INFO_GTE(BACKUP, 1))
                        fname, buf);                rprintf(FINFO, "backed up %s to %s\n", fname, buf);
        }        return ret;
        return 1; 
 }  }
   
/* backup switch routine called only when backing-up removed file */
/* main backup switch routine */int safe_delete(const char *fname)
int make_backup(const char *fname) 
 {  {
        if (backup_dir)        int ret;
                return keep_backup(fname);        deleting = 1;
        return make_simple_backup(fname);        ret = make_backup(fname, True);
         deleting = 0;
         return ret;
 }  }
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.4

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>