/* Work around rename bugs in some systems.

   Copyright (C) 2001-2003, 2005-2006, 2009-2018 Free Software Foundation, Inc.

   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, see <https://www.gnu.org/licenses/>.  */

/* Written by Volker Borchert, Eric Blake.  */

#include <config.h>

#include <stdio.h>

#undef rename

#if defined _WIN32 && ! defined __CYGWIN__

/* The mingw rename has problems with trailing slashes; it also

   requires use of native Windows calls to allow atomic renames over

   existing files.  */

# include <errno.h>

# include <stdbool.h>

# include <stdlib.h>

# include <sys/stat.h>

# include <unistd.h>

# define WIN32_LEAN_AND_MEAN

# include <windows.h>

# include "dirname.h"

/* Rename the file SRC to DST.  This replacement is necessary on

   Windows, on which the system rename function will not replace

   an existing DST.  */

int

rpl_rename (char const *src, char const *dst)

{

  int error;

  size_t src_len = strlen (src);

  size_t dst_len = strlen (dst);

  char *src_base = last_component (src);

  char *dst_base = last_component (dst);

  bool src_slash;

  bool dst_slash;

  bool dst_exists;

  struct stat src_st;

  struct stat dst_st;

  /* Filter out dot as last component.  */

  if (!src_len || !dst_len)

    {

      errno = ENOENT;

      return -1;

    }

  if (*src_base == '.')

    {

      size_t len = base_len (src_base);

      if (len == 1 || (len == 2 && src_base[1] == '.'))

        {

          errno = EINVAL;

          return -1;

        }

    }

  if (*dst_base == '.')

    {

      size_t len = base_len (dst_base);

      if (len == 1 || (len == 2 && dst_base[1] == '.'))

        {

          errno = EINVAL;

          return -1;

        }

    }

  /* Presence of a trailing slash requires directory semantics.  If

     the source does not exist, or if the destination cannot be turned

     into a directory, give up now.  Otherwise, strip trailing slashes

     before calling rename.  There are no symlinks on mingw, so stat

     works instead of lstat.  */

  src_slash = ISSLASH (src[src_len - 1]);

  dst_slash = ISSLASH (dst[dst_len - 1]);

  if (stat (src, &src_st))

    return -1;

  if (stat (dst, &dst_st))

    {

      if (errno != ENOENT || (!S_ISDIR (src_st.st_mode) && dst_slash))

        return -1;

      dst_exists = false;

    }

  else

    {

      if (S_ISDIR (dst_st.st_mode) != S_ISDIR (src_st.st_mode))

        {

          errno = S_ISDIR (dst_st.st_mode) ? EISDIR : ENOTDIR;

          return -1;

        }

      dst_exists = true;

    }

  /* There are no symlinks, so if a file existed with a trailing

     slash, it must be a directory, and we don't have to worry about

     stripping strip trailing slash.  However, mingw refuses to

     replace an existing empty directory, so we have to help it out.

     And canonicalize_file_name is not yet ported to mingw; however,

     for directories, getcwd works as a viable alternative.  Ensure

     that we can get back to where we started before using it; later

     attempts to return are fatal.  Note that we can end up losing a

     directory if rename then fails, but it was empty, so not much

     damage was done.  */

  if (dst_exists && S_ISDIR (dst_st.st_mode))

    {

      char *cwd = getcwd (NULL, 0);

      char *src_temp;

      char *dst_temp;

      if (!cwd || chdir (cwd))

        return -1;

      if (IS_ABSOLUTE_FILE_NAME (src))

        {

          dst_temp = chdir (dst) ? NULL : getcwd (NULL, 0);

          src_temp = chdir (src) ? NULL : getcwd (NULL, 0);

        }

      else

        {

          src_temp = chdir (src) ? NULL : getcwd (NULL, 0);

          if (!IS_ABSOLUTE_FILE_NAME (dst) && chdir (cwd))

            abort ();

          dst_temp = chdir (dst) ? NULL : getcwd (NULL, 0);

        }

      if (chdir (cwd))

        abort ();

      free (cwd);

      if (!src_temp || !dst_temp)

        {

          free (src_temp);

          free (dst_temp);

          errno = ENOMEM;

          return -1;

        }

      src_len = strlen (src_temp);

      if (strncmp (src_temp, dst_temp, src_len) == 0

          && (ISSLASH (dst_temp[src_len]) || dst_temp[src_len] == '\0'))

        {

          error = dst_temp[src_len];

          free (src_temp);

          free (dst_temp);

          if (error)

            {

              errno = EINVAL;

              return -1;

            }

          return 0;

        }

      if (rmdir (dst))

        {

          error = errno;

          free (src_temp);

          free (dst_temp);

          errno = error;

          return -1;

        }

      free (src_temp);

      free (dst_temp);

    }

  /* MoveFileEx works if SRC is a directory without any flags, but

     fails with MOVEFILE_REPLACE_EXISTING, so try without flags first.

     Thankfully, MoveFileEx handles hard links correctly, even though

     rename() does not.  */

  if (MoveFileEx (src, dst, 0))

    return 0;

  /* Retry with MOVEFILE_REPLACE_EXISTING if the move failed

     due to the destination already existing.  */

  error = GetLastError ();

  if (error == ERROR_FILE_EXISTS || error == ERROR_ALREADY_EXISTS)

    {

      if (MoveFileEx (src, dst, MOVEFILE_REPLACE_EXISTING))

        return 0;

      error = GetLastError ();

    }

  switch (error)

    {

    case ERROR_FILE_NOT_FOUND:

    case ERROR_PATH_NOT_FOUND:

    case ERROR_BAD_PATHNAME:

    case ERROR_DIRECTORY:

      errno = ENOENT;

      break;

    case ERROR_ACCESS_DENIED:

    case ERROR_SHARING_VIOLATION:

      errno = EACCES;

      break;

    case ERROR_OUTOFMEMORY:

      errno = ENOMEM;

      break;

    case ERROR_CURRENT_DIRECTORY:

      errno = EBUSY;

      break;

    case ERROR_NOT_SAME_DEVICE:

      errno = EXDEV;

      break;

    case ERROR_WRITE_PROTECT:

      errno = EROFS;

      break;

    case ERROR_WRITE_FAULT:

    case ERROR_READ_FAULT:

    case ERROR_GEN_FAILURE:

      errno = EIO;

      break;

    case ERROR_HANDLE_DISK_FULL:

    case ERROR_DISK_FULL:

    case ERROR_DISK_TOO_FRAGMENTED:

      errno = ENOSPC;

      break;

    case ERROR_FILE_EXISTS:

    case ERROR_ALREADY_EXISTS:

      errno = EEXIST;

      break;

    case ERROR_BUFFER_OVERFLOW:

    case ERROR_FILENAME_EXCED_RANGE:

      errno = ENAMETOOLONG;

      break;

    case ERROR_INVALID_NAME:

    case ERROR_DELETE_PENDING:

      errno = EPERM;        /* ? */

      break;

# ifndef ERROR_FILE_TOO_LARGE

/* This value is documented but not defined in all versions of windows.h.  */

#  define ERROR_FILE_TOO_LARGE 223

# endif

    case ERROR_FILE_TOO_LARGE:

      errno = EFBIG;

      break;

    default:

      errno = EINVAL;

      break;

    }

  return -1;

}

