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

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

#include <string.h>

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include "pax.h"

#include "cpio.h"

#include "extern.h"

static int rd_nm(ARCHD *, int);

static int rd_ln_nm(ARCHD *);

static int com_rd(ARCHD *);

/*

 * Routines which support the different cpio versions

 */

static int swp_head;		/* binary cpio header byte swap */

/*

 * Routines common to all versions of cpio

 */

/*

 * cpio_strd()

 *	Fire up the hard link detection code

 * Return:

 *      0 if ok -1 otherwise (the return values of lnk_start())

 */

int

cpio_strd(void)

{

}

/*

 * cpio_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,

 */

int

cpio_trail(ARCHD *arcn, char *notused, int notused2, int *notused3)

{

	/*

	 * look for trailer id in file we are about to process

	 */

}

/*

 * com_rd()

 *	operations common to all cpio read functions.

 * Return:

 *	0

 */

static int

com_rd(ARCHD *arcn)

{

	case C_ISFIFO:

	case C_ISDIR:

	case C_ISBLK:

	case C_ISCHR:

	case C_ISLNK:

	case C_ISOCK:

	case C_ISCTG:

	case C_ISREG:

	default:

		/*

		 * we have file data, set up skip (pad is set in the format

		 * specific sections)

		 */

		break;

	}

}

/*

 * cpio_endwr()

 *	write the special file with the name trailer in the proper format

 * Return:

 *	result of the write of the trailer from the cpio specific write func

 */

int

cpio_endwr(void)

{

	ARCHD last;

	/*

	 * create a trailer request and call the proper format write function

	 */

}

/*

 * rd_nm()

 *	read in the file name which follows the cpio header

 * Return:

 *	0 if ok, -1 otherwise

 */

static int

rd_nm(ARCHD *arcn, int nsz)

{

	/*

	 * do not even try bogus values

	 */

	}

	/*

	 * read the name and make sure it is not empty and is \0 terminated

	 */

	    (arcn->name[0] == '\0')) {

	}

}

/*

 * rd_ln_nm()

 *	read in the link name for a file with links. The link name is stored

 *	like file data (and is NOT \0 terminated!)

 * Return:

 *	0 if ok, -1 otherwise

 */

static int

rd_ln_nm(ARCHD *arcn)

{

	/*

	 * check the length specified for bogus values

	 */

	    (arcn->sb.st_size >= sizeof(arcn->ln_name))) {

		    arcn->sb.st_size);

	}

	/*

	 * read in the link name and \0 terminate it

	 */

	    (int)arcn->sb.st_size) {

	}

	/*

	 * watch out for those empty link names

	 */

	}

}

/*

 * Routines common to the extended byte oriented cpio format

 */

/*

 * cpio_id()

 *      determine if a block given to us is a valid extended byte oriented

 *	cpio header

 * Return:

 *      0 if a valid header, -1 otherwise

 */

int

cpio_id(char *blk, int size)

{

	    (strncmp(blk, AMAGIC, sizeof(AMAGIC) - 1) != 0))

}

/*

 * cpio_rd()

 *	determine if a buffer is a byte oriented extended cpio archive entry.

 *	convert and store the values in the ARCHD parameter.

 * Return:

 *	0 if a valid header, -1 otherwise.

 */

int

cpio_rd(ARCHD *arcn, char *buf)

{

	int nsz;

	u_quad_t val;

	HD_CPIO *hd;

	/*

	 * check that this is a valid header, if not return -1

	 */

	/*

	 * byte oriented cpio (posix) does not have padding! extract the octal

	 * ascii fields from the header

	 */

	    OCT);

	else

	    OCT);

	/*

	 * check name size and if valid, read in the name of this entry (name

	 * follows header in the archive)

	 */

		/*

		 * no link name to read for this file

		 */

	}

	/*

	 * check link name size and read in the link name. Link names are

	 * stored like file data.

	 */

	/*

	 * we have a valid header (with a link)

	 */

}

/*

 * cpio_endrd()

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

 * Return:

 *      size of trailer header in this format

 */

off_t

cpio_endrd(void)

{

}

/*

 * cpio_stwr()

 *	start up the device mapping table

 * Return:

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

 */

int

cpio_stwr(void)

{

}

/*

 * cpio_wr()

 *	copy the data in the ARCHD to buffer in extended byte oriented cpio

 *	format.

 * 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

cpio_wr(ARCHD *arcn)

{

	HD_CPIO *hd;

	int nsz;

	char hdblk[sizeof(HD_CPIO)];

	/*

	 * check and repair truncated device and inode fields in the header

	 */

	case PAX_CTG:

	case PAX_REG:

	case PAX_HRG:

		/*

		 * set data size for file data

		 */

		    sizeof(hd->c_filesize), OCT)) {

			    arcn->org_name);

		}

		break;

	case PAX_SLK:

		/*

		 * set data size to hold link name

		 */

		    sizeof(hd->c_filesize), OCT))

		break;

	default:

		/*

		 * all other file types have no file data

		 */

		     OCT))

		break;

	}

	/*

	 * copy the values to the header using octal ascii

	 */

	    ul_asc((u_long)arcn->sb.st_dev, hd->c_dev, sizeof(hd->c_dev),

		OCT) ||

	    ul_asc((u_long)arcn->sb.st_ino, hd->c_ino, sizeof(hd->c_ino),

		OCT) ||

	    ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode),

		OCT) ||

	    ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid),

		OCT) ||

	    ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid),

		OCT) ||

	    ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink),

		 OCT) ||

	    ul_asc((u_long)arcn->sb.st_rdev, hd->c_rdev, sizeof(hd->c_rdev),

		OCT) ||

	    uqd_asc(arcn->sb.st_mtime < 0 ? 0 : arcn->sb.st_mtime, hd->c_mtime,

		sizeof(hd->c_mtime), OCT) ||

	    ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), OCT))

		goto out;

	/*

	 * write the file name to the archive

	 */

	    (wr_rdbuf(arcn->name, nsz) < 0)) {

	}

	/*

	 * if this file has data, we are done. The caller will write the file

	 * data, if we are link tell caller we are done, go to next file

	 */

	/*

	 * write the link name to the archive, tell the caller to go to the

	 * next file as we are done.

	 */

	}

	/*

	 * header field is out of range

	 */

	    arcn->org_name);

}

/*

 * Routines common to the system VR4 version of cpio (with/without file CRC)

 */

/*

 * vcpio_id()

 *      determine if a block given to us is a valid system VR4 cpio header

 *	WITHOUT crc. WATCH it the magic cookies are in OCTAL, the header

 *	uses HEX

 * Return:

 *      0 if a valid header, -1 otherwise

 */

int

vcpio_id(char *blk, int size)

{

	    (strncmp(blk, AVMAGIC, sizeof(AVMAGIC) - 1) != 0))

}

/*

 * crc_id()

 *      determine if a block given to us is a valid system VR4 cpio header

 *	WITH crc. WATCH it the magic cookies are in OCTAL the header uses HEX

 * Return:

 *      0 if a valid header, -1 otherwise

 */

int

crc_id(char *blk, int size)

{

	    (strncmp(blk, AVCMAGIC, sizeof(AVCMAGIC) - 1) != 0))

}

/*

 * crc_strd()

 w	set file data CRC calculations. Fire up the hard link detection code

 * Return:

 *      0 if ok -1 otherwise (the return values of lnk_start())

 */

int

crc_strd(void)

{

}

/*

 * vcpio_rd()

 *	determine if a buffer is a system VR4 archive entry. (with/without CRC)

 *	convert and store the values in the ARCHD parameter.

 * Return:

 *	0 if a valid header, -1 otherwise.

 */

int

vcpio_rd(ARCHD *arcn, char *buf)

{

	HD_VCPIO *hd;

	dev_t devminor;

	dev_t devmajor;

	int nsz;

	/*

	 * during the id phase it was determined if we were using CRC, use the

	 * proper id routine.

	 */

	} else {

	}

	/*

	 * extract the hex ascii fields from the header

	 */

	    sizeof(hd->c_filesize), HEX);

	    HEX);

	/*

	 * check the length of the file name, if ok read it in, return -1 if

	 * bogus

	 */

	/*

	 * skip padding. header + filename is aligned to 4 byte boundaries

	 */

	/*

	 * if not a link (or a file with no data), calculate pad size (for

	 * padding which follows the file data), clear the link name and return

	 */

		/*

		 * we have a valid header (not a link)

		 */

	}

	/*

	 * read in the link name and skip over the padding

	 */

	    (rd_skip((off_t)(VCPIO_PAD(arcn->sb.st_size))) < 0))

	/*

	 * we have a valid header (with a link)

	 */

}

/*

 * vcpio_endrd()

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

 * Return:

 *      size of trailer header in this format

 */

off_t

vcpio_endrd(void)

{

		(VCPIO_PAD(sizeof(HD_VCPIO) + sizeof(TRAILER)))));

}

/*

 * crc_stwr()

 *	start up the device mapping table, enable crc file calculation

 * Return:

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

 */

int

crc_stwr(void)

{

}

/*

 * vcpio_wr()

 *	copy the data in the ARCHD to buffer in system VR4 cpio

 *	(with/without crc) format.

 * 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

vcpio_wr(ARCHD *arcn)

{

	HD_VCPIO *hd;

	unsigned int nsz;

	char hdblk[sizeof(HD_VCPIO)];

	/*

	 * check and repair truncated device and inode fields in the cpio

	 * header

	 */

	/*

	 * add the proper magic value depending whether we were asked for

	 * file data crc's, and the crc if needed.

	 */

			OCT) ||

		    ul_asc((u_long)arcn->crc,hd->c_chksum,sizeof(hd->c_chksum),

			HEX))

			goto out;

	} else {

			OCT) ||

		    ul_asc((u_long)0L, hd->c_chksum, sizeof(hd->c_chksum),HEX))

			goto out;

	}

	case PAX_CTG:

	case PAX_REG:

	case PAX_HRG:

		/*

		 * caller will copy file data to the archive. tell him how

		 * much to pad.

		 */

		    sizeof(hd->c_filesize), HEX)) {

			    arcn->org_name);

		}

		break;

	case PAX_SLK:

		/*

		 * no file data for the caller to process, the file data has

		 * the size of the link

		 */

		    sizeof(hd->c_filesize), HEX))

		break;

	default:

		/*

		 * no file data for the caller to process

		 */

		    HEX))

		break;

	}

	/*

	 * set the other fields in the header

	 */

		HEX) ||

	    ul_asc((u_long)arcn->sb.st_mode, hd->c_mode, sizeof(hd->c_mode),

		HEX) ||

	    ul_asc((u_long)arcn->sb.st_uid, hd->c_uid, sizeof(hd->c_uid),

		HEX) ||

	    ul_asc((u_long)arcn->sb.st_gid, hd->c_gid, sizeof(hd->c_gid),

		HEX) ||

	    ul_asc(arcn->sb.st_mtime < 0 ? 0 : arcn->sb.st_mtime, hd->c_mtime,

		sizeof(hd->c_mtime), HEX) ||

	    ul_asc((u_long)arcn->sb.st_nlink, hd->c_nlink, sizeof(hd->c_nlink),

		HEX) ||

	    ul_asc((u_long)MAJOR(arcn->sb.st_dev),hd->c_maj, sizeof(hd->c_maj),

		HEX) ||

	    ul_asc((u_long)MINOR(arcn->sb.st_dev),hd->c_min, sizeof(hd->c_min),

		HEX) ||

	    ul_asc((u_long)MAJOR(arcn->sb.st_rdev),hd->c_rmaj,sizeof(hd->c_maj),

		HEX) ||

	    ul_asc((u_long)MINOR(arcn->sb.st_rdev),hd->c_rmin,sizeof(hd->c_min),

		HEX) ||

	    ul_asc((u_long)nsz, hd->c_namesize, sizeof(hd->c_namesize), HEX))

		goto out;

	/*

	 * write the header, the file name and padding as required.

	 */

	    (wr_rdbuf(arcn->name, (int)nsz) < 0)  ||

	    (wr_skip((off_t)(VCPIO_PAD(sizeof(HD_VCPIO) + nsz))) < 0)) {

	}

	/*

	 * if we have file data, tell the caller we are done, copy the file

	 */

	/*

	 * if we are not a link, tell the caller we are done, go to next file

	 */

	/*

	 * write the link name, tell the caller we are done.

	 */

	    (wr_skip((off_t)(VCPIO_PAD(arcn->ln_nlen))) < 0)) {

		    arcn->org_name);

	}

	/*

	 * header field is out of range

	 */

}

