/*	$OpenBSD: tar.c,v 1.59 2016/02/15 02:38:53 guenther Exp $	*/

/*	$NetBSD: tar.c,v 1.5 1995/03/21 09:07:49 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 <ctype.h>

#include <errno.h>

#include <limits.h>

#include <string.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include "pax.h"

#include "extern.h"

#include "tar.h"

/*

 * Routines for reading, writing and header identify of various versions of tar

 */

static size_t expandname(char *, size_t, char **, const char *, size_t);

static u_long tar_chksm(char *, int);

static char *name_split(char *, int);

static int ul_oct(u_long, char *, int, int);

static int uqd_oct(u_quad_t, char *, int, int);

#ifndef SMALL

static int rd_xheader(ARCHD *arcn, int, off_t);

#endif

static uid_t uid_nobody;

static uid_t uid_warn;

static gid_t gid_nobody;

static gid_t gid_warn;

/*

 * Routines common to all versions of tar

 */

int tar_nodir;				/* do not write dirs under old tar */

char *gnu_name_string;			/* GNU ././@LongLink hackery name */

char *gnu_link_string;			/* GNU ././@LongLink hackery link */

/*

 * tar_endwr()

 *	add the tar trailer of two null blocks

 * Return:

 *	0 if ok, -1 otherwise (what wr_skip returns)

 */

int

tar_endwr(void)

}

/*

 * tar_endrd()

 *	no cleanup needed here, just return size of trailer (for append)

 * Return:

 *	size of trailer (2 * BLKMULT)

 */

off_t

tar_endrd(void)

}

/*

 * tar_trail()

 *	Called to determine if a header block is a valid trailer. We are passed

 *	the block, the in_sync flag (which tells us we are in resync mode;

 *	looking for a valid header), and cnt (which starts at zero) which is

 *	used to count the number of empty blocks we have seen so far.

 * Return:

 *	0 if a valid trailer, -1 if not a valid trailer, or 1 if the block

 *	could never contain a header.

 */

int

tar_trail(ARCHD *ignore, char *buf, int in_resync, int *cnt)

	int i;

	/*

	 * look for all zero, trailer is two consecutive blocks of zero

	 */

	}

	/*

	 * if not all zero it is not a trailer, but MIGHT be a header.

	 */

	/*

	 * When given a zero block, we must be careful!

	 * If we are not in resync mode, check for the trailer. Have to watch

	 * out that we do not mis-identify file data as the trailer, so we do

	 * NOT try to id a trailer during resync mode. During resync mode we

	 * might as well throw this block out since a valid header can NEVER be

	 * a block of all 0 (we must have a valid file name).

	 */

}

/*

 * ul_oct()

 *	convert an unsigned long to an octal string. many oddball field

 *	termination characters are used by the various versions of tar in the

 *	different fields. term selects which kind to use. str is '0' padded

 *	at the front to len. we are unable to use only one format as many old

 *	tar readers are very cranky about this.

 * Return:

 *	0 if the number fit into the string, -1 otherwise

 */

static int

ul_oct(u_long val, char *str, int len, int term)

	char *pt;

	/*

	 * term selects the appropriate character(s) for the end of the string

	 */

	case 3:

	case 2:

	case 1:

	case 0:

	default:

		break;

	}

	/*

	 * convert and blank pad if there is space

	 */

	}

}

/*

 * uqd_oct()

 *	convert an u_quad_t to an octal string. one of many oddball field

 *	termination characters are used by the various versions of tar in the

 *	different fields. term selects which kind to use. str is '0' padded

 *	at the front to len. we are unable to use only one format as many old

 *	tar readers are very cranky about this.

 * Return:

 *	0 if the number fit into the string, -1 otherwise

 */

static int

uqd_oct(u_quad_t val, char *str, int len, int term)

	char *pt;

	/*

	 * term selects the appropriate character(s) for the end of the string

	 */

	case 3:

	case 2:

	case 1:

	case 0:

	default:

		break;

	}

	/*

	 * convert and blank pad if there is space

	 */

	}

}

