xref: /onnv-gate/usr/src/cmd/ndmpd/tlm/tlm_restore_writer.c (revision 13023:7a57e737278a)

/*
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 */

/*
 * BSD 3 Clause License
 *
 * Copyright (c) 2007, The Storage Networking Industry Association.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 	- Redistributions of source code must retain the above copyright
 *	  notice, this list of conditions and the following disclaimer.
 *
 * 	- 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.
 *
 *	- Neither the name of The Storage Networking Industry Association (SNIA)
 *	  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 COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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 <stdlib.h>
#include <ctype.h>
#include <stdio.h>
#include <limits.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/acl.h>
#include <sys/mkdev.h>
#include <utime.h>
#include <unistd.h>
#include <pthread.h>
#include <archives.h>
#include <priv.h>
#include <tlm.h>
#include <libzfs.h>
#include <pwd.h>
#include <grp.h>
#include <ndmpd_prop.h>
#include "tlm_proto.h"


#define	PM_EXACT_OR_CHILD(m)	((m) == PM_EXACT || (m) == PM_CHILD)

typedef boolean_t name_match_fp_t(char *s, char *t);

static void set_acl(char *name,
    tlm_acls_t *acls);
static long restore_file(int *fp,
    char *real_name,
    long size,
    longlong_t huge_size,
    tlm_acls_t *,
    boolean_t want_this_file,
    tlm_cmd_t *,
    tlm_job_stats_t *);
static long restore_xattr_hdr(int *fp,
    char *name,
    char *fname,
    long size,
    tlm_acls_t *acls,
    tlm_cmd_t *local_commands,
    tlm_job_stats_t *job_stats);
static int get_long_name(int lib,
    int drv,
    long recsize,
    char *name,
    long *buf_spot,
    tlm_cmd_t *local_commands);
static int get_humongus_file_header(int lib,
    int	drv,
    long recsize,
    longlong_t *size,
    char *name,
    tlm_cmd_t *);
static int create_directory(char *dir,
    tlm_job_stats_t *);
static int create_hard_link(char *name,
    char *link,
    tlm_acls_t *,
    tlm_job_stats_t *);
static int create_sym_link(char *dst,
    char *target,
    tlm_acls_t *,
    tlm_job_stats_t *);
static int create_special(char,
    char *name,
    tlm_acls_t *,
    int,
    int,
    tlm_job_stats_t *);
static long load_acl_info(int lib,
    int	drv,
    long size,
    tlm_acls_t *,
    long *acl_spot,
    tlm_cmd_t *);
static char *get_read_buffer(int want,
    int	*error,
    int	*actual_size,
    tlm_cmd_t *);
static boolean_t wildcard_enabled(void);
static boolean_t is_file_wanted(char *name,
    char **sels,
    char **exls,
    int	flags,
    int	*mchtype,
    int	*pos);
static char *catnames(struct rs_name_maker *rnp,
    char *buf,
    int	pos,
    char *path);

static char *rs_new_name(struct rs_name_maker *rnp,
    char *real_name,
    int pos,
    char *path);

static void rs_create_new_bkpath(char *bk_path,
    char *path,
    char *pbuf);

typedef struct stack_ent {
	char *se_name;
	tlm_acls_t se_acls;
} stack_ent_t;


/*
 * dtree_push
 */
int
dtree_push(cstack_t *stp, char *nmp, tlm_acls_t *acls)
{
	int len;
	stack_ent_t *sp;

	sp = ndmp_malloc(sizeof (stack_ent_t));
	if (!sp || !nmp || !acls) {
		free(sp);
		return (-1);
	}

	len = strlen(nmp) + 1;
	sp->se_name = ndmp_malloc(len);
	if (!sp->se_name) {
		free(sp);
		return (-1);
	}

	(void) strlcpy(sp->se_name, nmp, len);
	(void) memcpy(&sp->se_acls, acls, sizeof (*acls));
	(void) memset(acls, 0, sizeof (tlm_acls_t));

	return (cstack_push(stp, (void *)sp, sizeof (*sp)));
}

/*
 * dtree_pop
 */
int
dtree_pop(cstack_t *stp)
{
	int err;
	stack_ent_t *sp;

	err = cstack_pop(stp, (void **)&sp, (void *)NULL);
	if (err)
		return (-1);

	set_acl(sp->se_name, &sp->se_acls);

	free(sp->se_name);
	free(sp);
	return (err);
}


/*
 * dtree_peek
 */
char *
dtree_peek(cstack_t *stp)
{
	int err;
	stack_ent_t *sp;

	err = cstack_top(stp, (void **)&sp, (void *)NULL);
	if (err)
		return (NULL);

	return (sp->se_name);
}

/*
 * NBU and EBS may not send us the correct file list containing hardlinks
 * during a DAR restore, e.g. they appear always send the first name
 * associated with an inode, even if other link names were
 * selected for the restore.  As a workaround, we use the file name entry
 * in sels[] (ignore the name in the tar header) as restore target.
 */
static char *
rs_darhl_new_name(struct rs_name_maker *rnp, char *name, char **sels, int *pos,
    char *longname)
{
	int x;

	for (x = 0; sels[x] != NULL; x++) {
		if (strcmp(sels[x], " ")) {
			*pos = x;
			(void) strlcpy(longname, sels[x], TLM_MAX_PATH_NAME);
			NDMP_LOG(LOG_DEBUG,
			    "to replace hardlink name [%s], pos [%d]",
			    longname, *pos);

			return (rs_new_name(rnp, name, *pos, longname));
		}
	}

	return (NULL);
}


/*
 * Main dir restore function for tar
 */
int
tar_getdir(tlm_commands_t *commands,
    tlm_cmd_t *local_commands,
    tlm_job_stats_t *job_stats,
    struct rs_name_maker *rnp,
    int	lib,
    int	drv,
    char **sels, /* what to get off the tape */
    char **exls, /* what to leave behind */
    int	flags,
    int	DAR,
    char *bk_path,
    struct hardlink_q *hardlink_q)
{
	int	fp = 0;		/* file being restored ... */
				/*  ...need to preserve across volume changes */
	tlm_acls_t *acls;	/* file access info */
	char	*longname;
	boolean_t is_long_name = FALSE;
	char	*longlink;
	char	*hugename;
	longlong_t huge_size = 0;	/* size of a HUGE file */
	long	acl_spot;		/* any ACL info on the next volume */
	long	file_size;		/* size of file to restore */
	long	size_left = 0;		/* need this after volume change */
	int	last_action = 0;	/* what we are doing at EOT */
	boolean_t multi_volume = FALSE;	/* is this a multi-volume switch ? */
	int	chk_rv;			/* scratch area */

	int	mchtype, pos;
					/*
					 * if an exact match is found for
					 * restore and its position in the
					 * selections list
					 */
	int	nzerohdr;		/* the number of empty tar headers */
	boolean_t break_flg;		/* exit the while loop */
	int	rv;
	long nm_end, lnk_end;
	char	*name, *nmp;
	cstack_t *stp;
	char 	*bkpath;
	char 	*parentlnk;
	int dir_dar = 0;

	/*
	 * The directory where temporary files may be created during a partial
	 * non-DAR restore of hardlinks.  It is intended to be initialized by
	 * an environment variable that can be set by user.
	 *
	 * It is not initialized for now.   We keep it here for future use.
	 */
	char *tmplink_dir = NULL;
	int dar_recovered = 0;
	char *thname_buf;

	/*
	 * startup
	 */

	longname = ndmp_malloc(TLM_MAX_PATH_NAME);
	longlink = ndmp_malloc(TLM_MAX_PATH_NAME);
	hugename = ndmp_malloc(TLM_MAX_PATH_NAME);
	parentlnk = ndmp_malloc(TLM_MAX_PATH_NAME);
	thname_buf = ndmp_malloc(TLM_MAX_PATH_NAME);
	name = ndmp_malloc(TLM_MAX_PATH_NAME);
	acls = ndmp_malloc(sizeof (tlm_acls_t));
	stp = cstack_new();
	if (longname == NULL || longlink == NULL || hugename == NULL ||
	    name == NULL || acls == NULL || stp == NULL || parentlnk == NULL ||
	    thname_buf == NULL) {
		cstack_delete(stp);
		free(longname);
		free(longlink);
		free(hugename);
		free(parentlnk);
		free(name);
		free(acls);
		free(thname_buf);
		return (-TLM_NO_SCRATCH_SPACE);
	}

	acl_spot = 0;
	*hugename = '\0';
	*parentlnk = '\0';
	nm_end = 0;
	*longname = '\0';
	lnk_end = 0;
	*longlink = '\0';
	(void) memset(acls, 0, sizeof (tlm_acls_t));
	if (IS_SET(flags, RSFLG_OVR_ALWAYS)) {
		acls->acl_overwrite = TRUE;
		NDMP_LOG(LOG_DEBUG, "RSFLG_OVR_ALWAYS");
	} else if (IS_SET(flags, RSFLG_OVR_UPDATE)) {
		acls->acl_update = TRUE;
		NDMP_LOG(LOG_DEBUG, "RSFLG_OVR_UPDATE");
	}