#else /* ! W32 platform */

# include <errno.h>

# include <stdio.h>

# include <stdlib.h>

# include <string.h>

# include <sys/stat.h>

# include <unistd.h>

# include "dirname.h"

# include "same-inode.h"

/* Rename the file SRC to DST, fixing any trailing slash bugs.  */

int

rpl_rename (char const *src, char const *dst)

{

  size_t src_len = strlen (src);

  size_t dst_len = strlen (dst);

  char *src_temp = (char *) src;

  char *dst_temp = (char *) dst;

  bool src_slash;

  bool dst_slash;

  bool dst_exists _GL_UNUSED;

  int ret_val = -1;

  int rename_errno = ENOTDIR;

  struct stat src_st;

  struct stat dst_st;

  if (!src_len || !dst_len)

    return rename (src, dst); /* Let strace see the ENOENT failure.  */

# if RENAME_DEST_EXISTS_BUG

  {

    char *src_base = last_component (src);

    char *dst_base = last_component (dst);

    if (*src_base == '.')

      {

        size_t len = base_len (src_base);

        if (len == 1 || (len == 2 && src_base[1] == '.'))

          {

            errno = EINVAL;

            return -1;

          }

      }

    if (*dst_base == '.')

      {

        size_t len = base_len (dst_base);

        if (len == 1 || (len == 2 && dst_base[1] == '.'))

          {

            errno = EINVAL;

            return -1;

          }

      }

  }

# endif /* RENAME_DEST_EXISTS_BUG */

  src_slash = src[src_len - 1] == '/';

  dst_slash = dst[dst_len - 1] == '/';

# if !RENAME_HARD_LINK_BUG && !RENAME_DEST_EXISTS_BUG

  /* If there are no trailing slashes, then trust the native

     implementation unless we also suspect issues with hard link

     detection or file/directory conflicts.  */

  if (!src_slash && !dst_slash)

    return rename (src, dst);

# endif /* !RENAME_HARD_LINK_BUG && !RENAME_DEST_EXISTS_BUG */

  /* Presence of a trailing slash requires directory semantics.  If

     the source does not exist, or if the destination cannot be turned

     into a directory, give up now.  Otherwise, strip trailing slashes

     before calling rename.  */

  if (lstat (src, &src_st))

    return -1;

  if (lstat (dst, &dst_st))

    {

      if (errno != ENOENT || (!S_ISDIR (src_st.st_mode) && dst_slash))

        return -1;

      dst_exists = false;

    }

  else

    {

      if (S_ISDIR (dst_st.st_mode) != S_ISDIR (src_st.st_mode))

        {

          errno = S_ISDIR (dst_st.st_mode) ? EISDIR : ENOTDIR;

          return -1;

        }

# if RENAME_HARD_LINK_BUG

      if (SAME_INODE (src_st, dst_st))

        return 0;

# endif /* RENAME_HARD_LINK_BUG */

      dst_exists = true;

    }

# if (RENAME_TRAILING_SLASH_SOURCE_BUG || RENAME_DEST_EXISTS_BUG        \

      || RENAME_HARD_LINK_BUG)

  /* If the only bug was that a trailing slash was allowed on a

     non-existing file destination, as in Solaris 10, then we've

     already covered that situation.  But if there is any problem with

     a trailing slash on an existing source or destination, as in

     Solaris 9, or if a directory can overwrite a symlink, as on

     Cygwin 1.5, or if directories cannot be created with trailing

     slash, as on NetBSD 1.6, then we must strip the offending slash

     and check that we have not encountered a symlink instead of a

     directory.

     Stripping a trailing slash interferes with POSIX semantics, where

     rename behavior on a symlink with a trailing slash operates on

     the corresponding target directory.  We prefer the GNU semantics

     of rejecting any use of a symlink with trailing slash, but do not

     enforce them, since Solaris 10 is able to obey POSIX semantics

     and there might be clients expecting it, as counter-intuitive as

     those semantics are.

     Technically, we could also follow the POSIX behavior by chasing a

     readlink trail, but that is harder to implement.  */

  if (src_slash)

    {

      src_temp = strdup (src);

      if (!src_temp)

        {

          /* Rather than rely on strdup-posix, we set errno ourselves.  */

          rename_errno = ENOMEM;

          goto out;

        }

      strip_trailing_slashes (src_temp);

      if (lstat (src_temp, &src_st))

        {

          rename_errno = errno;

          goto out;

        }

      if (S_ISLNK (src_st.st_mode))

        goto out;

    }

  if (dst_slash)

    {

      dst_temp = strdup (dst);

      if (!dst_temp)

        {

          rename_errno = ENOMEM;

          goto out;

        }

      strip_trailing_slashes (dst_temp);

      if (lstat (dst_temp, &dst_st))

        {

          if (errno != ENOENT)

            {

              rename_errno = errno;

              goto out;

            }

        }

      else if (S_ISLNK (dst_st.st_mode))

        goto out;

    }