/*

 * tar_chksm()

 *	calculate the checksum for a tar block counting the checksum field as

 *	all blanks (BLNKSUM is that value pre-calculated, the sum of 8 blanks).

 *	NOTE: we use len to short circuit summing 0's on write since we ALWAYS

 *	pad headers with 0.

 * Return:

 *	unsigned long checksum

 */

static u_long

tar_chksm(char *blk, int len)

	char *stop;

	char *pt;

	/*

	 * add the part of the block before the checksum field

	 */

	/*

	 * move past the checksum field and keep going, spec counts the

	 * checksum field as the sum of 8 blanks (which is pre-computed as

	 * BLNKSUM).

	 * ASSUMED: len is greater than CHK_OFFSET. (len is where our 0 padding

	 * starts, no point in summing zero's)

	 */

}

/*

 * Routines for old BSD style tar (also made portable to sysV tar)

 */

/*

 * tar_id()

 *	determine if a block given to us is a valid tar header (and not a USTAR

 *	header). We have to be on the lookout for those pesky blocks of	all

 *	zero's.

 * Return:

 *	0 if a tar header, -1 otherwise

 */

int

tar_id(char *blk, int size)

	HD_TAR *hd;

	HD_USTAR *uhd;

	/*

	 * check for block of zero's first, a simple and fast test, then make

	 * sure this is not a ustar header by looking for the ustar magic

	 * cookie. We should use TMAGLEN, but some USTAR archive programs are

	 * wrong and create archives missing the \0. Last we check the

	 * checksum. If this is ok we have to assume it is a valid header.

	 */

}

/*

 * tar_opt()

 *	handle tar format specific -o options

 * Return:

 *	0 if ok -1 otherwise

 */

int

tar_opt(void)

	OPLIST *opt;

		    strcmp(opt->value, TAR_NODIR)) {

			    opt->name, opt->value);

			    TAR_OPTION, TAR_NODIR);

		}

		/*

		 * we only support one option, and only when writing

		 */

			    opt->name, opt->value);

		}

	}

}

/*

 * tar_rd()

 *	extract the values out of block already determined to be a tar header.

 *	store the values in the ARCHD parameter.

 * Return:

 *	0

 */

int

tar_rd(ARCHD *arcn, char *buf)

	HD_TAR *hd;

	u_quad_t val;

	char *pt;

	/*

	 * we only get proper sized buffers passed to us

	 */

	/*

	 * copy out the name and values in the stat buffer

	 */

		    &gnu_name_string, hd->name, sizeof(hd->name));

		    &gnu_link_string, hd->linkname, sizeof(hd->linkname));

	}

	    0xfff);

	else

	/*

	 * have to look at the last character, it may be a '/' and that is used

	 * to encode this as a directory

	 */

	case SYMTYPE:

		/*

		 * symbolic link, need to get the link name and set the type in

		 * the st_mode so -v printing will look correct.

		 */

	case LNKTYPE:

		/*

		 * hard link, need to get the link name, set the type in the

		 * st_mode and st_nlink so -v printing will look better.

		 */

		/*

		 * no idea of what type this thing really points at, but

		 * we set something for printing only.

		 */

	case LONGLINKTYPE:

	case LONGNAMETYPE:

		/*

		 * GNU long link/file; we tag these here and let the

		 * pax internals deal with it -- too ugly otherwise.

		 */

		    hd->linkflag == LONGLINKTYPE ? PAX_GLL : PAX_GLF;

	case DIRTYPE:

		/*

		 * It is a directory, set the mode for -v printing

		 */

	case AREGTYPE:

	case REGTYPE:

	default:

		/*

		 * If we have a trailing / this is a directory and NOT a file.

		 */

			/*

			 * it is a directory, set the mode for -v printing

			 */

		} else {

			/*

			 * have a file that will be followed by data. Set the

			 * skip value to the size field and calculate the size

			 * of the padding.

			 */

		}

		break;

	}

	/*

	 * strip off any trailing slash.

	 */

	}

}

