12654012fSReza Sabdar /*
25181c2afSReza Sabdar * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
32efb3bf9SJan Kryl * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
42654012fSReza Sabdar */
52654012fSReza Sabdar
62654012fSReza Sabdar /*
72654012fSReza Sabdar * BSD 3 Clause License
82654012fSReza Sabdar *
92654012fSReza Sabdar * Copyright (c) 2007, The Storage Networking Industry Association.
102654012fSReza Sabdar *
112654012fSReza Sabdar * Redistribution and use in source and binary forms, with or without
122654012fSReza Sabdar * modification, are permitted provided that the following conditions
132654012fSReza Sabdar * are met:
14*82049ff5SToomas Soome * - Redistributions of source code must retain the above copyright
152654012fSReza Sabdar * notice, this list of conditions and the following disclaimer.
162654012fSReza Sabdar *
17*82049ff5SToomas Soome * - Redistributions in binary form must reproduce the above copyright
182654012fSReza Sabdar * notice, this list of conditions and the following disclaimer in
192654012fSReza Sabdar * the documentation and/or other materials provided with the
202654012fSReza Sabdar * distribution.
212654012fSReza Sabdar *
222654012fSReza Sabdar * - Neither the name of The Storage Networking Industry Association (SNIA)
232654012fSReza Sabdar * nor the names of its contributors may be used to endorse or promote
242654012fSReza Sabdar * products derived from this software without specific prior written
252654012fSReza Sabdar * permission.
262654012fSReza Sabdar *
272654012fSReza Sabdar * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
282654012fSReza Sabdar * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
292654012fSReza Sabdar * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
302654012fSReza Sabdar * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
312654012fSReza Sabdar * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
322654012fSReza Sabdar * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
332654012fSReza Sabdar * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
342654012fSReza Sabdar * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
352654012fSReza Sabdar * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
362654012fSReza Sabdar * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
372654012fSReza Sabdar * POSSIBILITY OF SUCH DAMAGE.
382654012fSReza Sabdar */
392654012fSReza Sabdar #include <stdlib.h>
402654012fSReza Sabdar #include <ctype.h>
412654012fSReza Sabdar #include <stdio.h>
422654012fSReza Sabdar #include <limits.h>
432654012fSReza Sabdar #include <string.h>
442654012fSReza Sabdar #include <time.h>
452654012fSReza Sabdar #include <sys/types.h>
462654012fSReza Sabdar #include <sys/acl.h>
475181c2afSReza Sabdar #include <sys/mkdev.h>
482654012fSReza Sabdar #include <utime.h>
492654012fSReza Sabdar #include <unistd.h>
502654012fSReza Sabdar #include <pthread.h>
512654012fSReza Sabdar #include <archives.h>
522654012fSReza Sabdar #include <priv.h>
532654012fSReza Sabdar #include <tlm.h>
542654012fSReza Sabdar #include <libzfs.h>
55b6b15642SReza Sabdar #include <pwd.h>
56b6b15642SReza Sabdar #include <grp.h>
572654012fSReza Sabdar #include <ndmpd_prop.h>
582654012fSReza Sabdar #include "tlm_proto.h"
592654012fSReza Sabdar
602654012fSReza Sabdar
612654012fSReza Sabdar #define PM_EXACT_OR_CHILD(m) ((m) == PM_EXACT || (m) == PM_CHILD)
622efb3bf9SJan Kryl #define ERROR_IS_FATAL(err) ((err) == ENOSPC || (err) == EDQUOT)
632654012fSReza Sabdar
642654012fSReza Sabdar typedef boolean_t name_match_fp_t(char *s, char *t);
652654012fSReza Sabdar
662efb3bf9SJan Kryl static int set_acl(char *name, tlm_acls_t *acls);
672efb3bf9SJan Kryl static int restore_file(int *fp,
682654012fSReza Sabdar char *real_name,
692654012fSReza Sabdar long size,
702654012fSReza Sabdar longlong_t huge_size,
712654012fSReza Sabdar tlm_acls_t *,
722654012fSReza Sabdar boolean_t want_this_file,
732654012fSReza Sabdar tlm_cmd_t *,
742efb3bf9SJan Kryl tlm_job_stats_t *,
752efb3bf9SJan Kryl long *);
762654012fSReza Sabdar static long restore_xattr_hdr(int *fp,
772654012fSReza Sabdar char *name,
782654012fSReza Sabdar char *fname,
792654012fSReza Sabdar long size,
802654012fSReza Sabdar tlm_acls_t *acls,
812654012fSReza Sabdar tlm_cmd_t *local_commands,
822654012fSReza Sabdar tlm_job_stats_t *job_stats);
832654012fSReza Sabdar static int get_long_name(int lib,
842654012fSReza Sabdar int drv,
852654012fSReza Sabdar long recsize,
862654012fSReza Sabdar char *name,
872654012fSReza Sabdar long *buf_spot,
882654012fSReza Sabdar tlm_cmd_t *local_commands);
892654012fSReza Sabdar static int get_humongus_file_header(int lib,
902654012fSReza Sabdar int drv,
912654012fSReza Sabdar long recsize,
922654012fSReza Sabdar longlong_t *size,
932654012fSReza Sabdar char *name,
942654012fSReza Sabdar tlm_cmd_t *);
952654012fSReza Sabdar static int create_directory(char *dir,
962654012fSReza Sabdar tlm_job_stats_t *);
972654012fSReza Sabdar static int create_hard_link(char *name,
982654012fSReza Sabdar char *link,
992654012fSReza Sabdar tlm_acls_t *,
1002654012fSReza Sabdar tlm_job_stats_t *);
1012654012fSReza Sabdar static int create_sym_link(char *dst,
1022654012fSReza Sabdar char *target,
1032654012fSReza Sabdar tlm_acls_t *,
1042654012fSReza Sabdar tlm_job_stats_t *);
1055181c2afSReza Sabdar static int create_special(char,
1065181c2afSReza Sabdar char *name,
1075181c2afSReza Sabdar tlm_acls_t *,
1085181c2afSReza Sabdar int,
1095181c2afSReza Sabdar int,
1105181c2afSReza Sabdar tlm_job_stats_t *);
1112654012fSReza Sabdar static long load_acl_info(int lib,
1122654012fSReza Sabdar int drv,
1132654012fSReza Sabdar long size,
1142654012fSReza Sabdar tlm_acls_t *,
1152654012fSReza Sabdar long *acl_spot,
1162654012fSReza Sabdar tlm_cmd_t *);
1172654012fSReza Sabdar static char *get_read_buffer(int want,
1182654012fSReza Sabdar int *error,
1192654012fSReza Sabdar int *actual_size,
1202654012fSReza Sabdar tlm_cmd_t *);
1212654012fSReza Sabdar static boolean_t wildcard_enabled(void);
1222654012fSReza Sabdar static boolean_t is_file_wanted(char *name,
1232654012fSReza Sabdar char **sels,
1242654012fSReza Sabdar char **exls,
1252654012fSReza Sabdar int flags,
1262654012fSReza Sabdar int *mchtype,
1272654012fSReza Sabdar int *pos);
1282654012fSReza Sabdar static char *catnames(struct rs_name_maker *rnp,
1292654012fSReza Sabdar char *buf,
1302654012fSReza Sabdar int pos,
1312654012fSReza Sabdar char *path);
1322654012fSReza Sabdar
1332654012fSReza Sabdar static char *rs_new_name(struct rs_name_maker *rnp,
1342654012fSReza Sabdar char *real_name,
1352654012fSReza Sabdar int pos,
1362654012fSReza Sabdar char *path);
1372654012fSReza Sabdar
138fb4eb4e8SReza Sabdar static void rs_create_new_bkpath(char *bk_path,
139fb4eb4e8SReza Sabdar char *path,
140fb4eb4e8SReza Sabdar char *pbuf);
141fb4eb4e8SReza Sabdar
1422654012fSReza Sabdar typedef struct stack_ent {
1432654012fSReza Sabdar char *se_name;
1442654012fSReza Sabdar tlm_acls_t se_acls;
1452654012fSReza Sabdar } stack_ent_t;
1462654012fSReza Sabdar
1472654012fSReza Sabdar
1482654012fSReza Sabdar /*
1492654012fSReza Sabdar * dtree_push
1502654012fSReza Sabdar */
1512654012fSReza Sabdar int
dtree_push(cstack_t * stp,char * nmp,tlm_acls_t * acls)1522654012fSReza Sabdar dtree_push(cstack_t *stp, char *nmp, tlm_acls_t *acls)
1532654012fSReza Sabdar {
1542654012fSReza Sabdar int len;
1552654012fSReza Sabdar stack_ent_t *sp;
1562654012fSReza Sabdar
1572654012fSReza Sabdar sp = ndmp_malloc(sizeof (stack_ent_t));
1582654012fSReza Sabdar if (!sp || !nmp || !acls) {
1592654012fSReza Sabdar free(sp);
1602654012fSReza Sabdar return (-1);
1612654012fSReza Sabdar }
1622654012fSReza Sabdar
1632654012fSReza Sabdar len = strlen(nmp) + 1;
1642654012fSReza Sabdar sp->se_name = ndmp_malloc(len);
1652654012fSReza Sabdar if (!sp->se_name) {
1662654012fSReza Sabdar free(sp);
1672654012fSReza Sabdar return (-1);
1682654012fSReza Sabdar }
1692654012fSReza Sabdar
1702654012fSReza Sabdar (void) strlcpy(sp->se_name, nmp, len);
1712654012fSReza Sabdar (void) memcpy(&sp->se_acls, acls, sizeof (*acls));
17286c48bbfSReza Sabdar (void) memset(acls, 0, sizeof (tlm_acls_t));
1732654012fSReza Sabdar
1742654012fSReza Sabdar return (cstack_push(stp, (void *)sp, sizeof (*sp)));
1752654012fSReza Sabdar }
1762654012fSReza Sabdar
1772654012fSReza Sabdar /*
1782654012fSReza Sabdar * dtree_pop
1792654012fSReza Sabdar */
1802654012fSReza Sabdar int
dtree_pop(cstack_t * stp)1812654012fSReza Sabdar dtree_pop(cstack_t *stp)
1822654012fSReza Sabdar {
1832654012fSReza Sabdar int err;
1842654012fSReza Sabdar stack_ent_t *sp;
1852654012fSReza Sabdar
1862654012fSReza Sabdar err = cstack_pop(stp, (void **)&sp, (void *)NULL);
1872654012fSReza Sabdar if (err)
1882654012fSReza Sabdar return (-1);
1892654012fSReza Sabdar
1902efb3bf9SJan Kryl err = set_acl(sp->se_name, &sp->se_acls);
1912654012fSReza Sabdar
1922654012fSReza Sabdar free(sp->se_name);
1932654012fSReza Sabdar free(sp);
1942654012fSReza Sabdar return (err);
1952654012fSReza Sabdar }
1962654012fSReza Sabdar
1972654012fSReza Sabdar
1982654012fSReza Sabdar /*
1992654012fSReza Sabdar * dtree_peek
2002654012fSReza Sabdar */
2012654012fSReza Sabdar char *
dtree_peek(cstack_t * stp)2022654012fSReza Sabdar dtree_peek(cstack_t *stp)
2032654012fSReza Sabdar {
2042654012fSReza Sabdar int err;
2052654012fSReza Sabdar stack_ent_t *sp;
2062654012fSReza Sabdar
2072654012fSReza Sabdar err = cstack_top(stp, (void **)&sp, (void *)NULL);
2082654012fSReza Sabdar if (err)
2092654012fSReza Sabdar return (NULL);
2102654012fSReza Sabdar
2112654012fSReza Sabdar return (sp->se_name);
2122654012fSReza Sabdar }
2132654012fSReza Sabdar
2142654012fSReza Sabdar /*
2152654012fSReza Sabdar * NBU and EBS may not send us the correct file list containing hardlinks
2162654012fSReza Sabdar * during a DAR restore, e.g. they appear always send the first name
2172654012fSReza Sabdar * associated with an inode, even if other link names were
2182654012fSReza Sabdar * selected for the restore. As a workaround, we use the file name entry
2192654012fSReza Sabdar * in sels[] (ignore the name in the tar header) as restore target.
2202654012fSReza Sabdar */
2212654012fSReza Sabdar static char *
rs_darhl_new_name(struct rs_name_maker * rnp,char * name,char ** sels,int * pos,char * longname)2222654012fSReza Sabdar rs_darhl_new_name(struct rs_name_maker *rnp, char *name, char **sels, int *pos,
2232654012fSReza Sabdar char *longname)
2242654012fSReza Sabdar {
2252654012fSReza Sabdar int x;
2262654012fSReza Sabdar
2272654012fSReza Sabdar for (x = 0; sels[x] != NULL; x++) {
2282654012fSReza Sabdar if (strcmp(sels[x], " ")) {
2292654012fSReza Sabdar *pos = x;
2302654012fSReza Sabdar (void) strlcpy(longname, sels[x], TLM_MAX_PATH_NAME);
2312654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
2322654012fSReza Sabdar "to replace hardlink name [%s], pos [%d]",
2332654012fSReza Sabdar longname, *pos);
2342654012fSReza Sabdar
2352654012fSReza Sabdar return (rs_new_name(rnp, name, *pos, longname));
2362654012fSReza Sabdar }
2372654012fSReza Sabdar }
2382654012fSReza Sabdar
2392654012fSReza Sabdar return (NULL);
2402654012fSReza Sabdar }
2412654012fSReza Sabdar
2422654012fSReza Sabdar
2432654012fSReza Sabdar /*
244859b7745SReza Sabdar * Main dir restore function for tar
2452efb3bf9SJan Kryl *
2462efb3bf9SJan Kryl * If this function returns non-zero return value it means that fatal error
2472efb3bf9SJan Kryl * was encountered.
2482654012fSReza Sabdar */
2492654012fSReza Sabdar 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,char ** exls,int flags,int DAR,char * bk_path,struct hardlink_q * hardlink_q)2502654012fSReza Sabdar tar_getdir(tlm_commands_t *commands,
2512654012fSReza Sabdar tlm_cmd_t *local_commands,
2522654012fSReza Sabdar tlm_job_stats_t *job_stats,
2532654012fSReza Sabdar struct rs_name_maker *rnp,
2542654012fSReza Sabdar int lib,
2552654012fSReza Sabdar int drv,
2562654012fSReza Sabdar char **sels, /* what to get off the tape */
2572654012fSReza Sabdar char **exls, /* what to leave behind */
2582654012fSReza Sabdar int flags,
259fb4eb4e8SReza Sabdar int DAR,
260fb4eb4e8SReza Sabdar char *bk_path,
261fb4eb4e8SReza Sabdar struct hardlink_q *hardlink_q)
2622654012fSReza Sabdar {
2632654012fSReza Sabdar int fp = 0; /* file being restored ... */
2642654012fSReza Sabdar /* ...need to preserve across volume changes */
2652654012fSReza Sabdar tlm_acls_t *acls; /* file access info */
2662654012fSReza Sabdar char *longname;
2672654012fSReza Sabdar boolean_t is_long_name = FALSE;
2682654012fSReza Sabdar char *longlink;
2692654012fSReza Sabdar char *hugename;
2702654012fSReza Sabdar longlong_t huge_size = 0; /* size of a HUGE file */
2712654012fSReza Sabdar long acl_spot; /* any ACL info on the next volume */
2722654012fSReza Sabdar long file_size; /* size of file to restore */
2732654012fSReza Sabdar long size_left = 0; /* need this after volume change */
2742654012fSReza Sabdar int last_action = 0; /* what we are doing at EOT */
2752654012fSReza Sabdar boolean_t multi_volume = FALSE; /* is this a multi-volume switch ? */
2762654012fSReza Sabdar int chk_rv; /* scratch area */
2772654012fSReza Sabdar
2782654012fSReza Sabdar int mchtype, pos;
2792654012fSReza Sabdar /*
2802654012fSReza Sabdar * if an exact match is found for
2812654012fSReza Sabdar * restore and its position in the
2822654012fSReza Sabdar * selections list
2832654012fSReza Sabdar */
2842654012fSReza Sabdar int nzerohdr; /* the number of empty tar headers */
2852654012fSReza Sabdar int rv;
2862654012fSReza Sabdar long nm_end, lnk_end;
2872654012fSReza Sabdar char *name, *nmp;
2882654012fSReza Sabdar cstack_t *stp;
289*82049ff5SToomas Soome char *bkpath;
290*82049ff5SToomas Soome char *parentlnk;
291c9fd6b31SReza Sabdar int dir_dar = 0;
292c9fd6b31SReza Sabdar
2932654012fSReza Sabdar /*
2942654012fSReza Sabdar * The directory where temporary files may be created during a partial
2952654012fSReza Sabdar * non-DAR restore of hardlinks. It is intended to be initialized by
2962654012fSReza Sabdar * an environment variable that can be set by user.
2972654012fSReza Sabdar *
2982654012fSReza Sabdar * It is not initialized for now. We keep it here for future use.
2992654012fSReza Sabdar */
3002654012fSReza Sabdar char *tmplink_dir = NULL;
301b6b15642SReza Sabdar int dar_recovered = 0;
302fb4eb4e8SReza Sabdar char *thname_buf;
3032654012fSReza Sabdar
3042654012fSReza Sabdar /*
3052654012fSReza Sabdar * startup
3062654012fSReza Sabdar */
3072654012fSReza Sabdar
3082654012fSReza Sabdar longname = ndmp_malloc(TLM_MAX_PATH_NAME);
3092654012fSReza Sabdar longlink = ndmp_malloc(TLM_MAX_PATH_NAME);
3102654012fSReza Sabdar hugename = ndmp_malloc(TLM_MAX_PATH_NAME);
3112654012fSReza Sabdar parentlnk = ndmp_malloc(TLM_MAX_PATH_NAME);
312fb4eb4e8SReza Sabdar thname_buf = ndmp_malloc(TLM_MAX_PATH_NAME);
3132654012fSReza Sabdar name = ndmp_malloc(TLM_MAX_PATH_NAME);
3142654012fSReza Sabdar acls = ndmp_malloc(sizeof (tlm_acls_t));
3152654012fSReza Sabdar stp = cstack_new();
3162654012fSReza Sabdar if (longname == NULL || longlink == NULL || hugename == NULL ||
317fb4eb4e8SReza Sabdar name == NULL || acls == NULL || stp == NULL || parentlnk == NULL ||
318fb4eb4e8SReza Sabdar thname_buf == NULL) {
3192654012fSReza Sabdar cstack_delete(stp);
3202654012fSReza Sabdar free(longname);
3212654012fSReza Sabdar free(longlink);
3222654012fSReza Sabdar free(hugename);
3232654012fSReza Sabdar free(parentlnk);
3242654012fSReza Sabdar free(name);
3252654012fSReza Sabdar free(acls);
326fb4eb4e8SReza Sabdar free(thname_buf);
3272654012fSReza Sabdar return (-TLM_NO_SCRATCH_SPACE);
3282654012fSReza Sabdar }
3292654012fSReza Sabdar
3302654012fSReza Sabdar acl_spot = 0;
3312654012fSReza Sabdar *hugename = '\0';
3322654012fSReza Sabdar *parentlnk = '\0';
3332654012fSReza Sabdar nm_end = 0;
3342654012fSReza Sabdar *longname = '\0';
3352654012fSReza Sabdar lnk_end = 0;
3362654012fSReza Sabdar *longlink = '\0';
3372654012fSReza Sabdar (void) memset(acls, 0, sizeof (tlm_acls_t));
3382654012fSReza Sabdar if (IS_SET(flags, RSFLG_OVR_ALWAYS)) {
3392654012fSReza Sabdar acls->acl_overwrite = TRUE;
3402654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "RSFLG_OVR_ALWAYS");
3412654012fSReza Sabdar } else if (IS_SET(flags, RSFLG_OVR_UPDATE)) {
3422654012fSReza Sabdar acls->acl_update = TRUE;
3432654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "RSFLG_OVR_UPDATE");
3442654012fSReza Sabdar }
3452654012fSReza Sabdar
3462654012fSReza Sabdar /*
3472654012fSReza Sabdar * work
3482654012fSReza Sabdar */
3492654012fSReza Sabdar rv = 0;
3502654012fSReza Sabdar nzerohdr = 0;
3512654012fSReza Sabdar while (commands->tcs_writer != TLM_ABORT &&
3522efb3bf9SJan Kryl local_commands->tc_writer != TLM_STOP && rv == 0) {
3532654012fSReza Sabdar tlm_tar_hdr_t fake_tar_hdr;
3542654012fSReza Sabdar char *file_name;
3552654012fSReza Sabdar char *link_name;
3562654012fSReza Sabdar int erc;
3572654012fSReza Sabdar int actual_size;
3582654012fSReza Sabdar boolean_t want_this_file;
3592654012fSReza Sabdar int want = sizeof (tlm_tar_hdr_t);
3602654012fSReza Sabdar tlm_tar_hdr_t *tar_hdr;
3612654012fSReza Sabdar
3622654012fSReza Sabdar /* The inode of an LF_LINK type. */
3632654012fSReza Sabdar unsigned long hardlink_inode = 0;
3642654012fSReza Sabdar
3652654012fSReza Sabdar /*
3662654012fSReza Sabdar * Indicate whether a file with the same inode has been
3672654012fSReza Sabdar * restored.
3682654012fSReza Sabdar */
3692654012fSReza Sabdar int hardlink_done = 0;
3702654012fSReza Sabdar
3712654012fSReza Sabdar /* The path of the restored hardlink file */
3722654012fSReza Sabdar char *hardlink_target = NULL;
3732654012fSReza Sabdar int is_hardlink = 0;
3742654012fSReza Sabdar
3752654012fSReza Sabdar /*
3762654012fSReza Sabdar * Whether a temporary file should be created for restoring
3772654012fSReza Sabdar * hardlink.
3782654012fSReza Sabdar */
3792654012fSReza Sabdar int hardlink_tmp_file = 0;
3802654012fSReza Sabdar char *hardlink_tmp_name = ".tmphlrsnondar";
3812654012fSReza Sabdar
3822654012fSReza Sabdar /* used to make up hardlink_tmp_name */
3832654012fSReza Sabdar static int hardlink_tmp_idx = 0;
3842654012fSReza Sabdar
3852654012fSReza Sabdar if (multi_volume) {
3862654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "multi_volume %c %d",
3872654012fSReza Sabdar last_action, size_left);
3882654012fSReza Sabdar
3892654012fSReza Sabdar /*
3902654012fSReza Sabdar * the previous volume is out of data
3912654012fSReza Sabdar * and is back in the rack, a new tape
3922654012fSReza Sabdar * is loaded and ready to read.
3932654012fSReza Sabdar *
3942654012fSReza Sabdar * We need to pick up where we left off.
3952654012fSReza Sabdar */
3962654012fSReza Sabdar (void) memset(&fake_tar_hdr, 0, sizeof (fake_tar_hdr));
3972654012fSReza Sabdar file_size = size_left;
3982654012fSReza Sabdar tar_hdr = &fake_tar_hdr;
3992654012fSReza Sabdar tar_hdr->th_linkflag = last_action;
4002654012fSReza Sabdar
4012654012fSReza Sabdar multi_volume = FALSE;
4022654012fSReza Sabdar last_action = 0;
4032654012fSReza Sabdar } else {
4042654012fSReza Sabdar tar_hdr = (tlm_tar_hdr_t *)get_read_buffer(want,
4052654012fSReza Sabdar &erc, &actual_size, local_commands);
4067bc22e45SReza Sabdar
4077bc22e45SReza Sabdar if (tar_hdr == NULL) {
4087bc22e45SReza Sabdar rv = -1;
4097bc22e45SReza Sabdar continue;
4107bc22e45SReza Sabdar }
4117bc22e45SReza Sabdar
4122654012fSReza Sabdar /*
4132654012fSReza Sabdar * we can ignore read errors here because
4142654012fSReza Sabdar * 1) they are logged by Restore Reader
4152654012fSReza Sabdar * 2) we are not doing anything important here
4162654012fSReza Sabdar * just looking for the next work record.
4172654012fSReza Sabdar */
4182654012fSReza Sabdar if (actual_size < want) {
4192654012fSReza Sabdar /*
4202654012fSReza Sabdar * EOF hits here
4212654012fSReza Sabdar *
4222654012fSReza Sabdar * wait for another buffer to come along
4232654012fSReza Sabdar * or until the Reader thread tells us
4242654012fSReza Sabdar * that no more tapes will be loaded ...
4252654012fSReza Sabdar * time to stop.
4262654012fSReza Sabdar */
4272654012fSReza Sabdar continue;
4282654012fSReza Sabdar }
4292654012fSReza Sabdar
4302654012fSReza Sabdar /*
4312654012fSReza Sabdar * check for "we are lost"
4322654012fSReza Sabdar */
4332654012fSReza Sabdar chk_rv = tlm_vfy_tar_checksum(tar_hdr);
4342654012fSReza Sabdar if (chk_rv == 0) {
4352654012fSReza Sabdar /* one of the end of tar file marks */
4362654012fSReza Sabdar if (++nzerohdr >= 2) {
4372654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
4382654012fSReza Sabdar "nzerohdr %d, breaking",
4392654012fSReza Sabdar nzerohdr);
4402654012fSReza Sabdar /* end of tar file */
4412654012fSReza Sabdar break;
4422654012fSReza Sabdar }
4432654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "nzerohdr %d, continuing",
4442654012fSReza Sabdar nzerohdr);
4452654012fSReza Sabdar continue;
4462654012fSReza Sabdar } else if (chk_rv < 0) {
4472654012fSReza Sabdar nzerohdr = 0;
4482654012fSReza Sabdar /* skip this record */
4492654012fSReza Sabdar continue;
4502654012fSReza Sabdar }
4512654012fSReza Sabdar nzerohdr = 0;
4522654012fSReza Sabdar
4532654012fSReza Sabdar /*
4542654012fSReza Sabdar * When files are spanned to the next tape, the
4552654012fSReza Sabdar * information of the acls must not be over-written
4562654012fSReza Sabdar * by the information of the LF_MULTIVOL and LF_VOLHDR
4572654012fSReza Sabdar * header, whose information is irrelevant to the file.
4582654012fSReza Sabdar * The information of the original header must be
4592654012fSReza Sabdar * kept in the 'acl'.
4602654012fSReza Sabdar */
4612654012fSReza Sabdar if (tar_hdr->th_linkflag != LF_MULTIVOL &&
4622654012fSReza Sabdar tar_hdr->th_linkflag != LF_VOLHDR) {
46386c48bbfSReza Sabdar if (tar_hdr->th_linkflag != LF_HUMONGUS) {
46486c48bbfSReza Sabdar acls->acl_attr.st_mode =
46586c48bbfSReza Sabdar oct_atoi(tar_hdr->th_mode);
46686c48bbfSReza Sabdar acls->acl_attr.st_size =
46786c48bbfSReza Sabdar oct_atoi(tar_hdr->th_size);
46886c48bbfSReza Sabdar acls->acl_attr.st_uid =
46986c48bbfSReza Sabdar oct_atoi(tar_hdr->th_uid);
47086c48bbfSReza Sabdar acls->acl_attr.st_gid =
47186c48bbfSReza Sabdar oct_atoi(tar_hdr->th_gid);
47286c48bbfSReza Sabdar acls->acl_attr.st_mtime =
47386c48bbfSReza Sabdar oct_atoi(tar_hdr->th_mtime);
47486c48bbfSReza Sabdar (void) strlcpy(acls->uname,
47586c48bbfSReza Sabdar tar_hdr->th_uname,
47686c48bbfSReza Sabdar sizeof (acls->uname));
47786c48bbfSReza Sabdar (void) strlcpy(acls->gname,
47886c48bbfSReza Sabdar tar_hdr->th_gname,
47986c48bbfSReza Sabdar sizeof (acls->gname));
48086c48bbfSReza Sabdar }
4812654012fSReza Sabdar file_size = oct_atoi(tar_hdr->th_size);
4822654012fSReza Sabdar acl_spot = 0;
4832654012fSReza Sabdar last_action = tar_hdr->th_linkflag;
4842654012fSReza Sabdar }
4852654012fSReza Sabdar }
4862654012fSReza Sabdar
4872654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "n [%s] f [%c] s %lld m %o u %d g %d t %d",
4882654012fSReza Sabdar tar_hdr->th_name, tar_hdr->th_linkflag,
4892654012fSReza Sabdar acls->acl_attr.st_size, acls->acl_attr.st_mode,
4902654012fSReza Sabdar acls->acl_attr.st_uid, acls->acl_attr.st_gid,
4912654012fSReza Sabdar acls->acl_attr.st_mtime);
4922654012fSReza Sabdar
493b6b15642SReza Sabdar /*
494b6b15642SReza Sabdar * If the restore is running using DAR we should check for
49586c48bbfSReza Sabdar * extended attribute entries
496b6b15642SReza Sabdar */
497b6b15642SReza Sabdar if (dar_recovered &&
498b6b15642SReza Sabdar tar_hdr->th_linkflag != LF_XATTR)
499b6b15642SReza Sabdar break;
500b6b15642SReza Sabdar
501fb4eb4e8SReza Sabdar rs_create_new_bkpath(bk_path, tar_hdr->th_name, thname_buf);
502fb4eb4e8SReza Sabdar
5032654012fSReza Sabdar switch (tar_hdr->th_linkflag) {
5042654012fSReza Sabdar case LF_MULTIVOL:
5052654012fSReza Sabdar multi_volume = TRUE;
5062654012fSReza Sabdar break;
5072654012fSReza Sabdar case LF_LINK:
5082654012fSReza Sabdar is_hardlink = 1;
5092654012fSReza Sabdar hardlink_inode =
5102654012fSReza Sabdar oct_atoi(tar_hdr->th_shared.th_hlink_ino);
5112654012fSReza Sabdar
5122654012fSReza Sabdar /*
5132654012fSReza Sabdar * Check if we have restored a link with the same inode
5142654012fSReza Sabdar * If the inode is 0, we have to restore it as a
5152654012fSReza Sabdar * regular file.
5162654012fSReza Sabdar */
5172654012fSReza Sabdar if (hardlink_inode) {
5182654012fSReza Sabdar hardlink_done = !hardlink_q_get(hardlink_q,
5192654012fSReza Sabdar hardlink_inode, 0, &hardlink_target);
5202654012fSReza Sabdar }
5212654012fSReza Sabdar
5222654012fSReza Sabdar if (hardlink_done) {
5232654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
5242654012fSReza Sabdar "found hardlink, inode = %u, target = [%s]",
5252654012fSReza Sabdar hardlink_inode,
5262654012fSReza Sabdar hardlink_target? hardlink_target : "--");
5272654012fSReza Sabdar
5282654012fSReza Sabdar /* create a hardlink to hardlink_target */
5292654012fSReza Sabdar file_name = (*longname == 0) ?
530fb4eb4e8SReza Sabdar thname_buf : longname;
531fb4eb4e8SReza Sabdar
5322654012fSReza Sabdar if (!is_file_wanted(file_name, sels, exls,
5332654012fSReza Sabdar flags, &mchtype, &pos)) {
5342654012fSReza Sabdar nmp = NULL;
5352654012fSReza Sabdar /*
5362654012fSReza Sabdar * This means that DMA did not send us
5372654012fSReza Sabdar * the correct fh_info for the file
5382654012fSReza Sabdar * in restore list. We use the file
5392654012fSReza Sabdar * name entry in sels[] (ignore the
5402654012fSReza Sabdar * name in the tar header) as restore
5412654012fSReza Sabdar * target.
5422654012fSReza Sabdar */
5432654012fSReza Sabdar if (DAR) {
5442654012fSReza Sabdar nmp = rs_darhl_new_name(rnp,
5452654012fSReza Sabdar name, sels, &pos,
5462654012fSReza Sabdar file_name);
5472654012fSReza Sabdar }
5482654012fSReza Sabdar } else {
5492654012fSReza Sabdar nmp = rs_new_name(rnp, name, pos,
5502654012fSReza Sabdar file_name);
5512654012fSReza Sabdar if (!nmp) {
5522654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
5532654012fSReza Sabdar "can't make name for %s",
5542654012fSReza Sabdar longname);
5552654012fSReza Sabdar }
5562654012fSReza Sabdar }
5572654012fSReza Sabdar
5582654012fSReza Sabdar if (nmp) {
5592654012fSReza Sabdar if (hardlink_target) {
5602654012fSReza Sabdar erc = create_hard_link(
5612654012fSReza Sabdar hardlink_target, nmp,
5622654012fSReza Sabdar acls, job_stats);
5632efb3bf9SJan Kryl if (ERROR_IS_FATAL(erc)) {
5642efb3bf9SJan Kryl rv = erc;
5652efb3bf9SJan Kryl continue;
5662efb3bf9SJan Kryl }
5672654012fSReza Sabdar if (erc == 0) {
5682654012fSReza Sabdar (void)
5692654012fSReza Sabdar tlm_entry_restored(
5702654012fSReza Sabdar job_stats,
5712654012fSReza Sabdar file_name, pos);
5722654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
5732654012fSReza Sabdar "restored %s -> %s",
5742654012fSReza Sabdar nmp,
5752654012fSReza Sabdar hardlink_target);
5762654012fSReza Sabdar }
5772654012fSReza Sabdar } else {
5782654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
5792654012fSReza Sabdar "no target for hardlink %s",
5802654012fSReza Sabdar nmp);
5812654012fSReza Sabdar }
5822654012fSReza Sabdar
5832654012fSReza Sabdar name[0] = 0;
5842654012fSReza Sabdar is_long_name = FALSE;
5852654012fSReza Sabdar }
5862654012fSReza Sabdar
5872654012fSReza Sabdar nm_end = 0;
5882654012fSReza Sabdar longname[0] = 0;
5892654012fSReza Sabdar lnk_end = 0;
5902654012fSReza Sabdar longlink[0] = 0;
5912654012fSReza Sabdar
5922654012fSReza Sabdar break;
5932654012fSReza Sabdar }
5942654012fSReza Sabdar /* otherwise fall through, restore like a normal file */
5952654012fSReza Sabdar /*FALLTHROUGH*/
5962654012fSReza Sabdar case LF_OLDNORMAL:
5972654012fSReza Sabdar /*
5982654012fSReza Sabdar * check for TAR's end-of-tape method
5992654012fSReza Sabdar * of zero filled records.
6002654012fSReza Sabdar */
6012654012fSReza Sabdar if (tar_hdr->th_name[0] == 0) {
6022654012fSReza Sabdar break;
6032654012fSReza Sabdar }
6042654012fSReza Sabdar /*
6052654012fSReza Sabdar * otherwise fall through,
6062654012fSReza Sabdar * this is an old style normal file header
6072654012fSReza Sabdar */
6082654012fSReza Sabdar /*FALLTHROUGH*/
6092654012fSReza Sabdar case LF_NORMAL:
6102654012fSReza Sabdar case LF_CONTIG:
6112654012fSReza Sabdar job_stats->js_files_so_far++;
6122654012fSReza Sabdar if (*hugename != 0) {
6132654012fSReza Sabdar (void) strlcpy(longname, hugename,
6142654012fSReza Sabdar TLM_MAX_PATH_NAME);
6152654012fSReza Sabdar } else if (*longname == 0) {
6162654012fSReza Sabdar if (tar_hdr->th_name[0] != '/') {
6172654012fSReza Sabdar /*
6182654012fSReza Sabdar * check for old tar format, it
6192654012fSReza Sabdar * does not have a leading "/"
6202654012fSReza Sabdar */
6212654012fSReza Sabdar longname[0] = '/';
6222654012fSReza Sabdar longname[1] = 0;
6232654012fSReza Sabdar (void) strlcat(longname,
6242654012fSReza Sabdar tar_hdr->th_name,
6252654012fSReza Sabdar TLM_MAX_PATH_NAME);
6262654012fSReza Sabdar } else {
6272654012fSReza Sabdar (void) strlcpy(longname,
628fb4eb4e8SReza Sabdar thname_buf,
6292654012fSReza Sabdar TLM_MAX_PATH_NAME);
6302654012fSReza Sabdar }
6312654012fSReza Sabdar }
6322654012fSReza Sabdar
6332654012fSReza Sabdar want_this_file = is_file_wanted(longname, sels, exls,
6342654012fSReza Sabdar flags, &mchtype, &pos);
6352654012fSReza Sabdar if (!want_this_file) {
6362654012fSReza Sabdar nmp = NULL;
6372654012fSReza Sabdar /*
6382654012fSReza Sabdar * This means that DMA did not send us valid
6392654012fSReza Sabdar * fh_info for the file in restore list. We
6402654012fSReza Sabdar * use the file name entry in sels[] (ignore
6412654012fSReza Sabdar * the name in the tar header) as restore
6422654012fSReza Sabdar * target.
6432654012fSReza Sabdar */
6442654012fSReza Sabdar if (DAR && (tar_hdr->th_linkflag == LF_LINK)) {
6452654012fSReza Sabdar nmp = rs_darhl_new_name(rnp, name,
6462654012fSReza Sabdar sels, &pos, longname);
6472efb3bf9SJan Kryl if (nmp == NULL) {
6482efb3bf9SJan Kryl rv = ENOMEM;
6492efb3bf9SJan Kryl continue;
6502654012fSReza Sabdar }
6512efb3bf9SJan Kryl
6522efb3bf9SJan Kryl want_this_file = TRUE;
6532efb3bf9SJan Kryl mchtype = PM_EXACT;
6542654012fSReza Sabdar }
6552654012fSReza Sabdar } else {
6562654012fSReza Sabdar nmp = rs_new_name(rnp, name, pos, longname);
6572654012fSReza Sabdar if (!nmp)
6582654012fSReza Sabdar want_this_file = FALSE;
6592654012fSReza Sabdar }
6602654012fSReza Sabdar
6612654012fSReza Sabdar if (nmp)
6622654012fSReza Sabdar (void) strlcpy(parentlnk, nmp, strlen(nmp) + 1);
6632654012fSReza Sabdar
6642654012fSReza Sabdar /*
6652654012fSReza Sabdar * For a hardlink, even if it's not asked to be
6662654012fSReza Sabdar * restored, we restore it to a temporary location,
6672654012fSReza Sabdar * in case other links to the same file need to be
6682654012fSReza Sabdar * restored later.
6692654012fSReza Sabdar *
6702654012fSReza Sabdar * The temp files are created in tmplink_dir, with
6712654012fSReza Sabdar * names like ".tmphlrsnondar*". They are cleaned up
6722654012fSReza Sabdar * at the completion of a restore. However, if a
6732654012fSReza Sabdar * restore were interrupted, e.g. by a system reboot,
6742654012fSReza Sabdar * they would have to be cleaned up manually in order
6752654012fSReza Sabdar * for the disk space to be freed.
6762654012fSReza Sabdar *
6772654012fSReza Sabdar * If tmplink_dir is NULL, no temperorary files are
6782654012fSReza Sabdar * created during a restore. This may result in some
6792654012fSReza Sabdar * hardlinks not being restored during a partial
6802654012fSReza Sabdar * restore.
6812654012fSReza Sabdar */
6822654012fSReza Sabdar if (is_hardlink && !DAR && !want_this_file && !nmp) {
6832654012fSReza Sabdar if (tmplink_dir) {
6842654012fSReza Sabdar (void) snprintf(name, TLM_MAX_PATH_NAME,
6852654012fSReza Sabdar "%s/%s_%d", tmplink_dir,
6862654012fSReza Sabdar hardlink_tmp_name,
6872654012fSReza Sabdar hardlink_tmp_idx);
6882654012fSReza Sabdar nmp = name;
6892654012fSReza Sabdar
6902654012fSReza Sabdar hardlink_tmp_idx++;
6912654012fSReza Sabdar hardlink_tmp_file = 1;
6922654012fSReza Sabdar want_this_file = TRUE;
6932654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
6942654012fSReza Sabdar "To restore temp hardlink file %s.",
6952654012fSReza Sabdar nmp);
6962654012fSReza Sabdar } else {
6972654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
6982654012fSReza Sabdar "No tmplink_dir specified.");
6992654012fSReza Sabdar }
7002654012fSReza Sabdar }
7012654012fSReza Sabdar
7022efb3bf9SJan Kryl rv = restore_file(&fp, nmp, file_size,
7032654012fSReza Sabdar huge_size, acls, want_this_file, local_commands,
7042efb3bf9SJan Kryl job_stats, &size_left);
7052efb3bf9SJan Kryl if (rv != 0)
7062efb3bf9SJan Kryl continue;
7072654012fSReza Sabdar
7082654012fSReza Sabdar /*
7092654012fSReza Sabdar * In the case of non-DAR, we have to record the first
7102654012fSReza Sabdar * link for an inode that has multiple links. That's
7112654012fSReza Sabdar * the only link with data records actually backed up.
7122654012fSReza Sabdar * In this way, when we run into the other links, they
7132654012fSReza Sabdar * will be treated as links, and we won't go to look
7142654012fSReza Sabdar * for the data records to restore. This is not a
7152654012fSReza Sabdar * problem for DAR, where DMA tells the tape where
7162654012fSReza Sabdar * to locate the data records.
7172654012fSReza Sabdar */
7182654012fSReza Sabdar if (is_hardlink && !DAR) {
7192654012fSReza Sabdar if (hardlink_q_add(hardlink_q, hardlink_inode,
7202654012fSReza Sabdar 0, nmp, hardlink_tmp_file))
7212654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
7222654012fSReza Sabdar "failed to add (%u, %s) to HL q",
7232654012fSReza Sabdar hardlink_inode, nmp);
7242654012fSReza Sabdar }
7252654012fSReza Sabdar
7262654012fSReza Sabdar /* remove / reverse the temporary stuff */
7272654012fSReza Sabdar if (hardlink_tmp_file) {
7282654012fSReza Sabdar nmp = NULL;
7292654012fSReza Sabdar want_this_file = FALSE;
7302654012fSReza Sabdar hardlink_tmp_file = 0;
7312654012fSReza Sabdar }
7322654012fSReza Sabdar
7332654012fSReza Sabdar /*
7342654012fSReza Sabdar * Check if it is time to set the attribute
7352654012fSReza Sabdar * of the restored directory
7362654012fSReza Sabdar */
7372654012fSReza Sabdar while (nmp && ((bkpath = dtree_peek(stp)) != NULL)) {
7382efb3bf9SJan Kryl int erc;
7392efb3bf9SJan Kryl
7402654012fSReza Sabdar if (strstr(nmp, bkpath))
7412654012fSReza Sabdar break;
7422654012fSReza Sabdar
7432efb3bf9SJan Kryl erc = dtree_pop(stp);
7442efb3bf9SJan Kryl if (ERROR_IS_FATAL(erc)) {
7452efb3bf9SJan Kryl rv = erc;
7462efb3bf9SJan Kryl break;
7472efb3bf9SJan Kryl }
7482654012fSReza Sabdar }
7492efb3bf9SJan Kryl if (rv != 0)
7502efb3bf9SJan Kryl continue;
7512654012fSReza Sabdar
7522654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "sizeleft %s %d, %lld", longname,
7532654012fSReza Sabdar size_left, huge_size);
7542654012fSReza Sabdar
7552654012fSReza Sabdar if (want_this_file) {
7562654012fSReza Sabdar job_stats->js_bytes_total += file_size;
7572654012fSReza Sabdar job_stats->js_files_total++;
7582654012fSReza Sabdar }
7592654012fSReza Sabdar
7602654012fSReza Sabdar huge_size -= file_size;
7612654012fSReza Sabdar if (huge_size < 0) {
7622654012fSReza Sabdar huge_size = 0;
7632654012fSReza Sabdar }
7642654012fSReza Sabdar if (size_left == 0 && huge_size == 0) {
7652654012fSReza Sabdar if (PM_EXACT_OR_CHILD(mchtype)) {
7662654012fSReza Sabdar (void) tlm_entry_restored(job_stats,
7672654012fSReza Sabdar longname, pos);
7682654012fSReza Sabdar
7692654012fSReza Sabdar /*
7702654012fSReza Sabdar * Add an entry to hardlink_q to record
7712654012fSReza Sabdar * this hardlink.
7722654012fSReza Sabdar */
7732654012fSReza Sabdar if (is_hardlink) {
7742654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
7752654012fSReza Sabdar "Restored hardlink file %s",
7762654012fSReza Sabdar nmp);
7772654012fSReza Sabdar
7782654012fSReza Sabdar if (DAR) {
7792654012fSReza Sabdar (void) hardlink_q_add(
7802654012fSReza Sabdar hardlink_q,
7812654012fSReza Sabdar hardlink_inode, 0,
7822654012fSReza Sabdar nmp, 0);
7832654012fSReza Sabdar }
7842654012fSReza Sabdar }
7852654012fSReza Sabdar }
7862654012fSReza Sabdar
7872654012fSReza Sabdar nm_end = 0;
7882654012fSReza Sabdar longname[0] = 0;
7892654012fSReza Sabdar lnk_end = 0;
7902654012fSReza Sabdar longlink[0] = 0;
7912654012fSReza Sabdar hugename[0] = 0;
7922654012fSReza Sabdar name[0] = 0;
7932654012fSReza Sabdar is_long_name = FALSE;
7942654012fSReza Sabdar }
7952654012fSReza Sabdar break;
7962654012fSReza Sabdar case LF_XATTR:
797fb4eb4e8SReza Sabdar file_name = (*longname == 0) ? thname_buf :
7982654012fSReza Sabdar longname;
7992654012fSReza Sabdar
8002654012fSReza Sabdar size_left = restore_xattr_hdr(&fp, parentlnk,
8012654012fSReza Sabdar file_name, file_size, acls, local_commands,
8022654012fSReza Sabdar job_stats);
8032654012fSReza Sabdar
8042654012fSReza Sabdar break;
8052654012fSReza Sabdar case LF_SYMLINK:
806fb4eb4e8SReza Sabdar file_name = (*longname == 0) ? thname_buf :
8072654012fSReza Sabdar longname;
8082654012fSReza Sabdar link_name = (*longlink == 0) ?
8092654012fSReza Sabdar tar_hdr->th_linkname : longlink;
8102654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "file_name[%s]", file_name);
8112654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "link_name[%s]", link_name);
8122654012fSReza Sabdar if (is_file_wanted(file_name, sels, exls, flags,
8132654012fSReza Sabdar &mchtype, &pos)) {
8142654012fSReza Sabdar nmp = rs_new_name(rnp, name, pos, file_name);
8152654012fSReza Sabdar if (nmp) {
8162654012fSReza Sabdar erc = create_sym_link(nmp, link_name,
8172654012fSReza Sabdar acls, job_stats);
8182efb3bf9SJan Kryl if (ERROR_IS_FATAL(erc)) {
8192efb3bf9SJan Kryl rv = erc;
8202efb3bf9SJan Kryl continue;
8212efb3bf9SJan Kryl }
8222654012fSReza Sabdar if (erc == 0 &&
8232654012fSReza Sabdar PM_EXACT_OR_CHILD(mchtype))
8242654012fSReza Sabdar (void) tlm_entry_restored(
8252654012fSReza Sabdar job_stats, file_name, pos);
8262654012fSReza Sabdar name[0] = 0;
8272654012fSReza Sabdar }
8282654012fSReza Sabdar }
8292654012fSReza Sabdar nm_end = 0;
8302654012fSReza Sabdar longname[0] = 0;
8312654012fSReza Sabdar lnk_end = 0;
8322654012fSReza Sabdar longlink[0] = 0;
8332654012fSReza Sabdar break;
8342654012fSReza Sabdar case LF_DIR:
835fb4eb4e8SReza Sabdar file_name = *longname == 0 ? thname_buf :
8362654012fSReza Sabdar longname;
8372654012fSReza Sabdar if (is_file_wanted(file_name, sels, exls, flags,
8382654012fSReza Sabdar &mchtype, &pos)) {
839c9fd6b31SReza Sabdar dir_dar = DAR;
8402654012fSReza Sabdar nmp = rs_new_name(rnp, name, pos, file_name);
8412654012fSReza Sabdar if (nmp && mchtype != PM_PARENT) {
8422654012fSReza Sabdar (void) strlcpy(parentlnk, nmp,
8432654012fSReza Sabdar strlen(nmp));
8442654012fSReza Sabdar erc = create_directory(nmp, job_stats);
8452efb3bf9SJan Kryl if (ERROR_IS_FATAL(erc)) {
8462efb3bf9SJan Kryl rv = erc;
8472efb3bf9SJan Kryl continue;
8482efb3bf9SJan Kryl }
8492654012fSReza Sabdar if (erc == 0 &&
8502654012fSReza Sabdar PM_EXACT_OR_CHILD(mchtype))
8512654012fSReza Sabdar (void) tlm_entry_restored(
8522654012fSReza Sabdar job_stats, file_name, pos);
8532654012fSReza Sabdar /*
8542654012fSReza Sabdar * Check if it is time to set
8552654012fSReza Sabdar * the attribute of the restored
8562654012fSReza Sabdar * directory
8572654012fSReza Sabdar */
8582654012fSReza Sabdar while ((bkpath = dtree_peek(stp))
8592654012fSReza Sabdar != NULL) {
8602efb3bf9SJan Kryl int rc;
8612efb3bf9SJan Kryl
8622654012fSReza Sabdar if (strstr(nmp, bkpath))
8632654012fSReza Sabdar break;
8642efb3bf9SJan Kryl rc = dtree_pop(stp);
8652efb3bf9SJan Kryl if (ERROR_IS_FATAL(rc)) {
8662efb3bf9SJan Kryl rv = rc;
8672efb3bf9SJan Kryl break;
8682efb3bf9SJan Kryl }
8692654012fSReza Sabdar }
8702efb3bf9SJan Kryl if (rv != 0)
8712efb3bf9SJan Kryl continue;
8722654012fSReza Sabdar
8732654012fSReza Sabdar (void) dtree_push(stp, nmp, acls);
8742654012fSReza Sabdar name[0] = 0;
8752654012fSReza Sabdar }
876c9fd6b31SReza Sabdar } else {
877c9fd6b31SReza Sabdar dir_dar = 0;
8782654012fSReza Sabdar }
8792654012fSReza Sabdar nm_end = 0;
8802654012fSReza Sabdar longname[0] = 0;
8812654012fSReza Sabdar lnk_end = 0;
8822654012fSReza Sabdar longlink[0] = 0;
8832654012fSReza Sabdar break;
8842654012fSReza Sabdar case LF_FIFO:
8855181c2afSReza Sabdar case LF_BLK:
8865181c2afSReza Sabdar case LF_CHR:
887fb4eb4e8SReza Sabdar file_name = *longname == 0 ? thname_buf :
8882654012fSReza Sabdar longname;
8892654012fSReza Sabdar if (is_file_wanted(file_name, sels, exls, flags,
8902654012fSReza Sabdar &mchtype, &pos)) {
8912654012fSReza Sabdar nmp = rs_new_name(rnp, name, pos, file_name);
8922654012fSReza Sabdar if (nmp) {
8935181c2afSReza Sabdar erc = create_special(
8945181c2afSReza Sabdar tar_hdr->th_linkflag, nmp, acls,
8955181c2afSReza Sabdar oct_atoi(tar_hdr->th_shared.
8965181c2afSReza Sabdar th_dev.th_devmajor),
8975181c2afSReza Sabdar oct_atoi(tar_hdr->th_shared.
8985181c2afSReza Sabdar th_dev.th_devminor), job_stats);
8992efb3bf9SJan Kryl if (ERROR_IS_FATAL(erc)) {
9002efb3bf9SJan Kryl rv = erc;
9012efb3bf9SJan Kryl continue;
9022efb3bf9SJan Kryl }
9032654012fSReza Sabdar if (erc == 0 &&
9042654012fSReza Sabdar PM_EXACT_OR_CHILD(mchtype))
9052654012fSReza Sabdar (void) tlm_entry_restored(
9062654012fSReza Sabdar job_stats, file_name, pos);
9072654012fSReza Sabdar name[0] = 0;
9082654012fSReza Sabdar }
9092654012fSReza Sabdar }
9102654012fSReza Sabdar nm_end = 0;
9112654012fSReza Sabdar longname[0] = 0;
9122654012fSReza Sabdar lnk_end = 0;
9132654012fSReza Sabdar longlink[0] = 0;
9142654012fSReza Sabdar break;
9152654012fSReza Sabdar case LF_LONGLINK:
916859b7745SReza Sabdar file_size = min(file_size,
917859b7745SReza Sabdar TLM_MAX_PATH_NAME - lnk_end - 1);
9182654012fSReza Sabdar file_size = max(0, file_size);
9192654012fSReza Sabdar size_left = get_long_name(lib, drv, file_size, longlink,
9202654012fSReza Sabdar &lnk_end, local_commands);
9212654012fSReza Sabdar
9222654012fSReza Sabdar if (size_left != 0)
9232654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
9242654012fSReza Sabdar "fsize %d sleft %d lnkend %d",
9252654012fSReza Sabdar file_size, size_left, lnk_end);
9262654012fSReza Sabdar break;
9272654012fSReza Sabdar case LF_LONGNAME:
928859b7745SReza Sabdar file_size = min(file_size,
929859b7745SReza Sabdar TLM_MAX_PATH_NAME - nm_end - 1);
9302654012fSReza Sabdar file_size = max(0, file_size);
9312654012fSReza Sabdar size_left = get_long_name(lib, drv, file_size, longname,
9322654012fSReza Sabdar &nm_end, local_commands);
9332654012fSReza Sabdar
9342654012fSReza Sabdar if (size_left != 0)
9352654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
9362654012fSReza Sabdar "fsize %d sleft %d nmend %d",
9372654012fSReza Sabdar file_size, size_left, nm_end);
9382654012fSReza Sabdar is_long_name = TRUE;
9392654012fSReza Sabdar break;
9402654012fSReza Sabdar case LF_ACL:
9412654012fSReza Sabdar size_left = load_acl_info(lib, drv, file_size, acls,
9422654012fSReza Sabdar &acl_spot, local_commands);
9432654012fSReza Sabdar break;
9442654012fSReza Sabdar case LF_VOLHDR:
9452654012fSReza Sabdar break;
9462654012fSReza Sabdar case LF_HUMONGUS:
9472654012fSReza Sabdar (void) memset(hugename, 0, TLM_MAX_PATH_NAME);
9482654012fSReza Sabdar (void) get_humongus_file_header(lib, drv, file_size,
9492654012fSReza Sabdar &huge_size, hugename, local_commands);
9502654012fSReza Sabdar break;
9512654012fSReza Sabdar default:
9522654012fSReza Sabdar break;
9532654012fSReza Sabdar
9542654012fSReza Sabdar }
9552654012fSReza Sabdar
9562654012fSReza Sabdar /*
9572654012fSReza Sabdar * If the restore is running using DAR we should check for
9582654012fSReza Sabdar * long file names and HUGE file sizes.
9592654012fSReza Sabdar */
9602654012fSReza Sabdar if (DAR && tar_hdr->th_linkflag != LF_ACL &&
961b6b15642SReza Sabdar tar_hdr->th_linkflag != LF_XATTR &&
962c9fd6b31SReza Sabdar !huge_size && !is_long_name && !dir_dar)
963b6b15642SReza Sabdar dar_recovered = 1;
9642654012fSReza Sabdar }
9652654012fSReza Sabdar
9662654012fSReza Sabdar /*
9672654012fSReza Sabdar * tear down
9682654012fSReza Sabdar */
9692efb3bf9SJan Kryl if (rv != 0)
9702efb3bf9SJan Kryl commands->tcs_reader = TLM_ABORT;
9712654012fSReza Sabdar if (fp != 0) {
9722654012fSReza Sabdar (void) close(fp);
9732654012fSReza Sabdar }
9742654012fSReza Sabdar while (dtree_pop(stp) != -1)
9752654012fSReza Sabdar ;
9762654012fSReza Sabdar cstack_delete(stp);
9772654012fSReza Sabdar free(acls);
9782654012fSReza Sabdar free(longname);
9792654012fSReza Sabdar free(parentlnk);
9802654012fSReza Sabdar free(longlink);
9812654012fSReza Sabdar free(hugename);
9822654012fSReza Sabdar free(name);
983fb4eb4e8SReza Sabdar free(thname_buf);
9842654012fSReza Sabdar return (rv);
9852654012fSReza Sabdar }
9862654012fSReza Sabdar
9872654012fSReza Sabdar /*
9882654012fSReza Sabdar * Main file restore function for tar (should run as a thread)
9892654012fSReza Sabdar */
990*82049ff5SToomas Soome void *
tar_getfile(void * ptr)991*82049ff5SToomas Soome tar_getfile(void *ptr)
9922654012fSReza Sabdar {
993*82049ff5SToomas Soome tlm_backup_restore_arg_t *argp = ptr;
9942654012fSReza Sabdar tlm_job_stats_t *job_stats;
9952654012fSReza Sabdar char **sels; /* list of files desired */
9962654012fSReza Sabdar char **exls; /* list of files not wanted */
9972654012fSReza Sabdar char *dir; /* where to restore the files */
9982654012fSReza Sabdar char job[TLM_MAX_BACKUP_JOB_NAME+1];
9992654012fSReza Sabdar /* the restore job name */
10002654012fSReza Sabdar int erc; /* error return codes */
10012654012fSReza Sabdar int flags;
10022654012fSReza Sabdar struct rs_name_maker rn;
10032654012fSReza Sabdar tlm_commands_t *commands;
10042654012fSReza Sabdar tlm_cmd_t *local_commands;
10052654012fSReza Sabdar char *list = NULL;
10062654012fSReza Sabdar
10072654012fSReza Sabdar commands = argp->ba_commands;
10082654012fSReza Sabdar local_commands = argp->ba_cmd;
10092654012fSReza Sabdar
10102654012fSReza Sabdar flags = 0;
10112654012fSReza Sabdar
10122654012fSReza Sabdar dir = ndmp_malloc(TLM_MAX_PATH_NAME);
10132654012fSReza Sabdar if (dir == NULL) {
10142654012fSReza Sabdar local_commands->tc_reader = TLM_STOP;
10152654012fSReza Sabdar (void) pthread_barrier_wait(&argp->ba_barrier);
1016*82049ff5SToomas Soome return ((void *)(uintptr_t)-1);
10172654012fSReza Sabdar }
10182654012fSReza Sabdar
10192654012fSReza Sabdar (void) strlcpy(job, argp->ba_job, TLM_MAX_BACKUP_JOB_NAME+1);
10202654012fSReza Sabdar (void) strlcpy(dir, argp->ba_dir, TLM_MAX_PATH_NAME);
10212654012fSReza Sabdar
10222654012fSReza Sabdar flags |= RSFLG_OVR_ALWAYS;
10232654012fSReza Sabdar flags |= RSFLG_IGNORE_CASE;
10242654012fSReza Sabdar
10252654012fSReza Sabdar /*
10262654012fSReza Sabdar * do not test for "dir" having no string, since that
10272654012fSReza Sabdar * is a legal condition. Restore to origional location
10282654012fSReza Sabdar * will not have a restore directory.
10292654012fSReza Sabdar */
10302654012fSReza Sabdar if (*job == '\0') {
10312654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "No job defined");
10322654012fSReza Sabdar local_commands->tc_reader = TLM_STOP;
10332654012fSReza Sabdar free(dir);
10342654012fSReza Sabdar (void) pthread_barrier_wait(&argp->ba_barrier);
1035*82049ff5SToomas Soome return ((void *)(uintptr_t)-1);
10362654012fSReza Sabdar }
10372654012fSReza Sabdar
10382654012fSReza Sabdar sels = argp->ba_sels;
10392654012fSReza Sabdar if (sels == NULL) {
10402654012fSReza Sabdar local_commands->tc_reader = TLM_STOP;
10412654012fSReza Sabdar free(dir);
10422654012fSReza Sabdar (void) pthread_barrier_wait(&argp->ba_barrier);
1043*82049ff5SToomas Soome return ((void *)(uintptr_t)-1);
10442654012fSReza Sabdar }
10452654012fSReza Sabdar exls = &list;
10462654012fSReza Sabdar
10472654012fSReza Sabdar tlm_log_list("selections", sels);
10482654012fSReza Sabdar tlm_log_list("exclusions", exls);
10492654012fSReza Sabdar
10502654012fSReza Sabdar if (wildcard_enabled())
10512654012fSReza Sabdar flags |= RSFLG_MATCH_WCARD;
10522654012fSReza Sabdar
10532654012fSReza Sabdar local_commands->tc_ref++;
10542654012fSReza Sabdar commands->tcs_writer_count++;
10552654012fSReza Sabdar
10562654012fSReza Sabdar /*
10572654012fSReza Sabdar * let the launcher continue
10582654012fSReza Sabdar */
10592654012fSReza Sabdar (void) pthread_barrier_wait(&argp->ba_barrier);
10602654012fSReza Sabdar
10612654012fSReza Sabdar job_stats = tlm_ref_job_stats(job);
10622654012fSReza Sabdar
10632654012fSReza Sabdar rn.rn_fp = catnames;
10642654012fSReza Sabdar rn.rn_nlp = dir;
10652654012fSReza Sabdar
10662654012fSReza Sabdar /*
10672654012fSReza Sabdar * work
10682654012fSReza Sabdar */
10692654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "start restore job %s", job);
10702654012fSReza Sabdar erc = tar_getdir(commands, local_commands, job_stats, &rn, 1, 1,
1071fb4eb4e8SReza Sabdar sels, exls, flags, 0, NULL, NULL);
10722654012fSReza Sabdar
10732654012fSReza Sabdar /*
10742654012fSReza Sabdar * teardown
10752654012fSReza Sabdar */
10762654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "end restore job %s", job);
10772654012fSReza Sabdar tlm_un_ref_job_stats(job);
10782654012fSReza Sabdar tlm_release_list(sels);
10792654012fSReza Sabdar tlm_release_list(exls);
10802654012fSReza Sabdar
10812654012fSReza Sabdar commands->tcs_writer_count--;
10822654012fSReza Sabdar local_commands->tc_reader = TLM_STOP;
10832654012fSReza Sabdar tlm_release_reader_writer_ipc(local_commands);
10842654012fSReza Sabdar free(dir);
1085*82049ff5SToomas Soome return ((void *)(uintptr_t)erc);
10862654012fSReza Sabdar }
10872654012fSReza Sabdar
10882654012fSReza Sabdar /*
10892654012fSReza Sabdar * Creates the directories all the way down to the
10902654012fSReza Sabdar * end if they dont exist
10912654012fSReza Sabdar */
10922654012fSReza Sabdar int
make_dirs(char * dir)10932654012fSReza Sabdar make_dirs(char *dir)
10942654012fSReza Sabdar {
10952654012fSReza Sabdar char c;
10962654012fSReza Sabdar char *cp, *end;
10972654012fSReza Sabdar struct stat64 st;
10982654012fSReza Sabdar
10992654012fSReza Sabdar cp = dir;
11002654012fSReza Sabdar cp += strspn(cp, "/");
11012654012fSReza Sabdar end = dir + strlen(dir);
11022654012fSReza Sabdar do {
11032654012fSReza Sabdar if (*cp == '\0' || *cp == '/') {
11042654012fSReza Sabdar c = *cp;
11052654012fSReza Sabdar *cp = '\0';
11062654012fSReza Sabdar if (lstat64(dir, &st) < 0)
11072654012fSReza Sabdar if (mkdir(dir, 0777) < 0) {
11082654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Error %d"
11092654012fSReza Sabdar " creating directory %s",
11102654012fSReza Sabdar errno, dir);
11112654012fSReza Sabdar *cp = c;
11122efb3bf9SJan Kryl return (errno);
11132654012fSReza Sabdar }
11142654012fSReza Sabdar
11152654012fSReza Sabdar *cp = c;
11162654012fSReza Sabdar }
11172654012fSReza Sabdar } while (++cp <= end);
11182654012fSReza Sabdar
11192654012fSReza Sabdar return (0);
11202654012fSReza Sabdar }
11212654012fSReza Sabdar
11222654012fSReza Sabdar /*
11232654012fSReza Sabdar * Creates the directories leading to the given path
11242654012fSReza Sabdar */
11252654012fSReza Sabdar int
mkbasedir(char * path)11262654012fSReza Sabdar mkbasedir(char *path)
11272654012fSReza Sabdar {
11282654012fSReza Sabdar int rv;
11292654012fSReza Sabdar char *cp;
11302654012fSReza Sabdar struct stat64 st;
11312654012fSReza Sabdar
11322654012fSReza Sabdar if (!path || !*path) {
11332654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Invalid argument");
11342654012fSReza Sabdar return (-1);
11352654012fSReza Sabdar }
11362654012fSReza Sabdar
11372654012fSReza Sabdar cp = strrchr(path, '/');
11382654012fSReza Sabdar if (cp)
11392654012fSReza Sabdar *cp = '\0';
11402654012fSReza Sabdar rv = lstat64(path, &st);
11412654012fSReza Sabdar if (rv < 0) /* need new directories */
11422654012fSReza Sabdar rv = make_dirs(path);
11432654012fSReza Sabdar if (cp)
11442654012fSReza Sabdar *cp = '/';
11452654012fSReza Sabdar
11462654012fSReza Sabdar return (rv);
11472654012fSReza Sabdar }
11482654012fSReza Sabdar
11492654012fSReza Sabdar
11502654012fSReza Sabdar /*
11512654012fSReza Sabdar * read the file off the tape back onto disk
11522efb3bf9SJan Kryl *
11532efb3bf9SJan Kryl * If the function returns a non-zero return code, it means that fatal error
11542efb3bf9SJan Kryl * was encountered and restore should terminate immediately.
11552654012fSReza Sabdar */
11562efb3bf9SJan Kryl static int
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,long * size_left)11572654012fSReza Sabdar restore_file(int *fp,
11582654012fSReza Sabdar char *real_name,
11592654012fSReza Sabdar long size,
11602654012fSReza Sabdar longlong_t huge_size,
11612654012fSReza Sabdar tlm_acls_t *acls,
11622654012fSReza Sabdar boolean_t want_this_file,
11632654012fSReza Sabdar tlm_cmd_t *local_commands,
11642efb3bf9SJan Kryl tlm_job_stats_t *job_stats,
11652efb3bf9SJan Kryl long *size_left)
11662654012fSReza Sabdar {
11672654012fSReza Sabdar struct stat64 attr;
11682efb3bf9SJan Kryl int ret, rv;
11692654012fSReza Sabdar
11702efb3bf9SJan Kryl *size_left = 0;
11712654012fSReza Sabdar if (!real_name) {
11722654012fSReza Sabdar if (want_this_file) {
11732654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "No file name but wanted!");
11742654012fSReza Sabdar want_this_file = FALSE;
11752654012fSReza Sabdar }
11762654012fSReza Sabdar } else
11772654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "new file[%s]", real_name);
11782654012fSReza Sabdar
11792654012fSReza Sabdar /*
11802654012fSReza Sabdar * OK, some FM is creeping in here ...
11812654012fSReza Sabdar * int *fp is used to keep the
11822654012fSReza Sabdar * backup file channel open through
11832654012fSReza Sabdar * the interruption of EOT and
11842654012fSReza Sabdar * processing the headers of the
11852654012fSReza Sabdar * next tape. So, if *fp is zero
11862654012fSReza Sabdar * then no file is open yet and all
11872654012fSReza Sabdar * is normal. If *fp has a number
11882654012fSReza Sabdar * then we are returning after an
11892654012fSReza Sabdar * EOT break.
11902654012fSReza Sabdar *
11912654012fSReza Sabdar * *fp is now also open for HUGE files
11922654012fSReza Sabdar * that are put back in sections.
11932654012fSReza Sabdar */
11942654012fSReza Sabdar
11952654012fSReza Sabdar if (*fp == 0 && want_this_file) {
11962654012fSReza Sabdar
11972efb3bf9SJan Kryl ret = mkbasedir(real_name);
11982efb3bf9SJan Kryl if (ret != 0) {
11992654012fSReza Sabdar job_stats->js_errors++;
12002efb3bf9SJan Kryl if (ERROR_IS_FATAL(ret))
12012efb3bf9SJan Kryl return (ret);
12022efb3bf9SJan Kryl }
12032654012fSReza Sabdar
12042efb3bf9SJan Kryl ret = stat64(real_name, (struct stat64 *)&attr);
12052efb3bf9SJan Kryl if (ret < 0) {
12062654012fSReza Sabdar /*EMPTY*/
12072654012fSReza Sabdar /* new file */
12082654012fSReza Sabdar } else if (acls->acl_overwrite) {
12092654012fSReza Sabdar /*EMPTY*/
12102654012fSReza Sabdar /* take this file no matter what */
12112654012fSReza Sabdar } else if (acls->acl_update) {
12122654012fSReza Sabdar if (attr.st_mtime < acls->acl_attr.st_mtime) {
12132654012fSReza Sabdar /*EMPTY*/
12142654012fSReza Sabdar /* tape is newer */
12152654012fSReza Sabdar } else {
12162654012fSReza Sabdar /* disk file is newer */
12172654012fSReza Sabdar want_this_file = FALSE;
12182654012fSReza Sabdar }
12192654012fSReza Sabdar } else {
12202654012fSReza Sabdar /*
12212654012fSReza Sabdar * no overwrite, no update,
12222654012fSReza Sabdar * do not ever replace old files.
12232654012fSReza Sabdar */
12242654012fSReza Sabdar want_this_file = TRUE;
12252654012fSReza Sabdar }
12262654012fSReza Sabdar if (want_this_file) {
12272654012fSReza Sabdar
1228c211fc47SReza Sabdar *fp = open(real_name, O_CREAT | O_TRUNC | O_WRONLY,
12292654012fSReza Sabdar S_IRUSR | S_IWUSR);
12302654012fSReza Sabdar if (*fp == -1) {
12312654012fSReza Sabdar NDMP_LOG(LOG_ERR,
12322efb3bf9SJan Kryl "Could not open %s for restore: %d",
12332efb3bf9SJan Kryl real_name, errno);
12342654012fSReza Sabdar job_stats->js_errors++;
12352654012fSReza Sabdar want_this_file = FALSE;
12362654012fSReza Sabdar /*
12372efb3bf9SJan Kryl * In case of non-fatal error we cannot return
12382efb3bf9SJan Kryl * here, because the file is still on the tape
12392efb3bf9SJan Kryl * and must be skipped over.
12402654012fSReza Sabdar */
12412efb3bf9SJan Kryl if (ERROR_IS_FATAL(errno))
12422efb3bf9SJan Kryl return (errno);
12432654012fSReza Sabdar }
12442654012fSReza Sabdar }
12452654012fSReza Sabdar (void) strlcpy(local_commands->tc_file_name, real_name,
12462654012fSReza Sabdar TLM_MAX_PATH_NAME);
12472654012fSReza Sabdar }
12482654012fSReza Sabdar
12492654012fSReza Sabdar /*
12502654012fSReza Sabdar * this is the size left in the next segment
12512654012fSReza Sabdar */
12522654012fSReza Sabdar huge_size -= size;
12532654012fSReza Sabdar
12542654012fSReza Sabdar /*
12552654012fSReza Sabdar * work
12562654012fSReza Sabdar */
12572efb3bf9SJan Kryl rv = 0;
12582654012fSReza Sabdar while (size > 0 && local_commands->tc_writer == TLM_RESTORE_RUN) {
12592654012fSReza Sabdar int actual_size;
12602654012fSReza Sabdar int error;
12612654012fSReza Sabdar char *rec;
12622654012fSReza Sabdar int write_size;
12632654012fSReza Sabdar
12642654012fSReza Sabdar /*
12652654012fSReza Sabdar * Use bytes_in_file field to tell reader the amount
12662654012fSReza Sabdar * of data still need to be read for this file.
12672654012fSReza Sabdar */
12682654012fSReza Sabdar job_stats->js_bytes_in_file = size;
12692654012fSReza Sabdar
12702654012fSReza Sabdar error = 0;
12712654012fSReza Sabdar rec = get_read_buffer(size, &error, &actual_size,
12722654012fSReza Sabdar local_commands);
12732654012fSReza Sabdar if (actual_size <= 0) {
12742654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
12752654012fSReza Sabdar "RESTORE WRITER> error %d, actual_size %d",
12762654012fSReza Sabdar error, actual_size);
12772654012fSReza Sabdar
12782654012fSReza Sabdar /* no more data for this file for now */
12792654012fSReza Sabdar job_stats->js_bytes_in_file = 0;
12802efb3bf9SJan Kryl *size_left = size;
12812efb3bf9SJan Kryl return (0);
12822654012fSReza Sabdar } else if (error) {
12832654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
12842654012fSReza Sabdar error, local_commands->tc_file_name);
12852654012fSReza Sabdar break;
12862efb3bf9SJan Kryl }
12872efb3bf9SJan Kryl
12882efb3bf9SJan Kryl write_size = min(size, actual_size);
12892efb3bf9SJan Kryl if (want_this_file) {
12902efb3bf9SJan Kryl ret = write(*fp, rec, write_size);
12912efb3bf9SJan Kryl if (ret < 0) {
12922efb3bf9SJan Kryl NDMP_LOG(LOG_ERR,
12932efb3bf9SJan Kryl "Write error %d for file [%s]", errno,
12942efb3bf9SJan Kryl local_commands->tc_file_name);
12952efb3bf9SJan Kryl job_stats->js_errors++;
12962efb3bf9SJan Kryl if (ERROR_IS_FATAL(errno)) {
12972efb3bf9SJan Kryl rv = errno;
12982efb3bf9SJan Kryl break;
12992efb3bf9SJan Kryl }
13002efb3bf9SJan Kryl } else {
13012efb3bf9SJan Kryl NS_ADD(wdisk, ret);
1302588541fbSReza Sabdar NS_INC(wfile);
13032efb3bf9SJan Kryl if (ret < write_size) {
13042efb3bf9SJan Kryl NDMP_LOG(LOG_ERR,
13052efb3bf9SJan Kryl "Partial write for file [%s]",
13062efb3bf9SJan Kryl local_commands->tc_file_name);
13072efb3bf9SJan Kryl }
13082654012fSReza Sabdar }
13092654012fSReza Sabdar }
13102efb3bf9SJan Kryl size -= write_size;
13112654012fSReza Sabdar }
13122654012fSReza Sabdar
13132654012fSReza Sabdar /* no more data for this file for now */
13142654012fSReza Sabdar job_stats->js_bytes_in_file = 0;
13152654012fSReza Sabdar
13162654012fSReza Sabdar /*
13172654012fSReza Sabdar * teardown
13182654012fSReza Sabdar */
13192654012fSReza Sabdar if (*fp != 0 && huge_size <= 0) {
13202654012fSReza Sabdar (void) close(*fp);
13212654012fSReza Sabdar *fp = 0;
13222efb3bf9SJan Kryl if (rv == 0) {
13232efb3bf9SJan Kryl ret = set_acl(real_name, acls);
13242efb3bf9SJan Kryl if (ERROR_IS_FATAL(ret))
13252efb3bf9SJan Kryl return (ret);
13262efb3bf9SJan Kryl }
13272654012fSReza Sabdar }
13282efb3bf9SJan Kryl return (rv);
13292654012fSReza Sabdar }
13302654012fSReza Sabdar
13312654012fSReza Sabdar /*
13322654012fSReza Sabdar * Set the extended attributes file attribute
13332654012fSReza Sabdar */
13342654012fSReza Sabdar static void
set_xattr(int fd,struct stat64 st)13352654012fSReza Sabdar set_xattr(int fd, struct stat64 st)
13362654012fSReza Sabdar {
13372654012fSReza Sabdar struct timeval times[2];
13382654012fSReza Sabdar
13392654012fSReza Sabdar times[0].tv_sec = st.st_atime;
13402654012fSReza Sabdar times[1].tv_sec = st.st_mtime;
13412654012fSReza Sabdar
13422654012fSReza Sabdar (void) fchmod(fd, st.st_mode);
13432654012fSReza Sabdar (void) fchown(fd, st.st_uid, st.st_gid);
13442654012fSReza Sabdar (void) futimesat(fd, ".", times);
13452654012fSReza Sabdar }
13462654012fSReza Sabdar
1347b6b15642SReza Sabdar /*
1348b6b15642SReza Sabdar * Read the system attribute file in a single buffer to write
1349b6b15642SReza Sabdar * it as a single write. A partial write to system attribute would
1350b6b15642SReza Sabdar * cause an EINVAL on write.
1351b6b15642SReza Sabdar */
1352b6b15642SReza Sabdar static char *
get_read_one_buf(char * rec,int actual_size,int size,int * error,tlm_cmd_t * lc)1353b6b15642SReza Sabdar get_read_one_buf(char *rec, int actual_size, int size, int *error,
1354b6b15642SReza Sabdar tlm_cmd_t *lc)
1355b6b15642SReza Sabdar {
1356b6b15642SReza Sabdar char *buf, *p;
1357b6b15642SReza Sabdar int read_size;
1358b6b15642SReza Sabdar int len;
1359b6b15642SReza Sabdar
1360b6b15642SReza Sabdar if (actual_size > size)
1361b6b15642SReza Sabdar return (rec);
1362b6b15642SReza Sabdar
1363b6b15642SReza Sabdar buf = ndmp_malloc(size);
1364b6b15642SReza Sabdar if (buf == NULL) {
1365b6b15642SReza Sabdar *error = ENOMEM;
1366b6b15642SReza Sabdar return (NULL);
1367b6b15642SReza Sabdar }
1368b6b15642SReza Sabdar (void) memcpy(buf, rec, actual_size);
1369b6b15642SReza Sabdar rec = buf;
1370b6b15642SReza Sabdar buf += actual_size;
1371b6b15642SReza Sabdar while (actual_size < size) {
1372b6b15642SReza Sabdar p = get_read_buffer(size - actual_size, error, &read_size, lc);
1373b6b15642SReza Sabdar len = min(size - actual_size, read_size);
1374b6b15642SReza Sabdar (void) memcpy(buf, p, len);
1375b6b15642SReza Sabdar actual_size += len;
1376b6b15642SReza Sabdar buf += len;
1377b6b15642SReza Sabdar }
1378b6b15642SReza Sabdar return (rec);
1379b6b15642SReza Sabdar }
1380b6b15642SReza Sabdar
1381b6b15642SReza Sabdar
13822654012fSReza Sabdar /*
13832654012fSReza Sabdar * read the extended attribute header and write
13842654012fSReza Sabdar * it to the file
13852654012fSReza Sabdar */
13862654012fSReza Sabdar 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)13872654012fSReza Sabdar restore_xattr_hdr(int *fp,
13882654012fSReza Sabdar char *name,
13892654012fSReza Sabdar char *fname,
13902654012fSReza Sabdar long size,
13912654012fSReza Sabdar tlm_acls_t *acls,
13922654012fSReza Sabdar tlm_cmd_t *local_commands,
13932654012fSReza Sabdar tlm_job_stats_t *job_stats)
13942654012fSReza Sabdar {
13952654012fSReza Sabdar tlm_tar_hdr_t *tar_hdr;
13962654012fSReza Sabdar struct xattr_hdr *xhdr;
13972654012fSReza Sabdar struct xattr_buf *xbuf;
13982654012fSReza Sabdar int namelen;
13992654012fSReza Sabdar char *xattrname;
14002654012fSReza Sabdar int actual_size;
14012654012fSReza Sabdar int error;
14022654012fSReza Sabdar
14032654012fSReza Sabdar if (!fname) {
14042654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "No file name but wanted!");
14052654012fSReza Sabdar } else {
14062654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "new xattr[%s]", fname);
14072654012fSReza Sabdar }
14082654012fSReza Sabdar
14092654012fSReza Sabdar error = 0;
14102654012fSReza Sabdar xhdr = (struct xattr_hdr *)get_read_buffer(size, &error,
14112654012fSReza Sabdar &actual_size, local_commands);
14127a088f03SReza Sabdar if (xhdr == NULL || error != 0) {
14132654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
14142654012fSReza Sabdar "Could not read xattr [%s:%s] for restore. ",
14152654012fSReza Sabdar name, fname);
14162654012fSReza Sabdar job_stats->js_errors++;
14172654012fSReza Sabdar return (0);
14182654012fSReza Sabdar }
14192654012fSReza Sabdar
14202654012fSReza Sabdar /* Check extended attribute header */
14212654012fSReza Sabdar if (strcmp(xhdr->h_version, XATTR_ARCH_VERS) != 0) {
14222654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
14232654012fSReza Sabdar "Unrecognized header format [%s]", xhdr->h_version);
14242654012fSReza Sabdar return (0);
14252654012fSReza Sabdar }
14262654012fSReza Sabdar xbuf = (struct xattr_buf *)(((char *)xhdr) + sizeof (struct xattr_hdr));
14272654012fSReza Sabdar
14282654012fSReza Sabdar (void) sscanf(xbuf->h_namesz, "%7d", &namelen);
14292654012fSReza Sabdar xattrname = xbuf->h_names + strlen(xbuf->h_names) + 1;
14302654012fSReza Sabdar
14312654012fSReza Sabdar if (*fp == 0) {
14322654012fSReza Sabdar int fd;
14332654012fSReza Sabdar
14342654012fSReza Sabdar fd = attropen(name, xattrname, O_CREAT | O_RDWR, 0755);
14352654012fSReza Sabdar if (fd == -1) {
14362654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
1437b6b15642SReza Sabdar "Could not open xattr [%s:%s] for restore err=%d.",
1438b6b15642SReza Sabdar name, xattrname, errno);
14392654012fSReza Sabdar job_stats->js_errors++;
1440b6b15642SReza Sabdar return (0);
14412654012fSReza Sabdar }
14422654012fSReza Sabdar (void) strlcpy(local_commands->tc_file_name, xattrname,
14432654012fSReza Sabdar TLM_MAX_PATH_NAME);
14442654012fSReza Sabdar *fp = fd;
14452654012fSReza Sabdar }
14462654012fSReza Sabdar
14472654012fSReza Sabdar /* Get the actual extended attribute file */
14482654012fSReza Sabdar tar_hdr = (tlm_tar_hdr_t *)get_read_buffer(sizeof (*tar_hdr),
14492654012fSReza Sabdar &error, &actual_size, local_commands);
14507a088f03SReza Sabdar if (tar_hdr == NULL || error != 0) {
14512654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
14522654012fSReza Sabdar "Could not read xattr data [%s:%s] for restore. ",
14532654012fSReza Sabdar fname, xattrname);
14542654012fSReza Sabdar job_stats->js_errors++;
14552654012fSReza Sabdar return (0);
14562654012fSReza Sabdar }
14572654012fSReza Sabdar acls->acl_attr.st_mode = oct_atoi(tar_hdr->th_mode);
14582654012fSReza Sabdar acls->acl_attr.st_size = oct_atoi(tar_hdr->th_size);
14592654012fSReza Sabdar acls->acl_attr.st_uid = oct_atoi(tar_hdr->th_uid);
14602654012fSReza Sabdar acls->acl_attr.st_gid = oct_atoi(tar_hdr->th_gid);
14612654012fSReza Sabdar acls->acl_attr.st_mtime = oct_atoi(tar_hdr->th_mtime);
14622654012fSReza Sabdar
1463b6b15642SReza Sabdar NDMP_LOG(LOG_DEBUG, "xattr_hdr: %s size %d mode %06o uid %d gid %d",
1464b6b15642SReza Sabdar xattrname, acls->acl_attr.st_size, acls->acl_attr.st_mode,
1465b6b15642SReza Sabdar acls->acl_attr.st_uid, acls->acl_attr.st_gid);
1466b6b15642SReza Sabdar
14672654012fSReza Sabdar size = acls->acl_attr.st_size;
14682654012fSReza Sabdar while (size > 0 && local_commands->tc_writer == TLM_RESTORE_RUN) {
14692654012fSReza Sabdar char *rec;
14702654012fSReza Sabdar int write_size;
1471b6b15642SReza Sabdar int sysattr_write = 0;
14722654012fSReza Sabdar
14732654012fSReza Sabdar error = 0;
14742654012fSReza Sabdar rec = get_read_buffer(size, &error, &actual_size,
14752654012fSReza Sabdar local_commands);
1476b6b15642SReza Sabdar
1477b6b15642SReza Sabdar if ((actual_size < size) && sysattr_rw(xattrname)) {
1478b6b15642SReza Sabdar rec = get_read_one_buf(rec, actual_size, size, &error,
1479b6b15642SReza Sabdar local_commands);
1480b6b15642SReza Sabdar if (rec == NULL) {
1481b6b15642SReza Sabdar NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
1482b6b15642SReza Sabdar error, xattrname);
1483b6b15642SReza Sabdar return (size);
1484b6b15642SReza Sabdar }
1485b6b15642SReza Sabdar actual_size = size;
1486b6b15642SReza Sabdar sysattr_write = 1;
1487b6b15642SReza Sabdar }
14882654012fSReza Sabdar if (actual_size <= 0) {
14892654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
14902654012fSReza Sabdar "RESTORE WRITER> error %d, actual_size %d",
14912654012fSReza Sabdar error, actual_size);
14922654012fSReza Sabdar
14932654012fSReza Sabdar return (size);
14942654012fSReza Sabdar } else if (error) {
14952654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
14962654012fSReza Sabdar error, local_commands->tc_file_name);
14972654012fSReza Sabdar break;
14982654012fSReza Sabdar } else {
14992654012fSReza Sabdar write_size = min(size, actual_size);
1500b6b15642SReza Sabdar if ((write_size = write(*fp, rec, write_size)) < 0) {
1501b6b15642SReza Sabdar if (sysattr_write)
1502b6b15642SReza Sabdar free(rec);
1503b6b15642SReza Sabdar
1504b6b15642SReza Sabdar break;
1505b6b15642SReza Sabdar }
1506b6b15642SReza Sabdar
15072654012fSReza Sabdar NS_ADD(wdisk, write_size);
15082654012fSReza Sabdar NS_INC(wfile);
15092654012fSReza Sabdar size -= write_size;
15102654012fSReza Sabdar }
1511b6b15642SReza Sabdar if (sysattr_write)
1512b6b15642SReza Sabdar free(rec);
15132654012fSReza Sabdar }
15142654012fSReza Sabdar
15152654012fSReza Sabdar if (*fp != 0) {
15162654012fSReza Sabdar set_xattr(*fp, acls->acl_attr);
15172654012fSReza Sabdar (void) close(*fp);
15182654012fSReza Sabdar *fp = 0;
15192654012fSReza Sabdar }
15202654012fSReza Sabdar return (0);
15212654012fSReza Sabdar }
15222654012fSReza Sabdar
15232654012fSReza Sabdar /*
15242654012fSReza Sabdar * Match the name with the list
15252654012fSReza Sabdar */
15262654012fSReza Sabdar static int
exact_find(char * name,char ** list)15272654012fSReza Sabdar exact_find(char *name, char **list)
15282654012fSReza Sabdar {
15292654012fSReza Sabdar boolean_t found;
15302654012fSReza Sabdar int i;
15312654012fSReza Sabdar char *cp;
15322654012fSReza Sabdar
15332654012fSReza Sabdar found = FALSE;
15342654012fSReza Sabdar for (i = 0; *list != NULL; list++, i++) {
15352654012fSReza Sabdar cp = *list + strspn(*list, "/");
15362654012fSReza Sabdar if (match(cp, name)) {
15372654012fSReza Sabdar found = TRUE;
15382654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "exact_find> found[%s]", cp);
15392654012fSReza Sabdar break;
15402654012fSReza Sabdar }
15412654012fSReza Sabdar }
15422654012fSReza Sabdar
15432654012fSReza Sabdar return (found);
15442654012fSReza Sabdar }
15452654012fSReza Sabdar
15462654012fSReza Sabdar /*
15472654012fSReza Sabdar * On error, return FALSE and prevent restoring(probably) unwanted data.
15482654012fSReza Sabdar */
15492654012fSReza Sabdar static int
is_parent(char * parent,char * child,int flags)15502654012fSReza Sabdar is_parent(char *parent, char *child, int flags)
15512654012fSReza Sabdar {
15522654012fSReza Sabdar char tmp[TLM_MAX_PATH_NAME];
15532654012fSReza Sabdar boolean_t rv;
15542654012fSReza Sabdar
15552654012fSReza Sabdar if (IS_SET(flags, RSFLG_MATCH_WCARD)) {
15562654012fSReza Sabdar if (!tlm_cat_path(tmp, parent, "*")) {
15572654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
15582654012fSReza Sabdar "is_parent> path too long [%s]", parent);
15592654012fSReza Sabdar rv = FALSE;
15602654012fSReza Sabdar } else
15612654012fSReza Sabdar rv = (match(tmp, child) != 0) ? TRUE : FALSE;
15622654012fSReza Sabdar } else {
15632654012fSReza Sabdar if (!tlm_cat_path(tmp, parent, "/")) {
15642654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
15652654012fSReza Sabdar "is_parent> path too long [%s]", parent);
15662654012fSReza Sabdar rv = FALSE;
15672654012fSReza Sabdar } else
15682654012fSReza Sabdar rv = (strncmp(tmp, child, strlen(tmp)) == 0) ?
15692654012fSReza Sabdar TRUE : FALSE;
15702654012fSReza Sabdar }
15712654012fSReza Sabdar
15722654012fSReza Sabdar return (rv);
15732654012fSReza Sabdar }
15742654012fSReza Sabdar
15752654012fSReza Sabdar /*
15762654012fSReza Sabdar * Used to match the filename inside the list
15772654012fSReza Sabdar */
15782654012fSReza Sabdar static boolean_t
strexactcmp(char * s,char * t)15792654012fSReza Sabdar strexactcmp(char *s, char *t)
15802654012fSReza Sabdar {
15812654012fSReza Sabdar return ((strcmp(s, t) == 0) ? TRUE : FALSE);
15822654012fSReza Sabdar }
15832654012fSReza Sabdar
15842654012fSReza Sabdar /*
15852654012fSReza Sabdar * Check if the file is needed to be restored
15862654012fSReza Sabdar */
15872654012fSReza Sabdar static boolean_t
is_file_wanted(char * name,char ** sels,char ** exls,int flags,int * mchtype,int * pos)15882654012fSReza Sabdar is_file_wanted(char *name,
15892654012fSReza Sabdar char **sels,
15902654012fSReza Sabdar char **exls,
15912654012fSReza Sabdar int flags,
15922654012fSReza Sabdar int *mchtype,
15932654012fSReza Sabdar int *pos)
15942654012fSReza Sabdar {
15952654012fSReza Sabdar char *p_sel;
15962654012fSReza Sabdar char *uc_name, *retry, *namep;
15972654012fSReza Sabdar boolean_t found;
15982654012fSReza Sabdar int i;
15992654012fSReza Sabdar name_match_fp_t *cmp_fp;
16002654012fSReza Sabdar
16012654012fSReza Sabdar if (name == NULL || sels == NULL || exls == NULL)
16022654012fSReza Sabdar return (FALSE);
16032654012fSReza Sabdar
16042654012fSReza Sabdar found = FALSE;
16052654012fSReza Sabdar if (mchtype != NULL)
16062654012fSReza Sabdar *mchtype = PM_NONE;
16072654012fSReza Sabdar if (pos != NULL)
16082654012fSReza Sabdar *pos = 0;
16092654012fSReza Sabdar
16102654012fSReza Sabdar /*
16112654012fSReza Sabdar * For empty selection, restore everything
16122654012fSReza Sabdar */
16132654012fSReza Sabdar if (*sels == NULL || **sels == '\0') {
16142654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "is_file_wanted: Restore all");
16152654012fSReza Sabdar return (TRUE);
16162654012fSReza Sabdar }
16172654012fSReza Sabdar
16182654012fSReza Sabdar retry = ndmp_malloc(TLM_MAX_PATH_NAME);
1619fb4eb4e8SReza Sabdar if (retry == NULL)
16202654012fSReza Sabdar return (FALSE);
16212654012fSReza Sabdar
16222654012fSReza Sabdar if (IS_SET(flags, RSFLG_MATCH_WCARD))
16232654012fSReza Sabdar cmp_fp = match;
16242654012fSReza Sabdar else
16252654012fSReza Sabdar cmp_fp = strexactcmp;
16262654012fSReza Sabdar
16272654012fSReza Sabdar namep = name + strspn(name, "/");
1628fb4eb4e8SReza Sabdar
16292654012fSReza Sabdar if (IS_SET(flags, RSFLG_IGNORE_CASE)) {
1630fb4eb4e8SReza Sabdar uc_name = ndmp_malloc(TLM_MAX_PATH_NAME);
1631fb4eb4e8SReza Sabdar if (uc_name == NULL) {
1632fb4eb4e8SReza Sabdar free(retry);
1633fb4eb4e8SReza Sabdar return (FALSE);
1634fb4eb4e8SReza Sabdar }
16352654012fSReza Sabdar (void) strlcpy(uc_name, namep, TLM_MAX_PATH_NAME);
16362654012fSReza Sabdar (void) strupr(uc_name);
16372654012fSReza Sabdar namep = uc_name;
16382654012fSReza Sabdar }
16392654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "is_file_wanted> flg: 0x%x name: [%s]",
16402654012fSReza Sabdar flags, name);
16412654012fSReza Sabdar
16422654012fSReza Sabdar for (i = 0; *sels != NULL; sels++, i++) {
16432654012fSReza Sabdar p_sel = *sels + strspn(*sels, "/");
16442654012fSReza Sabdar
16452654012fSReza Sabdar /*
16462654012fSReza Sabdar * Try exact match.
16472654012fSReza Sabdar */
16482654012fSReza Sabdar if ((*cmp_fp)(p_sel, namep)) {
16492654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "match1> pos: %d [%s][%s]",
16502654012fSReza Sabdar i, p_sel, name);
16512654012fSReza Sabdar found = TRUE;
16522654012fSReza Sabdar if (mchtype != NULL)
16532654012fSReza Sabdar *mchtype = PM_EXACT;
16542654012fSReza Sabdar break;
16552654012fSReza Sabdar }
16562654012fSReza Sabdar /*
16572654012fSReza Sabdar * Try "entry/" and the current selection. The
16582654012fSReza Sabdar * current selection may be something like "<something>/".
16592654012fSReza Sabdar */
16602654012fSReza Sabdar (void) tlm_cat_path(retry, namep, "/");
16612654012fSReza Sabdar if ((*cmp_fp)(p_sel, retry)) {
16622654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "match2> pos %d [%s][%s]",
16632654012fSReza Sabdar i, p_sel, name);
16642654012fSReza Sabdar found = TRUE;
16652654012fSReza Sabdar if (mchtype != NULL)
16662654012fSReza Sabdar *mchtype = PM_EXACT;
16672654012fSReza Sabdar break;
16682654012fSReza Sabdar }
16692654012fSReza Sabdar /*
16702654012fSReza Sabdar * If the following check returns true it means that the
16712654012fSReza Sabdar * 'name' is an entry below the 'p_sel' hierarchy.
16722654012fSReza Sabdar */
16732654012fSReza Sabdar if (is_parent(p_sel, namep, flags)) {
16742654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "parent1> pos %d [%s][%s]",
16752654012fSReza Sabdar i, p_sel, name);
16762654012fSReza Sabdar found = TRUE;
16772654012fSReza Sabdar if (mchtype != NULL)
16782654012fSReza Sabdar *mchtype = PM_CHILD;
16792654012fSReza Sabdar break;
16802654012fSReza Sabdar }
16812654012fSReza Sabdar /*
16822654012fSReza Sabdar * There is a special case for parent directories of a
16832654012fSReza Sabdar * selection. If 'p_sel' is something like "*d1", the
16842654012fSReza Sabdar * middle directories of the final entry can't be determined
16852654012fSReza Sabdar * until the final entry matches with 'p_sel'. At that
16862654012fSReza Sabdar * time the middle directories of the entry have been passed
16872654012fSReza Sabdar * and they can't be restored.
16882654012fSReza Sabdar */
16892654012fSReza Sabdar if (is_parent(namep, p_sel, flags)) {
16902654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "parent2> pos %d [%s][%s]",
16912654012fSReza Sabdar i, p_sel, name);
16922654012fSReza Sabdar found = TRUE;
16932654012fSReza Sabdar if (mchtype != NULL)
16942654012fSReza Sabdar *mchtype = PM_PARENT;
16952654012fSReza Sabdar break;
16962654012fSReza Sabdar }
16972654012fSReza Sabdar }
16982654012fSReza Sabdar
16992654012fSReza Sabdar /* Check for exclusions. */
17002654012fSReza Sabdar if (found && exact_find(namep, exls)) {
17012654012fSReza Sabdar if (mchtype != NULL)
17022654012fSReza Sabdar *mchtype = PM_NONE;
17032654012fSReza Sabdar found = FALSE;
17042654012fSReza Sabdar }
17052654012fSReza Sabdar if (found && pos != NULL)
17062654012fSReza Sabdar *pos = i;
17072654012fSReza Sabdar
1708fb4eb4e8SReza Sabdar if (IS_SET(flags, RSFLG_IGNORE_CASE))
1709fb4eb4e8SReza Sabdar free(uc_name);
17102654012fSReza Sabdar free(retry);
17112654012fSReza Sabdar return (found);
17122654012fSReza Sabdar }
17132654012fSReza Sabdar
17142654012fSReza Sabdar /*
17152654012fSReza Sabdar * Read the specified amount data into the buffer. Detects EOT or EOF
17162654012fSReza Sabdar * during read.
17172654012fSReza Sabdar *
17182654012fSReza Sabdar * Returns the number of bytes actually read. On error returns -1.
17192654012fSReza Sabdar */
17202654012fSReza Sabdar static int
input_mem(int l,int d,tlm_cmd_t * lcmds,char * mem,int len)17212654012fSReza Sabdar input_mem(int l,
17222654012fSReza Sabdar int d,
17232654012fSReza Sabdar tlm_cmd_t *lcmds,
17242654012fSReza Sabdar char *mem,
17252654012fSReza Sabdar int len)
17262654012fSReza Sabdar {
17272654012fSReza Sabdar int err;
17282654012fSReza Sabdar int toread, actual_size, rec_size;
17292654012fSReza Sabdar char *rec;
17302654012fSReza Sabdar
17312654012fSReza Sabdar if (l <= 0 || d <= 0 || !lcmds || !mem) {
17322654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Invalid argument");
17332654012fSReza Sabdar return (-1);
17342654012fSReza Sabdar }
17352654012fSReza Sabdar
17362654012fSReza Sabdar toread = len;
17372654012fSReza Sabdar while (toread > 0) {
17382654012fSReza Sabdar rec = get_read_buffer(toread, &err, &actual_size, lcmds);
17392654012fSReza Sabdar if (actual_size <= 0) {
17402654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "err %d act_size %d detected",
17412654012fSReza Sabdar err, actual_size);
17422654012fSReza Sabdar break;
17432654012fSReza Sabdar } else if (err) {
17442654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "error %d reading data", err);
17452654012fSReza Sabdar return (-1);
17462654012fSReza Sabdar }
17472654012fSReza Sabdar rec_size = min(actual_size, toread);
17482654012fSReza Sabdar (void) memcpy(mem, rec, rec_size);
17492654012fSReza Sabdar mem += rec_size;
17502654012fSReza Sabdar toread -= rec_size;
17512654012fSReza Sabdar }
17522654012fSReza Sabdar
17532654012fSReza Sabdar return (len - toread);
17542654012fSReza Sabdar }
17552654012fSReza Sabdar
17562654012fSReza Sabdar /*
17572654012fSReza Sabdar * pick up the name and size of a HUGE file
17582654012fSReza Sabdar */
17592654012fSReza Sabdar static int
get_humongus_file_header(int lib,int drv,long recsize,longlong_t * size,char * name,tlm_cmd_t * local_commands)17602654012fSReza Sabdar get_humongus_file_header(int lib,
17612654012fSReza Sabdar int drv,
17622654012fSReza Sabdar long recsize,
17632654012fSReza Sabdar longlong_t *size,
17642654012fSReza Sabdar char *name,
17652654012fSReza Sabdar tlm_cmd_t *local_commands)
17662654012fSReza Sabdar {
17672654012fSReza Sabdar char *p_record, *value;
17682654012fSReza Sabdar int rv;
17692654012fSReza Sabdar
17702654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "HUGE Record found: %d", recsize);
17712654012fSReza Sabdar
17722654012fSReza Sabdar rv = 0;
17732654012fSReza Sabdar if (recsize == 0) {
17742654012fSReza Sabdar /*
17752654012fSReza Sabdar * The humongus_file_header was written in a
17762654012fSReza Sabdar * RECORDSIZE block and the header.size field of this
17772654012fSReza Sabdar * record was 0 before this fix. For backward compatiblity
17782654012fSReza Sabdar * read only one RECORDSIZE-size block if the header.size
17792654012fSReza Sabdar * field is 0. Otherwise the header.size field should show
17802654012fSReza Sabdar * the length of the data of this header.
17812654012fSReza Sabdar */
17822654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Old HUGE record found");
17832654012fSReza Sabdar recsize = RECORDSIZE;
17842654012fSReza Sabdar }
17852654012fSReza Sabdar
17862654012fSReza Sabdar if (input_mem(lib, drv, local_commands, name, recsize) != recsize) {
17872654012fSReza Sabdar rv = -1;
17882654012fSReza Sabdar *size = 0;
17892654012fSReza Sabdar *name = '\0';
17902654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Error reading a HUGE file name");
17912654012fSReza Sabdar } else {
17922654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "HUGE [%s]", name);
17932654012fSReza Sabdar
17942654012fSReza Sabdar p_record = name;
17952654012fSReza Sabdar value = parse(&p_record, " ");
17962654012fSReza Sabdar *size = atoll(value);
17972654012fSReza Sabdar /*
17982654012fSReza Sabdar * Note: Since the backed up names are not longer than
17992654012fSReza Sabdar * NAME_MAX and the buffer passed to us is
18002654012fSReza Sabdar * TLM_MAX_PATH_NAME, it should be safe to use strlcpy
18012654012fSReza Sabdar * without check on the buffer size.
18022654012fSReza Sabdar */
18032654012fSReza Sabdar (void) strlcpy(name, p_record, TLM_MAX_PATH_NAME);
18042654012fSReza Sabdar }
18052654012fSReza Sabdar
18062654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "HUGE Record %lld [%s]", *size, name);
18072654012fSReza Sabdar
18082654012fSReza Sabdar return (rv);
18092654012fSReza Sabdar }
18102654012fSReza Sabdar
18112654012fSReza Sabdar /*
18122654012fSReza Sabdar * pick up the long name from the special tape file
18132654012fSReza Sabdar */
18142654012fSReza Sabdar static int
get_long_name(int lib,int drv,long recsize,char * name,long * buf_spot,tlm_cmd_t * local_commands)18152654012fSReza Sabdar get_long_name(int lib,
18162654012fSReza Sabdar int drv,
18172654012fSReza Sabdar long recsize,
18182654012fSReza Sabdar char *name,
18192654012fSReza Sabdar long *buf_spot,
18202654012fSReza Sabdar tlm_cmd_t *local_commands)
18212654012fSReza Sabdar {
18222654012fSReza Sabdar int nread;
18232654012fSReza Sabdar
18242654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "LONGNAME Record found rs %d bs %d", recsize,
18252654012fSReza Sabdar *buf_spot);
18262654012fSReza Sabdar
18272654012fSReza Sabdar if (*buf_spot < 0)
18282654012fSReza Sabdar *buf_spot = 0;
18292654012fSReza Sabdar
18302654012fSReza Sabdar nread = input_mem(lib, drv, local_commands, name + *buf_spot,
18312654012fSReza Sabdar recsize);
18322654012fSReza Sabdar if (nread < 0) {
18332654012fSReza Sabdar nread = recsize; /* return 0 as size left */
18342654012fSReza Sabdar name[*buf_spot] = '\0';
18352654012fSReza Sabdar NDMP_LOG(LOG_ERR, "Error %d reading a long file name %s.",
18362654012fSReza Sabdar nread, name);
18372654012fSReza Sabdar } else {
18382654012fSReza Sabdar *buf_spot += nread;
18392654012fSReza Sabdar name[*buf_spot] = '\0';
18402654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "LONGNAME [%s]", name);
18412654012fSReza Sabdar }
18422654012fSReza Sabdar
18432654012fSReza Sabdar return (recsize - nread);
18442654012fSReza Sabdar }
18452654012fSReza Sabdar
18462654012fSReza Sabdar /*
18472654012fSReza Sabdar * create a new directory
18482654012fSReza Sabdar */
18492efb3bf9SJan Kryl static int
create_directory(char * dir,tlm_job_stats_t * job_stats)18502654012fSReza Sabdar create_directory(char *dir, tlm_job_stats_t *job_stats)
18512654012fSReza Sabdar {
18522654012fSReza Sabdar struct stat64 attr;
18532654012fSReza Sabdar char *p;
18542654012fSReza Sabdar char temp;
18552654012fSReza Sabdar int erc;
18562654012fSReza Sabdar
18572654012fSReza Sabdar /*
18582654012fSReza Sabdar * Make sure all directories in this path exist, create them if
18592654012fSReza Sabdar * needed.
18602654012fSReza Sabdar */
18612654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "new dir[%s]", dir);
18622654012fSReza Sabdar
18632654012fSReza Sabdar erc = 0;
18642654012fSReza Sabdar p = &dir[1];
18652654012fSReza Sabdar do {
18662654012fSReza Sabdar temp = *p;
18672654012fSReza Sabdar if (temp == '/' || temp == 0) {
18682654012fSReza Sabdar *p = 0;
18692654012fSReza Sabdar if (stat64(dir, &attr) < 0) {
18702efb3bf9SJan Kryl if (mkdir(dir, 0777) != 0 && errno != EEXIST) {
18712efb3bf9SJan Kryl erc = errno;
18722654012fSReza Sabdar job_stats->js_errors++;
18732654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
18742efb3bf9SJan Kryl "Could not create directory %s: %d",
18752efb3bf9SJan Kryl dir, errno);
18762654012fSReza Sabdar break;
18772654012fSReza Sabdar }
18782654012fSReza Sabdar }
18792654012fSReza Sabdar *p = temp;
18802654012fSReza Sabdar }
18812654012fSReza Sabdar p++;
18822654012fSReza Sabdar } while (temp != 0);
18832654012fSReza Sabdar
18842654012fSReza Sabdar return (erc);
18852654012fSReza Sabdar }
18862654012fSReza Sabdar
18872654012fSReza Sabdar /*
18882654012fSReza Sabdar * create a new hardlink
18892654012fSReza Sabdar */
18902654012fSReza Sabdar static int
create_hard_link(char * name_old,char * name_new,tlm_acls_t * acls,tlm_job_stats_t * job_stats)18912654012fSReza Sabdar create_hard_link(char *name_old, char *name_new,
18922654012fSReza Sabdar tlm_acls_t *acls, tlm_job_stats_t *job_stats)
18932654012fSReza Sabdar {
18942654012fSReza Sabdar int erc;
18952654012fSReza Sabdar
18962efb3bf9SJan Kryl erc = mkbasedir(name_new);
18972efb3bf9SJan Kryl if (erc != 0)
18982efb3bf9SJan Kryl return (erc);
1899fb4eb4e8SReza Sabdar
19002efb3bf9SJan Kryl if (link(name_old, name_new) != 0)
19012efb3bf9SJan Kryl erc = errno;
1902fb4eb4e8SReza Sabdar
19032654012fSReza Sabdar if (erc) {
19042efb3bf9SJan Kryl /* Nothing to do if the destination already exists */
19052efb3bf9SJan Kryl if (erc == EEXIST)
19062efb3bf9SJan Kryl return (0);
19072654012fSReza Sabdar job_stats->js_errors++;
19082654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "error %d (errno %d) hardlink [%s] to [%s]",
19092654012fSReza Sabdar erc, errno, name_new, name_old);
19102efb3bf9SJan Kryl return (erc);
19112654012fSReza Sabdar }
19122efb3bf9SJan Kryl return (set_acl(name_new, acls));
19132654012fSReza Sabdar }
19142654012fSReza Sabdar
19152654012fSReza Sabdar /*
19162654012fSReza Sabdar * create a new symlink
19172654012fSReza Sabdar */
19182654012fSReza Sabdar /*ARGSUSED*/
19192654012fSReza Sabdar static int
create_sym_link(char * dst,char * target,tlm_acls_t * acls,tlm_job_stats_t * job_stats)19202654012fSReza Sabdar create_sym_link(char *dst, char *target, tlm_acls_t *acls,
19215181c2afSReza Sabdar tlm_job_stats_t *job_stats)
19222654012fSReza Sabdar {
19232654012fSReza Sabdar int erc;
1924859b7745SReza Sabdar struct stat64 *st;
19252654012fSReza Sabdar
19262efb3bf9SJan Kryl erc = mkbasedir(dst);
19272efb3bf9SJan Kryl if (erc != 0)
19282efb3bf9SJan Kryl return (erc);
19292654012fSReza Sabdar
1930859b7745SReza Sabdar st = &acls->acl_attr;
19312efb3bf9SJan Kryl if (symlink(target, dst) != 0) {
19322efb3bf9SJan Kryl erc = errno;
19335181c2afSReza Sabdar job_stats->js_errors++;
19342efb3bf9SJan Kryl NDMP_LOG(LOG_DEBUG, "error %d softlink [%s] to [%s]",
19352efb3bf9SJan Kryl errno, dst, target);
193686c48bbfSReza Sabdar } else {
1937859b7745SReza Sabdar st->st_mode |= S_IFLNK;
19382efb3bf9SJan Kryl erc = set_acl(dst, acls);
19392654012fSReza Sabdar }
19402654012fSReza Sabdar
19412654012fSReza Sabdar return (erc);
19422654012fSReza Sabdar }
19432654012fSReza Sabdar
19442654012fSReza Sabdar /*
19455181c2afSReza Sabdar * create a new FIFO, char/block device special files
19462654012fSReza Sabdar */
19472654012fSReza Sabdar static int
create_special(char flag,char * name,tlm_acls_t * acls,int major,int minor,tlm_job_stats_t * job_stats)19485181c2afSReza Sabdar create_special(char flag, char *name, tlm_acls_t *acls, int major, int minor,
19495181c2afSReza Sabdar tlm_job_stats_t *job_stats)
19502654012fSReza Sabdar {
19515181c2afSReza Sabdar dev_t dev;
19525181c2afSReza Sabdar mode_t mode;
19535181c2afSReza Sabdar
19545181c2afSReza Sabdar switch (flag) {
19555181c2afSReza Sabdar case LF_CHR:
19565181c2afSReza Sabdar mode = S_IFCHR;
19575181c2afSReza Sabdar dev = makedev(major, minor);
19585181c2afSReza Sabdar break;
19595181c2afSReza Sabdar case LF_BLK:
19605181c2afSReza Sabdar mode = S_IFBLK;
19615181c2afSReza Sabdar dev = makedev(major, minor);
19625181c2afSReza Sabdar break;
19635181c2afSReza Sabdar case LF_FIFO:
19645181c2afSReza Sabdar mode = S_IFIFO;
19655181c2afSReza Sabdar dev = 0;
19665181c2afSReza Sabdar break;
19675181c2afSReza Sabdar default:
19685181c2afSReza Sabdar NDMP_LOG(LOG_ERR, "unsupported flag %d", flag);
19695181c2afSReza Sabdar return (-1);
19705181c2afSReza Sabdar }
19715181c2afSReza Sabdar
19725181c2afSReza Sabdar /* Remove the old entry first */
19735181c2afSReza Sabdar if (rmdir(name) < 0) {
19745181c2afSReza Sabdar if (errno == ENOTDIR)
19755181c2afSReza Sabdar (void) unlink(name);
19765181c2afSReza Sabdar }
19772efb3bf9SJan Kryl if (mknod(name, 0777 | mode, dev) != 0) {
19785181c2afSReza Sabdar job_stats->js_errors++;
19792efb3bf9SJan Kryl NDMP_LOG(LOG_DEBUG, "error %d mknod [%s] major"
19802efb3bf9SJan Kryl " %d minor %d", errno, name, major, minor);
19812efb3bf9SJan Kryl return (errno);
19825181c2afSReza Sabdar }
19832efb3bf9SJan Kryl return (set_acl(name, acls));
19842654012fSReza Sabdar }
19852654012fSReza Sabdar
19862654012fSReza Sabdar /*
19872654012fSReza Sabdar * read in the ACLs for the next file
19882654012fSReza Sabdar */
19892654012fSReza Sabdar static long
load_acl_info(int lib,int drv,long file_size,tlm_acls_t * acls,long * acl_spot,tlm_cmd_t * local_commands)19902654012fSReza Sabdar load_acl_info(int lib,
19912654012fSReza Sabdar int drv,
19922654012fSReza Sabdar long file_size,
19932654012fSReza Sabdar tlm_acls_t *acls,
19942654012fSReza Sabdar long *acl_spot,
19952654012fSReza Sabdar tlm_cmd_t *local_commands)
19962654012fSReza Sabdar {
19972654012fSReza Sabdar char *bp;
19982654012fSReza Sabdar int nread;
19992654012fSReza Sabdar
20002654012fSReza Sabdar /*
20012654012fSReza Sabdar * If the ACL is spanned on tapes, then the acl_spot should NOT be
20022654012fSReza Sabdar * 0 on next calls to this function to read the rest of the ACL
20032654012fSReza Sabdar * on next tapes.
20042654012fSReza Sabdar */
20052654012fSReza Sabdar if (*acl_spot == 0) {
20062654012fSReza Sabdar (void) memset(acls, 0, sizeof (tlm_acls_t));
20072654012fSReza Sabdar }
20082654012fSReza Sabdar
20092654012fSReza Sabdar bp = ((char *)&acls->acl_info) + *acl_spot;
20102654012fSReza Sabdar nread = input_mem(lib, drv, local_commands, (void *)bp, file_size);
20112654012fSReza Sabdar if (nread < 0) {
20122654012fSReza Sabdar *acl_spot = 0;
20132654012fSReza Sabdar (void) memset(acls, 0, sizeof (tlm_acls_t));
20142654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Error reading ACL data");
20152654012fSReza Sabdar return (0);
20162654012fSReza Sabdar }
20172654012fSReza Sabdar *acl_spot += nread;
20182654012fSReza Sabdar acls->acl_non_trivial = TRUE;
20192654012fSReza Sabdar
20202654012fSReza Sabdar return (file_size - nread);
20212654012fSReza Sabdar }
20222654012fSReza Sabdar
20232654012fSReza Sabdar static int
ndmp_set_eprivs_least(void)20242654012fSReza Sabdar ndmp_set_eprivs_least(void)
20252654012fSReza Sabdar {
20262654012fSReza Sabdar priv_set_t *priv_set;
20272654012fSReza Sabdar
20282654012fSReza Sabdar if ((priv_set = priv_allocset()) == NULL) {
20292654012fSReza Sabdar NDMP_LOG(LOG_ERR, "Out of memory.");
20302654012fSReza Sabdar return (-1);
20312654012fSReza Sabdar }
2032634e26ecSCasper H.S. Dik
2033634e26ecSCasper H.S. Dik priv_basicset(priv_set);
2034634e26ecSCasper H.S. Dik
2035634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_PROC_AUDIT);
2036634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_PROC_SETID);
2037634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_PROC_OWNER);
2038634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_CHOWN);
2039634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_CHOWN_SELF);
2040634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_DAC_READ);
2041634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_DAC_SEARCH);
2042634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_DAC_WRITE);
2043634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_OWNER);
2044634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_FILE_SETID);
2045634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_SYS_LINKDIR);
2046634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_SYS_DEVICES);
2047634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_SYS_MOUNT);
2048634e26ecSCasper H.S. Dik (void) priv_addset(priv_set, PRIV_SYS_CONFIG);
20492654012fSReza Sabdar
20502654012fSReza Sabdar if (setppriv(PRIV_SET, PRIV_EFFECTIVE, priv_set) == -1) {
20512654012fSReza Sabdar NDMP_LOG(LOG_ERR, "Additional privileges required.");
20522654012fSReza Sabdar priv_freeset(priv_set);
20532654012fSReza Sabdar return (-1);
20542654012fSReza Sabdar }
20552654012fSReza Sabdar priv_freeset(priv_set);
20562654012fSReza Sabdar return (0);
20572654012fSReza Sabdar }
20582654012fSReza Sabdar
20592654012fSReza Sabdar static int
ndmp_set_eprivs_all(void)20602654012fSReza Sabdar ndmp_set_eprivs_all(void)
20612654012fSReza Sabdar {
20622654012fSReza Sabdar priv_set_t *priv_set;
20632654012fSReza Sabdar
2064634e26ecSCasper H.S. Dik if ((priv_set = priv_allocset()) == NULL) {
2065634e26ecSCasper H.S. Dik NDMP_LOG(LOG_ERR, "Out of memory.");
20662654012fSReza Sabdar return (-1);
20672654012fSReza Sabdar }
2068634e26ecSCasper H.S. Dik
2069634e26ecSCasper H.S. Dik priv_fillset(priv_set);
2070634e26ecSCasper H.S. Dik
20712654012fSReza Sabdar if (setppriv(PRIV_SET, PRIV_EFFECTIVE, priv_set) != 0) {
20722654012fSReza Sabdar NDMP_LOG(LOG_ERR, "Additional privileges required.");
20732654012fSReza Sabdar return (-1);
20742654012fSReza Sabdar }
20752654012fSReza Sabdar priv_freeset(priv_set);
20762654012fSReza Sabdar return (0);
20772654012fSReza Sabdar }
20782654012fSReza Sabdar
20792654012fSReza Sabdar /*
20802654012fSReza Sabdar * Set the standard attributes of the file
20812654012fSReza Sabdar */
20822efb3bf9SJan Kryl static int
set_attr(char * name,tlm_acls_t * acls)2083b6b15642SReza Sabdar set_attr(char *name, tlm_acls_t *acls)
20842654012fSReza Sabdar {
20852654012fSReza Sabdar struct utimbuf tbuf;
20862654012fSReza Sabdar boolean_t priv_all = FALSE;
2087b6b15642SReza Sabdar struct stat64 *st;
2088b6b15642SReza Sabdar uid_t uid;
2089b6b15642SReza Sabdar gid_t gid;
2090b6b15642SReza Sabdar struct passwd *pwd;
2091b6b15642SReza Sabdar struct group *grp;
20922efb3bf9SJan Kryl int erc = 0;
2093b6b15642SReza Sabdar
20942654012fSReza Sabdar
2095b6b15642SReza Sabdar if (!name || !acls)
20962efb3bf9SJan Kryl return (0);
20972654012fSReza Sabdar
2098b6b15642SReza Sabdar st = &acls->acl_attr;
2099b6b15642SReza Sabdar NDMP_LOG(LOG_DEBUG, "set_attr: %s uid %d gid %d uname %s gname %s "
2100b6b15642SReza Sabdar "mode %o", name, st->st_uid, st->st_gid, acls->uname, acls->gname,
2101b6b15642SReza Sabdar st->st_mode);
2102b6b15642SReza Sabdar
2103b6b15642SReza Sabdar uid = st->st_uid;
2104b6b15642SReza Sabdar if ((pwd = getpwnam(acls->uname)) != NULL) {
2105b6b15642SReza Sabdar NDMP_LOG(LOG_DEBUG, "set_attr: new uid %d old %d",
2106b6b15642SReza Sabdar pwd->pw_uid, uid);
2107b6b15642SReza Sabdar uid = pwd->pw_uid;
2108b6b15642SReza Sabdar }
2109b6b15642SReza Sabdar
2110b6b15642SReza Sabdar gid = st->st_gid;
2111b6b15642SReza Sabdar if ((grp = getgrnam(acls->gname)) != NULL) {
2112b6b15642SReza Sabdar NDMP_LOG(LOG_DEBUG, "set_attr: new gid %d old %d",
2113b6b15642SReza Sabdar grp->gr_gid, gid);
2114b6b15642SReza Sabdar gid = grp->gr_gid;
2115b6b15642SReza Sabdar }
21162654012fSReza Sabdar
21172efb3bf9SJan Kryl erc = lchown(name, uid, gid);
21182efb3bf9SJan Kryl if (erc != 0) {
21192efb3bf9SJan Kryl erc = errno;
21202654012fSReza Sabdar NDMP_LOG(LOG_ERR,
21212654012fSReza Sabdar "Could not set uid or/and gid for file %s.", name);
21222efb3bf9SJan Kryl }
21232654012fSReza Sabdar
21242654012fSReza Sabdar if ((st->st_mode & (S_ISUID | S_ISGID)) != 0) {
21252654012fSReza Sabdar /*
21262654012fSReza Sabdar * Change effective privileges to 'all' which is required to
21272654012fSReza Sabdar * change setuid bit for 'root' owned files. If fails, just
21282654012fSReza Sabdar * send error to log file and proceed.
21292654012fSReza Sabdar */
21302654012fSReza Sabdar if (ndmp_set_eprivs_all()) {
21312654012fSReza Sabdar NDMP_LOG(LOG_ERR,
21322654012fSReza Sabdar "Could not set effective privileges to 'all'.");
21332654012fSReza Sabdar } else {
21342654012fSReza Sabdar priv_all = TRUE;
21352654012fSReza Sabdar }
21362654012fSReza Sabdar }
21372654012fSReza Sabdar
2138859b7745SReza Sabdar if (!S_ISLNK(st->st_mode)) {
21392efb3bf9SJan Kryl erc = chmod(name, st->st_mode);
21402efb3bf9SJan Kryl if (erc != 0) {
21412efb3bf9SJan Kryl erc = errno;
2142859b7745SReza Sabdar NDMP_LOG(LOG_ERR, "Could not set correct file"
21432efb3bf9SJan Kryl " permission for file %s: %d", name, errno);
21442efb3bf9SJan Kryl }
2145859b7745SReza Sabdar
2146859b7745SReza Sabdar tbuf.modtime = st->st_mtime;
2147859b7745SReza Sabdar tbuf.actime = st->st_atime;
2148859b7745SReza Sabdar (void) utime(name, &tbuf);
2149859b7745SReza Sabdar }
21502654012fSReza Sabdar
21512654012fSReza Sabdar if (priv_all == TRUE) {
21522654012fSReza Sabdar /*
21532654012fSReza Sabdar * Give up the 'all' privileges for effective sets and go back
21542654012fSReza Sabdar * to least required privileges. If fails, just send error to
21552654012fSReza Sabdar * log file and proceed.
21562654012fSReza Sabdar */
21572654012fSReza Sabdar if (ndmp_set_eprivs_least())
21582654012fSReza Sabdar NDMP_LOG(LOG_ERR,
21592654012fSReza Sabdar "Could not set least required privileges.");
21602654012fSReza Sabdar }
21612efb3bf9SJan Kryl
21622efb3bf9SJan Kryl return (erc);
21632654012fSReza Sabdar }
21642654012fSReza Sabdar
21652654012fSReza Sabdar /*
21662654012fSReza Sabdar * Set the ACL info for the file
21672654012fSReza Sabdar */
21682efb3bf9SJan Kryl static int
set_acl(char * name,tlm_acls_t * acls)21692654012fSReza Sabdar set_acl(char *name, tlm_acls_t *acls)
21702654012fSReza Sabdar {
21712654012fSReza Sabdar int erc;
21722654012fSReza Sabdar acl_t *aclp = NULL;
21732654012fSReza Sabdar
21742654012fSReza Sabdar if (name)
21752654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "set_acl: %s", name);
21762efb3bf9SJan Kryl if (acls == NULL)
21772efb3bf9SJan Kryl return (0);
21782654012fSReza Sabdar
21792efb3bf9SJan Kryl /* Need a place to save real modification time */
21802654012fSReza Sabdar
21812efb3bf9SJan Kryl erc = set_attr(name, acls);
21822efb3bf9SJan Kryl if (ERROR_IS_FATAL(erc))
21832efb3bf9SJan Kryl return (erc);
21842654012fSReza Sabdar
21852efb3bf9SJan Kryl if (!acls->acl_non_trivial) {
21862efb3bf9SJan Kryl (void) memset(acls, 0, sizeof (tlm_acls_t));
21872efb3bf9SJan Kryl NDMP_LOG(LOG_DEBUG, "set_acl: skipping trivial");
21882efb3bf9SJan Kryl return (erc);
21892efb3bf9SJan Kryl }
21902efb3bf9SJan Kryl
21912efb3bf9SJan Kryl erc = acl_fromtext(acls->acl_info.attr_info, &aclp);
21922efb3bf9SJan Kryl if (erc != 0) {
21932efb3bf9SJan Kryl NDMP_LOG(LOG_DEBUG,
21942efb3bf9SJan Kryl "TAPE RESTORE> acl_fromtext errno %d", erc);
21952efb3bf9SJan Kryl }
21962efb3bf9SJan Kryl if (aclp) {
21972efb3bf9SJan Kryl erc = acl_set(name, aclp);
21982efb3bf9SJan Kryl if (erc < 0) {
21992efb3bf9SJan Kryl erc = errno;
22002654012fSReza Sabdar NDMP_LOG(LOG_DEBUG,
22012efb3bf9SJan Kryl "TAPE RESTORE> acl_set errno %d", errno);
22022654012fSReza Sabdar }
22032efb3bf9SJan Kryl acl_free(aclp);
22042654012fSReza Sabdar }
22052efb3bf9SJan Kryl (void) memset(acls, 0, sizeof (tlm_acls_t));
22062efb3bf9SJan Kryl return (erc);
22072654012fSReza Sabdar }
22082654012fSReza Sabdar
22092654012fSReza Sabdar /*
22102654012fSReza Sabdar * a wrapper to tlm_get_read_buffer so that
22112654012fSReza Sabdar * we can cleanly detect ABORT commands
22122654012fSReza Sabdar * without involving the TLM library with
22132654012fSReza Sabdar * our problems.
22142654012fSReza Sabdar */
22152654012fSReza Sabdar static char *
get_read_buffer(int want,int * error,int * actual_size,tlm_cmd_t * local_commands)22162654012fSReza Sabdar get_read_buffer(int want,
22172654012fSReza Sabdar int *error,
22182654012fSReza Sabdar int *actual_size,
22192654012fSReza Sabdar tlm_cmd_t *local_commands)
22202654012fSReza Sabdar {
22212654012fSReza Sabdar while (local_commands->tc_writer == TLM_RESTORE_RUN) {
22222654012fSReza Sabdar char *rec;
22232654012fSReza Sabdar rec = tlm_get_read_buffer(want, error,
22242654012fSReza Sabdar local_commands->tc_buffers, actual_size);
22252654012fSReza Sabdar if (rec != 0) {
22262654012fSReza Sabdar return (rec);
22272654012fSReza Sabdar }
22282654012fSReza Sabdar }
22292654012fSReza Sabdar
22302654012fSReza Sabdar /*
22312654012fSReza Sabdar * the job is ending, give Writer a buffer that will never be read ...
22322654012fSReza Sabdar * it does not matter anyhow, we are aborting.
22332654012fSReza Sabdar */
22342654012fSReza Sabdar *actual_size = RECORDSIZE;
22352654012fSReza Sabdar return (NULL);
22362654012fSReza Sabdar }
22372654012fSReza Sabdar
22382654012fSReza Sabdar /*
22392654012fSReza Sabdar * Enable wildcard for restore options
22402654012fSReza Sabdar */
22412654012fSReza Sabdar static boolean_t
wildcard_enabled(void)22422654012fSReza Sabdar wildcard_enabled(void)
22432654012fSReza Sabdar {
22442654012fSReza Sabdar char *cp;
22452654012fSReza Sabdar
22462654012fSReza Sabdar cp = ndmpd_get_prop_default(NDMP_RESTORE_WILDCARD_ENABLE, "n");
22472654012fSReza Sabdar return ((toupper(*cp) == 'Y') ? TRUE : FALSE);
22482654012fSReza Sabdar }
22492654012fSReza Sabdar
22502654012fSReza Sabdar
22512654012fSReza Sabdar /*
22522654012fSReza Sabdar * Concatenate two names
22532654012fSReza Sabdar */
22542654012fSReza Sabdar /*ARGSUSED*/
22552654012fSReza Sabdar static char *
catnames(struct rs_name_maker * rnp,char * buf,int pos,char * path)22562654012fSReza Sabdar catnames(struct rs_name_maker *rnp, char *buf, int pos, char *path)
22572654012fSReza Sabdar {
22582654012fSReza Sabdar char *rv;
22592654012fSReza Sabdar
22602654012fSReza Sabdar rv = NULL;
22612654012fSReza Sabdar if (!buf) {
22622654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "buf is NULL");
22632654012fSReza Sabdar } else if (!path) {
22642654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "path is NULL");
22652654012fSReza Sabdar } else if (!rnp->rn_nlp) {
22662654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "rn_nlp is NULL [%s]", path);
22672654012fSReza Sabdar } else if (!tlm_cat_path(buf, rnp->rn_nlp, path)) {
22682654012fSReza Sabdar NDMP_LOG(LOG_DEBUG, "Path too long [%s][%s]",
22692654012fSReza Sabdar rnp->rn_nlp, path);
22702654012fSReza Sabdar } else
22712654012fSReza Sabdar rv = buf;
22722654012fSReza Sabdar
22732654012fSReza Sabdar return (rv);
22742654012fSReza Sabdar }
22752654012fSReza Sabdar
22762654012fSReza Sabdar
22772654012fSReza Sabdar /*
22782654012fSReza Sabdar * Create a new name path for restore
22792654012fSReza Sabdar */
22802654012fSReza Sabdar static char *
rs_new_name(struct rs_name_maker * rnp,char * buf,int pos,char * path)22812654012fSReza Sabdar rs_new_name(struct rs_name_maker *rnp, char *buf, int pos, char *path)
22822654012fSReza Sabdar {
22832654012fSReza Sabdar if (!rnp || !rnp->rn_fp)
22842654012fSReza Sabdar return (NULL);
22852654012fSReza Sabdar
22862654012fSReza Sabdar return (*rnp->rn_fp)(rnp, buf, pos, path);
22872654012fSReza Sabdar }
22882654012fSReza Sabdar
2289fb4eb4e8SReza Sabdar /*
2290fb4eb4e8SReza Sabdar * Clear the extra "/" in the tar header if exists
2291fb4eb4e8SReza Sabdar */
2292fb4eb4e8SReza Sabdar static void
rs_create_new_bkpath(char * bk_path,char * path,char * pbuf)2293fb4eb4e8SReza Sabdar rs_create_new_bkpath(char *bk_path, char *path, char *pbuf)
2294fb4eb4e8SReza Sabdar {
2295fb4eb4e8SReza Sabdar char *p, *slashp;
2296fb4eb4e8SReza Sabdar
2297fb4eb4e8SReza Sabdar if ((p = strstr(path, bk_path)) == NULL) {
2298fb4eb4e8SReza Sabdar (void) strlcpy(pbuf, path, TLM_MAX_PATH_NAME);
2299fb4eb4e8SReza Sabdar return;
2300fb4eb4e8SReza Sabdar }
2301fb4eb4e8SReza Sabdar if (*(p += strlen(bk_path)) == '/')
2302fb4eb4e8SReza Sabdar p++;
2303fb4eb4e8SReza Sabdar
2304fb4eb4e8SReza Sabdar slashp = bk_path + strlen(bk_path) - 1;
2305fb4eb4e8SReza Sabdar if (*slashp == '/')
2306fb4eb4e8SReza Sabdar (void) snprintf(pbuf, TLM_MAX_PATH_NAME, "%s%s", bk_path, p);
2307fb4eb4e8SReza Sabdar else
2308fb4eb4e8SReza Sabdar (void) snprintf(pbuf, TLM_MAX_PATH_NAME, "%s/%s", bk_path, p);
2309fb4eb4e8SReza Sabdar
2310fb4eb4e8SReza Sabdar NDMP_LOG(LOG_DEBUG, "old path [%s] new path [%s]", path, pbuf);
2311fb4eb4e8SReza Sabdar }
2312fb4eb4e8SReza Sabdar
2313fb4eb4e8SReza Sabdar
23142654012fSReza Sabdar /*
23152654012fSReza Sabdar * Iterate over ZFS metadata stored in the backup stream and use the callback
23162654012fSReza Sabdar * to restore it.
23172654012fSReza Sabdar */
23182654012fSReza Sabdar int
ndmp_iter_zfs(ndmp_context_t * nctx,int (* np_restore_property)(nvlist_t *,void *),void * ptr)23192654012fSReza Sabdar ndmp_iter_zfs(ndmp_context_t *nctx, int (*np_restore_property)(nvlist_t *,
23202654012fSReza Sabdar void *), void *ptr)
23212654012fSReza Sabdar {
23222654012fSReza Sabdar tlm_commands_t *cmds;
23232654012fSReza Sabdar ndmp_metadata_header_t *mhp;
232442ed7838SReza Sabdar ndmp_metadata_header_ext_t *mhpx;
23252654012fSReza Sabdar ndmp_metadata_property_t *mpp;
232642ed7838SReza Sabdar ndmp_metadata_property_ext_t *mppx;
23272654012fSReza Sabdar tlm_cmd_t *lcmd;
23282654012fSReza Sabdar int actual_size;
23292654012fSReza Sabdar nvlist_t *nvl;
23302654012fSReza Sabdar nvlist_t *valp;
23312654012fSReza Sabdar nvpair_t *nvp = NULL;
23322654012fSReza Sabdar char plname[100];
23332654012fSReza Sabdar char *mhbuf, *pp, *tp;
23342654012fSReza Sabdar int rv, i;
23352654012fSReza Sabdar int size, lsize, sz;
23362654012fSReza Sabdar int align = RECORDSIZE - 1;
23372654012fSReza Sabdar
23382654012fSReza Sabdar if (nctx == NULL || (cmds = (tlm_commands_t *)nctx->nc_cmds) == NULL)
23392654012fSReza Sabdar return (-1);
23402654012fSReza Sabdar
23412654012fSReza Sabdar nctx->nc_plname = plname;
23422654012fSReza Sabdar if ((lcmd = cmds->tcs_command) == NULL ||
23432654012fSReza Sabdar lcmd->tc_buffers == NULL)
23442654012fSReza Sabdar return (-1);
23452654012fSReza Sabdar
234642ed7838SReza Sabdar /* Default minimum bytes needed */
23472654012fSReza Sabdar size = sizeof (ndmp_metadata_header_t) +
23482654012fSReza Sabdar ZFS_MAX_PROPS * sizeof (ndmp_metadata_property_t);
23492654012fSReza Sabdar size += align;
23502654012fSReza Sabdar size &= ~align;
23512654012fSReza Sabdar
23522654012fSReza Sabdar if ((mhbuf = malloc(size)) == NULL)
23532654012fSReza Sabdar return (-1);
23542654012fSReza Sabdar
23552654012fSReza Sabdar /* LINTED improper alignment */
23562654012fSReza Sabdar while ((mhp = (ndmp_metadata_header_t *)get_read_buffer(size, &rv,
23572654012fSReza Sabdar &actual_size, lcmd)) != NULL) {
23582654012fSReza Sabdar pp = mhbuf;
23592654012fSReza Sabdar
23602654012fSReza Sabdar if (strncmp(mhp->nh_magic, ZFS_META_MAGIC,
236142ed7838SReza Sabdar sizeof (mhp->nh_magic)) != 0 &&
236242ed7838SReza Sabdar strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
23632654012fSReza Sabdar sizeof (mhp->nh_magic)) != 0) {
23642654012fSReza Sabdar /* No more metadata */
23652654012fSReza Sabdar tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
236642ed7838SReza Sabdar free(mhbuf);
23672654012fSReza Sabdar return (0);
23682654012fSReza Sabdar }
23692654012fSReza Sabdar
237042ed7838SReza Sabdar if (strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
237142ed7838SReza Sabdar sizeof (mhp->nh_magic)) == 0) {
237242ed7838SReza Sabdar mhpx = (ndmp_metadata_header_ext_t *)mhp;
237342ed7838SReza Sabdar if (mhpx->nh_total_bytes > size) {
237442ed7838SReza Sabdar if ((pp = realloc(mhbuf, mhpx->nh_total_bytes))
237542ed7838SReza Sabdar == NULL) {
237642ed7838SReza Sabdar free(mhbuf);
237742ed7838SReza Sabdar return (-1);
237842ed7838SReza Sabdar }
237942ed7838SReza Sabdar mhbuf = pp;
238042ed7838SReza Sabdar }
238142ed7838SReza Sabdar size = mhpx->nh_total_bytes;
238242ed7838SReza Sabdar }
238342ed7838SReza Sabdar
23842654012fSReza Sabdar (void) memcpy(pp, (char *)mhp, (actual_size < size) ?
23852654012fSReza Sabdar actual_size : size);
23862654012fSReza Sabdar pp += (actual_size < size) ? actual_size : size;
23872654012fSReza Sabdar
23882654012fSReza Sabdar sz = actual_size;
23892654012fSReza Sabdar while (sz < size &&
23902654012fSReza Sabdar ((tp = get_read_buffer(size - sz, &rv, &lsize,
23912654012fSReza Sabdar lcmd))) != NULL) {
239242ed7838SReza Sabdar (void) memcpy(pp, tp, lsize);
23932654012fSReza Sabdar sz += lsize;
23942654012fSReza Sabdar pp += lsize;
23952654012fSReza Sabdar }
23962654012fSReza Sabdar if (sz > size) {
23972654012fSReza Sabdar tlm_unget_read_buffer(lcmd->tc_buffers, sz - size);
23982654012fSReza Sabdar }
239942ed7838SReza Sabdar
24002654012fSReza Sabdar /* LINTED improper alignment */
24012654012fSReza Sabdar mhp = (ndmp_metadata_header_t *)mhbuf;
24022654012fSReza Sabdar
240342ed7838SReza Sabdar nvl = NULL;
240442ed7838SReza Sabdar if (strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
240542ed7838SReza Sabdar sizeof (mhp->nh_magic)) == 0) {
240642ed7838SReza Sabdar /* New metadata format */
240742ed7838SReza Sabdar /* LINTED improper alignment */
240842ed7838SReza Sabdar mhpx = (ndmp_metadata_header_ext_t *)mhbuf;
240942ed7838SReza Sabdar
241042ed7838SReza Sabdar if (mhpx->nh_major > META_HDR_MAJOR_VERSION) {
241142ed7838SReza Sabdar /* Major header mismatch */
241242ed7838SReza Sabdar NDMP_LOG(LOG_ERR, "metadata header mismatch",
241342ed7838SReza Sabdar "M%d != M%d", mhpx->nh_major,
241442ed7838SReza Sabdar META_HDR_MAJOR_VERSION);
241542ed7838SReza Sabdar free(mhbuf);
241642ed7838SReza Sabdar return (-1);
241742ed7838SReza Sabdar }
241842ed7838SReza Sabdar if (mhpx->nh_major == META_HDR_MAJOR_VERSION &&
241942ed7838SReza Sabdar mhpx->nh_minor > META_HDR_MINOR_VERSION) {
242042ed7838SReza Sabdar /* Minor header mismatch */
242142ed7838SReza Sabdar NDMP_LOG(LOG_ERR, "Warning:"
242242ed7838SReza Sabdar "metadata header mismatch m%d != m%d",
242342ed7838SReza Sabdar mhpx->nh_minor,
242442ed7838SReza Sabdar META_HDR_MINOR_VERSION);
242542ed7838SReza Sabdar continue;
242642ed7838SReza Sabdar }
24272654012fSReza Sabdar
242842ed7838SReza Sabdar nctx->nc_plversion = mhpx->nh_plversion;
242942ed7838SReza Sabdar (void) strlcpy(plname, mhpx->nh_plname,
243042ed7838SReza Sabdar sizeof (plname));
24312654012fSReza Sabdar
243242ed7838SReza Sabdar if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
24332654012fSReza Sabdar goto nvlist_err;
243442ed7838SReza Sabdar
243542ed7838SReza Sabdar mppx = &mhpx->nh_property[0];
243642ed7838SReza Sabdar for (i = 0; i < mhpx->nh_count && mppx; i++, mppx++) {
243742ed7838SReza Sabdar if (!*mppx->mp_name)
243842ed7838SReza Sabdar continue;
243942ed7838SReza Sabdar valp = NULL;
244042ed7838SReza Sabdar if (nvlist_alloc(&valp,
244142ed7838SReza Sabdar NV_UNIQUE_NAME, 0) != 0 ||
244242ed7838SReza Sabdar nvlist_add_string(valp, "value",
244342ed7838SReza Sabdar mppx->mp_value) != 0 ||
244442ed7838SReza Sabdar nvlist_add_string(valp, "source",
244542ed7838SReza Sabdar mppx->mp_source) != 0 ||
244642ed7838SReza Sabdar nvlist_add_nvlist(nvl, mppx->mp_name,
244742ed7838SReza Sabdar valp) != 0) {
244842ed7838SReza Sabdar nvlist_free(valp);
244942ed7838SReza Sabdar goto nvlist_err;
245042ed7838SReza Sabdar }
245142ed7838SReza Sabdar nvlist_free(valp);
245242ed7838SReza Sabdar }
245342ed7838SReza Sabdar } else {
245442ed7838SReza Sabdar nctx->nc_plversion = mhp->nh_plversion;
245542ed7838SReza Sabdar (void) strlcpy(plname, mhp->nh_plname,
245642ed7838SReza Sabdar sizeof (plname));
245742ed7838SReza Sabdar
245842ed7838SReza Sabdar if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
245942ed7838SReza Sabdar goto nvlist_err;
246042ed7838SReza Sabdar
246142ed7838SReza Sabdar mpp = &mhp->nh_property[0];
246242ed7838SReza Sabdar for (i = 0; i < mhp->nh_count && mpp; i++, mpp++) {
246342ed7838SReza Sabdar if (!*mpp->mp_name)
246442ed7838SReza Sabdar continue;
246542ed7838SReza Sabdar valp = NULL;
246642ed7838SReza Sabdar if (nvlist_alloc(&valp,
246742ed7838SReza Sabdar NV_UNIQUE_NAME, 0) != 0 ||
246842ed7838SReza Sabdar nvlist_add_string(valp, "value",
246942ed7838SReza Sabdar mpp->mp_value) != 0 ||
247042ed7838SReza Sabdar nvlist_add_string(valp, "source",
247142ed7838SReza Sabdar mpp->mp_source) != 0 ||
247242ed7838SReza Sabdar nvlist_add_nvlist(nvl, mpp->mp_name,
247342ed7838SReza Sabdar valp) != 0) {
247442ed7838SReza Sabdar nvlist_free(valp);
247542ed7838SReza Sabdar goto nvlist_err;
247642ed7838SReza Sabdar }
247742ed7838SReza Sabdar nvlist_free(valp);
247842ed7838SReza Sabdar }
24792654012fSReza Sabdar }
24802654012fSReza Sabdar
24812654012fSReza Sabdar if (np_restore_property(nvl, ptr) != 0)
24822654012fSReza Sabdar goto nvlist_err;
24832654012fSReza Sabdar
248442ed7838SReza Sabdar while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL &&
248542ed7838SReza Sabdar nvpair_value_nvlist(nvp, &valp) == 0) {
248642ed7838SReza Sabdar nvlist_free(valp);
248742ed7838SReza Sabdar }
248842ed7838SReza Sabdar nvlist_free(nvl);
24892654012fSReza Sabdar }
24902654012fSReza Sabdar
249142ed7838SReza Sabdar free(mhbuf);
24922654012fSReza Sabdar return (0);
24932654012fSReza Sabdar
24942654012fSReza Sabdar nvlist_err:
24952654012fSReza Sabdar free(mhbuf);
249642ed7838SReza Sabdar
249742ed7838SReza Sabdar while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL &&
249842ed7838SReza Sabdar nvpair_value_nvlist(nvp, &valp) == 0) {
249942ed7838SReza Sabdar nvlist_free(valp);
25002654012fSReza Sabdar }
250142ed7838SReza Sabdar nvlist_free(nvl);
25022654012fSReza Sabdar return (-1);
25032654012fSReza Sabdar }
25042654012fSReza Sabdar
25052654012fSReza Sabdar /*
25062654012fSReza Sabdar * Returns the version number of the plugin which created the metadata
25072654012fSReza Sabdar */
25082654012fSReza Sabdar uint_t
ndmp_context_get_version(ndmp_context_t * nctx)25092654012fSReza Sabdar ndmp_context_get_version(ndmp_context_t *nctx)
25102654012fSReza Sabdar {
25112654012fSReza Sabdar tlm_commands_t *cmds;
25122654012fSReza Sabdar ndmp_metadata_header_t *mhp;
25132654012fSReza Sabdar tlm_cmd_t *lcmd;
25142654012fSReza Sabdar int actual_size;
25152654012fSReza Sabdar int rv;
25162654012fSReza Sabdar int size;
25172654012fSReza Sabdar int align = RECORDSIZE - 1;
25182654012fSReza Sabdar
25192654012fSReza Sabdar if (nctx == NULL || (cmds = (tlm_commands_t *)nctx->nc_cmds) == NULL)
25202654012fSReza Sabdar return (0);
25212654012fSReza Sabdar
25222654012fSReza Sabdar if ((lcmd = cmds->tcs_command) == NULL ||
25232654012fSReza Sabdar lcmd->tc_buffers == NULL)
25242654012fSReza Sabdar return (0);
25252654012fSReza Sabdar
25262654012fSReza Sabdar size = sizeof (ndmp_metadata_header_t);
25272654012fSReza Sabdar size += align;
25282654012fSReza Sabdar size &= ~align;
25292654012fSReza Sabdar
25302654012fSReza Sabdar /* LINTED improper alignment */
25312654012fSReza Sabdar if ((mhp = (ndmp_metadata_header_t *)get_read_buffer(size, &rv,
25322654012fSReza Sabdar &actual_size, lcmd)) != NULL) {
25332654012fSReza Sabdar if (strncmp(mhp->nh_magic, ZFS_META_MAGIC,
25342654012fSReza Sabdar sizeof (mhp->nh_magic)) != 0) {
25352654012fSReza Sabdar /* No more metadata */
25362654012fSReza Sabdar tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
25372654012fSReza Sabdar return (0);
25382654012fSReza Sabdar }
25392654012fSReza Sabdar
25402654012fSReza Sabdar nctx->nc_plversion = mhp->nh_plversion;
25412654012fSReza Sabdar tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
25422654012fSReza Sabdar }
25432654012fSReza Sabdar
25442654012fSReza Sabdar return (nctx->nc_plversion);
25452654012fSReza Sabdar }
2546