binutils/rename.c

   1 /* rename.c -- rename a file, preserving symlinks.
   2    Copyright (C) 1999-2020 Free Software Foundation, Inc.
   3
   4    This file is part of GNU Binutils.
   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, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  19    02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "bucomm.h"
  24
  25 #ifdef HAVE_GOOD_UTIME_H
  26 #include <utime.h>
  27 #else /* ! HAVE_GOOD_UTIME_H */
  28 #ifdef HAVE_UTIMES
  29 #include <sys/time.h>
  30 #endif /* HAVE_UTIMES */
  31 #endif /* ! HAVE_GOOD_UTIME_H */
  32
  33 #if ! defined (_WIN32) || defined (__CYGWIN32__)
  34 static int simple_copy (const char *, const char *);
  35
  36 /* The number of bytes to copy at once.  */
  37 #define COPY_BUF 8192
  38
  39 /* Copy file FROM to file TO, performing no translations.
  40    Return 0 if ok, -1 if error.  */
  41
  42 static int
  43 simple_copy (const char *from, const char *to)
  44 {
  45   int fromfd, tofd, nread;
  46   int saved;
  47   char buf[COPY_BUF];
  48
  49   fromfd = open (from, O_RDONLY | O_BINARY);
  50   if (fromfd < 0)
  51     return -1;
  52 #ifdef O_CREAT
  53   tofd = open (to, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, 0777);
  54 #else
  55   tofd = creat (to, 0777);
  56 #endif
  57   if (tofd < 0)
  58     {
  59       saved = errno;
  60       close (fromfd);
  61       errno = saved;
  62       return -1;
  63     }
  64   while ((nread = read (fromfd, buf, sizeof buf)) > 0)
  65     {
  66       if (write (tofd, buf, nread) != nread)
  67         {
  68           saved = errno;
  69           close (fromfd);
  70           close (tofd);
  71           errno = saved;
  72           return -1;
  73         }
  74     }
  75   saved = errno;
  76   close (fromfd);
  77   close (tofd);
  78   if (nread < 0)
  79     {
  80       errno = saved;
  81       return -1;
  82     }
  83   return 0;
  84 }
  85 #endif /* __CYGWIN32__ or not _WIN32 */
  86
  87 /* Set the times of the file DESTINATION to be the same as those in
  88    STATBUF.  */
  89
  90 void
  91 set_times (const char *destination, const struct stat *statbuf)
  92 {
  93   int result;
  94
  95   {
  96 #ifdef HAVE_GOOD_UTIME_H
  97     struct utimbuf tb;
  98
  99     tb.actime = statbuf->st_atime;
 100     tb.modtime = statbuf->st_mtime;
 101     result = utime (destination, &tb);
 102 #else /* ! HAVE_GOOD_UTIME_H */
 103 #ifndef HAVE_UTIMES
 104     long tb[2];
 105
 106     tb[0] = statbuf->st_atime;
 107     tb[1] = statbuf->st_mtime;
 108     result = utime (destination, tb);
 109 #else /* HAVE_UTIMES */
 110     struct timeval tv[2];
 111
 112     tv[0].tv_sec = statbuf->st_atime;
 113     tv[0].tv_usec = 0;
 114     tv[1].tv_sec = statbuf->st_mtime;
 115     tv[1].tv_usec = 0;
 116     result = utimes (destination, tv);
 117 #endif /* HAVE_UTIMES */
 118 #endif /* ! HAVE_GOOD_UTIME_H */
 119   }
 120
 121   if (result != 0)
 122     non_fatal (_("%s: cannot set time: %s"), destination, strerror (errno));
 123 }
 124
 125 #ifndef S_ISLNK
 126 #ifdef S_IFLNK
 127 #define S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)
 128 #else
 129 #define S_ISLNK(m) 0
 130 #define lstat stat
 131 #endif
 132 #endif
 133
 134 /* Rename FROM to TO, copying if TO is a link.
 135    Return 0 if ok, -1 if error.  */
 136
 137 int
 138 smart_rename (const char *from, const char *to, int preserve_dates ATTRIBUTE_UNUSED)
 139 {
 140   bfd_boolean exists;
 141   struct stat s;
 142   int ret = 0;
 143
 144   exists = lstat (to, &s) == 0;
 145
 146 #if defined (_WIN32) && !defined (__CYGWIN32__)
 147   /* Win32, unlike unix, will not erase `to' in `rename(from, to)' but
 148      fail instead.  Also, chown is not present.  */
 149
 150   if (exists)
 151     remove (to);
 152
 153   ret = rename (from, to);
 154   if (ret != 0)
 155     {
 156       /* We have to clean up here.  */
 157       non_fatal (_("unable to rename '%s'; reason: %s"), to, strerror (errno));
 158       unlink (from);
 159     }
 160 #else
 161   /* Use rename only if TO is not a symbolic link and has
 162      only one hard link, and we have permission to write to it.  */
 163   if (! exists
 164       || (!S_ISLNK (s.st_mode)
 165           && S_ISREG (s.st_mode)
 166           && (s.st_mode & S_IWUSR)
 167           && s.st_nlink == 1)
 168       )
 169     {
 170       ret = rename (from, to);
 171       if (ret == 0)
 172         {
 173           if (exists)
 174             {
 175               /* Try to preserve the permission bits and ownership of
 176                  TO.  First get the mode right except for the setuid
 177                  bit.  Then change the ownership.  Then fix the setuid
 178                  bit.  We do the chmod before the chown because if the
 179                  chown succeeds, and we are a normal user, we won't be
 180                  able to do the chmod afterward.  We don't bother to
 181                  fix the setuid bit first because that might introduce
 182                  a fleeting security problem, and because the chown
 183                  will clear the setuid bit anyhow.  We only fix the
 184                  setuid bit if the chown succeeds, because we don't
 185                  want to introduce an unexpected setuid file owned by
 186                  the user running objcopy.  */
 187               chmod (to, s.st_mode & 0777);
 188               if (chown (to, s.st_uid, s.st_gid) >= 0)
 189                 chmod (to, s.st_mode & 07777);
 190             }
 191         }
 192       else
 193         {
 194           /* We have to clean up here.  */
 195           non_fatal (_("unable to rename '%s'; reason: %s"), to, strerror (errno));
 196           unlink (from);
 197         }
 198     }
 199   else
 200     {
 201       ret = simple_copy (from, to);
 202       if (ret != 0)
 203         non_fatal (_("unable to copy file '%s'; reason: %s"), to, strerror (errno));
 204
 205       if (preserve_dates)
 206         set_times (to, &s);
 207       unlink (from);
 208     }
 209 #endif /* _WIN32 && !__CYGWIN32__ */
 210
 211   return ret;
 212 }