copyf.c revision 5c51f1241dbbdf2656d0e10011981411ed0c9673
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2005 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <libgen.h>
#include <fcntl.h>
#include <sys/types.h>
#include <utime.h>
#include <sys/stat.h>
#include <locale.h>
#include <libintl.h>
#include <sys/mman.h>
/*
* consolidation pkg command library includes
*/
#include "pkglib.h"
/*
* local pkg command library includes
*/
#include "libinst.h"
#include "libadm.h"
#include "messages.h"
/*
* MAXMAPSIZE controls the largest mapping to use at a time; please refer
* to mmap(2) for details of how this size is incremented and rounded; briefly
* each mapping request has an additional 16Kb added to it - mappings over
* 4Mb will be rounded to a 4Mb boundary - thus if there were 8mb, adding
* in the 16Kb overhead the mapping would use another 4Mb-16kb - that is
* why there is 16Kb subtracted from the total
*/
#define MAXMAPSIZE (1024*1024*8)-(1024*16) /* map at most 8MB */
#define SMALLFILESIZE (32*1024) /* dont mmap files less than 32kb */
/*
* Name: copyF
* Description: fast copy of file - use mmap()/write() loop if possible
* Arguments: char *srcPath - name of source file to copy from
* char *dstPath - name of target file to copy to
* time_t a_mytime: control setting of access/modification times:
* == 0 - replicate source file access/modification times
* != 0 - use specified time for access/modification times
* Returns: int
* == 0 - successful
* != 0 - failure
*/
int
copyf(char *a_srcPath, char *a_dstPath, time_t a_mytime)
{
struct stat srcStatbuf;
struct utimbuf times;
int srcFd;
int dstFd;
int status;
char *pt;
/* open source file for reading */
srcFd = open(a_srcPath, O_RDONLY, 0);
if (srcFd < 0) {
progerr(ERR_OPEN_READ, a_srcPath, errno, strerror(errno));
return (-1);
}
/* obtain file status of source file */
if (fstat(srcFd, &srcStatbuf) != 0) {
progerr(ERR_FSTAT, srcFd, a_srcPath, errno, strerror(errno));
(void) close(srcFd);
return (-1);
}
/* open target file for writing */
dstFd = open(a_dstPath, O_WRONLY | O_TRUNC | O_CREAT,
srcStatbuf.st_mode);
if (dstFd < 0) {
/* create directory structure if missing */
pt = a_dstPath;
while (pt = strchr(pt+1, '/')) {
*pt = '\0';
if (isdir(a_dstPath)) {
if (mkdir(a_dstPath, 0755)) {
progerr(ERR_NODIR, a_dstPath,
errno, strerror(errno));
*pt = '/';
(void) close(srcFd);
return (-1);
}
}
*pt = '/';
}
/* attempt to create target file again */
dstFd = open(a_dstPath, O_WRONLY | O_TRUNC | O_CREAT,
srcStatbuf.st_mode);
if (dstFd < 0) {
progerr(ERR_OPEN_WRITE, a_dstPath, errno,
strerror(errno));
(void) close(srcFd);
return (-1);
}
}
/*
* source and target files are open: copy data
*/
status = copyFile(srcFd, dstFd, a_srcPath, a_dstPath, &srcStatbuf, 0);
(void) close(srcFd);
(void) close(dstFd);
/*
* determine how to set access/modification times for target:
* -- a_mytime == 0: replicate source file access/modification times
* -- otherwise: use a_mytime for file access/modification times
*/
if (a_mytime == 0) {
times.actime = srcStatbuf.st_atime;
times.modtime = srcStatbuf.st_mtime;
} else {
times.actime = a_mytime;
times.modtime = a_mytime;
}
/* set access/modification times for target */
if (utime(a_dstPath, &times) != 0) {
progerr(ERR_MODTIM, a_dstPath, errno, strerror(errno));
return (-1);
}
/* return error if copy failed */
if (status != 0) {
progerr(ERR_READ, a_srcPath, errno, strerror(errno));
return (-1);
}
/* success! */
return (0);
}
/*
* Name: copyFile
* Description: fast copy of file - use mmap()/write() loop if possible
* Arguments: int srcFd - file descriptor open on source file
* int dstFd - file descriptor open on target file
* char *srcPath - name of source file (for error messages)
* char *dstPath - name of target file (for error messages)
* struct stat *a_srcStatbuf - stat structure for source file
* long a_iosize - preferred io size for read/write loop
* Returns: int
* == 0 - successful
* != 0 - failure
*/
int
copyFile(int a_srcFd, int a_dstFd, char *a_srcPath, char *a_dstPath,
struct stat *a_srcStatbuf, long a_iosize)
{
caddr_t cp;
off_t filesize = a_srcStatbuf->st_size;
size_t mapsize = 0;
size_t munmapsize = 0;
off_t offset = 0;
echoDebug(DBG_COPY_FILE, a_srcPath, a_dstPath);
/*
* if the source is a regular file and is not "too small", then cause
* the file to be mapped into memory
*/
if (S_ISREG(a_srcStatbuf->st_mode) && (filesize > SMALLFILESIZE)) {
/*
* Determine size of initial mapping. This will determine the
* size of the address space chunk we work with. This initial
* mapping size will be used to perform munmap() in the future.
*/
mapsize = MAXMAPSIZE;
if (filesize < mapsize) {
mapsize = filesize;
}
/*
* remember size of mapping to "unmap" - if the source file
* exceeds MAXMAPSIZE bytes, then the final mapping of the
* source file will be less than MAXMAPSIZE, and we need to
* make sure that the entire mapping is unmapped when done.
*/
munmapsize = mapsize;
/* map the first segment of the source into memory */
cp = mmap((caddr_t)NULL, mapsize, PROT_READ,
(MAP_SHARED|MAP_ALIGN), a_srcFd, (off_t)0);
if (cp == MAP_FAILED) {
mapsize = 0; /* can't mmap today */
}
}
/*
* if the source was not mapped into memory, copy via read/write loop
*/
if (mapsize == 0) {
char *buf = (char *)NULL;
size_t blocksize;
int pagesize = getpagesize();
/* set blocksize for copy */
blocksize = a_iosize;
if ((blocksize == 0) || (blocksize > SMALLFILESIZE)) {
blocksize = SMALLFILESIZE;
} else if (blocksize < pagesize) {
blocksize = pagesize;
}
/* allocate i/o transfer buffer */
buf = memalign((size_t)pagesize, blocksize);
if (buf == (char *)NULL) {
progerr(ERR_COPY_MEMORY, a_srcPath, errno,
strerror(errno));
return (1);
}
/* copy the file contents */
for (;;) {
ssize_t n;
/* read next block of data */
n = read(a_srcFd, buf, blocksize);
if (n == 0) {
/* end of file - return success */
(void) free(buf);
return (0);
} else if (n < 0) {
/* read error - return error */
progerr(ERR_READ, a_srcPath,
errno, strerror(errno));
(void) free(buf);
return (1);
}
/* write out block of data just read in */
if (vfpSafeWrite(a_dstFd, buf, (size_t)n) != n) {
/* short write/write error - return error */
progerr(ERR_WRITE, a_dstPath,
errno, strerror(errno));
(void) free(buf);
return (1);
}
}
}
/*
* the source has been mapped into memory, copy via mappings
*/
for (;;) {
ssize_t nbytes;
/* write first mappings worth of data */
nbytes = write(a_dstFd, cp, mapsize);
/*
* if we write less than the mmaped size it's due to a
* media error on the input file or out of space on
* the output file. So, try again, and look for errno.
*/
if ((nbytes >= 0) && (nbytes != (ssize_t)mapsize)) {
size_t remains;
remains = mapsize - nbytes;
while (remains > 0) {
nbytes = write(a_dstFd,
(cp + mapsize - remains), remains);
if (nbytes >= 0) {
remains -= nbytes;
if (remains == 0) {
nbytes = mapsize;
}
continue;
}
/* i/o error - report and exit */
if (errno == ENOSPC) {
progerr(ERR_WRITE, a_dstPath,
errno, strerror(errno));
} else {
progerr(ERR_READ, a_srcPath,
errno, strerror(errno));
}
/* unmap source file mapping */
(void) munmap(cp, munmapsize);
return (1);
}
}
/*
* although the write manual page doesn't specify this
* as a possible errno, it is set when the nfs read
* via the mmap'ed file is accessed, so report the
* problem as a source access problem, not a target file
* problem
*/
if (nbytes < 0) {
if (errno == EACCES) {
progerr(ERR_READ, a_srcPath,
errno, strerror(errno));
} else {
progerr(ERR_WRITE, a_dstPath,
errno, strerror(errno));
}
/* unmap source file mapping */
(void) munmap(cp, munmapsize);
return (1);
}
filesize -= nbytes;
if (filesize == 0) {
break;
}
offset += nbytes;
if (filesize < mapsize) {
mapsize = filesize;
}
/* map next segment of file on top of existing mapping */
cp = mmap(cp, mapsize, PROT_READ, (MAP_SHARED|MAP_FIXED),
a_srcFd, offset);
if (cp == MAP_FAILED) {
progerr(ERR_MAPFAILED, a_srcPath, errno,
strerror(errno));
/* unmap source file mapping */
(void) munmap(cp, munmapsize);
return (1);
}
}
/* unmap source file mapping */
(void) munmap(cp, munmapsize);
return (0);
}
/*
* Name: openLocal
* Description: open a file and assure that the descriptor returned is open on
* a file that is local to the current system - if the file is not
* local to this system, copy the file to a temporary file first,
* and then pass a handle back opened on the temporary file
* Arguments: a_path - [RO, *RO] - (char *)
* Pointer to string representing the path to the file
* to open
* a_oflag - [RO, *RO] - (int)
* Integer representing the "mode" bits for an open(2) call
* a_tmpdir - [RO, *RO] - (char *)
* Pointer to string representing the path to a directory
* where a temporary copy of the file can be placed if
* the source file is not local to this system. If this is
* NULL or does not exist, P_tmpdir is used.
* Returns: int
* >= 0 - file descriptor opened on the file
* == -1 - failed to open - errno contains error code
* NOTE: If the file is not local and is copied locally, the file is
* setup in such a way that it will be removed when the last
* file descriptor opened on the file is closed - there is no need
* to know the path to the temporary file or to remove it
* when done.
*/
int
openLocal(char *a_path, int a_oflag, char *a_tmpdir)
{
char *bn;
char template[PATH_MAX];
int fd;
int lerrno;
int n;
int tmpFd;
struct stat statbuf;
/* open source file */
fd = open(a_path, a_oflag);
if (fd < 0) {
return (fd);
}
/* return open fd if the source file is not remote */
if (!isFdRemote(fd)) {
return (fd);
}
/*
* source file is remote - must make a local copy
*/
/* get the source file's status */
n = fstat(fd, &statbuf);
if (n < 0) {
lerrno = errno;
(void) close(fd);
errno = lerrno;
return (-1);
}
/* generate unique temporary file name */
if ((a_tmpdir == (char *)NULL) || (*a_tmpdir == '\0') ||
(isdir(a_tmpdir) != 0)) {
a_tmpdir = P_tmpdir;
}
bn = basename(a_path);
n = strlen(a_tmpdir);
n = snprintf(template, sizeof (template), "%s%s%sXXXXXX",
a_tmpdir, a_tmpdir[n-1] == '/' ? "" : "/", bn);
if (n > sizeof (template)) {
(void) close(fd);
return (EINVAL);
}
/* create the temporary file and open it */
tmpFd = mkstemp(template);
if (tmpFd < 0) {
lerrno = errno;
(void) close(fd);
errno = lerrno;
return (tmpFd);
}
/* unlink the file so when it is closed it is automatically deleted */
(void) unlink(template);
/* copy the source file to the temporary file */
n = copyFile(fd, tmpFd, a_path, template, &statbuf, 0L);
lerrno = errno;
(void) close(fd);
if (n != 0) {
(void) close(tmpFd);
errno = lerrno;
return (-1);
}
/* return handle to temporary file created */
return (tmpFd);
}