lib/rename.c

   1 /* Work around rename bugs in some systems.
   2
   3    Copyright (C) 2001, 2002, 2003, 2005, 2006, 2009 Free Software
   4    Foundation, Inc.
   5
   6    This program is free software: you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Written by Volker Borchert, Eric Blake.  */
  20
  21 #include <config.h>
  22
  23 #include <stdio.h>
  24
  25 #undef rename
  26
  27 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
  28 /* The mingw rename has problems with trailing slashes; it also
  29    requires use of native Windows calls to allow atomic renames over
  30    existing files.  */
  31
  32 # include <errno.h>
  33
  34 # define WIN32_LEAN_AND_MEAN
  35 # include <windows.h>
  36
  37 /* Rename the file SRC to DST.  This replacement is necessary on
  38    Windows, on which the system rename function will not replace
  39    an existing DST.  */
  40 int
  41 rpl_rename (char const *src, char const *dst)
  42 {
  43   int error;
  44
  45   /* MoveFileEx works if SRC is a directory without any flags,
  46      but fails with MOVEFILE_REPLACE_EXISTING, so try without
  47      flags first. */
  48   if (MoveFileEx (src, dst, 0))
  49     return 0;
  50
  51   /* Retry with MOVEFILE_REPLACE_EXISTING if the move failed
  52    * due to the destination already existing. */
  53   error = GetLastError ();
  54   if (error == ERROR_FILE_EXISTS || error == ERROR_ALREADY_EXISTS)
  55     {
  56       if (MoveFileEx (src, dst, MOVEFILE_REPLACE_EXISTING))
  57         return 0;
  58
  59       error = GetLastError ();
  60     }
  61
  62   switch (error)
  63     {
  64     case ERROR_FILE_NOT_FOUND:
  65     case ERROR_PATH_NOT_FOUND:
  66     case ERROR_BAD_PATHNAME:
  67     case ERROR_DIRECTORY:
  68       errno = ENOENT;
  69       break;
  70
  71     case ERROR_ACCESS_DENIED:
  72     case ERROR_SHARING_VIOLATION:
  73       errno = EACCES;
  74       break;
  75
  76     case ERROR_OUTOFMEMORY:
  77       errno = ENOMEM;
  78       break;
  79
  80     case ERROR_CURRENT_DIRECTORY:
  81       errno = EBUSY;
  82       break;
  83
  84     case ERROR_NOT_SAME_DEVICE:
  85       errno = EXDEV;
  86       break;
  87
  88     case ERROR_WRITE_PROTECT:
  89       errno = EROFS;
  90       break;
  91
  92     case ERROR_WRITE_FAULT:
  93     case ERROR_READ_FAULT:
  94     case ERROR_GEN_FAILURE:
  95       errno = EIO;
  96       break;
  97
  98     case ERROR_HANDLE_DISK_FULL:
  99     case ERROR_DISK_FULL:
 100     case ERROR_DISK_TOO_FRAGMENTED:
 101       errno = ENOSPC;
 102       break;
 103
 104     case ERROR_FILE_EXISTS:
 105     case ERROR_ALREADY_EXISTS:
 106       errno = EEXIST;
 107       break;
 108
 109     case ERROR_BUFFER_OVERFLOW:
 110     case ERROR_FILENAME_EXCED_RANGE:
 111       errno = ENAMETOOLONG;
 112       break;
 113
 114     case ERROR_INVALID_NAME:
 115     case ERROR_DELETE_PENDING:
 116       errno = EPERM;        /* ? */
 117       break;
 118
 119 # ifndef ERROR_FILE_TOO_LARGE
 120 /* This value is documented but not defined in all versions of windows.h. */
 121 #  define ERROR_FILE_TOO_LARGE 223
 122 # endif
 123     case ERROR_FILE_TOO_LARGE:
 124       errno = EFBIG;
 125       break;
 126
 127     default:
 128       errno = EINVAL;
 129       break;
 130     }
 131
 132   return -1;
 133 }
 134
 135 #else /* ! W32 platform */
 136
 137 # include <errno.h>
 138 # include <stdio.h>
 139 # include <stdlib.h>
 140 # include <string.h>
 141 # include <sys/stat.h>
 142
 143 # include "dirname.h"
 144 # include "same-inode.h"
 145
 146 /* Rename the file SRC to DST, fixing any trailing slash bugs.  */
 147
 148 int
 149 rpl_rename (char const *src, char const *dst)
 150 {
 151   size_t src_len = strlen (src);
 152   size_t dst_len = strlen (dst);
 153   char *src_temp = (char *) src;
 154   char *dst_temp = (char *) dst;
 155   bool src_slash;
 156   bool dst_slash;
 157   int ret_val = -1;
 158   int rename_errno = ENOTDIR;
 159   struct stat src_st;
 160   struct stat dst_st;
 161
 162   if (!src_len || !dst_len)
 163     return rename (src, dst); /* Let strace see the ENOENT failure.  */
 164
 165 # if RENAME_DEST_EXISTS_BUG
 166   {
 167     char *src_base = last_component (src);
 168     char *dst_base = last_component (dst);
 169     if (*src_base == '.')
 170       {
 171         size_t len = base_len (src_base);
 172         if (len == 1 || (len == 2 && src_base[1] == '.'))
 173           {
 174             errno = EINVAL;
 175             return -1;
 176           }
 177       }
 178     if (*dst_base == '.')
 179       {
 180         size_t len = base_len (dst_base);
 181         if (len == 1 || (len == 2 && dst_base[1] == '.'))
 182           {
 183             errno = EINVAL;
 184             return -1;
 185           }
 186       }
 187   }
 188 # endif /* RENAME_DEST_EXISTS_BUG */
 189
 190   src_slash = src[src_len - 1] == '/';
 191   dst_slash = dst[dst_len - 1] == '/';
 192
 193 # if !RENAME_DEST_EXISTS_BUG
 194   /* If there are no trailing slashes, then trust the native
 195      implementation unless we also suspect issues with hard link
 196      detection.  */
 197   if (!src_slash && !dst_slash)
 198     return rename (src, dst);
 199 # endif /* !RENAME_DEST_EXISTS_BUG */
 200
 201   /* Presence of a trailing slash requires directory semantics.  If
 202      the source does not exist, or if the destination cannot be turned
 203      into a directory, give up now.  Otherwise, strip trailing slashes
 204      before calling rename.  */
 205   if (lstat (src, &src_st))
 206     return -1;
 207   if (lstat (dst, &dst_st))
 208     {
 209       if (errno != ENOENT || (!S_ISDIR (src_st.st_mode) && dst_slash))
 210         return -1;
 211     }
 212   else
 213     {
 214       if (S_ISDIR (dst_st.st_mode) != S_ISDIR (src_st.st_mode))
 215         {
 216           errno = S_ISDIR (dst_st.st_mode) ? EISDIR : ENOTDIR;
 217           return -1;
 218         }
 219 # if RENAME_DEST_EXISTS_BUG
 220       if (SAME_INODE (src_st, dst_st))
 221         return 0;
 222 # endif /* RENAME_DEST_EXISTS_BUG */
 223     }
 224
 225 # if RENAME_TRAILING_SLASH_SOURCE_BUG || RENAME_DEST_EXISTS_BUG
 226   /* If the only bug was that a trailing slash was allowed on a
 227      non-existing file destination, as in Solaris 10, then we've
 228      already covered that situation.  But if there is any problem with
 229      a trailing slash on an existing source or destination, as in
 230      Solaris 9, or if a directory can overwrite a symlink, as on
 231      Cygwin 1.5, or if directories cannot be created with trailing
 232      slash, as on NetBSD 1.6, then we must strip the offending slash
 233      and check that we have not encountered a symlink instead of a
 234      directory.
 235
 236      Stripping a trailing slash interferes with POSIX semantics, where
 237      rename behavior on a symlink with a trailing slash operates on
 238      the corresponding target directory.  We prefer the GNU semantics
 239      of rejecting any use of a symlink with trailing slash, but do not
 240      enforce them, since Solaris 10 is able to obey POSIX semantics
 241      and there might be clients expecting it, as counter-intuitive as
 242      those semantics are.
 243
 244      Technically, we could also follow the POSIX behavior by chasing a
 245      readlink trail, but that is harder to implement.  */
 246   if (src_slash)
 247     {
 248       src_temp = strdup (src);
 249       if (!src_temp)
 250         {
 251           /* Rather than rely on strdup-posix, we set errno ourselves.  */
 252           rename_errno = ENOMEM;
 253           goto out;
 254         }
 255       strip_trailing_slashes (src_temp);
 256       if (lstat (src_temp, &src_st))
 257         {
 258           rename_errno = errno;
 259           goto out;
 260         }
 261       if (S_ISLNK (src_st.st_mode))
 262         goto out;
 263     }
 264   if (dst_slash)
 265     {
 266       dst_temp = strdup (dst);
 267       if (!dst_temp)
 268         {
 269           rename_errno = ENOMEM;
 270           goto out;
 271         }
 272       strip_trailing_slashes (dst_temp);
 273       if (lstat (dst_temp, &dst_st))
 274         {
 275           if (errno != ENOENT)
 276             {
 277               rename_errno = errno;
 278               goto out;
 279             }
 280         }
 281       else if (S_ISLNK (dst_st.st_mode))
 282         goto out;
 283     }
 284 # endif /* RENAME_TRAILING_SLASH_SOURCE_BUG || RENAME_DEST_EXISTS_BUG */
 285
 286   ret_val = rename (src_temp, dst_temp);
 287   rename_errno = errno;
 288  out:
 289   if (src_temp != src)
 290     free (src_temp);
 291   if (dst_temp != dst)
 292     free (dst_temp);
 293   errno = rename_errno;
 294   return ret_val;
 295 }
 296 #endif /* ! W32 platform */