	/*
	 * work
	 */
	rv = 0;
	nzerohdr = 0;
	break_flg = FALSE;
	while (commands->tcs_writer != TLM_ABORT &&
	    local_commands->tc_writer != TLM_STOP) {
		tlm_tar_hdr_t fake_tar_hdr;
		char	*file_name;
		char	*link_name;
		int	erc;
		int	actual_size;
		boolean_t want_this_file;
		int	want = sizeof (tlm_tar_hdr_t);
		tlm_tar_hdr_t *tar_hdr;

		/* The inode of an LF_LINK type. */
		unsigned long hardlink_inode = 0;

		/*
		 * Indicate whether a file with the same inode has been
		 * restored.
		 */
		int hardlink_done = 0;

		/* The path of the restored hardlink file */
		char *hardlink_target = NULL;
		int is_hardlink = 0;

		/*
		 * Whether a temporary file should be created for restoring
		 * hardlink.
		 */
		int hardlink_tmp_file = 0;
		char *hardlink_tmp_name = ".tmphlrsnondar";

		/* used to make up hardlink_tmp_name */
		static int hardlink_tmp_idx = 0;

		if (break_flg) {
			NDMP_LOG(LOG_DEBUG,
			    "Exiting writer thread drive %d", drv);
			break;
		}

		if (multi_volume) {
			NDMP_LOG(LOG_DEBUG, "multi_volume %c %d",
			    last_action, size_left);

			/*
			 * the previous volume is out of data
			 * and is back in the rack, a new tape
			 * is loaded and ready to read.
			 *
			 * We need to pick up where we left off.
			 */
			(void) memset(&fake_tar_hdr, 0, sizeof (fake_tar_hdr));
			file_size = size_left;
			tar_hdr = &fake_tar_hdr;
			tar_hdr->th_linkflag = last_action;

			multi_volume = FALSE;
			last_action = 0;
		} else {
			tar_hdr = (tlm_tar_hdr_t *)get_read_buffer(want,
			    &erc, &actual_size, local_commands);

			if (tar_hdr == NULL) {
				rv = -1;
				continue;
			}

			/*
			 * we can ignore read errors here because
			 *   1) they are logged by Restore Reader
			 *   2) we are not doing anything important here
			 *	just looking for the next work record.
			 */
			if (actual_size < want) {
				/*
				 * EOF hits here
				 *
				 * wait for another buffer to come along
				 * or until the Reader thread tells us
				 * that no more tapes will be loaded ...
				 * time to stop.
				 */
				continue;
			}

			/*
			 * check for "we are lost"
			 */
			chk_rv = tlm_vfy_tar_checksum(tar_hdr);
			if (chk_rv == 0) {
				/* one of the end of tar file marks */
				if (++nzerohdr >= 2) {
					NDMP_LOG(LOG_DEBUG,
					    "nzerohdr %d, breaking",
					    nzerohdr);
					/* end of tar file */
					break;
				}
				NDMP_LOG(LOG_DEBUG, "nzerohdr %d, continuing",
				    nzerohdr);
				continue;
			} else if (chk_rv < 0) {
				nzerohdr = 0;
				/* skip this record */
				continue;
			}
			nzerohdr = 0;

			/*
			 * When files are spanned to the next tape, the
			 * information of the acls must not be over-written
			 * by the information of the LF_MULTIVOL and LF_VOLHDR
			 * header, whose information is irrelevant to the file.
			 * The information of the original header must be
			 * kept in the 'acl'.
			 */
			if (tar_hdr->th_linkflag != LF_MULTIVOL &&
			    tar_hdr->th_linkflag != LF_VOLHDR) {
				if (tar_hdr->th_linkflag != LF_HUMONGUS) {
					acls->acl_attr.st_mode =
					    oct_atoi(tar_hdr->th_mode);
					acls->acl_attr.st_size =
					    oct_atoi(tar_hdr->th_size);
					acls->acl_attr.st_uid =
					    oct_atoi(tar_hdr->th_uid);
					acls->acl_attr.st_gid =
					    oct_atoi(tar_hdr->th_gid);
					acls->acl_attr.st_mtime =
					    oct_atoi(tar_hdr->th_mtime);
					(void) strlcpy(acls->uname,
					    tar_hdr->th_uname,
					    sizeof (acls->uname));
					(void) strlcpy(acls->gname,
					    tar_hdr->th_gname,
					    sizeof (acls->gname));
				}
				file_size = oct_atoi(tar_hdr->th_size);
				acl_spot = 0;
				last_action = tar_hdr->th_linkflag;
			}
		}

		NDMP_LOG(LOG_DEBUG, "n [%s] f [%c] s %lld m %o u %d g %d t %d",
		    tar_hdr->th_name, tar_hdr->th_linkflag,
		    acls->acl_attr.st_size, acls->acl_attr.st_mode,
		    acls->acl_attr.st_uid, acls->acl_attr.st_gid,
		    acls->acl_attr.st_mtime);

		/*
		 * If the restore is running using DAR we should check for
		 * extended attribute entries
		 */
		if (dar_recovered &&
		    tar_hdr->th_linkflag != LF_XATTR)
			break;

		rs_create_new_bkpath(bk_path, tar_hdr->th_name, thname_buf);

		switch (tar_hdr->th_linkflag) {
		case LF_MULTIVOL:
			multi_volume = TRUE;
			break;
		case LF_LINK:
			is_hardlink = 1;
			hardlink_inode =
			    oct_atoi(tar_hdr->th_shared.th_hlink_ino);

			/*
			 * Check if we have restored a link with the same inode
			 * If the inode is 0, we have to restore it as a
			 * regular file.
			 */
			if (hardlink_inode) {
				hardlink_done = !hardlink_q_get(hardlink_q,
				    hardlink_inode, 0, &hardlink_target);
			}

			if (hardlink_done) {
				NDMP_LOG(LOG_DEBUG,
				    "found hardlink, inode = %u, target = [%s]",
				    hardlink_inode,
				    hardlink_target? hardlink_target : "--");

				/* create a hardlink to hardlink_target */
				file_name = (*longname == 0) ?
				    thname_buf : longname;

				if (!is_file_wanted(file_name, sels, exls,
				    flags, &mchtype, &pos)) {
					nmp = NULL;
					/*
					 * This means that DMA did not send us
					 * the correct fh_info for the file
					 * in restore list.  We use the file
					 * name entry in sels[] (ignore the
					 * name in the tar header) as restore
					 * target.
					 */
					if (DAR) {
						nmp = rs_darhl_new_name(rnp,
						    name, sels, &pos,
						    file_name);
					}
				} else {
					nmp = rs_new_name(rnp, name, pos,
					    file_name);
					if (!nmp) {
						NDMP_LOG(LOG_DEBUG,
						    "can't make name for %s",
						    longname);
					}
				}

				if (nmp) {
					if (hardlink_target) {
						erc = create_hard_link(
						    hardlink_target, nmp,
						    acls, job_stats);
						if (erc == 0) {
							(void)
							    tlm_entry_restored(
							    job_stats,
							    file_name, pos);
							NDMP_LOG(LOG_DEBUG,
							    "restored %s -> %s",
							    nmp,
							    hardlink_target);
						}
					} else {
						NDMP_LOG(LOG_DEBUG,
						    "no target for hardlink %s",
						    nmp);
					}

					name[0] = 0;
					is_long_name = FALSE;
				}

				nm_end = 0;
				longname[0] = 0;
				lnk_end = 0;
				longlink[0] = 0;

				break;
			}
			/* otherwise fall through, restore like a normal file */
			/*FALLTHROUGH*/
		case LF_OLDNORMAL:
			/*
			 * check for TAR's end-of-tape method
			 * of zero filled records.
			 */
			if (tar_hdr->th_name[0] == 0) {
				break;
			}
			/*
			 * otherwise fall through,
			 * this is an old style normal file header
			 */
			/*FALLTHROUGH*/
		case LF_NORMAL:
		case LF_CONTIG:
			job_stats->js_files_so_far++;
			if (*hugename != 0) {
				(void) strlcpy(longname, hugename,
				    TLM_MAX_PATH_NAME);
			} else if (*longname == 0) {
				if (tar_hdr->th_name[0] != '/') {
					/*
					 * check for old tar format, it
					 * does not have a leading "/"
					 */
					longname[0] = '/';
					longname[1] = 0;
					(void) strlcat(longname,
					    tar_hdr->th_name,
					    TLM_MAX_PATH_NAME);
				} else {
					(void) strlcpy(longname,
					    thname_buf,
					    TLM_MAX_PATH_NAME);
				}
			}

			want_this_file = is_file_wanted(longname, sels, exls,
			    flags, &mchtype, &pos);
			if (!want_this_file) {
				nmp = NULL;
				/*
				 * This means that DMA did not send us valid
				 * fh_info for the file in restore list.  We
				 * use the file name entry in sels[] (ignore
				 * the name in the tar header) as restore
				 * target.
				 */
				if (DAR && (tar_hdr->th_linkflag == LF_LINK)) {
					nmp = rs_darhl_new_name(rnp, name,
					    sels, &pos, longname);

					if (nmp) {
						want_this_file = TRUE;
						mchtype = PM_EXACT;
					} else {
						break_flg = TRUE;
						break;
					}
				}
			} else {
				nmp = rs_new_name(rnp, name, pos, longname);
				if (!nmp)
					want_this_file = FALSE;
			}

			if (nmp)
				(void) strlcpy(parentlnk, nmp, strlen(nmp) + 1);

			/*
			 * For a hardlink, even if it's not asked to be
			 * restored, we restore it to a temporary location,
			 * in case other links to the same file need to be
			 * restored later.
			 *
			 * The temp files are created in tmplink_dir, with
			 * names like ".tmphlrsnondar*".  They are cleaned up
			 * at the completion of a restore.  However, if a
			 * restore were interrupted, e.g. by a system reboot,
			 * they would have to be cleaned up manually in order
			 * for the disk space to be freed.
			 *
			 * If tmplink_dir is NULL, no temperorary files are
			 * created during a restore.  This may result in some
			 * hardlinks not being restored during a partial
			 * restore.
			 */
			if (is_hardlink && !DAR && !want_this_file && !nmp) {
				if (tmplink_dir) {
					(void) snprintf(name, TLM_MAX_PATH_NAME,
					    "%s/%s_%d", tmplink_dir,
					    hardlink_tmp_name,
					    hardlink_tmp_idx);
					nmp = name;

					hardlink_tmp_idx++;
					hardlink_tmp_file = 1;
					want_this_file = TRUE;
					NDMP_LOG(LOG_DEBUG,
					    "To restore temp hardlink file %s.",
					    nmp);
				} else {
					NDMP_LOG(LOG_DEBUG,
					    "No tmplink_dir specified.");
				}
			}

			size_left = restore_file(&fp, nmp, file_size,
			    huge_size, acls, want_this_file, local_commands,
			    job_stats);

			/*
			 * In the case of non-DAR, we have to record the first
			 * link for an inode that has multiple links. That's
			 * the only link with data records actually backed up.
			 * In this way, when we run into the other links, they
			 * will be treated as links, and we won't go to look
			 * for the data records to restore.  This is not a
			 * problem for DAR, where DMA tells the tape where
			 * to locate the data records.
			 */
			if (is_hardlink && !DAR) {
				if (hardlink_q_add(hardlink_q, hardlink_inode,
				    0, nmp, hardlink_tmp_file))
					NDMP_LOG(LOG_DEBUG,
					    "failed to add (%u, %s) to HL q",
					    hardlink_inode, nmp);
			}

			/* remove / reverse the temporary stuff */
			if (hardlink_tmp_file) {
				nmp = NULL;
				want_this_file = FALSE;
				hardlink_tmp_file = 0;
			}

			/*
			 * Check if it is time to set the attribute
			 * of the restored directory
			 */
			while (nmp && ((bkpath = dtree_peek(stp)) != NULL)) {
				if (strstr(nmp, bkpath))
					break;

				(void) dtree_pop(stp);
			}

			NDMP_LOG(LOG_DEBUG, "sizeleft %s %d, %lld", longname,
			    size_left, huge_size);

			if (size_left == -TLM_STOP) {
				break_flg = TRUE;
				rv = -1;
				commands->tcs_reader = TLM_ABORT;
				NDMP_LOG(LOG_DEBUG, "restoring [%s] failed",
				    longname);
				break;
			}

			if (want_this_file) {
				job_stats->js_bytes_total += file_size;
				job_stats->js_files_total++;
			}

			huge_size -= file_size;
			if (huge_size < 0) {
				huge_size = 0;
			}
			if (size_left == 0 && huge_size == 0) {
				if (PM_EXACT_OR_CHILD(mchtype)) {
					(void) tlm_entry_restored(job_stats,
					    longname, pos);

					/*
					 * Add an entry to hardlink_q to record
					 * this hardlink.
					 */
					if (is_hardlink) {
						NDMP_LOG(LOG_DEBUG,
						    "Restored hardlink file %s",
						    nmp);

						if (DAR) {
							(void) hardlink_q_add(
							    hardlink_q,
							    hardlink_inode, 0,
							    nmp, 0);
						}
					}
				}

				nm_end = 0;
				longname[0] = 0;
				lnk_end = 0;
				longlink[0] = 0;
				hugename[0] = 0;
				name[0] = 0;
				is_long_name = FALSE;
			}
			break;
		case LF_XATTR:
			file_name = (*longname == 0) ? thname_buf :
			    longname;

			size_left = restore_xattr_hdr(&fp, parentlnk,
			    file_name, file_size, acls, local_commands,
			    job_stats);

			break;
		case LF_SYMLINK:
			file_name = (*longname == 0) ? thname_buf :
			    longname;
			link_name = (*longlink == 0) ?
			    tar_hdr->th_linkname : longlink;
			NDMP_LOG(LOG_DEBUG, "file_name[%s]", file_name);
			NDMP_LOG(LOG_DEBUG, "link_name[%s]", link_name);
			if (is_file_wanted(file_name, sels, exls, flags,
			    &mchtype, &pos)) {
				nmp = rs_new_name(rnp, name, pos, file_name);
				if (nmp) {
					erc = create_sym_link(nmp, link_name,
					    acls, job_stats);
					if (erc == 0 &&
					    PM_EXACT_OR_CHILD(mchtype))
						(void) tlm_entry_restored(
						    job_stats, file_name, pos);
					name[0] = 0;
				}
			}
			nm_end = 0;
			longname[0] = 0;
			lnk_end = 0;
			longlink[0] = 0;
			break;
		case LF_DIR:
			file_name = *longname == 0 ? thname_buf :
			    longname;
			if (is_file_wanted(file_name, sels, exls, flags,
			    &mchtype, &pos)) {
				dir_dar = DAR;
				nmp = rs_new_name(rnp, name, pos, file_name);
				if (nmp && mchtype != PM_PARENT) {
					(void) strlcpy(parentlnk, nmp,
					    strlen(nmp));
					erc = create_directory(nmp, job_stats);
					if (erc == 0 &&
					    PM_EXACT_OR_CHILD(mchtype))
						(void) tlm_entry_restored(
						    job_stats, file_name, pos);
					/*
					 * Check if it is time to set
					 * the attribute of the restored
					 * directory
					 */
					while ((bkpath = dtree_peek(stp))
					    != NULL) {
						if (strstr(nmp, bkpath))
							break;
						(void) dtree_pop(stp);
					}

					(void) dtree_push(stp, nmp, acls);
					name[0] = 0;
				}
			} else {
				dir_dar = 0;
			}
			nm_end = 0;
			longname[0] = 0;
			lnk_end = 0;
			longlink[0] = 0;
			break;
		case LF_FIFO:
		case LF_BLK:
		case LF_CHR:
			file_name = *longname == 0 ? thname_buf :
			    longname;
			if (is_file_wanted(file_name, sels, exls, flags,
			    &mchtype, &pos)) {
				nmp = rs_new_name(rnp, name, pos, file_name);
				if (nmp) {
					erc = create_special(
					    tar_hdr->th_linkflag, nmp, acls,
					    oct_atoi(tar_hdr->th_shared.
					    th_dev.th_devmajor),
					    oct_atoi(tar_hdr->th_shared.
					    th_dev.th_devminor), job_stats);
					if (erc == 0 &&
					    PM_EXACT_OR_CHILD(mchtype))
						(void) tlm_entry_restored(
						    job_stats, file_name, pos);
					name[0] = 0;
				}
			}
			nm_end = 0;
			longname[0] = 0;
			lnk_end = 0;
			longlink[0] = 0;
			break;
		case LF_LONGLINK:
			file_size = min(file_size,
			    TLM_MAX_PATH_NAME - lnk_end - 1);
			file_size = max(0, file_size);
			size_left = get_long_name(lib, drv, file_size, longlink,
			    &lnk_end, local_commands);

			if (size_left != 0)
				NDMP_LOG(LOG_DEBUG,
				    "fsize %d sleft %d lnkend %d",
				    file_size, size_left, lnk_end);
			break;
		case LF_LONGNAME:
			file_size = min(file_size,
			    TLM_MAX_PATH_NAME - nm_end - 1);
			file_size = max(0, file_size);
			size_left = get_long_name(lib, drv, file_size, longname,
			    &nm_end, local_commands);

			if (size_left != 0)
				NDMP_LOG(LOG_DEBUG,
				    "fsize %d sleft %d nmend %d",
				    file_size, size_left, nm_end);
			is_long_name = TRUE;
			break;
		case LF_ACL:
			size_left = load_acl_info(lib, drv, file_size, acls,
			    &acl_spot, local_commands);
			break;
		case LF_VOLHDR:
			break;
		case LF_HUMONGUS:
			(void) memset(hugename, 0, TLM_MAX_PATH_NAME);
			(void) get_humongus_file_header(lib, drv, file_size,
			    &huge_size, hugename, local_commands);
			break;
		default:
			break;

		}

		/*
		 * If the restore is running using DAR we should check for
		 * long file names and HUGE file sizes.
		 */
		if (DAR && tar_hdr->th_linkflag != LF_ACL &&
		    tar_hdr->th_linkflag != LF_XATTR &&
		    !huge_size && !is_long_name && !dir_dar)
			dar_recovered = 1;
	}

