/*	$OpenBSD: xinstall.c,v 1.65 2016/05/13 17:51:15 jmc Exp $	*/

/*	$NetBSD: xinstall.c,v 1.9 1995/12/20 10:25:17 jonathan Exp $	*/

/*

 * Copyright (c) 1987, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#include <sys/param.h>	/* MAXBSIZE */

#include <sys/wait.h>

#include <sys/mman.h>

#include <sys/stat.h>

#include <ctype.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <grp.h>

#include <paths.h>

#include <pwd.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include <utime.h>

#include <libgen.h>

#include "pathnames.h"

#define MINIMUM(a, b)	(((a) < (b)) ? (a) : (b))

#define	DIRECTORY	0x01		/* Tell install it's a directory. */

#define	SETFLAGS	0x02		/* Tell install to set flags. */

#define	USEFSYNC	0x04		/* Tell install to use fsync(2). */

#define NOCHANGEBITS	(UF_IMMUTABLE | UF_APPEND | SF_IMMUTABLE | SF_APPEND)

#define BACKUP_SUFFIX	".old"

struct passwd *pp;

struct group *gp;

int dobackup, docompare, dodest, dodir, dopreserve, dostrip, safecopy;

int mode = S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;

char pathbuf[PATH_MAX], tempfile[PATH_MAX];

char *suffix = BACKUP_SUFFIX;

uid_t uid;

gid_t gid;

void	copy(int, char *, int, char *, off_t, int);

int	compare(int, const char *, off_t, int, const char *, off_t);

void	install(char *, char *, u_long, u_int);

void	install_dir(char *, int);

void	strip(char *);

void	usage(void);

int	create_newfile(char *, struct stat *);

int	create_tempfile(char *, char *, size_t);

int	file_write(int, char *, size_t, int *, int *, int);

void	file_flush(int, int);

int

main(int argc, char *argv[])

	struct stat from_sb, to_sb;

	void *set;

	u_int32_t fset;

	u_int iflags;

	int ch, no_target;

		case 'C':

		case 'B':

			/* fall through; -B implies -b */

		case 'b':

		case 'c':

			/* For backwards compatibility. */

			break;

		case 'F':

		case 'f':

		case 'g':

		case 'm':

		case 'o':

		case 'p':

		case 'S':

		case 's':

		case 'D':

		case 'd':

		case '?':

		default:

		}

	/* some options make no sense when creating directories */

	/* must have at least two arguments, except when creating directories */

	/* need to make a temp copy so we can compare stripped version */

	/* get group and owner id's */

		/* NOTREACHED */

	}

		/*

		 * When -D is passed, do not chmod the directory with the mode set for

		 * the target file. If more restrictive permissions are required then

		 * '-d -m' ought to be used instead.

		 */

	}

		/* NOTREACHED */

	}

	/* can't do file1 file2 directory/file */

		    to_sb.st_ino == from_sb.st_ino)

	}

	/* NOTREACHED */

}

/*

 * install --

 *	build a path name and install the file

 */

void

