/*	$OpenBSD: ar_subs.c,v 1.45 2015/03/19 05:14:24 guenther Exp $	*/

/*	$NetBSD: ar_subs.c,v 1.5 1995/03/21 09:07:06 cgd Exp $	*/

/*-

 * Copyright (c) 1992 Keith Muller.

 * Copyright (c) 1992, 1993

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

 *

 * This code is derived from software contributed to Berkeley by

 * Keith Muller of the University of California, San Diego.

 *

 * 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/types.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <signal.h>

#include <string.h>

#include <stdio.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <stdlib.h>

#include "pax.h"

#include "extern.h"

static void wr_archive(ARCHD *, int is_app);

static int get_arc(void);

static int next_head(ARCHD *);

extern sigset_t s_mask;

/*

 * Routines which control the overall operation modes of pax as specified by

 * the user: list, append, read ...

 */

static char hdbuf[BLKMULT];		/* space for archive header on read */

u_long flcnt;				/* number of files processed */

/*

 * list()

 *	list the contents of an archive which match user supplied pattern(s)

 *	(no pattern matches all).

 */

void

list(void)

	ARCHD *arcn;

	int res;

	ARCHD archd;

	time_t now;

	/*

	 * figure out archive type; pass any format specific options to the

	 * archive option processing routine; call the format init routine. We

	 * also save current time for ls_list() so we do not make a system

	 * call for each file we need to print. If verbose (vflag) start up

	 * the name and group caches.

	 */

	    ((*frmt->st_rd)() < 0))

		return;

		return;

	/*

	 * step through the archive until the format says it is done

	 */

			/*

			 * we need to read, to get the real filename

			 */

			off_t cnt;

			    ? -1 : -2, &cnt))

			continue;

		}

		/*

		 * check for pattern, and user specified options match.

		 * When all patterns are matched we are done.

		 */

			/*

			 * pattern resulted in a selected file

			 */

			/*

			 * modify the name as requested by the user if name

			 * survives modification, do a listing of the file

			 */

		}

		/*

		 * skip to next archive format header using values calculated

		 * by the format header read routine

		 */

	}

	/*

	 * all done, let format have a chance to cleanup, and make sure that

	 * the patterns supplied by the user were all matched

	 */

}

static int

cmp_file_times(int mtime_flag, int ctime_flag, ARCHD *arcn, struct stat *sbp)

{

	struct stat sb;

	}

		        timespeccmp(&arcn->sb.st_ctim, &sbp->st_ctim, <=));

	else

}

/*

 * extract()

 *	extract the member(s) of an archive as specified by user supplied

 *	pattern(s) (no patterns extracts all members)

 */

void

extract(void)

	ARCHD *arcn;

	int res;

	off_t cnt;

	ARCHD archd;

	int fd;

	time_t now;

	/*

	 * figure out archive type; pass any format specific options to the

	 * archive option processing routine; call the format init routine;

	 * start up the directory modification time and access mode database

	 */

	    ((*frmt->st_rd)() < 0) || (dir_start() < 0))

		return;

	/*

	 * When we are doing interactive rename, we store the mapping of names

	 * so we can fix up hard links files later in the archive.

	 */

	/*

	 * step through each entry on the archive until the format read routine

	 * says it is done

	 */

			/*

			 * we need to read, to get the real filename

			 */

			    ? -1 : -2, &cnt))

			continue;

		}

		/*

		 * check for pattern, and user specified options match. When

		 * all the patterns are matched we are done

		 */

			/*

			 * file is not selected. skip past any file data and

			 * padding and go back for the next archive member

			 */

		}

		/*

		 * with -u or -D only extract when the archive member is newer

		 * than the file with the same name in the file system (no

		 * test of being the same type is required).

		 * NOTE: this test is done BEFORE name modifications as

		 * specified by pax. this operation can be confusing to the

		 * user who might expect the test to be done on an existing

		 * file AFTER the name mod. In honesty the pax spec is probably

		 * flawed in this respect.

		 */

		    cmp_file_times(uflag, Dflag, arcn, NULL)) {

		}

		/*

		 * this archive member is now been selected. modify the name.

		 */

			break;

			/*

			 * a bad name mod, skip and purge name from link table

			 */

		}

		/*

		 * Non standard -Y and -Z flag. When the existing file is

		 * same age or newer skip

		 */

		    cmp_file_times(Yflag, Zflag, arcn, NULL)) {

		}

			else {

			}

		}

		/*

		 * if required, chdir around.

		 */

				    arcn->pat->chdname);

		/*

		 * all ok, extract this member based on type

		 */

			/*

			 * process archive members that are not regular files.

			 * throw out padding and any data that might follow the

			 * header (as determined by the format).

			 */

			else

			}

			goto popd;

		}

		/*

		 * we have a file with data here. If we can not create it, skip

		 * over the data and purge the name from hard link table

		 */

		}

		/*

		 * extract the file from the archive and skip over padding and

		 * any unprocessed data

		 */

		}

		/*

		 * if required, chdir around.

		 */

				    "Can't fchdir to starting directory");

	}

	/*

	 * all done, restore directory modes and times as required; make sure

	 * all patterns supplied by the user were matched; block off signals

	 * to avoid chance for multiple entry into the cleanup code.

	 */

}

/*

 * wr_archive()

 *	Write an archive. used in both creating a new archive and appends on

 *	previously written archive.

 */

static void

wr_archive(ARCHD *arcn, int is_app)

	int res;

	int hlk;

	int wr_one;

	off_t cnt;

	int (*wrf)(ARCHD *);

	time_t now;

	/*

	 * if this format supports hard link storage, start up the database

	 * that detects them.

	 */

	/*

	 * if this is not append, and there are no files, we do not write a

	 * trailer

	 */

	/*

	 * start up the file traversal code and format specific write

	 */

		return;

	/*

	 * When we are doing interactive rename, we store the mapping of names

	 * so we can fix up hard links files later in the archive.

	 */

	/*

	 * while there are files to archive, process them one at at time

	 */

		/*

		 * check if this file meets user specified options match.

		 */

			/*

			 * only archive if this file is newer than a file with

			 * the same name that is already stored on the archive

			 */

			}

		}

		/*

		 * this file is considered selected now. see if this is a hard

		 * link to a file already stored

		 */

			/*

			 * we will have to read this file. by opening it now we

			 * can avoid writing a header to the archive for a file

			 * we were later unable to read (we also purge it from

			 * the link table).

			 */

					arcn->org_name);

			}

		}

		/*

		 * Now modify the name as requested by the user

		 */

			/*

			 * name modification says to skip this file, close the

			 * file and purge link table entry

			 */

		}

			/*

			 * unable to obtain the crc we need, close the file,

			 * purge link table entry

			 */

		}

			else {

			}

		}

		/*

		 * looks safe to store the file, have the format specific

		 * routine write routine store the file header on the archive

		 */

		}

			/*

			 * format write says no file data needs to be stored

			 * so we are done messing with this file

			 */

			}

		}

		/*

		 * Add file data to the archive, quit on write error. if we

		 * cannot write the entire file contents to the archive we

		 * must pad the archive to replace the missing file data

		 * (otherwise during an extract the file header for the file

		 * which FOLLOWS this one will not be where we expect it to

		 * be).

		 */

		}

		/*

		 * pad as required, cnt is number of bytes not written

		 */

		    ((arcn->pad > 0) && (wr_skip(arcn->pad) < 0)))

			break;

	}

	/*

	 * tell format to write trailer; pad to block boundary; reset directory

	 * mode/access times, and check if all patterns supplied by the user

	 * were matched. block off signals to avoid chance for multiple entry

	 * into the cleanup code

	 */

	}

}

/*

 * append()

 *	Add file to previously written archive. Archive format specified by the

 *	user must agree with archive. The archive is read first to collect

 *	modification times (if -u) and locate the archive trailer. The archive

 *	is positioned in front of the record with the trailer and wr_archive()

 *	is called to add the new members.

 *	PAX IMPLEMENTATION DETAIL NOTE:

 *	-u is implemented by adding the new members to the end of the archive.

 *	Care is taken so that these do not end up as links to the older

 *	version of the same file already stored in the archive. It is expected

 *	when extraction occurs these newer versions will over-write the older

 *	ones stored "earlier" in the archive (this may be a bad assumption as

 *	it depends on the implementation of the program doing the extraction).

 *	It is really difficult to splice in members without either re-writing

 *	the entire archive (from the point were the old version was), or having

 *	assistance of the format specification in terms of a special update

 *	header that invalidates a previous archive record. The posix spec left

 *	the method used to implement -u unspecified. This pax is able to

 *	over write existing files that it creates.

 */

void

append(void)

	ARCHD *arcn;

	int res;

	ARCHD archd;

	FSUB *orgfrmt;

	int udev;

	off_t tlen;

	/*

	 * Do not allow an append operation if the actual archive is of a

	 * different format than the user specified format.

	 */

		    frmt->name, orgfrmt->name);

	}

	/*

	 * pass the format any options and start up format

	 */

		return;

	/*

	 * if we only are adding members that are newer, we need to save the

	 * mod times for all files we see.

	 */

	/*

	 * some archive formats encode hard links by recording the device and

	 * file serial number (inode) but copy the file anyway (multiple times)

	 * to the archive. When we append, we run the risk that newly added

	 * files may have the same device and inode numbers as those recorded

	 * on the archive but during a previous run. If this happens, when the

	 * archive is extracted we get INCORRECT hard links. We avoid this by

	 * remapping the device numbers so that newly added files will never

	 * use the same device number as one found on the archive. remapping

	 * allows new members to safely have links among themselves. remapping

	 * also avoids problems with file inode (serial number) truncations

	 * when the inode number is larger than storage space in the archive

	 * header. See the remap routines for more details.

	 */

	/*

	 * reading the archive may take a long time. If verbose tell the user

	 */

			"%s: Reading archive to position at the end...", argv0);

	}

	/*

	 * step through the archive until the format says it is done

	 */

		/*

		 * check if this file meets user specified options.

		 */

			continue;

		}

			/*

			 * see if this is the newest version of this file has

			 * already been seen, if so skip.

			 */

				continue;

			}

		}

		/*

		 * Store this device number. Device numbers seen during the

		 * read phase of append will cause newly appended files with a

		 * device number seen in the old part of the archive to be

		 * remapped to an unused device number.

		 */

		    (rd_skip(arcn->skip + arcn->pad) == 1))

			break;

	}

	/*

	 * done, finish up read and get the number of bytes to back up so we

	 * can add new members. The format might have used the hard link table,

	 * purge it.

	 */

	/*

	 * try to position for write, if this fails quit. if any error occurs,

	 * we will refuse to write

	 */

	/*

	 * tell the user we are done reading.

	 */

	}

	/*

	 * go to the writing phase to add the new members

	 */

}

/*

 * archive()

 *	write a new archive

 */

void

archive(void)

	ARCHD archd;

	/*

	 * if we only are adding members that are newer, we need to save the

	 * mod times for all files; set up for writing; pass the format any

	 * options write the archive

	 */

		return;

}

/*

 * copy()

 *	copy files from one part of the file system to another. this does not

 *	use any archive storage. The EFFECT OF THE COPY IS THE SAME as if an

 *	archive was written and then extracted in the destination directory

 *	(except the files are forced to be under the destination directory).

 */

void

copy(void)

{

	ARCHD *arcn;

	int res;

	int fddest;

	char *dest_pt;

	size_t dlen;

	size_t drem;

	struct stat sb;

	ARCHD archd;

	char dirbuf[PAXPATHLEN+1];

	/*

	 * set up the destination dir path and make sure it is a directory. We

	 * make sure we have a trailing / on the destination

	 */

	    (dlen == sizeof(dirbuf) - 1 && dirbuf[dlen - 1] != '/')) {

	}

	}

			dirptr);

	}

	}

	/*

	 * start up the hard link table; file traversal routines and the

	 * modification time and access mode database

	 */

		return;

	/*

	 * When we are doing interactive rename, we store the mapping of names

	 * so we can fix up hard links files later in the archive.

	 */

	/*

	 * set up to cp file trees

	 */

	/*

	 * while there are files to archive, process them

	 */

		/*

		 * check if this file meets user specified options

		 */

		/*

		 * if there is already a file in the destination directory with

		 * the same name and it is newer, skip the one stored on the

		 * archive.

		 * NOTE: this test is done BEFORE name modifications as

		 * specified by pax. this can be confusing to the user who

		 * might expect the test to be done on an existing file AFTER

		 * the name mod. In honesty the pax spec is probably flawed in

		 * this respect

		 */

			/*

			 * create the destination name

			 */

			    drem + 1) > drem) {

					arcn->name);

			}

			/*

			 * if existing file is same age or newer skip

			 */

			}

		}

		/*

		 * this file is considered selected. See if this is a hard link

		 * to a previous file; modify the name as requested by the

		 * user; set the final destination.

		 */

			break;

			/*

			 * skip file, purge from link table

			 */

		}

		/*

		 * Non standard -Y and -Z flag. When the existing file is

		 * same age or newer skip

		 */

		    cmp_file_times(Yflag, Zflag, arcn, NULL))

		}

		/*

		 * try to create a hard link to the src file if requested

		 * but make sure we are not trying to overwrite ourselves.

		 */

		else

			}

			continue;

		}

		/*

		 * have to create a new file

		 */

			/*

			 * create a link or special file

			 */

			else

			}

			continue;

		}

		/*

		 * have to copy a regular file to the destination directory.

		 * first open source file and then create the destination file

		 */

			    arcn->org_name);

		}

		}

		/*

		 * copy source file data to the destination file

		 */

		}

	}

	/*

	 * restore directory modes and times as required; make sure all

	 * patterns were selected block off signals to avoid chance for

	 * multiple entry into the cleanup code.

	 */

}

/*

 * next_head()

 *	try to find a valid header in the archive. Uses format specific

 *	routines to extract the header and id the trailer. Trailers may be