	/*
	 * tear down
	 */
	if (fp != 0) {
		(void) close(fp);
	}
	while (dtree_pop(stp) != -1)
		;
	cstack_delete(stp);
	free(acls);
	free(longname);
	free(parentlnk);
	free(longlink);
	free(hugename);
	free(name);
	free(thname_buf);
	return (rv);
}

/*
 * Main file restore function for tar (should run as a thread)
 */
int
tar_getfile(tlm_backup_restore_arg_t *argp)
{
	tlm_job_stats_t	*job_stats;
	char	**sels;		/* list of files desired */
	char	**exls;		/* list of files not wanted */
	char	*dir;		/* where to restore the files */
	char	job[TLM_MAX_BACKUP_JOB_NAME+1];
				/* the restore job name */
	int	erc;		/* error return codes */
	int	flags;
	struct	rs_name_maker rn;
	tlm_commands_t *commands;
	tlm_cmd_t *local_commands;
	char *list = NULL;

	commands = argp->ba_commands;
	local_commands = argp->ba_cmd;

	flags = 0;

	dir = ndmp_malloc(TLM_MAX_PATH_NAME);
	if (dir == NULL) {
		local_commands->tc_reader = TLM_STOP;
		(void) pthread_barrier_wait(&argp->ba_barrier);
		return (-1);
	}

	(void) strlcpy(job, argp->ba_job, TLM_MAX_BACKUP_JOB_NAME+1);
	(void) strlcpy(dir, argp->ba_dir, TLM_MAX_PATH_NAME);

	flags |= RSFLG_OVR_ALWAYS;
	flags |= RSFLG_IGNORE_CASE;

	/*
	 * do not test for "dir" having no string, since that
	 * is a legal condition.  Restore to origional location
	 * will not have a restore directory.
	 */
	if (*job == '\0') {
		NDMP_LOG(LOG_DEBUG, "No job defined");
		local_commands->tc_reader = TLM_STOP;
		free(dir);
		(void) pthread_barrier_wait(&argp->ba_barrier);
		return (-1);
	}

	sels = argp->ba_sels;
	if (sels == NULL) {
		local_commands->tc_reader = TLM_STOP;
		free(dir);
		(void) pthread_barrier_wait(&argp->ba_barrier);
		return (-1);
	}
	exls = &list;

	tlm_log_list("selections", sels);
	tlm_log_list("exclusions", exls);

	if (wildcard_enabled())
		flags |= RSFLG_MATCH_WCARD;

	local_commands->tc_ref++;
	commands->tcs_writer_count++;

	/*
	 * let the launcher continue
	 */
	(void) pthread_barrier_wait(&argp->ba_barrier);

	job_stats = tlm_ref_job_stats(job);

	rn.rn_fp = catnames;
	rn.rn_nlp = dir;

	/*
	 * work
	 */
	NDMP_LOG(LOG_DEBUG, "start restore job %s", job);
	erc = tar_getdir(commands, local_commands, job_stats, &rn, 1, 1,
	    sels, exls, flags, 0, NULL, NULL);

	/*
	 * teardown
	 */
	NDMP_LOG(LOG_DEBUG, "end restore job %s", job);
	tlm_un_ref_job_stats(job);
	tlm_release_list(sels);
	tlm_release_list(exls);

	commands->tcs_writer_count--;
	local_commands->tc_reader = TLM_STOP;
	tlm_release_reader_writer_ipc(local_commands);
	free(dir);
	return (erc);
}