install(char *from_name, char *to_name, u_long fset, u_int flags)

	struct stat from_sb, to_sb;

	struct timespec ts[2];

	char *p;

	/* If try to install NULL file to a directory, fails. */

		/* Build the target path. */

			    to_name,

			    (p = strrchr(from_name, '/')) ? ++p : from_name);

		}

	} else {

	}

		/* Only compare against regular files. */

		}

		/* File does not exist so silently ignore compare flag. */

	}

	}

	} else {

	}

					from_sb.st_size, to_fd,

					to_name, to_sb.st_size));

			/* Truncate "to" file for copy unless we match */

			}

		}

			     safecopy ? tempfile : to_name, from_sb.st_size,

			     ((off_t)from_sb.st_blocks * S_BLKSIZE < from_sb.st_size));

	}

		/*

		 * Re-open our fd on the target, in case we used a strip

		 *  that does not work in-place -- like gnu binutils strip.

		 */

		     0)) < 0)

	}

	/*

	 * Compare the (possibly stripped) temp file to the target.

	 */

		struct stat temp_sb;

		/* Re-open to_fd using the real target name. */

		}

			    to_name, to_sb.st_size) == 0) {

			/*

			 * If target has more than one link we need to

			 * replace it in order to snap the extra links.

			 * Need to preserve target file times, though.

			 */

			} else {

			}

		}

	}

	/*

	 * Preserve the timestamp of the source file if necessary.

	 */

	}

	/*

	 * Set owner, group, mode for target; do the chown first,

	 * chown may lose the setuid bits.

	 */

	    fchown(to_fd, uid, gid)) {

		    safecopy ? tempfile : to_name, strerror(serrno));

	}

		    strerror(serrno));

	}

	/*

	 * If provided a set of flags, set them, otherwise, preserve the

	 * flags, except for the dump flag.

	 */

	    flags & SETFLAGS ? fset : from_sb.st_flags & ~UF_NODUMP)) {

			    safecopy ? tempfile :to_name, strerror(errno));

	}

	/*

	 * Move the new file into place if doing a safe copy

	 * and the files are different (or just not compared).

	 */

		/* Try to turn off the immutable bits. */

			char backup[PATH_MAX];

			    suffix);

			/* It is ok for the target file not to exist. */

				     backup, strerror(serrno));

			}

		}

			     to_name, strerror(serrno));

		}

	}

/*

 * copy --

 *	copy from one file to another

 */

void

copy(int from_fd, char *from_name, int to_fd, char *to_name, off_t size,

    int sparse)

	ssize_t nr, nw;

	int serrno;

	char *p, buf[MAXBSIZE];

	/* Rewind file descriptors. */

	/*

	 * Mmap and write if less than 8M (the limit is so we don't totally

	 * trash memory on big files.  This is really a minor hack, but it

	 * wins some CPU back.  Sparse files need special treatment.

	 */

		size_t siz;

		    from_fd, (off_t)0)) == MAP_FAILED) {

		}

			    to_name, strerror(nw > 0 ? EIO : serrno));

		}

	} else {

		struct stat sb;

		/*

		 * Pass the blocksize of the file being written to the write

		 * routine.  if the size is zero, use the default S_BLKSIZE.

		 */

		else

			else

				    to_name, strerror(nw > 0 ? EIO : serrno));

			}

		}

		}

	}

}

/*

 * compare --

 *	compare two files; non-zero means files differ

 */

int

compare(int from_fd, const char *from_name, off_t from_len, int to_fd,

    const char *to_name, off_t to_len)

{

	caddr_t p1, p2;

	size_t length;

	off_t from_off, to_off, remainder;

	int dfound;

	/*

	 * Compare the two files being careful not to mmap

	 * more than 8M at a time.

	 */

	do {

		    from_fd, from_off)) == MAP_FAILED)

		    to_fd, to_off)) == MAP_FAILED)

		}

}

/*

 * strip --

 *	use strip(1) to strip the target file

 */

void

strip(char *to_name)

	int serrno, status;

	char * volatile path_strip;

	case -1:

	case 0:

	default:

	}

/*

 * install_dir --

 *	build directory hierarchy

 */

void

install_dir(char *path, int mode)

{

	char *p;

	struct stat sb;

	int ch;

					/* Not there; use mkdir()s errno */

					    path);

					/* NOTREACHED */

				}

					/* Is there, but isn't a directory */

					/* NOTREACHED */

				}

			}

 		}

	    chmod(path, mode)) {

	}

}

/*

 * usage --

 *	print a usage message and die

 */

void

usage(void)

{

usage: install [-bCcDdFpSs] [-B suffix] [-f flags] [-g group] [-m mode] [-o owner]\n	       source ... target ...\n");

	/* NOTREACHED */

}

/*

 * create_tempfile --

 *	create a temporary file based on path and open it

 */

int

create_tempfile(char *path, char *temp, size_t tsize)

	char *p;

	else

}

/*

 * create_newfile --

 *	create a new file, overwriting an existing one if necessary

 */

int

