Tree - cross/tpax

cross / tpax

Files

Commit: a11b545a85a90f5f13b5cfd116e55a8179d2b39d

Blob Blame History Raw

 /**************************************************************/
/*  tpax: a topological pax implementation                    */
/*  Copyright (C) 2020--2024  SysDeer Technologies, LLC       */
/*  Released under GPLv2 and GPLv3; see COPYING.TPAX.         */
/**************************************************************/
 
#include <tpax/tpax.h>
#include "tpax_driver_impl.h"
#include "tpax_errinfo_impl.h"
#include "tpax_visibility_impl.h"
 
#ifndef ssizeof
#define ssizeof(x) (ssize_t)(sizeof(x))
#endif
 
static const char tpax_cpio_trailer[11] = TPAX_CPIO_TRAILER;
 
static void tpax_cpio_octal_write(char * ch, ssize_t len, uint64_t val)
{
	for (; len; ) {
		ch[--len] = val % 8 + '0';
		val /= 8;
	}
}
 
static int tpax_archive_append_memory_data(
	int                             fdout,
	const void *                    buf,
	ssize_t                         nbytes)
{
	ssize_t       ret;
	const char *  ch;
 
	for (ch=buf; nbytes; ch+=ret) {
		ret = write(fdout,ch,nbytes);
 
		while ((ret < 0) && (errno == EINTR))
			ret = write(fdout,ch,nbytes);
 
		if (ret < 0)
			return ret;
 
		nbytes -= ret;
	}
 
	return 0;
}
 
static int tpax_archive_append_pad(
	const struct tpax_driver_ctx *  dctx,
	int                             fdout,
	const struct stat *             st)
{
	int     ret;
	off_t   cpos;
	ssize_t nbytes;
	char    buf[512];
 
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO)
		return 0;
 
	nbytes  = st->st_size;
	nbytes += 0x1ff;
	nbytes |= 0x1ff;
	nbytes ^= 0x1ff;
	nbytes -= st->st_size;
 
	memset(buf,0,nbytes);
 
	cpos  = tpax_get_driver_cpos(dctx);
	cpos += st->st_size + nbytes;
 
	if (!(ret = tpax_archive_append_memory_data(fdout,buf,nbytes)))
		tpax_set_driver_cpos(dctx,cpos);
 
	return ret;
}
 
static int tpax_archive_write_ret(
	int                             ret,
	const struct tpax_driver_ctx *  dctx,
	struct tpax_unit_ctx *          uctx)
{
	if (dctx->cctx->drvflags & TPAX_DRIVER_VERBOSE)
		tpax_dprintf(tpax_driver_fderr(dctx),"\n",0);
 
	tpax_lib_free_unit_ctx(uctx);
	return ret;
}
 
static int tpax_apply_string_replacement(
	const struct tpax_driver_ctx *  dctx,
	const char *                    path,
	char *                          replbuf,
	size_t                          buflen)
{
	int                            ret;
	struct tpax_driver_ctx_impl *  ictx;
	struct tpax_replstr *          replstrv;
 
	ictx = tpax_get_driver_ictx(dctx);
 
	if (!(replstrv = ictx->replstrv))
		return 0;
 
	for (ret=0; !ret && replstrv->regexp; replstrv++) {
		ret = tpax_util_path_replstr(
			replbuf,path,
			replstrv->replstr,
			&replstrv->regex,
			buflen,replstrv->flags);
 
		if ((ret > 0) && (replstrv->flags & TPAX_REPL_PRINT))
			tpax_dprintf(tpax_driver_fderr(dctx),"%s >> %s\n",path,replbuf);
	}
 
	return ret;
}
 
