Back to index

cell-binutils  2.17cvs20070401
Defines | Functions
rename.c File Reference
#include "bfd.h"
#include "bucomm.h"
#include <sys/stat.h>

Go to the source code of this file.

Defines

#define O_BINARY   0
#define COPY_BUF   8192
#define S_ISLNK(m)   0
#define lstat   stat

Functions

static int simple_copy (const char *, const char *)
void set_times (const char *destination, const struct stat *statbuf)
int smart_rename (const char *from, const char *to, int preserve_dates ATTRIBUTE_UNUSED)

Define Documentation

#define COPY_BUF   8192

Definition at line 44 of file rename.c.

#define lstat   stat

Definition at line 137 of file rename.c.

#define O_BINARY   0

Definition at line 37 of file rename.c.

#define S_ISLNK (   m)    0

Definition at line 136 of file rename.c.


Function Documentation

void set_times ( const char *  destination,
const struct stat statbuf 
)

Definition at line 98 of file rename.c.

{
  int result;

  {
#ifdef HAVE_GOOD_UTIME_H
    struct utimbuf tb;

    tb.actime = statbuf->st_atime;
    tb.modtime = statbuf->st_mtime;
    result = utime (destination, &tb);
#else /* ! HAVE_GOOD_UTIME_H */
#ifndef HAVE_UTIMES
    long tb[2];

    tb[0] = statbuf->st_atime;
    tb[1] = statbuf->st_mtime;
    result = utime (destination, tb);
#else /* HAVE_UTIMES */
    struct timeval tv[2];

    tv[0].tv_sec = statbuf->st_atime;
    tv[0].tv_usec = 0;
    tv[1].tv_sec = statbuf->st_mtime;
    tv[1].tv_usec = 0;
    result = utimes (destination, tv);
#endif /* HAVE_UTIMES */
#endif /* ! HAVE_GOOD_UTIME_H */
  }

  if (result != 0)
    non_fatal (_("%s: cannot set time: %s"), destination, strerror (errno));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int simple_copy ( const char *  from,
const char *  to 
) [static]

Definition at line 50 of file rename.c.

{
  int fromfd, tofd, nread;
  int saved;
  char buf[COPY_BUF];

  fromfd = open (from, O_RDONLY | O_BINARY);
  if (fromfd < 0)
    return -1;
#ifdef O_CREAT
  tofd = open (to, O_CREAT | O_WRONLY | O_TRUNC | O_BINARY, 0777);
#else
  tofd = creat (to, 0777);
#endif
  if (tofd < 0)
    {
      saved = errno;
      close (fromfd);
      errno = saved;
      return -1;
    }
  while ((nread = read (fromfd, buf, sizeof buf)) > 0)
    {
      if (write (tofd, buf, nread) != nread)
       {
         saved = errno;
         close (fromfd);
         close (tofd);
         errno = saved;
         return -1;
       }
    }
  saved = errno;
  close (fromfd);
  close (tofd);
  if (nread < 0)
    {
      errno = saved;
      return -1;
    }
  return 0;
}

Here is the caller graph for this function:

int smart_rename ( const char *  from,
const char *  to,
int preserve_dates  ATTRIBUTE_UNUSED 
)

Definition at line 145 of file rename.c.

{
  bfd_boolean exists;
  struct stat s;
  int ret = 0;

  exists = lstat (to, &s) == 0;

#if defined (_WIN32) && !defined (__CYGWIN32__)
  /* Win32, unlike unix, will not erase `to' in `rename(from, to)' but
     fail instead.  Also, chown is not present.  */

  if (exists)
    remove (to);

  ret = rename (from, to);
  if (ret != 0)
    {
      /* We have to clean up here.  */
      non_fatal (_("unable to rename '%s' reason: %s"), to, strerror (errno));
      unlink (from);
    }
#else
  /* Use rename only if TO is not a symbolic link and has
     only one hard link, and we have permission to write to it.  */
  if (! exists
      || (!S_ISLNK (s.st_mode)
         && S_ISREG (s.st_mode)
         && (s.st_mode & S_IWUSR)
         && s.st_nlink == 1)
      )
    {
      ret = rename (from, to);
      if (ret == 0)
       {
         if (exists)
           {
             /* Try to preserve the permission bits and ownership of
               TO.  First get the mode right except for the setuid
               bit.  Then change the ownership.  Then fix the setuid
               bit.  We do the chmod before the chown because if the
               chown succeeds, and we are a normal user, we won't be
               able to do the chmod afterward.  We don't bother to
               fix the setuid bit first because that might introduce
               a fleeting security problem, and because the chown
               will clear the setuid bit anyhow.  We only fix the
               setuid bit if the chown succeeds, because we don't
               want to introduce an unexpected setuid file owned by
               the user running objcopy.  */
             chmod (to, s.st_mode & 0777);
             if (chown (to, s.st_uid, s.st_gid) >= 0)
              chmod (to, s.st_mode & 07777);
           }
       }
      else
       {
         /* We have to clean up here.  */
         non_fatal (_("unable to rename '%s' reason: %s"), to, strerror (errno));
         unlink (from);
       }
    }
  else
    {
      ret = simple_copy (from, to);
      if (ret != 0)
       non_fatal (_("unable to copy file '%s' reason: %s"), to, strerror (errno));

      if (preserve_dates)
       set_times (to, &s);
      unlink (from);
    }
#endif /* _WIN32 && !__CYGWIN32__ */

  return ret;
}

Here is the call graph for this function: