/*	$OpenBSD: ar_io.c,v 1.56 2016/06/03 23:22:20 tedu Exp $	*/

/*	$NetBSD: ar_io.c,v 1.5 1996/03/26 23:54:13 mrg 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 <sys/ioctl.h>

#include <sys/mtio.h>

#include <sys/wait.h>

#include <signal.h>

#include <string.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <err.h>

#include "pax.h"

#include "options.h"

#include "extern.h"

/*

 * Routines which deal directly with the archive I/O device/file.

 */

#define DMOD		0666		/* default mode of created archives */

#define EXT_MODE	O_RDONLY	/* open mode for list/extract */

#define AR_MODE		(O_WRONLY | O_CREAT | O_TRUNC)	/* mode for archive */

#define APP_MODE	O_RDWR		/* mode for append */

#define STDO		"<STDOUT>"	/* pseudo name for stdout */

#define STDN		"<STDIN>"	/* pseudo name for stdin */

static int arfd = -1;			/* archive file descriptor */

static int artyp = ISREG;		/* archive type: file/FIFO/tape */

static int arvol = 1;			/* archive volume number */

static int lstrval = -1;		/* return value from last i/o */

static int io_ok;			/* i/o worked on volume after resync */

static int did_io;			/* did i/o ever occur on volume? */

static int done;			/* set via tty termination */

static struct stat arsb;		/* stat of archive device at open */

static int invld_rec;			/* tape has out of spec record size */

static int wr_trail = 1;		/* trailer was rewritten in append */

static int can_unlnk = 0;		/* do we unlink null archives?  */

const char *arcname;			/* printable name of archive */

const char *gzip_program;		/* name of gzip program */

static pid_t zpid = -1;			/* pid of child process */

int force_one_volume;			/* 1 if we ignore volume changes */

static int get_phys(void);

extern sigset_t s_mask;

static void ar_start_gzip(int, const char *, int);

/*

 * ar_open()

 *	Opens the next archive volume. Determines the type of the device and

 *	sets up block sizes as required by the archive device and the format.

 *	Note: we may be called with name == NULL on the first open only.

 * Return:

 *	-1 on failure, 0 otherwise

 */

int

ar_open(const char *name)

	struct mtget mb;

	/*

	 * open based on overall operation mode

	 */

	case LIST:

	case EXTRACT:

		break;

	case ARCHIVE:

		else

		break;

	case APPND:

				name);

		break;

	case COPY:

		/*

		 * arfd not used in COPY mode

		 */

	}

		}

	/*

	 * set up is based on device type

	 */

	}

		    arcname);

	}

	else

	/*

	 * make sure beyond any doubt that we can unlink only regular files

	 * we created

	 */

	/*

	 * if we are writing, we are done

	 */

	}

	/*

	 * set default blksz on read. APPNDs writes rdblksz on the last volume

	 * On all new archive volumes, we shift to wrblksz (if the user

	 * specified one, otherwise we will continue to use rdblksz). We

	 * must set blocksize based on what kind of device the archive is

	 * stored.

	 */

	case ISTAPE:

		/*

		 * Tape drives come in at least two flavors. Those that support

		 * variable sized records and those that have fixed sized

		 * records. They must be treated differently. For tape drives

		 * that support variable sized records, we must make large

		 * reads to make sure we get the entire record, otherwise we

		 * will just get the first part of the record (up to size we

		 * asked). Tapes with fixed sized records may or may not return

		 * multiple records in a single read. We really do not care

		 * what the physical record size is UNLESS we are going to

		 * append. (We will need the physical block size to rewrite

		 * the trailer). Only when we are appending do we go to the

		 * effort to figure out the true PHYSICAL record size.

		 */

	case ISPIPE:

	case ISBLK:

	case ISCHR:

		/*

		 * Blocksize is not a major issue with these devices (but must

		 * be kept a multiple of 512). If the user specified a write

		 * block size, we use that to read. Under append, we must

		 * always keep blksz == rdblksz. Otherwise we go ahead and use

		 * the device optimal blocksize as (and if) returned by stat

		 * and if it is within pax specs.

		 */

		}

		    ((arsb.st_blksize % BLKMULT) == 0))

		else

		/*

		 * For performance go for large reads when we can without harm

		 */

		else

		break;

	case ISREG:

		/*

		 * if the user specified wrblksz works, use it. Under appends

		 * we must always keep blksz == rdblksz

		 */

		}

		/*

		 * See if we can find the blocking factor from the file size

		 */

		/*

		 * When we cannot find a match, we may have a flawed archive.

		 */

		/*

		 * for performance go for large reads when we can

		 */

		else

		break;

	default:

		/*

		 * should never happen, worst case, slow...

		 */

		break;

	}

}

/*

 * ar_close(int int_sig)

 *	closes archive device, increments volume number, and prints i/o summary

 *	If in_sig is set we're in a signal handler and can't flush stdio.

 */

void

ar_close(int in_sig)

	int status;

	}

	/*

	 * Close archive file. This may take a LONG while on tapes (we may be

	 * forced to wait for the rewind to complete) so tell the user what is

	 * going on (this avoids the user hitting control-c thinking pax is

	 * broken).

	 */

		    "%s%s: Waiting for tape drive close to complete...",

		    vfpart ? "\n" : "", argv0);

	}

	/*

	 * if nothing was written to the archive (and we created it), we remove

	 * it

	 */

	    (arsb.st_size == 0)) {

	}

	/*

	 * for a quick extract/list, pax frequently exits before the child

	 * process is done

	 */

	}

	/* Do not exit before child to ensure data integrity */

	}

	}

	}

	/*

	 * The volume number is only increased when the last device has data

	 * and we have already determined the archive format.

	 */

	}

	/*

	 * Print out a summary of I/O for this archive volume.

	 */

	}

	/*

	 * If we have not determined the format yet, we just say how many bytes

	 * we have skipped over looking for a header to id. there is no way we

	 * could have written anything yet.

	 */

		    "%s: unknown format, %llu bytes skipped.\n", argv0, rdcnt);

	}

		    " %llu bytes read, %llu bytes written.\n",

		    argv0, frmt->name, arvol-1, flcnt, rdcnt, wrcnt);

#ifndef NOCPIO

		    (rdcnt ? rdcnt : wrcnt) / 5120);

#endif /* !NOCPIO */

}

/*

 * ar_drain()

 *	drain any archive format independent padding from an archive read

 *	from a socket or a pipe. This is to prevent the process on the

 *	other side of the pipe from getting a SIGPIPE (pax will stop

 *	reading an archive once a format dependent trailer is detected).

 */

void

ar_drain(void)

	int res;

	char drbuf[MAXBLK];

	/*

	 * we only drain from a pipe/socket. Other devices can be closed

	 * without reading up to end of file. We sure hope that pipe is closed

	 * on the other side so we will get an EOF.

	 */

		return;

	/*

	 * keep reading until pipe is drained

	 */

		continue;

}

/*

 * ar_set_wr()

 *	Set up device right before switching from read to write in an append.

 *	device dependent code (if required) to do this should be added here.

 *	For all archive devices we are already positioned at the place we want

 *	to start writing when this routine is called.

 * Return:

 *	0 if all ready to write, -1 otherwise

 */

int

ar_set_wr(void)

	off_t cpos;

	/*

	 * we must make sure the trailer is rewritten on append, ar_next()

	 * will stop us if the archive containing the trailer was not written

	 */

	/*

	 * Add any device dependent code as required here

	 */

	/*

	 * Ok we have an archive in a regular file. If we were rewriting a

	 * file, we must get rid of all the stuff after the current offset

	 * (it was not written by pax).

	 */

	    (ftruncate(arfd, cpos) < 0)) {

	}

}

/*

 * ar_app_ok()

 *	check if the last volume in the archive allows appends. We cannot check

 *	this until we are ready to write since there is no spec that says all

 *	volumes in a single archive have to be of the same type...

 * Return:

 *	0 if we can append, -1 otherwise.

 */

int

ar_app_ok(void)

	}

		rdblksz, argv0);

}

/*

 * ar_read()

 *	read up to a specified number of bytes from the archive into the

 *	supplied buffer. When dealing with tapes we may not always be able to

 *	read what we want.

 * Return:

 *	Number of bytes in buffer. 0 for end of file, -1 for a read error.

 */

int

ar_read(char *buf, int cnt)

	/*

	 * if last i/o was in error, no more reads until reset or new volume

	 */

	/*

	 * how we read must be based on device type

	 */

	case ISTAPE:

			/*

			 * CAUTION: tape systems may not always return the same

			 * sized records so we leave blksz == MAXBLK. The

			 * physical record size that a tape drive supports is

			 * very hard to determine in a uniform and portable

			 * manner.

			 */

				/*

				 * Record size changed. If this happens on

				 * any record after the first, we probably have

				 * a tape drive which has a fixed record size

				 * (we are getting multiple records in a single

				 * read). Watch out for record blocking that

				 * violates pax spec (must be a multiple of

				 * BLKMULT).

				 */

			}

		}

		break;

	case ISREG:

	case ISBLK:

	case ISCHR:

	case ISPIPE:

	default:

		/*

		 * Files are so easy to deal with. These other things cannot

		 * be trusted at all. So when we are dealing with character

		 * devices and pipes we just take what they have ready for us

		 * and return. Trying to do anything else with them runs the

		 * risk of failure.

		 */

		}

		break;

	}

	/*

	 * We are in trouble at this point, something is broken...

	 */

	else

}

/*

 * ar_write()

 *	Write a specified number of bytes in supplied buffer to the archive

 *	device so it appears as a single "block". Deals with errors and tries

 *	to recover when faced with short writes.

 * Return:

 *	Number of bytes written. 0 indicates end of volume reached and with no

 *	flaws (as best that can be detected). A -1 indicates an unrecoverable

 *	error in the archive occurred.

 */

int

ar_write(char *buf, int bsz)

	int res;

	off_t cpos;

	/*

	 * do not allow pax to create a "bad" archive. Once a write fails on

	 * an archive volume prevent further writes to it.

	 */

	}

	/*

	 * write broke, see what we can do with it. We try to send any partial

	 * writes that may violate pax spec to the next archive volume.

	 */

	else

	case ISREG:

			/*

			 * try to fix up partial writes which are not BLKMULT

			 * in size by forcing the runt record to next archive

			 * volume

			 */

		}

		/*

		 * if file is out of space, handle it like a return of 0

		 */

		break;

	case ISTAPE:

	case ISCHR:

	case ISBLK:

		}

		/*

		 * see if we reached the end of media, if so force a change to

		 * the next volume

		 */

		break;

	case ISPIPE:

	default:

		/*

		 * we cannot fix errors to these devices

		 */

		break;

	}

	/*

	 * Better tell the user the bad news...

	 * if this is a block aligned archive format, we may have a bad archive

	 * if the format wants the header to start at a BLKMULT boundary. While

	 * we can deal with the mis-aligned data, it violates spec and other

	 * archive readers will likely fail. if the format is not block

	 * aligned, the user may be lucky (and the archive is ok).

	 */

	}

	/*

	 * If we were trying to rewrite the trailer and it didn't work, we

	 * must quit right away.

	 */

	}

	else

}

/*

 * ar_rdsync()

 *	Try to move past a bad spot on a flawed archive as needed to continue

 *	I/O. Clears error flags to allow I/O to continue.

 * Return:

 *	0 when ok to try i/o again, -1 otherwise.

 */

int

ar_rdsync(void)

{

	long fsbz;

	off_t cpos;

	off_t mpos;

	struct mtop mb;

	/*

	 * Fail resync attempts at user request (done) or if this is going to be

	 * an update/append to a existing archive. if last i/o hit media end,

	 * we need to go to the next volume not try a resync

	 */

	}

	case ISTAPE:

		/*

		 * if the last i/o was a successful data transfer, we assume

		 * the fault is just a bad record on the tape that we are now

		 * past. If we did not get any data since the last resync try

		 * to move the tape forward one PHYSICAL record past any

		 * damaged tape section. Some tape drives are stubborn and need

		 * to be pushed.

		 */

		}

	case ISREG:

	case ISCHR:

	case ISBLK:

		/*

		 * try to step over the bad part of the device.

		 */

	case ISPIPE:

	default:

		/*

		 * cannot recover on these archive device types

		 */

		break;

	}

	}

}

/*

 * ar_fow()

 *	Move the I/O position within the archive forward the specified number of

 *	bytes as supported by the device. If we cannot move the requested

 *	number of bytes, return the actual number of bytes moved in skipped.

 * Return:

 *	0 if moved the requested distance, -1 on complete failure, 1 on

 *	partial move (the amount moved is in skipped)

 */

int

ar_fow(off_t sksz, off_t *skipped)

{

	off_t cpos;

	off_t mpos;

	/*

	 * we cannot move forward at EOF or error

	 */

	/*

	 * Safer to read forward on devices where it is hard to find the end of

	 * the media without reading to it. With tapes we cannot be sure of the

	 * number of physical blocks to skip (we do not know physical block

	 * size at this point), so we must only read forward on tapes!

	 */

	/*

	 * figure out where we are in the archive

	 */

		/*

		 * we can be asked to move farther than there are bytes in this

		 * volume, if so, just go to file end and let normal buf_fill()

		 * deal with the end of file (it will go to next volume by

		 * itself)

		 */

		} else

	}

}

/*

 * ar_rev()

 *	move the i/o position within the archive backwards the specified byte

 *	count as supported by the device. With tapes drives we RESET rdblksz to

 *	the PHYSICAL blocksize.

 *	NOTE: We should only be called to move backwards so we can rewrite the

 *	last records (the trailer) of an archive (APPEND).

 * Return:

 *	0 if moved the requested distance, -1 on complete failure

 */

int

ar_rev(off_t sksz)

	off_t cpos;

	struct mtop mb;

	int phyblk;

	/*

	 * make sure we do not have try to reverse on a flawed archive

	 */

	case ISPIPE:

		/*

		 * cannot go backwards on these critters

		 */

	case ISREG:

	case ISBLK:

	case ISCHR:

	default:

		/*

		 * For things other than files, backwards movement has a very

		 * high probability of failure as we really do not know the

		 * true attributes of the device we are talking to (the device

		 * may not even have the ability to lseek() in any direction).

		 * First we figure out where we are in the archive.

		 */

			   "Unable to obtain current archive byte offset");

		}

		/*

		 * we may try to go backwards past the start when the archive

		 * is only a single record. If this happens and we are on a

		 * multi-volume archive, we need to go to the end of the

		 * previous volume and continue our movement backwards from

		 * there.

		 */

				/*

				 * this should never happen

				 */

			}

		}

		}

		break;

	case ISTAPE:

		/*

		 * Calculate and move the proper number of PHYSICAL tape

		 * blocks. If the sksz is not an even multiple of the physical

		 * tape size, we cannot do the move (this should never happen).

		 * (We also cannot handle trailers spread over two vols.)

		 * get_phys() also makes sure we are in front of the filemark.

		 */

		}

		/*

		 * make sure future tape reads only go by physical tape block

		 * size (set rdblksz to the real size).

		 */

		/*

		 * if no movement is required, just return (we must be after

		 * get_phys() so the physical blocksize is properly set)

		 */

		/*

		 * ok we have to move. Make sure the tape drive can do it.

		 */

			    "Tape drive unable to backspace requested amount");

		}

		/*

		 * move backwards the requested number of bytes

		 */

			    mb.mt_count);

		}

		break;

	}

}