/*

 * tar_wr()

 *	write a tar header for the file specified in the ARCHD to the archive.

 *	Have to check for file types that cannot be stored and file names that

 *	are too long. Be careful of the term (last arg) to ul_oct, each field

 *	of tar has it own spec for the termination character(s).

 *	ASSUMED: space after header in header block is zero filled

 * Return:

 *	0 if file has data to be written after the header, 1 if file has NO

 *	data to write after the header, -1 if archive write failed

 */

int

tar_wr(ARCHD *arcn)

	HD_TAR *hd;

	int len;

	char hdblk[sizeof(HD_TAR)];

	/*

	 * check for those file system types which tar cannot store

	 */

	case PAX_DIR:

		/*

		 * user asked that dirs not be written to the archive

		 */

		break;

	case PAX_CHR:

		    arcn->org_name);

	case PAX_BLK:

	case PAX_SCK:

	case PAX_FIF:

	case PAX_SLK:

	case PAX_HLK:

	case PAX_HRG:

			    arcn->ln_name);

		}

		break;

	case PAX_REG:

	case PAX_CTG:

	default:

		break;

	}

	/*

	 * check file name len, remember extra char for dirs (the / at the end)

	 */

	}

	/*

	 * Copy the data out of the ARCHD into the tar header based on the type

	 * of the file. Remember, many tar readers want all fields to be

	 * padded with zero so we zero the header first.  We then set the

	 * linkflag field (type), the linkname, the size, and set the padding

	 * (if any) to be added after the file data (0 for all other types,

	 * as they only have a header).

	 */

		/*

		 * directories are the same as files, except have a filename

		 * that ends with a /, we add the slash here. No data follows

		 * dirs, so no pad.

		 */

		/*

		 * no data follows this file, so no pad

		 */

		    sizeof(arcn->ln_name));

		/*

		 * no data follows this file, so no pad

		 */

		    sizeof(arcn->ln_name));

	} else {

		/*

		 * data follows this file, so set the pad

		 */

		    sizeof(hd->size), 1)) {

		}

	}

	/*

	 * copy those fields that are independent of the type

	 */

	    uqd_oct(arcn->sb.st_mtime < 0 ? 0 : arcn->sb.st_mtime, hd->mtime,

		sizeof(hd->mtime), 1) ||

	    ul_oct((u_long)arcn->sb.st_uid, hd->uid, sizeof(hd->uid), 0) ||

	    ul_oct((u_long)arcn->sb.st_gid, hd->gid, sizeof(hd->gid), 0))

		goto out;

	/*

	 * calculate and add the checksum, then write the header. A return of

	 * 0 tells the caller to now write the file data, 1 says no data needs

	 * to be written

	 */

	    sizeof(hd->chksum), 3))

	/*

	 * header field is out of range

	 */

}

/*

 * Routines for POSIX ustar

 */

/*

 * ustar_strd()

 *	initialization for ustar read

 * Return:

 *	0 if ok, -1 otherwise

 */

int

ustar_strd(void)

}

/*

 * ustar_stwr()

 *	initialization for ustar write

 * Return:

 *	0 if ok, -1 otherwise

 */

int

ustar_stwr(void)

}

/*

 * ustar_id()

 *	determine if a block given to us is a valid ustar header. We have to

 *	be on the lookout for those pesky blocks of all zero's

 * Return:

 *	0 if a ustar header, -1 otherwise

 */

int

ustar_id(char *blk, int size)

	HD_USTAR *hd;

	/*

	 * check for block of zero's first, a simple and fast test then check

	 * ustar magic cookie. We should use TMAGLEN, but some USTAR archive

	 * programs are fouled up and create archives missing the \0. Last we

	 * check the checksum. If ok we have to assume it is a valid header.

	 */

}