/*
 * Creates the directories all the way down to the
 * end if they dont exist
 */
int
make_dirs(char *dir)
{
	char c;
	char *cp, *end;
	struct stat64 st;

	cp = dir;
	cp += strspn(cp, "/");
	end = dir + strlen(dir);
	do {
		if (*cp == '\0' || *cp == '/') {
			c = *cp;
			*cp = '\0';
			if (lstat64(dir, &st) < 0)
				if (mkdir(dir, 0777) < 0) {
					NDMP_LOG(LOG_DEBUG, "Error %d"
					    " creating directory %s",
					    errno, dir);
					*cp = c;
					return (-1);
				}

			*cp = c;
		}
	} while (++cp <= end);

	return (0);
}

/*
 * Creates the directories leading to the given path
 */
int
mkbasedir(char *path)
{
	int rv;
	char *cp;
	struct stat64 st;

	if (!path || !*path) {
		NDMP_LOG(LOG_DEBUG, "Invalid argument");
		return (-1);
	}

	cp = strrchr(path, '/');
	if (cp)
		*cp = '\0';
	rv = lstat64(path, &st);
	if (rv < 0)	/* need new directories */
		rv = make_dirs(path);
	if (cp)
		*cp = '/';

	return (rv);
}


/*
 * read the file off the tape back onto disk
 */
static long
restore_file(int *fp,
    char *real_name,
    long size,
    longlong_t huge_size,
    tlm_acls_t *acls,
    boolean_t want_this_file,
    tlm_cmd_t *local_commands,
    tlm_job_stats_t *job_stats)
{
	struct stat64	attr;

	if (!real_name) {
		if (want_this_file) {
			NDMP_LOG(LOG_DEBUG, "No file name but wanted!");
			want_this_file = FALSE;
		}
	} else
		NDMP_LOG(LOG_DEBUG, "new file[%s]", real_name);

	/*
	 * OK, some FM is creeping in here ...
	 * int *fp is used to keep the
	 * backup file channel open through
	 * the interruption of EOT and
	 * processing the headers of the
	 * next tape.  So, if *fp is zero
	 * then no file is open yet and all
	 * is normal.  If *fp has a number
	 * then we are returning after an
	 * EOT break.
	 *
	 * *fp is now also open for HUGE files
	 * that are put back in sections.
	 */

	if (*fp == 0 && want_this_file) {
		int	erc_stat;

		if (mkbasedir(real_name) < 0)
			job_stats->js_errors++;

		erc_stat = stat64(real_name, (struct stat64 *)&attr);
		if (erc_stat < 0) {
			/*EMPTY*/
			/* new file */
		} else if (acls->acl_overwrite) {
			/*EMPTY*/
			/* take this file no matter what */
		} else if (acls->acl_update) {
			if (attr.st_mtime < acls->acl_attr.st_mtime) {
				/*EMPTY*/
				/* tape is newer */
			} else {
				/* disk file is newer */
				want_this_file = FALSE;
			}
		} else {
			/*
			 * no overwrite, no update,
			 * do not ever replace old files.
			 */
			want_this_file = TRUE;
		}
		if (want_this_file) {

			*fp = open(real_name, O_CREAT | O_TRUNC | O_WRONLY,
			    S_IRUSR | S_IWUSR);
			if (*fp == -1) {
				NDMP_LOG(LOG_ERR,
				    "Could not open %s for restore.",
				    real_name);
				NDMP_LOG(LOG_DEBUG,
				    "fp=%d err=%d ", *fp, errno);
				job_stats->js_errors++;
				want_this_file = FALSE;
				/*
				 * we cannot return here,
				 * the file is still on
				 * the tape and must be
				 * skipped over.
				 */
			}
		}
		(void) strlcpy(local_commands->tc_file_name, real_name,
		    TLM_MAX_PATH_NAME);
	}

	/*
	 * this is the size left in the next segment
	 */
	huge_size -= size;

	/*
	 * work
	 */
	while (size > 0 && local_commands->tc_writer == TLM_RESTORE_RUN) {
		int	actual_size;
		int	error;
		char	*rec;
		int	write_size;

		/*
		 * Use bytes_in_file field to tell reader the amount
		 * of data still need to be read for this file.
		 */
		job_stats->js_bytes_in_file = size;

		error = 0;
		rec = get_read_buffer(size, &error, &actual_size,
		    local_commands);
		if (actual_size <= 0) {
			NDMP_LOG(LOG_DEBUG,
			    "RESTORE WRITER> error %d, actual_size %d",
			    error, actual_size);

			/* no more data for this file for now */
			job_stats->js_bytes_in_file = 0;

			return (size);
		} else if (error) {
			NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
			    error, local_commands->tc_file_name);
			break;
		} else {
			write_size = min(size, actual_size);
			if (want_this_file) {
				write_size = write(*fp, rec, write_size);
				NS_ADD(wdisk, write_size);
				NS_INC(wfile);
			}
			size -= write_size;
		}
	}

	/* no more data for this file for now */
	job_stats->js_bytes_in_file = 0;

	/*
	 * teardown
	 */
	if (*fp != 0 && huge_size <= 0) {
		(void) close(*fp);
		*fp = 0;
		set_acl(real_name, acls);
	}
	return (0);
}

/*
 * Set the extended attributes file attribute
 */
static void
set_xattr(int fd, struct stat64 st)
{
	struct timeval times[2];

	times[0].tv_sec = st.st_atime;
	times[1].tv_sec = st.st_mtime;

	(void) fchmod(fd, st.st_mode);
	(void) fchown(fd, st.st_uid, st.st_gid);
	(void) futimesat(fd, ".", times);
}

/*
 * Read the system attribute file in a single buffer to write
 * it as a single write. A partial write to system attribute would
 * cause an EINVAL on write.
 */
static char *
get_read_one_buf(char *rec, int actual_size, int size, int *error,
    tlm_cmd_t *lc)
{
	char *buf, *p;
	int read_size;
	int len;

	if (actual_size > size)
		return (rec);

	buf = ndmp_malloc(size);
	if (buf == NULL) {
		*error = ENOMEM;
		return (NULL);
	}
	(void) memcpy(buf, rec, actual_size);
	rec = buf;
	buf += actual_size;
	while (actual_size < size) {
		p = get_read_buffer(size - actual_size, error, &read_size, lc);
		len = min(size - actual_size, read_size);
		(void) memcpy(buf, p, len);
		actual_size += len;
		buf += len;
	}
	return (rec);
}


/*
 * read the extended attribute header and write
 * it to the file
 */
static long
restore_xattr_hdr(int *fp,
    char *name,
    char *fname,
    long size,
    tlm_acls_t *acls,
    tlm_cmd_t *local_commands,
    tlm_job_stats_t *job_stats)
{
	tlm_tar_hdr_t *tar_hdr;
	struct xattr_hdr *xhdr;
	struct xattr_buf *xbuf;
	int namelen;
	char *xattrname;
	int actual_size;
	int error;

	if (!fname) {
		NDMP_LOG(LOG_DEBUG, "No file name but wanted!");
	} else {
		NDMP_LOG(LOG_DEBUG, "new xattr[%s]", fname);
	}

	error = 0;
	xhdr = (struct xattr_hdr *)get_read_buffer(size, &error,
	    &actual_size, local_commands);
	if (xhdr == NULL || error != 0) {
		NDMP_LOG(LOG_DEBUG,
		    "Could not read xattr [%s:%s] for restore. ",
		    name, fname);
		job_stats->js_errors++;
		return (0);
	}

	/* Check extended attribute header */
	if (strcmp(xhdr->h_version, XATTR_ARCH_VERS) != 0) {
		NDMP_LOG(LOG_DEBUG,
		    "Unrecognized header format [%s]", xhdr->h_version);
		return (0);
	}
	xbuf = (struct xattr_buf *)(((char *)xhdr) + sizeof (struct xattr_hdr));

	(void) sscanf(xbuf->h_namesz, "%7d", &namelen);
	xattrname = xbuf->h_names + strlen(xbuf->h_names) + 1;

	if (*fp == 0) {
		int fd;

		fd = attropen(name, xattrname, O_CREAT | O_RDWR, 0755);
		if (fd == -1) {
			NDMP_LOG(LOG_DEBUG,
			    "Could not open xattr [%s:%s] for restore err=%d.",
			    name, xattrname, errno);
			job_stats->js_errors++;
			return (0);
		}
		(void) strlcpy(local_commands->tc_file_name, xattrname,
		    TLM_MAX_PATH_NAME);
		*fp = fd;
	}

	/* Get the actual extended attribute file */
	tar_hdr = (tlm_tar_hdr_t *)get_read_buffer(sizeof (*tar_hdr),
	    &error, &actual_size, local_commands);
	if (tar_hdr == NULL || error != 0) {
		NDMP_LOG(LOG_DEBUG,
		    "Could not read xattr data [%s:%s] for restore. ",
		    fname, xattrname);
		job_stats->js_errors++;
		return (0);
	}
	acls->acl_attr.st_mode = oct_atoi(tar_hdr->th_mode);
	acls->acl_attr.st_size = oct_atoi(tar_hdr->th_size);
	acls->acl_attr.st_uid = oct_atoi(tar_hdr->th_uid);
	acls->acl_attr.st_gid = oct_atoi(tar_hdr->th_gid);
	acls->acl_attr.st_mtime = oct_atoi(tar_hdr->th_mtime);

	NDMP_LOG(LOG_DEBUG, "xattr_hdr: %s size %d mode %06o uid %d gid %d",
	    xattrname, acls->acl_attr.st_size, acls->acl_attr.st_mode,
	    acls->acl_attr.st_uid, acls->acl_attr.st_gid);

	size = acls->acl_attr.st_size;
	while (size > 0 && local_commands->tc_writer == TLM_RESTORE_RUN) {
		char	*rec;
		int	write_size;
		int	sysattr_write = 0;

		error = 0;
		rec = get_read_buffer(size, &error, &actual_size,
		    local_commands);

		if ((actual_size < size) && sysattr_rw(xattrname)) {
			rec = get_read_one_buf(rec, actual_size, size, &error,
			    local_commands);
			if (rec == NULL) {
				NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
				    error, xattrname);
				return (size);
			}
			actual_size = size;
			sysattr_write = 1;
		}
		if (actual_size <= 0) {
			NDMP_LOG(LOG_DEBUG,
			    "RESTORE WRITER> error %d, actual_size %d",
			    error, actual_size);

			return (size);
		} else if (error) {
			NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
			    error, local_commands->tc_file_name);
			break;
		} else {
			write_size = min(size, actual_size);
			if ((write_size = write(*fp, rec, write_size)) < 0) {
				if (sysattr_write)
					free(rec);

				break;
			}

			NS_ADD(wdisk, write_size);
			NS_INC(wfile);
			size -= write_size;
		}
		if (sysattr_write)
			free(rec);
	}

	if (*fp != 0) {
		set_xattr(*fp, acls->acl_attr);
		(void) close(*fp);
		*fp = 0;
	}
	return (0);
}

/*
 * Match the name with the list
 */
static int
exact_find(char *name, char **list)
{
	boolean_t found;
	int i;
	char *cp;

	found = FALSE;
	for (i = 0; *list != NULL; list++, i++) {
		cp = *list + strspn(*list, "/");
		if (match(cp, name)) {
			found = TRUE;
			NDMP_LOG(LOG_DEBUG, "exact_find> found[%s]", cp);
			break;
		}
	}

	return (found);
}

/*
 * On error, return FALSE and prevent restoring(probably) unwanted data.
 */
static int
is_parent(char *parent, char *child, int flags)
{
	char tmp[TLM_MAX_PATH_NAME];
	boolean_t rv;

	if (IS_SET(flags, RSFLG_MATCH_WCARD)) {
		if (!tlm_cat_path(tmp, parent, "*")) {
			NDMP_LOG(LOG_DEBUG,
			    "is_parent> path too long [%s]", parent);
			rv = FALSE;
		} else
			rv = (match(tmp, child) != 0) ? TRUE : FALSE;
	} else {
		if (!tlm_cat_path(tmp, parent, "/")) {
			NDMP_LOG(LOG_DEBUG,
			    "is_parent> path too long [%s]", parent);
			rv = FALSE;
		} else
			rv = (strncmp(tmp, child, strlen(tmp)) == 0) ?
			    TRUE : FALSE;
	}

	return (rv);
}

/*
 * Used to match the filename inside the list
 */
static boolean_t
strexactcmp(char *s, char *t)
{
	return ((strcmp(s, t) == 0) ? TRUE : FALSE);
}

/*
 * Check if the file is needed to be restored
 */
static boolean_t
is_file_wanted(char *name,
    char **sels,
    char **exls,
    int flags,
    int *mchtype,
    int *pos)
{
	char *p_sel;
	char *uc_name, *retry, *namep;
	boolean_t found;
	int i;
	name_match_fp_t *cmp_fp;

	if (name == NULL || sels == NULL || exls == NULL)
		return (FALSE);

	found = FALSE;
	if (mchtype != NULL)
		*mchtype = PM_NONE;
	if (pos != NULL)
		*pos = 0;

	/*
	 * For empty selection, restore everything
	 */
	if (*sels == NULL || **sels == '\0') {
		NDMP_LOG(LOG_DEBUG, "is_file_wanted: Restore all");
		return (TRUE);
	}

	retry = ndmp_malloc(TLM_MAX_PATH_NAME);
	if (retry == NULL)
		return (FALSE);

	if (IS_SET(flags, RSFLG_MATCH_WCARD))
		cmp_fp = match;
	else
		cmp_fp = strexactcmp;

	namep = name + strspn(name, "/");

	if (IS_SET(flags, RSFLG_IGNORE_CASE)) {
		uc_name = ndmp_malloc(TLM_MAX_PATH_NAME);
		if (uc_name == NULL) {
			free(retry);
			return (FALSE);
		}
		(void) strlcpy(uc_name, namep, TLM_MAX_PATH_NAME);
		(void) strupr(uc_name);
		namep = uc_name;
	}
	NDMP_LOG(LOG_DEBUG, "is_file_wanted> flg: 0x%x name: [%s]",
	    flags, name);

	for (i = 0; *sels != NULL; sels++, i++) {
		p_sel = *sels + strspn(*sels, "/");

		/*
		 * Try exact match.
		 */
		if ((*cmp_fp)(p_sel, namep)) {
			NDMP_LOG(LOG_DEBUG, "match1> pos: %d [%s][%s]",
			    i, p_sel, name);
			found = TRUE;
			if (mchtype != NULL)
				*mchtype = PM_EXACT;
			break;
		}
		/*
		 * Try "entry/" and the current selection.  The
		 * current selection may be something like "<something>/".
		 */
		(void) tlm_cat_path(retry, namep, "/");
		if ((*cmp_fp)(p_sel, retry)) {
			NDMP_LOG(LOG_DEBUG, "match2> pos %d [%s][%s]",
			    i, p_sel, name);
			found = TRUE;
			if (mchtype != NULL)
				*mchtype = PM_EXACT;
			break;
		}
		/*
		 * If the following check returns true it means that the
		 * 'name' is an entry below the 'p_sel' hierarchy.
		 */
		if (is_parent(p_sel, namep, flags)) {
			NDMP_LOG(LOG_DEBUG, "parent1> pos %d [%s][%s]",
			    i, p_sel, name);
			found = TRUE;
			if (mchtype != NULL)
				*mchtype = PM_CHILD;
			break;
		}
		/*
		 * There is a special case for parent directories of a
		 * selection.  If 'p_sel' is something like "*d1", the
		 * middle directories of the final entry can't be determined
		 * until the final entry matches with 'p_sel'.  At that
		 * time the middle directories of the entry have been passed
		 * and they can't be restored.
		 */
		if (is_parent(namep, p_sel, flags)) {
			NDMP_LOG(LOG_DEBUG, "parent2> pos %d [%s][%s]",
			    i, p_sel, name);
			found = TRUE;
			if (mchtype != NULL)
				*mchtype = PM_PARENT;
			break;
		}
	}

	/* Check for exclusions.  */
	if (found && exact_find(namep, exls)) {
		if (mchtype != NULL)
			*mchtype = PM_NONE;
		found = FALSE;
	}
	if (found && pos != NULL)
		*pos = i;

	if (IS_SET(flags, RSFLG_IGNORE_CASE))
		free(uc_name);
	free(retry);
	return (found);
}

/*
 * Read the specified amount data into the buffer.  Detects EOT or EOF
 * during read.
 *
 * Returns the number of bytes actually read.  On error returns -1.
 */
static int
input_mem(int l,
    int d,
    tlm_cmd_t *lcmds,
    char *mem,
    int len)
{
	int err;
	int toread, actual_size, rec_size;
	char *rec;

	if (l <= 0 || d <= 0 || !lcmds || !mem) {
		NDMP_LOG(LOG_DEBUG, "Invalid argument");
		return (-1);
	}

	toread = len;
	while (toread > 0) {
		rec = get_read_buffer(toread, &err, &actual_size, lcmds);
		if (actual_size <= 0) {
			NDMP_LOG(LOG_DEBUG, "err %d act_size %d detected",
			    err, actual_size);
			break;
		} else if (err) {
			NDMP_LOG(LOG_DEBUG, "error %d reading data", err);
			return (-1);
		}
		rec_size = min(actual_size, toread);
		(void) memcpy(mem, rec, rec_size);
		mem += rec_size;
		toread -= rec_size;
	}

	return (len - toread);
}

/*
 * pick up the name and size of a HUGE file
 */
static	int
get_humongus_file_header(int lib,
    int	drv,
    long recsize,
    longlong_t *size,
    char *name,
    tlm_cmd_t *local_commands)
{
	char *p_record, *value;
	int rv;

	NDMP_LOG(LOG_DEBUG, "HUGE Record found: %d", recsize);

	rv = 0;
	if (recsize == 0) {
		/*
		 * The humongus_file_header was written in a
		 * RECORDSIZE block and the header.size field of this
		 * record was 0 before this fix.  For backward compatiblity
		 * read only one RECORDSIZE-size block if the header.size
		 * field is 0.  Otherwise the header.size field should show
		 * the length of the data of this header.
		 */
		NDMP_LOG(LOG_DEBUG, "Old HUGE record found");
		recsize = RECORDSIZE;
	}

	if (input_mem(lib, drv, local_commands, name, recsize) != recsize) {
		rv = -1;
		*size = 0;
		*name = '\0';
		NDMP_LOG(LOG_DEBUG, "Error reading a HUGE file name");
	} else {
		NDMP_LOG(LOG_DEBUG, "HUGE [%s]", name);

		p_record = name;
		value = parse(&p_record, " ");
		*size = atoll(value);
		/*
		 * Note: Since the backed up names are not longer than
		 * NAME_MAX and the buffer passed to us is
		 * TLM_MAX_PATH_NAME, it should be safe to use strlcpy
		 * without check on the buffer size.
		 */
		(void) strlcpy(name, p_record, TLM_MAX_PATH_NAME);
	}

	NDMP_LOG(LOG_DEBUG, "HUGE Record %lld [%s]", *size, name);

	return (rv);
}

/*
 * pick up the long name from the special tape file
 */
static int
get_long_name(int lib,
    int drv,
    long recsize,
    char *name,
    long *buf_spot,
    tlm_cmd_t *local_commands)
{
	int nread;

	NDMP_LOG(LOG_DEBUG, "LONGNAME Record found rs %d bs %d", recsize,
	    *buf_spot);

	if (*buf_spot < 0)
		*buf_spot = 0;

	nread = input_mem(lib, drv, local_commands, name + *buf_spot,
	    recsize);
	if (nread < 0) {
		nread = recsize; /* return 0 as size left */
		name[*buf_spot] = '\0';
		NDMP_LOG(LOG_ERR, "Error %d reading a long file name %s.",
		    nread, name);
	} else {
		*buf_spot += nread;
		name[*buf_spot] = '\0';
		NDMP_LOG(LOG_DEBUG, "LONGNAME [%s]", name);
	}

	return (recsize - nread);
}

/*
 * create a new directory
 */
static	int
create_directory(char *dir, tlm_job_stats_t *job_stats)
{
	struct stat64 attr;
	char	*p;
	char	temp;
	int	erc;

	/*
	 * Make sure all directories in this path exist, create them if
	 * needed.
	 */
	NDMP_LOG(LOG_DEBUG, "new dir[%s]", dir);

	erc = 0;
	p = &dir[1];
	do {
		temp = *p;
		if (temp == '/' || temp == 0) {
			*p = 0;
			if (stat64(dir, &attr) < 0) {
				erc = mkdir(dir, 0777);
				if (erc < 0) {
					job_stats->js_errors++;
					NDMP_LOG(LOG_DEBUG,
					    "Could not create directory %s",
					    dir);
					break;
				}
			}
			*p = temp;
		}
		p++;
	} while (temp != 0);

	return (erc);
}

/*
 * create a new hardlink
 */
static int
create_hard_link(char *name_old, char *name_new,
    tlm_acls_t *acls, tlm_job_stats_t *job_stats)
{
	int erc;

	if (mkbasedir(name_new)) {
		NDMP_LOG(LOG_DEBUG, "faile to make base dir for [%s]",
		    name_new);

		return (-1);
	}

	erc = link(name_old, name_new);

	/* Nothing to do if the destination already exists */
	if (erc && (errno == EEXIST))
		return (0);

	if (erc) {
		job_stats->js_errors++;
		NDMP_LOG(LOG_DEBUG, "error %d (errno %d) hardlink [%s] to [%s]",
		    erc, errno, name_new, name_old);
	} else {
		set_acl(name_new, acls);
	}
	return (erc);
}

/*
 * create a new symlink
 */
/*ARGSUSED*/
static int
create_sym_link(char *dst, char *target, tlm_acls_t *acls,
    tlm_job_stats_t *job_stats)
{
	int erc;
	struct stat64 *st;

	if (mkbasedir(dst) < 0)
		return (-1);

	st = &acls->acl_attr;
	erc = symlink(target, dst);
	if (erc) {
		job_stats->js_errors++;
		NDMP_LOG(LOG_DEBUG, "error %d (errno %d) softlink [%s] to [%s]",
		    erc, errno, dst, target);
	} else {
		st->st_mode |= S_IFLNK;
		set_acl(dst, acls);
	}

	return (erc);
}

/*
 * create a new FIFO, char/block device special files
 */