static int tpax_archive_write_impl(
	const struct tpax_driver_ctx *  dctx,
	const struct tpax_dirent *      cdent,
	int                             fdcwd,
	int                             fdout)
{
	int                             ret;
	struct tpax_unit_ctx *          uctx;
	struct tpax_cpio_header         chdr;
	struct tpax_ustar_header        uhdr;
	const struct stat *             st;
	struct stat                     stbuf;
	const  char *                   apath;
	const  char *                   path;
	const  char *                   slnk;
	const  char *                   mlnk;
	off_t                           hpos;
	off_t                           dpos;
	int                             fdtmp;
	int                             slen;
	ssize_t                         nread;
	ssize_t                         nbytes;
	void *                          buf;
	size_t                          buflen;
	size_t                          cmplen;
	void *				membuf;
	char *                          ch;
	char                           	replbuf[PATH_MAX];
	char                           	pathbuf[PATH_MAX];
 
	/* followed symlink? */
	if (cdent->flags & TPAX_ITEM_NAMEREF)
		return 0;
 
	/* full path */
	if (!(path = tpax_queue_item_full_path(dctx,cdent)))
		return TPAX_CUSTOM_ERROR(
			dctx,
			TPAX_ERR_FLOW_ERROR);
 
	/* regex matching and patter substitution */
	if ((slen = tpax_apply_string_replacement(dctx,path,replbuf,PATH_MAX)) < 0)
		return TPAX_CUSTOM_ERROR(
			dctx,
			TPAX_ERR_FLOW_ERROR);
 
	apath = slen ? replbuf : path;
 
	/* verbose mode */
	if (dctx->cctx->drvflags & TPAX_DRIVER_VERBOSE)
		tpax_dprintf(tpax_driver_fderr(dctx),"%s",apath);
 
	/* uctx */
	if (tpax_lib_get_unit_ctx(dctx,fdcwd,path,&uctx) < 0)
		return tpax_archive_write_ret(
			TPAX_NESTED_ERROR(dctx),
			dctx,0);
 
	st   = uctx->st;
	slnk = uctx->link[0];
	mlnk = 0;
 
	if (cdent->flags & TPAX_ITEM_SYMLINK) {
		st   = &stbuf;
		mlnk = slnk;
		slnk = 0;
		ch   = 0;
 
		if (mlnk[0] != '/') {
			if (strlen(path) >= PATH_MAX)
				return tpax_archive_write_ret(
					TPAX_CUSTOM_ERROR(
						dctx,
						TPAX_ERR_FLOW_ERROR),
					dctx,uctx);
 
			strcpy(pathbuf,path);
 
			ch = strrchr(pathbuf,'/');
		}
 
		if (ch && (++ch - pathbuf >= PATH_MAX))
			return tpax_archive_write_ret(
				TPAX_CUSTOM_ERROR(
					dctx,
					TPAX_ERR_FLOW_ERROR),
				dctx,uctx);
 
		if (ch) {
			strcpy(ch,mlnk);
			mlnk = pathbuf;
		}
 
		if (fstatat(fdcwd,mlnk,&stbuf,0) < 0)
			return tpax_archive_write_ret(
				TPAX_SYSTEM_ERROR(dctx),
				dctx,uctx);
	}
 
	/* record errors */
	tpax_driver_set_ectx(
		dctx,0,path);
 
	/* header offset */
	hpos = tpax_get_driver_cpos(dctx);
 
	/* header */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_RUSTAR) {
		ret = tpax_meta_init_rustar_header(apath,st,slnk,&uhdr);
 
	} else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_USTAR) {
		ret = tpax_meta_init_ustar_header(apath,st,slnk,&uhdr);
 
	} else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO) {
		ret = tpax_meta_init_cpio_header(
			apath,st,slnk,
			cdent->cpdev,
			cdent->cpino,
			cdent->nlink,
			&chdr);
	}
 
	if (ret < 0)
		return tpax_archive_write_ret(
			TPAX_NESTED_ERROR(dctx),
			dctx,uctx);
 
	/* buffer  */
	membuf = 0;
	fdtmp  = -1;
 
	/* associated data? */
	if S_ISREG(st->st_mode) {
		buf = tpax_get_driver_anon_map_addr(
			dctx,&buflen);
 
		if (buflen >= (cmplen = st->st_size))
			membuf = buf;
 
		/* snapshot */
		if (membuf) {
			if (tpax_io_create_memory_snapshot(
					dctx,fdcwd,
					mlnk ? mlnk : path,
					st,membuf) < 0)
				return tpax_archive_write_ret(
					TPAX_NESTED_ERROR(dctx),
					dctx,uctx);
		} else {
			if ((fdtmp = tpax_io_create_tmpfs_snapshot(
					dctx,fdcwd,
					mlnk ? mlnk : path,
					st)) < 0)
				return tpax_archive_write_ret(
					TPAX_NESTED_ERROR(dctx),
					dctx,uctx);
 
			if (lseek(fdtmp,0,SEEK_SET) < 0)
				return tpax_archive_write_ret(
					TPAX_SYSTEM_ERROR(dctx),
					dctx,uctx);
		}
	}
 
	/* append header (and cpio symbolic link data) */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO) {
		ret = tpax_archive_append_memory_data(
			fdout,&chdr,
			offsetof(struct tpax_cpio_header,c_namedata));
 
		if (ret == 0)
			ret = tpax_archive_append_memory_data(
				fdout,apath,
				strlen(apath) + 1);
 
		if ((ret == 0) && slnk)
			ret = tpax_archive_append_memory_data(
				fdout,slnk,
				strlen(slnk));
	} else {
		ret = tpax_archive_append_memory_data(
			fdout,&uhdr,
			ssizeof(uhdr));
	}
 
	if (ret < 0) {
		if (fdtmp >= 0)
			close(fdtmp);
 
		return tpax_archive_write_ret(
			TPAX_SYSTEM_ERROR(dctx),
			dctx,uctx);
	}
 
	/* data offset */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO) {
		dpos  = hpos;
		dpos += offsetof(struct tpax_cpio_header,c_namedata);
		dpos += strlen(apath) + 1;
		dpos += slnk ? strlen(slnk) : 0;
	} else {
		dpos  = hpos + ssizeof(uhdr);
	}
 
	tpax_set_driver_cpos(dctx,dpos);
 
	/* all done? */
	if (!(S_ISREG(st->st_mode)))
		return tpax_archive_write_ret(
			0,dctx,uctx);
 
	/* append data from snapshot */
	if (fdtmp >= 0) {
		buf = tpax_get_driver_anon_map_addr(
			dctx,&buflen);
 
		for (nread=0; nread<st->st_size; ) {
			nbytes = read(fdtmp,buf,buflen);
 
			while ((nbytes < 0) && (errno == EINTR))
				nbytes = read(fdtmp,buf,buflen);
 
			if (nbytes < 0) {
				close(fdtmp);
				return tpax_archive_write_ret(
					TPAX_SYSTEM_ERROR(dctx),
					dctx,uctx);
 
			} else if (nbytes == 0) {
				close(fdtmp);
				return tpax_archive_write_ret(
					TPAX_CUSTOM_ERROR(dctx,TPAX_ERR_FLOW_ERROR),
					dctx,uctx);
 
			} else {
				nread += nbytes;
			}
 
			if (tpax_archive_append_memory_data(fdout,buf,nbytes) < 0) {
				close(fdtmp);
				return tpax_archive_write_ret(
					TPAX_SYSTEM_ERROR(dctx),
					dctx,uctx);
			}
		}
 
		close(fdtmp);
	} else {
		if (tpax_archive_append_memory_data(
				fdout,membuf,
				st->st_size) < 0)
			return tpax_archive_write_ret(
				TPAX_SYSTEM_ERROR(dctx),
				dctx,uctx);
	}
 
	return tpax_archive_write_ret(
		tpax_archive_append_pad(dctx,fdout,st),
		dctx,uctx);
}
 