/*

 * Routines common to the old binary header cpio

 */

/*

 * bcpio_id()

 *      determine if a block given to us is a old binary cpio header

 *	(with/without header byte swapping)

 * Return:

 *      0 if a valid header, -1 otherwise

 */

int

bcpio_id(char *blk, int size)

{

	/*

	 * check both normal and byte swapped magic cookies

	 */

	}

}

/*

 * bcpio_rd()

 *	determine if a buffer is a old binary archive entry. (it may have byte

 *	swapped header) convert and store the values in the ARCHD parameter.

 *	This is a very old header format and should not really be used.

 * Return:

 *	0 if a valid header, -1 otherwise.

 */

int

bcpio_rd(ARCHD *arcn, char *buf)

{

	HD_BCPIO *hd;

	int nsz;

	/*

	 * check the header

	 */

		/*

		 * header has swapped bytes on 16 bit boundaries

		 */

			((time_t)(RSHRT_EXT(hd->h_mtime_2)));

			((off_t)(RSHRT_EXT(hd->h_filesize_2)));

	} else {

			((time_t)(SHRT_EXT(hd->h_mtime_2)));

			((off_t)(SHRT_EXT(hd->h_filesize_2)));

	}

	/*

	 * check the file name size, if bogus give up. otherwise read the file

	 * name

	 */

	/*

	 * header + file name are aligned to 2 byte boundaries, skip if needed

	 */

	/*

	 * if not a link (or a file with no data), calculate pad size (for

	 * padding which follows the file data), clear the link name and return

	 */

		/*

		 * we have a valid header (not a link)

		 */

	}

	    (rd_skip((off_t)(BCPIO_PAD(arcn->sb.st_size))) < 0))

	/*

	 * we have a valid header (with a link)

	 */

}

/*

 * bcpio_endrd()

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

 * Return:

 *      size of trailer header in this format

 */

off_t

bcpio_endrd(void)

{

		(BCPIO_PAD(sizeof(HD_BCPIO) + sizeof(TRAILER)))));

}

/*

 * bcpio_wr()

 *	copy the data in the ARCHD to buffer in old binary cpio format

 *	There is a real chance of field overflow with this critter. So we

 *	always check the conversion is ok. nobody in their right mind

 *	should write an archive in this format...

 * 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

bcpio_wr(ARCHD *arcn)

{

	HD_BCPIO *hd;

	int nsz;

	char hdblk[sizeof(HD_BCPIO)];

	off_t t_offt;

	int t_int;

	time_t t_timet;

	/*

	 * check and repair truncated device and inode fields in the cpio

	 * header

	 */

	case PAX_CTG:

	case PAX_REG:

	case PAX_HRG:

		/*

		 * caller will copy file data to the archive. tell him how

		 * much to pad.

		 */