static int
create_special(char flag, char *name, tlm_acls_t *acls, int major, int minor,
    tlm_job_stats_t *job_stats)
{
	dev_t dev;
	mode_t mode;
	int erc;

	switch (flag) {
	case LF_CHR:
		mode = S_IFCHR;
		dev = makedev(major, minor);
		break;
	case LF_BLK:
		mode = S_IFBLK;
		dev = makedev(major, minor);
		break;
	case LF_FIFO:
		mode = S_IFIFO;
		dev = 0;
		break;
	default:
		NDMP_LOG(LOG_ERR, "unsupported flag %d", flag);
		return (-1);
	}

	/* Remove the old entry first */
	if (rmdir(name) < 0) {
		if (errno == ENOTDIR)
			(void) unlink(name);
	}
	erc = mknod(name, 0777 | mode, dev);
	if (erc) {
		job_stats->js_errors++;
		NDMP_LOG(LOG_DEBUG, "error %d (errno %d) mknod [%s] major"
		    " %d minor %d", erc, errno, name, major, minor);
	} else {
		set_acl(name, acls);
	}
	return (erc);
}

/*
 * read in the ACLs for the next file
 */
static long
load_acl_info(int lib,
    int drv,
    long file_size,
    tlm_acls_t *acls,
    long *acl_spot,
    tlm_cmd_t *local_commands)
{
	char *bp;
	int nread;

	/*
	 * If the ACL is spanned on tapes, then the acl_spot should NOT be
	 * 0 on next calls to this function to read the rest of the ACL
	 * on next tapes.
	 */
	if (*acl_spot == 0) {
		(void) memset(acls, 0, sizeof (tlm_acls_t));
	}

	bp = ((char *)&acls->acl_info) + *acl_spot;
	nread = input_mem(lib, drv, local_commands, (void *)bp, file_size);
	if (nread < 0) {
		*acl_spot = 0;
		(void) memset(acls, 0, sizeof (tlm_acls_t));
		NDMP_LOG(LOG_DEBUG, "Error reading ACL data");
		return (0);
	}
	*acl_spot += nread;
	acls->acl_non_trivial = TRUE;

	return (file_size - nread);
}

static int
ndmp_set_eprivs_least(void)
{
	priv_set_t *priv_set;

	if ((priv_set = priv_allocset()) == NULL) {
		NDMP_LOG(LOG_ERR, "Out of memory.");
		return (-1);
	}

	priv_basicset(priv_set);

	(void) priv_addset(priv_set, PRIV_PROC_AUDIT);
	(void) priv_addset(priv_set, PRIV_PROC_SETID);
	(void) priv_addset(priv_set, PRIV_PROC_OWNER);
	(void) priv_addset(priv_set, PRIV_FILE_CHOWN);
	(void) priv_addset(priv_set, PRIV_FILE_CHOWN_SELF);
	(void) priv_addset(priv_set, PRIV_FILE_DAC_READ);
	(void) priv_addset(priv_set, PRIV_FILE_DAC_SEARCH);
	(void) priv_addset(priv_set, PRIV_FILE_DAC_WRITE);
	(void) priv_addset(priv_set, PRIV_FILE_OWNER);
	(void) priv_addset(priv_set, PRIV_FILE_SETID);
	(void) priv_addset(priv_set, PRIV_SYS_LINKDIR);
	(void) priv_addset(priv_set, PRIV_SYS_DEVICES);
	(void) priv_addset(priv_set, PRIV_SYS_MOUNT);
	(void) priv_addset(priv_set, PRIV_SYS_CONFIG);

	if (setppriv(PRIV_SET, PRIV_EFFECTIVE, priv_set) == -1) {
		NDMP_LOG(LOG_ERR, "Additional privileges required.");
		priv_freeset(priv_set);
		return (-1);
	}
	priv_freeset(priv_set);
	return (0);
}

static int
ndmp_set_eprivs_all(void)
{
	priv_set_t *priv_set;

	if ((priv_set = priv_allocset()) == NULL) {
		NDMP_LOG(LOG_ERR, "Out of memory.");
		return (-1);
	}

	priv_fillset(priv_set);

	if (setppriv(PRIV_SET, PRIV_EFFECTIVE, priv_set) != 0) {
		NDMP_LOG(LOG_ERR, "Additional privileges required.");
		return (-1);
	}
	priv_freeset(priv_set);
	return (0);
}

/*
 * Set the standard attributes of the file
 */
static void
set_attr(char *name, tlm_acls_t *acls)
{
	struct utimbuf tbuf;
	boolean_t priv_all = FALSE;
	struct stat64 *st;
	uid_t uid;
	gid_t gid;
	struct passwd *pwd;
	struct group *grp;


	if (!name || !acls)
		return;

	st = &acls->acl_attr;
	NDMP_LOG(LOG_DEBUG, "set_attr: %s uid %d gid %d uname %s gname %s "
	    "mode %o", name, st->st_uid, st->st_gid, acls->uname, acls->gname,
	    st->st_mode);

	uid = st->st_uid;
	if ((pwd = getpwnam(acls->uname)) != NULL) {
		NDMP_LOG(LOG_DEBUG, "set_attr: new uid %d old %d",
		    pwd->pw_uid, uid);
		uid = pwd->pw_uid;
	}

	gid = st->st_gid;
	if ((grp = getgrnam(acls->gname)) != NULL) {
		NDMP_LOG(LOG_DEBUG, "set_attr: new gid %d old %d",
		    grp->gr_gid, gid);
		gid = grp->gr_gid;
	}

	if (lchown(name, uid, gid))
		NDMP_LOG(LOG_ERR,
		    "Could not set uid or/and gid for file %s.", name);

	if ((st->st_mode & (S_ISUID | S_ISGID)) != 0) {
		/*
		 * Change effective privileges to 'all' which is required to
		 * change setuid bit for 'root' owned files. If fails, just
		 * send error to log file and proceed.
		 */
		if (ndmp_set_eprivs_all()) {
			NDMP_LOG(LOG_ERR,
			    "Could not set effective privileges to 'all'.");
		} else {
			priv_all = TRUE;
		}
	}

	if (!S_ISLNK(st->st_mode)) {
		if (chmod(name, st->st_mode))
			NDMP_LOG(LOG_ERR, "Could not set correct file"
			    " permission for file %s.", name);

		tbuf.modtime = st->st_mtime;
		tbuf.actime = st->st_atime;
		(void) utime(name, &tbuf);
	}

	if (priv_all == TRUE) {
		/*
		 * Give up the 'all' privileges for effective sets and go back
		 * to least required privileges. If fails, just send error to
		 * log file and proceed.
		 */
		if (ndmp_set_eprivs_least())
			NDMP_LOG(LOG_ERR,
			    "Could not set least required privileges.");
	}
}

/*
 * Set the ACL info for the file
 */
static void
set_acl(char *name, tlm_acls_t *acls)
{
	int erc;
	acl_t *aclp = NULL;

	if (name)
		NDMP_LOG(LOG_DEBUG, "set_acl: %s", name);
	if (acls != 0) {
		/* Need a place to save real modification time */

		set_attr(name, acls);

		if (!acls->acl_non_trivial) {
			(void) memset(acls, 0, sizeof (tlm_acls_t));
			NDMP_LOG(LOG_DEBUG, "set_acl: skipping trivial");
			return;
		}

		erc = acl_fromtext(acls->acl_info.attr_info, &aclp);
		if (erc != 0) {
			NDMP_LOG(LOG_DEBUG,
			    "TAPE RESTORE> acl_fromtext errno %d", erc);
		}
		if (aclp) {
			erc = acl_set(name, aclp);
			if (erc < 0) {
				NDMP_LOG(LOG_DEBUG,
				    "TAPE RESTORE> acl_set errno %d", errno);
			}
			acl_free(aclp);
		}
		(void) memset(acls, 0, sizeof (tlm_acls_t));
	}
}

/*
 * a wrapper to tlm_get_read_buffer so that
 * we can cleanly detect ABORT commands
 * without involving the TLM library with
 * our problems.
 */
static char *
get_read_buffer(int want,
    int	*error,
    int	*actual_size,
    tlm_cmd_t *local_commands)
{
	while (local_commands->tc_writer == TLM_RESTORE_RUN) {
		char	*rec;
		rec = tlm_get_read_buffer(want, error,
		    local_commands->tc_buffers, actual_size);
		if (rec != 0) {
			return (rec);
		}
	}

	/*
	 * the job is ending, give Writer a buffer that will never be read ...
	 * it does not matter anyhow, we are aborting.
	 */
	*actual_size = RECORDSIZE;
	return (NULL);
}

/*
 * Enable wildcard for restore options
 */
static boolean_t
wildcard_enabled(void)
{
	char *cp;

	cp = ndmpd_get_prop_default(NDMP_RESTORE_WILDCARD_ENABLE, "n");
	return ((toupper(*cp) == 'Y') ? TRUE : FALSE);
}


/*
 * Concatenate two names
 */