int tpax_archive_write(const struct tpax_driver_ctx * dctx)
{
	struct tpax_driver_ctx_impl *   ictx;
	struct tpax_dirent **           direntv;
	int                             fdcwd;
	int                             fdout;
 
	/* driver */
	ictx  = tpax_get_driver_ictx(dctx);
	fdcwd = tpax_driver_fdcwd(dctx);
	fdout = tpax_driver_fdout(dctx);
 
	/* quote to archive */
	if (tpax_update_queue_vector(dctx) < 0)
		return TPAX_NESTED_ERROR(dctx);
 
	for (direntv=ictx->direntv; *direntv; direntv++)
		if (tpax_archive_write_impl(dctx,*direntv,fdcwd,fdout) < 0)
			return TPAX_NESTED_ERROR(dctx);
 
	return 0;
}
 
static int tpax_archive_seal_cpio(const struct tpax_driver_ctx * dctx)
{
	int                             fdout;
	off_t                           cpos;
	ssize_t                         nbytes;
	ssize_t                         blksize;
	ssize_t                         nwritten;
	char                            buf[1024];
	struct tpax_cpio_header         chdr;
 
	/* trailer initialization */
	memset(buf,0,sizeof(buf));
	memset(&chdr,0,sizeof(chdr));
 
	tpax_cpio_octal_write(chdr.c_magic,sizeof(chdr.c_magic),0070707);
	tpax_cpio_octal_write(chdr.c_dev,sizeof(chdr.c_dev),0);
	tpax_cpio_octal_write(chdr.c_ino,sizeof(chdr.c_ino),0);
	tpax_cpio_octal_write(chdr.c_mode,sizeof(chdr.c_mode),0);
	tpax_cpio_octal_write(chdr.c_uid,sizeof(chdr.c_uid),0);
	tpax_cpio_octal_write(chdr.c_gid,sizeof(chdr.c_gid),0);
	tpax_cpio_octal_write(chdr.c_nlink,sizeof(chdr.c_nlink),1);
	tpax_cpio_octal_write(chdr.c_rdev,sizeof(chdr.c_rdev),0);
	tpax_cpio_octal_write(chdr.c_mtime,sizeof(chdr.c_mtime),0);
 
	tpax_cpio_octal_write(chdr.c_filesize,sizeof(chdr.c_filesize),0);
	tpax_cpio_octal_write(chdr.c_namesize,sizeof(chdr.c_namesize),sizeof(tpax_cpio_trailer));
 
	/* fdout, archive block size, current position */
	fdout   = tpax_driver_fdout(dctx);
	blksize = dctx->cctx->blksize;
	cpos    = tpax_get_driver_cpos(dctx);
 
	/* trailer header */
	nbytes = offsetof(struct tpax_cpio_header,c_namedata);
 
	if (tpax_archive_append_memory_data(fdout,&chdr,nbytes) < 0)
		return TPAX_SYSTEM_ERROR(dctx);
 
	cpos += nbytes;
 
	/* trailer c_namedata[] */
	nbytes = sizeof(tpax_cpio_trailer);
 
	if (tpax_archive_append_memory_data(fdout,tpax_cpio_trailer,nbytes) < 0)
		return TPAX_SYSTEM_ERROR(dctx);
 
	cpos += nbytes;
 
	/* pad the current block to a 512 byte boundary */
	nbytes = (cpos % 512) ? 512 - (cpos % 512) : 0;
 
	if (tpax_archive_append_memory_data(fdout,buf,nbytes) < 0)
		return TPAX_SYSTEM_ERROR(dctx);
 
	cpos += nbytes;
 
	/* already at block boundary? */
	if ((cpos % blksize) == 0) {
		tpax_set_driver_cpos(dctx,cpos);
		return 0;
	}
 
	/* zero-fill the remainder of the block */
	nbytes  = cpos / blksize;
	nbytes *= blksize;
	nbytes += blksize;
 
	for (nwritten=cpos; nwritten<nbytes; nwritten+=512)
		if (tpax_archive_append_memory_data(fdout,buf,512) < 0)
			return TPAX_SYSTEM_ERROR(dctx);
 
	/* all done */
	tpax_set_driver_cpos(dctx,nwritten);
 
	return 0;
}
 
