xref: /onnv-gate/usr/src/cmd/svr4pkg/libinst/copyf.c (revision 9781:ccf49524d5dc)

/*
 * 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);
}