/*ARGSUSED*/
static char *
catnames(struct rs_name_maker *rnp, char *buf, int pos, char *path)
{
	char *rv;

	rv = NULL;
	if (!buf) {
		NDMP_LOG(LOG_DEBUG, "buf is NULL");
	} else if (!path) {
		NDMP_LOG(LOG_DEBUG, "path is NULL");
	} else if (!rnp->rn_nlp) {
		NDMP_LOG(LOG_DEBUG, "rn_nlp is NULL [%s]", path);
	} else if (!tlm_cat_path(buf, rnp->rn_nlp, path)) {
		NDMP_LOG(LOG_DEBUG, "Path too long [%s][%s]",
		    rnp->rn_nlp, path);
	} else
		rv = buf;

	return (rv);
}


/*
 * Create a new name path for restore
 */
static char *
rs_new_name(struct rs_name_maker *rnp, char *buf, int pos, char *path)
{
	if (!rnp || !rnp->rn_fp)
		return (NULL);

	return (*rnp->rn_fp)(rnp, buf, pos, path);
}

/*
 * Clear the extra "/" in the tar header if exists
 */
static void
rs_create_new_bkpath(char *bk_path, char *path, char *pbuf)
{
	char *p, *slashp;

	if ((p = strstr(path, bk_path)) == NULL) {
		(void) strlcpy(pbuf, path, TLM_MAX_PATH_NAME);
		return;
	}
	if (*(p += strlen(bk_path)) == '/')
		p++;

	slashp = bk_path + strlen(bk_path) - 1;
	if (*slashp == '/')
		(void) snprintf(pbuf, TLM_MAX_PATH_NAME, "%s%s", bk_path, p);
	else
		(void) snprintf(pbuf, TLM_MAX_PATH_NAME, "%s/%s", bk_path, p);

	NDMP_LOG(LOG_DEBUG, "old path [%s] new path [%s]", path, pbuf);
}


/*
 * Iterate over ZFS metadata stored in the backup stream and use the callback
 * to restore it.
 */
int
ndmp_iter_zfs(ndmp_context_t *nctx, int (*np_restore_property)(nvlist_t *,
    void *), void *ptr)
{
	tlm_commands_t *cmds;
	ndmp_metadata_header_t *mhp;
	ndmp_metadata_header_ext_t *mhpx;
	ndmp_metadata_property_t *mpp;
	ndmp_metadata_property_ext_t *mppx;
	tlm_cmd_t *lcmd;
	int actual_size;
	nvlist_t *nvl;
	nvlist_t *valp;
	nvpair_t *nvp = NULL;
	char plname[100];
	char *mhbuf, *pp, *tp;
	int rv, i;
	int size, lsize, sz;
	int align = RECORDSIZE - 1;

	if (nctx == NULL || (cmds = (tlm_commands_t *)nctx->nc_cmds) == NULL)
		return (-1);

	nctx->nc_plname = plname;
	if ((lcmd = cmds->tcs_command) == NULL ||
	    lcmd->tc_buffers == NULL)
		return (-1);

	/* Default minimum bytes needed */
	size = sizeof (ndmp_metadata_header_t) +
	    ZFS_MAX_PROPS * sizeof (ndmp_metadata_property_t);
	size += align;
	size &= ~align;

	if ((mhbuf = malloc(size)) == NULL)
		return (-1);

	/* LINTED improper alignment */
	while ((mhp = (ndmp_metadata_header_t *)get_read_buffer(size, &rv,
	    &actual_size, lcmd)) != NULL) {
		pp = mhbuf;

		if (strncmp(mhp->nh_magic, ZFS_META_MAGIC,
		    sizeof (mhp->nh_magic)) != 0 &&
		    strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
		    sizeof (mhp->nh_magic)) != 0) {
			/* No more metadata */
			tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
			free(mhbuf);
			return (0);
		}

		if (strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
		    sizeof (mhp->nh_magic)) == 0) {
			mhpx = (ndmp_metadata_header_ext_t *)mhp;
			if (mhpx->nh_total_bytes > size) {
				if ((pp = realloc(mhbuf, mhpx->nh_total_bytes))
				    == NULL) {
					free(mhbuf);
					return (-1);
				}
				mhbuf = pp;
			}
			size = mhpx->nh_total_bytes;
		}

		(void) memcpy(pp, (char *)mhp, (actual_size < size) ?
		    actual_size : size);
		pp += (actual_size < size) ? actual_size : size;

		sz = actual_size;
		while (sz < size &&
		    ((tp = get_read_buffer(size - sz, &rv, &lsize,
		    lcmd))) != NULL) {
			(void) memcpy(pp, tp, lsize);
			sz += lsize;
			pp += lsize;
		}
		if (sz > size) {
			tlm_unget_read_buffer(lcmd->tc_buffers, sz - size);
		}

		/* LINTED improper alignment */
		mhp = (ndmp_metadata_header_t *)mhbuf;

		nvl = NULL;
		if (strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
		    sizeof (mhp->nh_magic)) == 0) {
			/* New metadata format */
			/* LINTED improper alignment */
			mhpx = (ndmp_metadata_header_ext_t *)mhbuf;

			if (mhpx->nh_major > META_HDR_MAJOR_VERSION) {
				/* Major header mismatch */
				NDMP_LOG(LOG_ERR, "metadata header mismatch",
				    "M%d != M%d", mhpx->nh_major,
				    META_HDR_MAJOR_VERSION);
				free(mhbuf);
				return (-1);
			}
			if (mhpx->nh_major == META_HDR_MAJOR_VERSION &&
			    mhpx->nh_minor > META_HDR_MINOR_VERSION) {
				/* Minor header mismatch */
				NDMP_LOG(LOG_ERR, "Warning:"
				    "metadata header mismatch m%d != m%d",
				    mhpx->nh_minor,
				    META_HDR_MINOR_VERSION);
				continue;
			}

			nctx->nc_plversion = mhpx->nh_plversion;
			(void) strlcpy(plname, mhpx->nh_plname,
			    sizeof (plname));

			if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
				goto nvlist_err;

			mppx = &mhpx->nh_property[0];
			for (i = 0; i < mhpx->nh_count && mppx; i++, mppx++) {
				if (!*mppx->mp_name)
					continue;
				valp = NULL;
				if (nvlist_alloc(&valp,
				    NV_UNIQUE_NAME, 0) != 0 ||
				    nvlist_add_string(valp, "value",
				    mppx->mp_value) != 0 ||
				    nvlist_add_string(valp, "source",
				    mppx->mp_source) != 0 ||
				    nvlist_add_nvlist(nvl, mppx->mp_name,
				    valp) != 0) {
					nvlist_free(valp);
					goto nvlist_err;
				}
				nvlist_free(valp);
			}
		} else {
			nctx->nc_plversion = mhp->nh_plversion;
			(void) strlcpy(plname, mhp->nh_plname,
			    sizeof (plname));

			if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
				goto nvlist_err;

			mpp = &mhp->nh_property[0];
			for (i = 0; i < mhp->nh_count && mpp; i++, mpp++) {
				if (!*mpp->mp_name)
					continue;
				valp = NULL;
				if (nvlist_alloc(&valp,
				    NV_UNIQUE_NAME, 0) != 0 ||
				    nvlist_add_string(valp, "value",
				    mpp->mp_value) != 0 ||
				    nvlist_add_string(valp, "source",
				    mpp->mp_source) != 0 ||
				    nvlist_add_nvlist(nvl, mpp->mp_name,
				    valp) != 0) {
					nvlist_free(valp);
					goto nvlist_err;
				}
				nvlist_free(valp);
			}
		}

		if (np_restore_property(nvl, ptr) != 0)
			goto nvlist_err;

		while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL &&
		    nvpair_value_nvlist(nvp, &valp) == 0) {
			nvlist_free(valp);
		}
		nvlist_free(nvl);
	}

	free(mhbuf);
	return (0);

nvlist_err:
	free(mhbuf);

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL &&
	    nvpair_value_nvlist(nvp, &valp) == 0) {
		nvlist_free(valp);
	}
	nvlist_free(nvl);
	return (-1);
}

/*
 * Returns the version number of the plugin which created the metadata
 */
uint_t
ndmp_context_get_version(ndmp_context_t *nctx)
{
	tlm_commands_t *cmds;
	ndmp_metadata_header_t *mhp;
	tlm_cmd_t *lcmd;
	int actual_size;
	int rv;
	int size;
	int align = RECORDSIZE - 1;

	if (nctx == NULL || (cmds = (tlm_commands_t *)nctx->nc_cmds) == NULL)
		return (0);

	if ((lcmd = cmds->tcs_command) == NULL ||
	    lcmd->tc_buffers == NULL)
		return (0);

	size = sizeof (ndmp_metadata_header_t);
	size += align;
	size &= ~align;

	/* LINTED improper alignment */
	if ((mhp = (ndmp_metadata_header_t *)get_read_buffer(size, &rv,
	    &actual_size, lcmd)) != NULL) {
		if (strncmp(mhp->nh_magic, ZFS_META_MAGIC,
		    sizeof (mhp->nh_magic)) != 0) {
			/* No more metadata */
			tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
			return (0);
		}

		nctx->nc_plversion = mhp->nh_plversion;
		tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
	}

	return (nctx->nc_plversion);
}