int tpax_archive_seal(const struct tpax_driver_ctx * dctx)
{
	int     fdout;
	off_t   cpos;
	ssize_t nbytes;
	ssize_t nwritten;
	ssize_t blksize;
	char    buf[1024];
 
	/* cpio trailer? */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO)
		return tpax_archive_seal_cpio(dctx);
 
	/* archive block size, current position */
	blksize = dctx->cctx->blksize;
	cpos    = tpax_get_driver_cpos(dctx);
 
	/* internal error? */
	if (cpos % 512)
		return TPAX_CUSTOM_ERROR(dctx,TPAX_ERR_FLOW_ERROR);
 
	/* ustar, pax */
	fdout = tpax_driver_fdout(dctx);
	memset(buf,0,sizeof(buf));
 
	if (tpax_archive_append_memory_data(fdout,buf,2*512) < 0)
		return TPAX_SYSTEM_ERROR(dctx);
 
	cpos += 2*512;
 
	/* pax? */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_PAX) {
		tpax_set_driver_cpos(dctx,cpos);
		return 0;
	}
 
	/* already at block boundary? */
	if ((cpos % blksize) == 0) {
		tpax_set_driver_cpos(dctx,cpos);
		return 0;
	}
 
	/* zero-fill the remainder of the block */
	nbytes  = cpos / blksize;
	nbytes *= blksize;
	nbytes += blksize;
 
	for (nwritten=cpos; nwritten<nbytes; nwritten+=512)
		if (tpax_archive_append_memory_data(fdout,buf,512) < 0)
			return TPAX_SYSTEM_ERROR(dctx);
 
	/* all done */
	tpax_set_driver_cpos(dctx,nwritten);
 
	return 0;
}

	/**************************************************************/
	/* tpax: a topological pax implementation */
	/* Copyright (C) 2020--2024 SysDeer Technologies, LLC */
	/* Released under GPLv2 and GPLv3; see COPYING.TPAX. */
	/**************************************************************/

	#include <tpax/tpax.h>
	#include "tpax_driver_impl.h"
	#include "tpax_errinfo_impl.h"
	#include "tpax_visibility_impl.h"

	#ifndef ssizeof
	#define ssizeof(x) (ssize_t)(sizeof(x))
	#endif

	static const char tpax_cpio_trailer[11] = TPAX_CPIO_TRAILER;

	static void tpax_cpio_octal_write(char * ch, ssize_t len, uint64_t val)
	{
	for (; len; ) {
	ch[--len] = val % 8 + '0';
	val /= 8;
	}
	}

	static int tpax_archive_append_memory_data(
	int fdout,
	const void * buf,
	ssize_t nbytes)
	{
	ssize_t ret;
	const char * ch;

	for (ch=buf; nbytes; ch+=ret) {
	ret = write(fdout,ch,nbytes);

	while ((ret < 0) && (errno == EINTR))
	ret = write(fdout,ch,nbytes);

	if (ret < 0)
	return ret;

	nbytes -= ret;
	}

	return 0;
	}

	static int tpax_archive_append_pad(
	const struct tpax_driver_ctx * dctx,
	int fdout,
	const struct stat * st)
	{
	int ret;
	off_t cpos;
	ssize_t nbytes;
	char buf[512];

	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO)
	return 0;

	nbytes = st->st_size;
	nbytes += 0x1ff;
	nbytes \|= 0x1ff;
	nbytes ^= 0x1ff;
	nbytes -= st->st_size;

	memset(buf,0,nbytes);

	cpos = tpax_get_driver_cpos(dctx);
	cpos += st->st_size + nbytes;

	if (!(ret = tpax_archive_append_memory_data(fdout,buf,nbytes)))
	tpax_set_driver_cpos(dctx,cpos);

	return ret;
	}

	static int tpax_archive_write_ret(
	int ret,
	const struct tpax_driver_ctx * dctx,
	struct tpax_unit_ctx * uctx)
	{
	if (dctx->cctx->drvflags & TPAX_DRIVER_VERBOSE)
	tpax_dprintf(tpax_driver_fderr(dctx),"\n",0);

	tpax_lib_free_unit_ctx(uctx);
	return ret;
	}

	static int tpax_apply_string_replacement(
	const struct tpax_driver_ctx * dctx,
	const char * path,
	char * replbuf,
	size_t buflen)
	{
	int ret;
	struct tpax_driver_ctx_impl * ictx;
	struct tpax_replstr * replstrv;

	ictx = tpax_get_driver_ictx(dctx);

	if (!(replstrv = ictx->replstrv))
	return 0;

	for (ret=0; !ret && replstrv->regexp; replstrv++) {
	ret = tpax_util_path_replstr(
	replbuf,path,
	replstrv->replstr,
	&replstrv->regex,
	buflen,replstrv->flags);

	if ((ret > 0) && (replstrv->flags & TPAX_REPL_PRINT))
	tpax_dprintf(tpax_driver_fderr(dctx),"%s >> %s\n",path,replbuf);
	}

	return ret;
	}

	static int tpax_archive_write_impl(
	const struct tpax_driver_ctx * dctx,
	const struct tpax_dirent * cdent,
	int fdcwd,
	int fdout)
	{
	int ret;
	struct tpax_unit_ctx * uctx;
	struct tpax_cpio_header chdr;
	struct tpax_ustar_header uhdr;
	const struct stat * st;
	struct stat stbuf;
	const char * apath;
	const char * path;
	const char * slnk;
	const char * mlnk;
	off_t hpos;
	off_t dpos;
	int fdtmp;
	int slen;
	ssize_t nread;
	ssize_t nbytes;
	void * buf;
	size_t buflen;
	size_t cmplen;
	void * membuf;
	char * ch;
	char replbuf[PATH_MAX];
	char pathbuf[PATH_MAX];

	/* followed symlink? */
	if (cdent->flags & TPAX_ITEM_NAMEREF)
	return 0;

	/* full path */
	if (!(path = tpax_queue_item_full_path(dctx,cdent)))
	return TPAX_CUSTOM_ERROR(
	dctx,
	TPAX_ERR_FLOW_ERROR);

	/* regex matching and patter substitution */
	if ((slen = tpax_apply_string_replacement(dctx,path,replbuf,PATH_MAX)) < 0)
	return TPAX_CUSTOM_ERROR(
	dctx,
	TPAX_ERR_FLOW_ERROR);

	apath = slen ? replbuf : path;

	/* verbose mode */
	if (dctx->cctx->drvflags & TPAX_DRIVER_VERBOSE)
	tpax_dprintf(tpax_driver_fderr(dctx),"%s",apath);

	/* uctx */
	if (tpax_lib_get_unit_ctx(dctx,fdcwd,path,&uctx) < 0)
	return tpax_archive_write_ret(
	TPAX_NESTED_ERROR(dctx),
	dctx,0);

	st = uctx->st;
	slnk = uctx->link[0];
	mlnk = 0;

	if (cdent->flags & TPAX_ITEM_SYMLINK) {
	st = &stbuf;
	mlnk = slnk;
	slnk = 0;
	ch = 0;

	if (mlnk[0] != '/') {
	if (strlen(path) >= PATH_MAX)
	return tpax_archive_write_ret(
	TPAX_CUSTOM_ERROR(
	dctx,
	TPAX_ERR_FLOW_ERROR),
	dctx,uctx);

	strcpy(pathbuf,path);

	ch = strrchr(pathbuf,'/');
	}

	if (ch && (++ch - pathbuf >= PATH_MAX))
	return tpax_archive_write_ret(
	TPAX_CUSTOM_ERROR(
	dctx,
	TPAX_ERR_FLOW_ERROR),
	dctx,uctx);

	if (ch) {
	strcpy(ch,mlnk);
	mlnk = pathbuf;
	}

	if (fstatat(fdcwd,mlnk,&stbuf,0) < 0)
	return tpax_archive_write_ret(
	TPAX_SYSTEM_ERROR(dctx),
	dctx,uctx);
	}

	/* record errors */
	tpax_driver_set_ectx(
	dctx,0,path);

	/* header offset */
	hpos = tpax_get_driver_cpos(dctx);

	/* header */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_RUSTAR) {
	ret = tpax_meta_init_rustar_header(apath,st,slnk,&uhdr);

	} else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_USTAR) {
	ret = tpax_meta_init_ustar_header(apath,st,slnk,&uhdr);

	} else if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO) {
	ret = tpax_meta_init_cpio_header(
	apath,st,slnk,
	cdent->cpdev,
	cdent->cpino,
	cdent->nlink,
	&chdr);
	}

	if (ret < 0)
	return tpax_archive_write_ret(
	TPAX_NESTED_ERROR(dctx),
	dctx,uctx);

	/* buffer */
	membuf = 0;
	fdtmp = -1;

	/* associated data? */
	if S_ISREG(st->st_mode) {
	buf = tpax_get_driver_anon_map_addr(
	dctx,&buflen);

	if (buflen >= (cmplen = st->st_size))
	membuf = buf;

	/* snapshot */
	if (membuf) {
	if (tpax_io_create_memory_snapshot(
	dctx,fdcwd,
	mlnk ? mlnk : path,
	st,membuf) < 0)
	return tpax_archive_write_ret(
	TPAX_NESTED_ERROR(dctx),
	dctx,uctx);
	} else {
	if ((fdtmp = tpax_io_create_tmpfs_snapshot(
	dctx,fdcwd,
	mlnk ? mlnk : path,
	st)) < 0)
	return tpax_archive_write_ret(
	TPAX_NESTED_ERROR(dctx),
	dctx,uctx);

	if (lseek(fdtmp,0,SEEK_SET) < 0)
	return tpax_archive_write_ret(
	TPAX_SYSTEM_ERROR(dctx),
	dctx,uctx);
	}
	}

	/* append header (and cpio symbolic link data) */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO) {
	ret = tpax_archive_append_memory_data(
	fdout,&chdr,
	offsetof(struct tpax_cpio_header,c_namedata));

	if (ret == 0)
	ret = tpax_archive_append_memory_data(
	fdout,apath,
	strlen(apath) + 1);

	if ((ret == 0) && slnk)
	ret = tpax_archive_append_memory_data(
	fdout,slnk,
	strlen(slnk));
	} else {
	ret = tpax_archive_append_memory_data(
	fdout,&uhdr,
	ssizeof(uhdr));
	}

	if (ret < 0) {
	if (fdtmp >= 0)
	close(fdtmp);

	return tpax_archive_write_ret(
	TPAX_SYSTEM_ERROR(dctx),
	dctx,uctx);
	}

	/* data offset */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO) {
	dpos = hpos;
	dpos += offsetof(struct tpax_cpio_header,c_namedata);
	dpos += strlen(apath) + 1;
	dpos += slnk ? strlen(slnk) : 0;
	} else {
	dpos = hpos + ssizeof(uhdr);
	}

	tpax_set_driver_cpos(dctx,dpos);

	/* all done? */
	if (!(S_ISREG(st->st_mode)))
	return tpax_archive_write_ret(
	0,dctx,uctx);

	/* append data from snapshot */
	if (fdtmp >= 0) {
	buf = tpax_get_driver_anon_map_addr(
	dctx,&buflen);

	for (nread=0; nread<st->st_size; ) {
	nbytes = read(fdtmp,buf,buflen);

	while ((nbytes < 0) && (errno == EINTR))
	nbytes = read(fdtmp,buf,buflen);

	if (nbytes < 0) {
	close(fdtmp);
	return tpax_archive_write_ret(
	TPAX_SYSTEM_ERROR(dctx),
	dctx,uctx);

	} else if (nbytes == 0) {
	close(fdtmp);
	return tpax_archive_write_ret(
	TPAX_CUSTOM_ERROR(dctx,TPAX_ERR_FLOW_ERROR),
	dctx,uctx);

	} else {
	nread += nbytes;
	}

	if (tpax_archive_append_memory_data(fdout,buf,nbytes) < 0) {
	close(fdtmp);
	return tpax_archive_write_ret(
	TPAX_SYSTEM_ERROR(dctx),
	dctx,uctx);
	}
	}

	close(fdtmp);
	} else {
	if (tpax_archive_append_memory_data(
	fdout,membuf,
	st->st_size) < 0)
	return tpax_archive_write_ret(
	TPAX_SYSTEM_ERROR(dctx),
	dctx,uctx);
	}

	return tpax_archive_write_ret(
	tpax_archive_append_pad(dctx,fdout,st),
	dctx,uctx);
	}

	int tpax_archive_write(const struct tpax_driver_ctx * dctx)
	{
	struct tpax_driver_ctx_impl * ictx;
	struct tpax_dirent ** direntv;
	int fdcwd;
	int fdout;

	/* driver */
	ictx = tpax_get_driver_ictx(dctx);
	fdcwd = tpax_driver_fdcwd(dctx);
	fdout = tpax_driver_fdout(dctx);

	/* quote to archive */
	if (tpax_update_queue_vector(dctx) < 0)
	return TPAX_NESTED_ERROR(dctx);

	for (direntv=ictx->direntv; *direntv; direntv++)
	if (tpax_archive_write_impl(dctx,*direntv,fdcwd,fdout) < 0)
	return TPAX_NESTED_ERROR(dctx);

	return 0;
	}

	static int tpax_archive_seal_cpio(const struct tpax_driver_ctx * dctx)
	{
	int fdout;
	off_t cpos;
	ssize_t nbytes;
	ssize_t blksize;
	ssize_t nwritten;
	char buf[1024];
	struct tpax_cpio_header chdr;

	/* trailer initialization */
	memset(buf,0,sizeof(buf));
	memset(&chdr,0,sizeof(chdr));

	tpax_cpio_octal_write(chdr.c_magic,sizeof(chdr.c_magic),0070707);
	tpax_cpio_octal_write(chdr.c_dev,sizeof(chdr.c_dev),0);
	tpax_cpio_octal_write(chdr.c_ino,sizeof(chdr.c_ino),0);
	tpax_cpio_octal_write(chdr.c_mode,sizeof(chdr.c_mode),0);
	tpax_cpio_octal_write(chdr.c_uid,sizeof(chdr.c_uid),0);
	tpax_cpio_octal_write(chdr.c_gid,sizeof(chdr.c_gid),0);
	tpax_cpio_octal_write(chdr.c_nlink,sizeof(chdr.c_nlink),1);
	tpax_cpio_octal_write(chdr.c_rdev,sizeof(chdr.c_rdev),0);
	tpax_cpio_octal_write(chdr.c_mtime,sizeof(chdr.c_mtime),0);

	tpax_cpio_octal_write(chdr.c_filesize,sizeof(chdr.c_filesize),0);
	tpax_cpio_octal_write(chdr.c_namesize,sizeof(chdr.c_namesize),sizeof(tpax_cpio_trailer));

	/* fdout, archive block size, current position */
	fdout = tpax_driver_fdout(dctx);
	blksize = dctx->cctx->blksize;
	cpos = tpax_get_driver_cpos(dctx);

	/* trailer header */
	nbytes = offsetof(struct tpax_cpio_header,c_namedata);

	if (tpax_archive_append_memory_data(fdout,&chdr,nbytes) < 0)
	return TPAX_SYSTEM_ERROR(dctx);

	cpos += nbytes;

	/* trailer c_namedata[] */
	nbytes = sizeof(tpax_cpio_trailer);

	if (tpax_archive_append_memory_data(fdout,tpax_cpio_trailer,nbytes) < 0)
	return TPAX_SYSTEM_ERROR(dctx);

	cpos += nbytes;

	/* pad the current block to a 512 byte boundary */
	nbytes = (cpos % 512) ? 512 - (cpos % 512) : 0;

	if (tpax_archive_append_memory_data(fdout,buf,nbytes) < 0)
	return TPAX_SYSTEM_ERROR(dctx);

	cpos += nbytes;

	/* already at block boundary? */
	if ((cpos % blksize) == 0) {
	tpax_set_driver_cpos(dctx,cpos);
	return 0;
	}

	/* zero-fill the remainder of the block */
	nbytes = cpos / blksize;
	nbytes *= blksize;
	nbytes += blksize;

	for (nwritten=cpos; nwritten<nbytes; nwritten+=512)
	if (tpax_archive_append_memory_data(fdout,buf,512) < 0)
	return TPAX_SYSTEM_ERROR(dctx);

	/* all done */
	tpax_set_driver_cpos(dctx,nwritten);

	return 0;
	}

	int tpax_archive_seal(const struct tpax_driver_ctx * dctx)
	{
	int fdout;
	off_t cpos;
	ssize_t nbytes;
	ssize_t nwritten;
	ssize_t blksize;
	char buf[1024];

	/* cpio trailer? */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_CPIO)
	return tpax_archive_seal_cpio(dctx);

	/* archive block size, current position */
	blksize = dctx->cctx->blksize;
	cpos = tpax_get_driver_cpos(dctx);

	/* internal error? */
	if (cpos % 512)
	return TPAX_CUSTOM_ERROR(dctx,TPAX_ERR_FLOW_ERROR);

	/* ustar, pax */
	fdout = tpax_driver_fdout(dctx);
	memset(buf,0,sizeof(buf));

	if (tpax_archive_append_memory_data(fdout,buf,2*512) < 0)
	return TPAX_SYSTEM_ERROR(dctx);

	cpos += 2*512;

	/* pax? */
	if (dctx->cctx->drvflags & TPAX_DRIVER_WRITE_FORMAT_PAX) {
	tpax_set_driver_cpos(dctx,cpos);
	return 0;
	}

	/* already at block boundary? */
	if ((cpos % blksize) == 0) {
	tpax_set_driver_cpos(dctx,cpos);
	return 0;
	}

	/* zero-fill the remainder of the block */
	nbytes = cpos / blksize;
	nbytes *= blksize;
	nbytes += blksize;

	for (nwritten=cpos; nwritten<nbytes; nwritten+=512)
	if (tpax_archive_append_memory_data(fdout,buf,512) < 0)
	return TPAX_SYSTEM_ERROR(dctx);

	/* all done */
	tpax_set_driver_cpos(dctx,nwritten);

	return 0;
	}

cross / tpax

Source Code

Files