create_newfile(char *path, struct stat *sbp)

	char backup[PATH_MAX];

	/*

	 * Unlink now... avoid ETXTBSY errors later.  Try and turn

	 * off the append/immutable bits -- if we fail, go ahead,

	 * it might work.

	 */

		/* It is ok for the target file not to exist. */

	} else {

	}

}

/*

 * file_write()

 *	Write/copy a file (during copy or archive extract). This routine knows

 *	how to copy files with lseek holes in it. (Which are read as file

 *	blocks containing all 0's but do not have any file blocks associated

 *	with the data). Typical examples of these are files created by dbm

 *	variants (.pag files). While the file size of these files are huge, the

 *	actual storage is quite small (the files are sparse). The problem is

 *	the holes read as all zeros so are probably stored on the archive that

 *	way (there is no way to determine if the file block is really a hole,

 *	we only know that a file block of all zero's can be a hole).

 *	At this writing, no major archive format knows how to archive files

 *	with holes. However, on extraction (or during copy, -rw) we have to

 *	deal with these files. Without detecting the holes, the files can

 *	consume a lot of file space if just written to disk. This replacement

 *	for write when passed the basic allocation size of a file system block,

 *	uses lseek whenever it detects the input data is all 0 within that

 *	file block. In more detail, the strategy is as follows:

 *	While the input is all zero keep doing an lseek. Keep track of when we

 *	pass over file block boundaries. Only write when we hit a non zero

 *	input. once we have written a file block, we continue to write it to

 *	the end (we stop looking at the input). When we reach the start of the

 *	next file block, start checking for zero blocks again. Working on file

 *	block boundaries significantly reduces the overhead when copying files

 *	that are NOT very sparse. This overhead (when compared to a write) is

 *	almost below the measurement resolution on many systems. Without it,

 *	files with holes cannot be safely copied. It does has a side effect as

 *	it can put holes into files that did not have them before, but that is

 *	not a problem since the file contents are unchanged (in fact it saves

 *	file space). (Except on paging files for diskless clients. But since we

 *	cannot determine one of those file from here, we ignore them). If this

 *	ever ends up on a system where CTG files are supported and the holes

 *	are not desired, just do a conditional test in those routines that

 *	call file_write() and have it call write() instead. BEFORE CLOSING THE

 *	FILE, make sure to call file_flush() when the last write finishes with

 *	an empty block. A lot of file systems will not create an lseek hole at

 *	the end. In this case we drop a single 0 at the end to force the

 *	trailing 0's in the file.

 *	---Parameters---

 *	rem: how many bytes left in this file system block

 *	isempt: have we written to the file block yet (is it empty)

 *	sz: basic file block allocation size

 *	cnt: number of bytes on this write

 *	str: buffer to write

 * Return:

 *	number of bytes written, -1 on write (or lseek) error.

 */

int

file_write(int fd, char *str, size_t cnt, int *rem, int *isempt, int sz)

{

	char *pt;

	char *end;

	size_t wcnt;

	/*

	 * while we have data to process

	 */

			/*

			 * We are now at the start of file system block again

			 * (or what we think one is...). start looking for

			 * empty blocks again

			 */

		}

		/*

		 * only examine up to the end of the current file block or

		 * remaining characters to write, whatever is smaller

		 */

			/*

			 * have not written to this block yet, so we keep

			 * looking for zero's

			 */

			/*

			 * look for a zero filled buffer

			 */

				/*

				 * skip, buf is empty so far

				 */

				}

			}

			/*

			 * drat, the buf is not zero filled

			 */

		}

		/*

		 * have non-zero data in this file system block, have to write

		 */

		}

	}

}

/*

 * file_flush()

 *	when the last file block in a file is zero, many file systems will not

 *	let us create a hole at the end. To get the last block with zeros, we

 *	write the last BYTE with a zero (back up one byte and write a zero).

 */

void

file_flush(int fd, int isempt)

{

	static char blnk[] = "\0";

	/*

	 * silly test, but make sure we are only called when the last block is

	 * filled with all zeros.

	 */

	/*

	 * move back one byte and write a zero

	 */

	}

	return;

}