/*

 * ustar_rd()

 *	extract the values out of block already determined to be a ustar header.

 *	store the values in the ARCHD parameter.

 * Return:

 *	0

 */

int

ustar_rd(ARCHD *arcn, char *buf)

	char *dest;

	dev_t devmajor;

	dev_t devminor;

	u_quad_t val;

	/*

	 * we only get proper sized buffers

	 */

#ifndef SMALL

#endif

#ifndef SMALL

	/* Process Extended headers. */

		    (off_t)asc_ul(hd->size, sizeof(hd->size), OCT)) < 0)

		/* Update and check the ustar header. */

		/* if the next block is another extension, reset the values */

	}

#endif

		/*

		 * See if the filename is split into two parts. if, so join

		 * the parts.  We copy the prefix first and add a / between

		 * the prefix and name.

		 */

			    hd->prefix, sizeof(hd->prefix));

		} else

		    hd->typeflag != LONGNAMETYPE) {

			    sizeof(arcn->name) - cnt, &gnu_name_string,

			    hd->name, sizeof(hd->name));

		}

	}

	    hd->typeflag != LONGLINKTYPE && hd->typeflag != LONGNAMETYPE) {

		    &gnu_link_string, hd->linkname, sizeof(hd->linkname));

	}

	/*

	 * follow the spec to the letter. we should only have mode bits, strip

	 * off all other crud we may be passed.

	 */

	    0xfff);

	else

	/*

	 * If we can find the ascii names for gname and uname in the password

	 * and group files we will use the uid's and gid they bind. Otherwise

	 * we use the uid and gid values stored in the header. (This is what

	 * the posix spec wants).

	 */

	/*

	 * set the defaults, these may be changed depending on the file type

	 */

	/*

	 * set the mode and PAX type according to the typeflag in the header

	 */

	case FIFOTYPE:

	case DIRTYPE:

		/*

		 * Some programs that create ustar archives append a '/'

		 * to the pathname for directories. This clearly violates

		 * ustar specs, but we will silently strip it off anyway.

		 */

		break;

	case BLKTYPE:

	case CHRTYPE:

		/*

		 * this type requires the rdev field to be set.

		 */

		} else {

		}

	case SYMTYPE:

	case LNKTYPE:

		} else {

			/*

			 * so printing looks better

			 */

		}

		break;

	case LONGLINKTYPE:

	case LONGNAMETYPE:

		/*

		 * GNU long link/file; we tag these here and let the

		 * pax internals deal with it -- too ugly otherwise.

		 */

		    hd->typeflag == LONGLINKTYPE ? PAX_GLL : PAX_GLF;

	case CONTTYPE:

	case AREGTYPE:

	case REGTYPE:

	default:

		/*

		 * these types have file data that follows. Set the skip and

		 * pad fields.

		 */

		break;

	}

}

/*

 * ustar_wr()

 *	write a ustar header for the file specified in the ARCHD to the archive

 *	Have to check for file types that cannot be stored and file names that

 *	are too long. Be careful of the term (last arg) to ul_oct, we only use

 *	'\0' for the termination character (this is different than picky tar)

 *	ASSUMED: space after header in header block is zero filled

 * Return:

 *	0 if file has data to be written after the header, 1 if file has NO

 *	data to write after the header, -1 if archive write failed

 */

int

ustar_wr(ARCHD *arcn)

	HD_USTAR *hd;

	char *pt;

	char hdblk[sizeof(HD_USTAR)];

	/*

	 * check for those file system types ustar cannot store

	 */

	}

	/*

	 * user asked that dirs not be written to the archive

	 */

	/*

	 * check the length of the linkname

	 */

	}

	/*

	 * split the path name into prefix and name fields (if needed). if

	 * pt != arcn->name, the name has to be split

	 */

	}

	/*

	 * zero out the header so we don't have to worry about zero fill below

	 */