binutils/rename.c

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