# endif /* RENAME_TRAILING_SLASH_SOURCE_BUG || RENAME_DEST_EXISTS_BUG

           || RENAME_HARD_LINK_BUG */

# if RENAME_DEST_EXISTS_BUG

  /* Cygwin 1.5 sometimes behaves oddly when moving a non-empty

     directory on top of an empty one (the old directory name can

     reappear if the new directory tree is removed).  Work around this

     by removing the target first, but don't remove the target if it

     is a subdirectory of the source.  Note that we can end up losing

     a directory if rename then fails, but it was empty, so not much

     damage was done.  */

  if (dst_exists && S_ISDIR (dst_st.st_mode))

    {

      if (src_st.st_dev != dst_st.st_dev)

        {

          rename_errno = EXDEV;

          goto out;

        }

      if (src_temp != src)

        free (src_temp);

      src_temp = canonicalize_file_name (src);

      if (dst_temp != dst)

        free (dst_temp);

      dst_temp = canonicalize_file_name (dst);

      if (!src_temp || !dst_temp)

        {

          rename_errno = ENOMEM;

          goto out;

        }

      src_len = strlen (src_temp);

      if (strncmp (src_temp, dst_temp, src_len) == 0

          && dst_temp[src_len] == '/')

        {

          rename_errno = EINVAL;

          goto out;

        }

      if (rmdir (dst))

        {

          rename_errno = errno;

          goto out;

        }

    }

# endif /* RENAME_DEST_EXISTS_BUG */

  ret_val = rename (src_temp, dst_temp);

  rename_errno = errno;

 out: _GL_UNUSED_LABEL;

  if (src_temp != src)

    free (src_temp);

  if (dst_temp != dst)

    free (dst_temp);

  errno = rename_errno;

  return ret_val;

}

#endif /* ! W32 platform */