1 /*
2 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
4 */
5
6 /*
7 * BSD 3 Clause License
8 *
9 * Copyright (c) 2007, The Storage Networking Industry Association.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * - Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 *
17 * - Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in
19 * the documentation and/or other materials provided with the
20 * distribution.
21 *
22 * - Neither the name of The Storage Networking Industry Association (SNIA)
23 * nor the names of its contributors may be used to endorse or promote
24 * products derived from this software without specific prior written
25 * permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
28 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
31 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39 #include <stdlib.h>
40 #include <ctype.h>
41 #include <stdio.h>
42 #include <limits.h>
43 #include <string.h>
44 #include <time.h>
45 #include <sys/types.h>
46 #include <sys/acl.h>
47 #include <sys/mkdev.h>
48 #include <utime.h>
49 #include <unistd.h>
50 #include <pthread.h>
51 #include <archives.h>
52 #include <priv.h>
53 #include <tlm.h>
54 #include <libzfs.h>
55 #include <pwd.h>
56 #include <grp.h>
57 #include <ndmpd_prop.h>
58 #include "tlm_proto.h"
59
60
61 #define PM_EXACT_OR_CHILD(m) ((m) == PM_EXACT || (m) == PM_CHILD)
62 #define ERROR_IS_FATAL(err) ((err) == ENOSPC || (err) == EDQUOT)
63
64 typedef boolean_t name_match_fp_t(char *s, char *t);
65
66 static int set_acl(char *name, tlm_acls_t *acls);
67 static int restore_file(int *fp,
68 char *real_name,
69 long size,
70 longlong_t huge_size,
71 tlm_acls_t *,
72 boolean_t want_this_file,
73 tlm_cmd_t *,
74 tlm_job_stats_t *,
75 long *);
76 static long restore_xattr_hdr(int *fp,
77 char *name,
78 char *fname,
79 long size,
80 tlm_acls_t *acls,
81 tlm_cmd_t *local_commands,
82 tlm_job_stats_t *job_stats);
83 static int get_long_name(int lib,
84 int drv,
85 long recsize,
86 char *name,
87 long *buf_spot,
88 tlm_cmd_t *local_commands);
89 static int get_humongus_file_header(int lib,
90 int drv,
91 long recsize,
92 longlong_t *size,
93 char *name,
94 tlm_cmd_t *);
95 static int create_directory(char *dir,
96 tlm_job_stats_t *);
97 static int create_hard_link(char *name,
98 char *link,
99 tlm_acls_t *,
100 tlm_job_stats_t *);
101 static int create_sym_link(char *dst,
102 char *target,
103 tlm_acls_t *,
104 tlm_job_stats_t *);
105 static int create_special(char,
106 char *name,
107 tlm_acls_t *,
108 int,
109 int,
110 tlm_job_stats_t *);
111 static long load_acl_info(int lib,
112 int drv,
113 long size,
114 tlm_acls_t *,
115 long *acl_spot,
116 tlm_cmd_t *);
117 static char *get_read_buffer(int want,
118 int *error,
119 int *actual_size,
120 tlm_cmd_t *);
121 static boolean_t wildcard_enabled(void);
122 static boolean_t is_file_wanted(char *name,
123 char **sels,
124 char **exls,
125 int flags,
126 int *mchtype,
127 int *pos);
128 static char *catnames(struct rs_name_maker *rnp,
129 char *buf,
130 int pos,
131 char *path);
132
133 static char *rs_new_name(struct rs_name_maker *rnp,
134 char *real_name,
135 int pos,
136 char *path);
137
138 static void rs_create_new_bkpath(char *bk_path,
139 char *path,
140 char *pbuf);
141
142 typedef struct stack_ent {
143 char *se_name;
144 tlm_acls_t se_acls;
145 } stack_ent_t;
146
147
148 /*
149 * dtree_push
150 */
151 int
dtree_push(cstack_t * stp,char * nmp,tlm_acls_t * acls)152 dtree_push(cstack_t *stp, char *nmp, tlm_acls_t *acls)
153 {
154 int len;
155 stack_ent_t *sp;
156
157 sp = ndmp_malloc(sizeof (stack_ent_t));
158 if (!sp || !nmp || !acls) {
159 free(sp);
160 return (-1);
161 }
162
163 len = strlen(nmp) + 1;
164 sp->se_name = ndmp_malloc(len);
165 if (!sp->se_name) {
166 free(sp);
167 return (-1);
168 }
169
170 (void) strlcpy(sp->se_name, nmp, len);
171 (void) memcpy(&sp->se_acls, acls, sizeof (*acls));
172 (void) memset(acls, 0, sizeof (tlm_acls_t));
173
174 return (cstack_push(stp, (void *)sp, sizeof (*sp)));
175 }
176
177 /*
178 * dtree_pop
179 */
180 int
dtree_pop(cstack_t * stp)181 dtree_pop(cstack_t *stp)
182 {
183 int err;
184 stack_ent_t *sp;
185
186 err = cstack_pop(stp, (void **)&sp, (void *)NULL);
187 if (err)
188 return (-1);
189
190 err = set_acl(sp->se_name, &sp->se_acls);
191
192 free(sp->se_name);
193 free(sp);
194 return (err);
195 }
196
197
198 /*
199 * dtree_peek
200 */
201 char *
dtree_peek(cstack_t * stp)202 dtree_peek(cstack_t *stp)
203 {
204 int err;
205 stack_ent_t *sp;
206
207 err = cstack_top(stp, (void **)&sp, (void *)NULL);
208 if (err)
209 return (NULL);
210
211 return (sp->se_name);
212 }
213
214 /*
215 * NBU and EBS may not send us the correct file list containing hardlinks
216 * during a DAR restore, e.g. they appear always send the first name
217 * associated with an inode, even if other link names were
218 * selected for the restore. As a workaround, we use the file name entry
219 * in sels[] (ignore the name in the tar header) as restore target.
220 */
221 static char *
rs_darhl_new_name(struct rs_name_maker * rnp,char * name,char ** sels,int * pos,char * longname)222 rs_darhl_new_name(struct rs_name_maker *rnp, char *name, char **sels, int *pos,
223 char *longname)
224 {
225 int x;
226
227 for (x = 0; sels[x] != NULL; x++) {
228 if (strcmp(sels[x], " ")) {
229 *pos = x;
230 (void) strlcpy(longname, sels[x], TLM_MAX_PATH_NAME);
231 NDMP_LOG(LOG_DEBUG,
232 "to replace hardlink name [%s], pos [%d]",
233 longname, *pos);
234
235 return (rs_new_name(rnp, name, *pos, longname));
236 }
237 }
238
239 return (NULL);
240 }
241
242
243 /*
244 * Main dir restore function for tar
245 *
246 * If this function returns non-zero return value it means that fatal error
247 * was encountered.
248 */
249 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)250 tar_getdir(tlm_commands_t *commands,
251 tlm_cmd_t *local_commands,
252 tlm_job_stats_t *job_stats,
253 struct rs_name_maker *rnp,
254 int lib,
255 int drv,
256 char **sels, /* what to get off the tape */
257 char **exls, /* what to leave behind */
258 int flags,
259 int DAR,
260 char *bk_path,
261 struct hardlink_q *hardlink_q)
262 {
263 int fp = 0; /* file being restored ... */
264 /* ...need to preserve across volume changes */
265 tlm_acls_t *acls; /* file access info */
266 char *longname;
267 boolean_t is_long_name = FALSE;
268 char *longlink;
269 char *hugename;
270 longlong_t huge_size = 0; /* size of a HUGE file */
271 long acl_spot; /* any ACL info on the next volume */
272 long file_size; /* size of file to restore */
273 long size_left = 0; /* need this after volume change */
274 int last_action = 0; /* what we are doing at EOT */
275 boolean_t multi_volume = FALSE; /* is this a multi-volume switch ? */
276 int chk_rv; /* scratch area */
277
278 int mchtype, pos;
279 /*
280 * if an exact match is found for
281 * restore and its position in the
282 * selections list
283 */
284 int nzerohdr; /* the number of empty tar headers */
285 int rv;
286 long nm_end, lnk_end;
287 char *name, *nmp;
288 cstack_t *stp;
289 char *bkpath;
290 char *parentlnk;
291 int dir_dar = 0;
292
293 /*
294 * The directory where temporary files may be created during a partial
295 * non-DAR restore of hardlinks. It is intended to be initialized by
296 * an environment variable that can be set by user.
297 *
298 * It is not initialized for now. We keep it here for future use.
299 */
300 char *tmplink_dir = NULL;
301 int dar_recovered = 0;
302 char *thname_buf;
303
304 /*
305 * startup
306 */
307
308 longname = ndmp_malloc(TLM_MAX_PATH_NAME);
309 longlink = ndmp_malloc(TLM_MAX_PATH_NAME);
310 hugename = ndmp_malloc(TLM_MAX_PATH_NAME);
311 parentlnk = ndmp_malloc(TLM_MAX_PATH_NAME);
312 thname_buf = ndmp_malloc(TLM_MAX_PATH_NAME);
313 name = ndmp_malloc(TLM_MAX_PATH_NAME);
314 acls = ndmp_malloc(sizeof (tlm_acls_t));
315 stp = cstack_new();
316 if (longname == NULL || longlink == NULL || hugename == NULL ||
317 name == NULL || acls == NULL || stp == NULL || parentlnk == NULL ||
318 thname_buf == NULL) {
319 cstack_delete(stp);
320 free(longname);
321 free(longlink);
322 free(hugename);
323 free(parentlnk);
324 free(name);
325 free(acls);
326 free(thname_buf);
327 return (-TLM_NO_SCRATCH_SPACE);
328 }
329
330 acl_spot = 0;
331 *hugename = '\0';
332 *parentlnk = '\0';
333 nm_end = 0;
334 *longname = '\0';
335 lnk_end = 0;
336 *longlink = '\0';
337 (void) memset(acls, 0, sizeof (tlm_acls_t));
338 if (IS_SET(flags, RSFLG_OVR_ALWAYS)) {
339 acls->acl_overwrite = TRUE;
340 NDMP_LOG(LOG_DEBUG, "RSFLG_OVR_ALWAYS");
341 } else if (IS_SET(flags, RSFLG_OVR_UPDATE)) {
342 acls->acl_update = TRUE;
343 NDMP_LOG(LOG_DEBUG, "RSFLG_OVR_UPDATE");
344 }
345
346 /*
347 * work
348 */
349 rv = 0;
350 nzerohdr = 0;
351 while (commands->tcs_writer != TLM_ABORT &&
352 local_commands->tc_writer != TLM_STOP && rv == 0) {
353 tlm_tar_hdr_t fake_tar_hdr;
354 char *file_name;
355 char *link_name;
356 int erc;
357 int actual_size;
358 boolean_t want_this_file;
359 int want = sizeof (tlm_tar_hdr_t);
360 tlm_tar_hdr_t *tar_hdr;
361
362 /* The inode of an LF_LINK type. */
363 unsigned long hardlink_inode = 0;
364
365 /*
366 * Indicate whether a file with the same inode has been
367 * restored.
368 */
369 int hardlink_done = 0;
370
371 /* The path of the restored hardlink file */
372 char *hardlink_target = NULL;
373 int is_hardlink = 0;
374
375 /*
376 * Whether a temporary file should be created for restoring
377 * hardlink.
378 */
379 int hardlink_tmp_file = 0;
380 char *hardlink_tmp_name = ".tmphlrsnondar";
381
382 /* used to make up hardlink_tmp_name */
383 static int hardlink_tmp_idx = 0;
384
385 if (multi_volume) {
386 NDMP_LOG(LOG_DEBUG, "multi_volume %c %d",
387 last_action, size_left);
388
389 /*
390 * the previous volume is out of data
391 * and is back in the rack, a new tape
392 * is loaded and ready to read.
393 *
394 * We need to pick up where we left off.
395 */
396 (void) memset(&fake_tar_hdr, 0, sizeof (fake_tar_hdr));
397 file_size = size_left;
398 tar_hdr = &fake_tar_hdr;
399 tar_hdr->th_linkflag = last_action;
400
401 multi_volume = FALSE;
402 last_action = 0;
403 } else {
404 tar_hdr = (tlm_tar_hdr_t *)get_read_buffer(want,
405 &erc, &actual_size, local_commands);
406
407 if (tar_hdr == NULL) {
408 rv = -1;
409 continue;
410 }
411
412 /*
413 * we can ignore read errors here because
414 * 1) they are logged by Restore Reader
415 * 2) we are not doing anything important here
416 * just looking for the next work record.
417 */
418 if (actual_size < want) {
419 /*
420 * EOF hits here
421 *
422 * wait for another buffer to come along
423 * or until the Reader thread tells us
424 * that no more tapes will be loaded ...
425 * time to stop.
426 */
427 continue;
428 }
429
430 /*
431 * check for "we are lost"
432 */
433 chk_rv = tlm_vfy_tar_checksum(tar_hdr);
434 if (chk_rv == 0) {
435 /* one of the end of tar file marks */
436 if (++nzerohdr >= 2) {
437 NDMP_LOG(LOG_DEBUG,
438 "nzerohdr %d, breaking",
439 nzerohdr);
440 /* end of tar file */
441 break;
442 }
443 NDMP_LOG(LOG_DEBUG, "nzerohdr %d, continuing",
444 nzerohdr);
445 continue;
446 } else if (chk_rv < 0) {
447 nzerohdr = 0;
448 /* skip this record */
449 continue;
450 }
451 nzerohdr = 0;
452
453 /*
454 * When files are spanned to the next tape, the
455 * information of the acls must not be over-written
456 * by the information of the LF_MULTIVOL and LF_VOLHDR
457 * header, whose information is irrelevant to the file.
458 * The information of the original header must be
459 * kept in the 'acl'.
460 */
461 if (tar_hdr->th_linkflag != LF_MULTIVOL &&
462 tar_hdr->th_linkflag != LF_VOLHDR) {
463 if (tar_hdr->th_linkflag != LF_HUMONGUS) {
464 acls->acl_attr.st_mode =
465 oct_atoi(tar_hdr->th_mode);
466 acls->acl_attr.st_size =
467 oct_atoi(tar_hdr->th_size);
468 acls->acl_attr.st_uid =
469 oct_atoi(tar_hdr->th_uid);
470 acls->acl_attr.st_gid =
471 oct_atoi(tar_hdr->th_gid);
472 acls->acl_attr.st_mtime =
473 oct_atoi(tar_hdr->th_mtime);
474 (void) strlcpy(acls->uname,
475 tar_hdr->th_uname,
476 sizeof (acls->uname));
477 (void) strlcpy(acls->gname,
478 tar_hdr->th_gname,
479 sizeof (acls->gname));
480 }
481 file_size = oct_atoi(tar_hdr->th_size);
482 acl_spot = 0;
483 last_action = tar_hdr->th_linkflag;
484 }
485 }
486
487 NDMP_LOG(LOG_DEBUG, "n [%s] f [%c] s %lld m %o u %d g %d t %d",
488 tar_hdr->th_name, tar_hdr->th_linkflag,
489 acls->acl_attr.st_size, acls->acl_attr.st_mode,
490 acls->acl_attr.st_uid, acls->acl_attr.st_gid,
491 acls->acl_attr.st_mtime);
492
493 /*
494 * If the restore is running using DAR we should check for
495 * extended attribute entries
496 */
497 if (dar_recovered &&
498 tar_hdr->th_linkflag != LF_XATTR)
499 break;
500
501 rs_create_new_bkpath(bk_path, tar_hdr->th_name, thname_buf);
502
503 switch (tar_hdr->th_linkflag) {
504 case LF_MULTIVOL:
505 multi_volume = TRUE;
506 break;
507 case LF_LINK:
508 is_hardlink = 1;
509 hardlink_inode =
510 oct_atoi(tar_hdr->th_shared.th_hlink_ino);
511
512 /*
513 * Check if we have restored a link with the same inode
514 * If the inode is 0, we have to restore it as a
515 * regular file.
516 */
517 if (hardlink_inode) {
518 hardlink_done = !hardlink_q_get(hardlink_q,
519 hardlink_inode, 0, &hardlink_target);
520 }
521
522 if (hardlink_done) {
523 NDMP_LOG(LOG_DEBUG,
524 "found hardlink, inode = %u, target = [%s]",
525 hardlink_inode,
526 hardlink_target? hardlink_target : "--");
527
528 /* create a hardlink to hardlink_target */
529 file_name = (*longname == 0) ?
530 thname_buf : longname;
531
532 if (!is_file_wanted(file_name, sels, exls,
533 flags, &mchtype, &pos)) {
534 nmp = NULL;
535 /*
536 * This means that DMA did not send us
537 * the correct fh_info for the file
538 * in restore list. We use the file
539 * name entry in sels[] (ignore the
540 * name in the tar header) as restore
541 * target.
542 */
543 if (DAR) {
544 nmp = rs_darhl_new_name(rnp,
545 name, sels, &pos,
546 file_name);
547 }
548 } else {
549 nmp = rs_new_name(rnp, name, pos,
550 file_name);
551 if (!nmp) {
552 NDMP_LOG(LOG_DEBUG,
553 "can't make name for %s",
554 longname);
555 }
556 }
557
558 if (nmp) {
559 if (hardlink_target) {
560 erc = create_hard_link(
561 hardlink_target, nmp,
562 acls, job_stats);
563 if (ERROR_IS_FATAL(erc)) {
564 rv = erc;
565 continue;
566 }
567 if (erc == 0) {
568 (void)
569 tlm_entry_restored(
570 job_stats,
571 file_name, pos);
572 NDMP_LOG(LOG_DEBUG,
573 "restored %s -> %s",
574 nmp,
575 hardlink_target);
576 }
577 } else {
578 NDMP_LOG(LOG_DEBUG,
579 "no target for hardlink %s",
580 nmp);
581 }
582
583 name[0] = 0;
584 is_long_name = FALSE;
585 }
586
587 nm_end = 0;
588 longname[0] = 0;
589 lnk_end = 0;
590 longlink[0] = 0;
591
592 break;
593 }
594 /* otherwise fall through, restore like a normal file */
595 /*FALLTHROUGH*/
596 case LF_OLDNORMAL:
597 /*
598 * check for TAR's end-of-tape method
599 * of zero filled records.
600 */
601 if (tar_hdr->th_name[0] == 0) {
602 break;
603 }
604 /*
605 * otherwise fall through,
606 * this is an old style normal file header
607 */
608 /*FALLTHROUGH*/
609 case LF_NORMAL:
610 case LF_CONTIG:
611 job_stats->js_files_so_far++;
612 if (*hugename != 0) {
613 (void) strlcpy(longname, hugename,
614 TLM_MAX_PATH_NAME);
615 } else if (*longname == 0) {
616 if (tar_hdr->th_name[0] != '/') {
617 /*
618 * check for old tar format, it
619 * does not have a leading "/"
620 */
621 longname[0] = '/';
622 longname[1] = 0;
623 (void) strlcat(longname,
624 tar_hdr->th_name,
625 TLM_MAX_PATH_NAME);
626 } else {
627 (void) strlcpy(longname,
628 thname_buf,
629 TLM_MAX_PATH_NAME);
630 }
631 }
632
633 want_this_file = is_file_wanted(longname, sels, exls,
634 flags, &mchtype, &pos);
635 if (!want_this_file) {
636 nmp = NULL;
637 /*
638 * This means that DMA did not send us valid
639 * fh_info for the file in restore list. We
640 * use the file name entry in sels[] (ignore
641 * the name in the tar header) as restore
642 * target.
643 */
644 if (DAR && (tar_hdr->th_linkflag == LF_LINK)) {
645 nmp = rs_darhl_new_name(rnp, name,
646 sels, &pos, longname);
647 if (nmp == NULL) {
648 rv = ENOMEM;
649 continue;
650 }
651
652 want_this_file = TRUE;
653 mchtype = PM_EXACT;
654 }
655 } else {
656 nmp = rs_new_name(rnp, name, pos, longname);
657 if (!nmp)
658 want_this_file = FALSE;
659 }
660
661 if (nmp)
662 (void) strlcpy(parentlnk, nmp, strlen(nmp) + 1);
663
664 /*
665 * For a hardlink, even if it's not asked to be
666 * restored, we restore it to a temporary location,
667 * in case other links to the same file need to be
668 * restored later.
669 *
670 * The temp files are created in tmplink_dir, with
671 * names like ".tmphlrsnondar*". They are cleaned up
672 * at the completion of a restore. However, if a
673 * restore were interrupted, e.g. by a system reboot,
674 * they would have to be cleaned up manually in order
675 * for the disk space to be freed.
676 *
677 * If tmplink_dir is NULL, no temperorary files are
678 * created during a restore. This may result in some
679 * hardlinks not being restored during a partial
680 * restore.
681 */
682 if (is_hardlink && !DAR && !want_this_file && !nmp) {
683 if (tmplink_dir) {
684 (void) snprintf(name, TLM_MAX_PATH_NAME,
685 "%s/%s_%d", tmplink_dir,
686 hardlink_tmp_name,
687 hardlink_tmp_idx);
688 nmp = name;
689
690 hardlink_tmp_idx++;
691 hardlink_tmp_file = 1;
692 want_this_file = TRUE;
693 NDMP_LOG(LOG_DEBUG,
694 "To restore temp hardlink file %s.",
695 nmp);
696 } else {
697 NDMP_LOG(LOG_DEBUG,
698 "No tmplink_dir specified.");
699 }
700 }
701
702 rv = restore_file(&fp, nmp, file_size,
703 huge_size, acls, want_this_file, local_commands,
704 job_stats, &size_left);
705 if (rv != 0)
706 continue;
707
708 /*
709 * In the case of non-DAR, we have to record the first
710 * link for an inode that has multiple links. That's
711 * the only link with data records actually backed up.
712 * In this way, when we run into the other links, they
713 * will be treated as links, and we won't go to look
714 * for the data records to restore. This is not a
715 * problem for DAR, where DMA tells the tape where
716 * to locate the data records.
717 */
718 if (is_hardlink && !DAR) {
719 if (hardlink_q_add(hardlink_q, hardlink_inode,
720 0, nmp, hardlink_tmp_file))
721 NDMP_LOG(LOG_DEBUG,
722 "failed to add (%u, %s) to HL q",
723 hardlink_inode, nmp);
724 }
725
726 /* remove / reverse the temporary stuff */
727 if (hardlink_tmp_file) {
728 nmp = NULL;
729 want_this_file = FALSE;
730 hardlink_tmp_file = 0;
731 }
732
733 /*
734 * Check if it is time to set the attribute
735 * of the restored directory
736 */
737 while (nmp && ((bkpath = dtree_peek(stp)) != NULL)) {
738 int erc;
739
740 if (strstr(nmp, bkpath))
741 break;
742
743 erc = dtree_pop(stp);
744 if (ERROR_IS_FATAL(erc)) {
745 rv = erc;
746 break;
747 }
748 }
749 if (rv != 0)
750 continue;
751
752 NDMP_LOG(LOG_DEBUG, "sizeleft %s %d, %lld", longname,
753 size_left, huge_size);
754
755 if (want_this_file) {
756 job_stats->js_bytes_total += file_size;
757 job_stats->js_files_total++;
758 }
759
760 huge_size -= file_size;
761 if (huge_size < 0) {
762 huge_size = 0;
763 }
764 if (size_left == 0 && huge_size == 0) {
765 if (PM_EXACT_OR_CHILD(mchtype)) {
766 (void) tlm_entry_restored(job_stats,
767 longname, pos);
768
769 /*
770 * Add an entry to hardlink_q to record
771 * this hardlink.
772 */
773 if (is_hardlink) {
774 NDMP_LOG(LOG_DEBUG,
775 "Restored hardlink file %s",
776 nmp);
777
778 if (DAR) {
779 (void) hardlink_q_add(
780 hardlink_q,
781 hardlink_inode, 0,
782 nmp, 0);
783 }
784 }
785 }
786
787 nm_end = 0;
788 longname[0] = 0;
789 lnk_end = 0;
790 longlink[0] = 0;
791 hugename[0] = 0;
792 name[0] = 0;
793 is_long_name = FALSE;
794 }
795 break;
796 case LF_XATTR:
797 file_name = (*longname == 0) ? thname_buf :
798 longname;
799
800 size_left = restore_xattr_hdr(&fp, parentlnk,
801 file_name, file_size, acls, local_commands,
802 job_stats);
803
804 break;
805 case LF_SYMLINK:
806 file_name = (*longname == 0) ? thname_buf :
807 longname;
808 link_name = (*longlink == 0) ?
809 tar_hdr->th_linkname : longlink;
810 NDMP_LOG(LOG_DEBUG, "file_name[%s]", file_name);
811 NDMP_LOG(LOG_DEBUG, "link_name[%s]", link_name);
812 if (is_file_wanted(file_name, sels, exls, flags,
813 &mchtype, &pos)) {
814 nmp = rs_new_name(rnp, name, pos, file_name);
815 if (nmp) {
816 erc = create_sym_link(nmp, link_name,
817 acls, job_stats);
818 if (ERROR_IS_FATAL(erc)) {
819 rv = erc;
820 continue;
821 }
822 if (erc == 0 &&
823 PM_EXACT_OR_CHILD(mchtype))
824 (void) tlm_entry_restored(
825 job_stats, file_name, pos);
826 name[0] = 0;
827 }
828 }
829 nm_end = 0;
830 longname[0] = 0;
831 lnk_end = 0;
832 longlink[0] = 0;
833 break;
834 case LF_DIR:
835 file_name = *longname == 0 ? thname_buf :
836 longname;
837 if (is_file_wanted(file_name, sels, exls, flags,
838 &mchtype, &pos)) {
839 dir_dar = DAR;
840 nmp = rs_new_name(rnp, name, pos, file_name);
841 if (nmp && mchtype != PM_PARENT) {
842 (void) strlcpy(parentlnk, nmp,
843 strlen(nmp));
844 erc = create_directory(nmp, job_stats);
845 if (ERROR_IS_FATAL(erc)) {
846 rv = erc;
847 continue;
848 }
849 if (erc == 0 &&
850 PM_EXACT_OR_CHILD(mchtype))
851 (void) tlm_entry_restored(
852 job_stats, file_name, pos);
853 /*
854 * Check if it is time to set
855 * the attribute of the restored
856 * directory
857 */
858 while ((bkpath = dtree_peek(stp))
859 != NULL) {
860 int rc;
861
862 if (strstr(nmp, bkpath))
863 break;
864 rc = dtree_pop(stp);
865 if (ERROR_IS_FATAL(rc)) {
866 rv = rc;
867 break;
868 }
869 }
870 if (rv != 0)
871 continue;
872
873 (void) dtree_push(stp, nmp, acls);
874 name[0] = 0;
875 }
876 } else {
877 dir_dar = 0;
878 }
879 nm_end = 0;
880 longname[0] = 0;
881 lnk_end = 0;
882 longlink[0] = 0;
883 break;
884 case LF_FIFO:
885 case LF_BLK:
886 case LF_CHR:
887 file_name = *longname == 0 ? thname_buf :
888 longname;
889 if (is_file_wanted(file_name, sels, exls, flags,
890 &mchtype, &pos)) {
891 nmp = rs_new_name(rnp, name, pos, file_name);
892 if (nmp) {
893 erc = create_special(
894 tar_hdr->th_linkflag, nmp, acls,
895 oct_atoi(tar_hdr->th_shared.
896 th_dev.th_devmajor),
897 oct_atoi(tar_hdr->th_shared.
898 th_dev.th_devminor), job_stats);
899 if (ERROR_IS_FATAL(erc)) {
900 rv = erc;
901 continue;
902 }
903 if (erc == 0 &&
904 PM_EXACT_OR_CHILD(mchtype))
905 (void) tlm_entry_restored(
906 job_stats, file_name, pos);
907 name[0] = 0;
908 }
909 }
910 nm_end = 0;
911 longname[0] = 0;
912 lnk_end = 0;
913 longlink[0] = 0;
914 break;
915 case LF_LONGLINK:
916 file_size = min(file_size,
917 TLM_MAX_PATH_NAME - lnk_end - 1);
918 file_size = max(0, file_size);
919 size_left = get_long_name(lib, drv, file_size, longlink,
920 &lnk_end, local_commands);
921
922 if (size_left != 0)
923 NDMP_LOG(LOG_DEBUG,
924 "fsize %d sleft %d lnkend %d",
925 file_size, size_left, lnk_end);
926 break;
927 case LF_LONGNAME:
928 file_size = min(file_size,
929 TLM_MAX_PATH_NAME - nm_end - 1);
930 file_size = max(0, file_size);
931 size_left = get_long_name(lib, drv, file_size, longname,
932 &nm_end, local_commands);
933
934 if (size_left != 0)
935 NDMP_LOG(LOG_DEBUG,
936 "fsize %d sleft %d nmend %d",
937 file_size, size_left, nm_end);
938 is_long_name = TRUE;
939 break;
940 case LF_ACL:
941 size_left = load_acl_info(lib, drv, file_size, acls,
942 &acl_spot, local_commands);
943 break;
944 case LF_VOLHDR:
945 break;
946 case LF_HUMONGUS:
947 (void) memset(hugename, 0, TLM_MAX_PATH_NAME);
948 (void) get_humongus_file_header(lib, drv, file_size,
949 &huge_size, hugename, local_commands);
950 break;
951 default:
952 break;
953
954 }
955
956 /*
957 * If the restore is running using DAR we should check for
958 * long file names and HUGE file sizes.
959 */
960 if (DAR && tar_hdr->th_linkflag != LF_ACL &&
961 tar_hdr->th_linkflag != LF_XATTR &&
962 !huge_size && !is_long_name && !dir_dar)
963 dar_recovered = 1;
964 }
965
966 /*
967 * tear down
968 */
969 if (rv != 0)
970 commands->tcs_reader = TLM_ABORT;
971 if (fp != 0) {
972 (void) close(fp);
973 }
974 while (dtree_pop(stp) != -1)
975 ;
976 cstack_delete(stp);
977 free(acls);
978 free(longname);
979 free(parentlnk);
980 free(longlink);
981 free(hugename);
982 free(name);
983 free(thname_buf);
984 return (rv);
985 }
986
987 /*
988 * Main file restore function for tar (should run as a thread)
989 */
990 void *
tar_getfile(void * ptr)991 tar_getfile(void *ptr)
992 {
993 tlm_backup_restore_arg_t *argp = ptr;
994 tlm_job_stats_t *job_stats;
995 char **sels; /* list of files desired */
996 char **exls; /* list of files not wanted */
997 char *dir; /* where to restore the files */
998 char job[TLM_MAX_BACKUP_JOB_NAME+1];
999 /* the restore job name */
1000 int erc; /* error return codes */
1001 int flags;
1002 struct rs_name_maker rn;
1003 tlm_commands_t *commands;
1004 tlm_cmd_t *local_commands;
1005 char *list = NULL;
1006
1007 commands = argp->ba_commands;
1008 local_commands = argp->ba_cmd;
1009
1010 flags = 0;
1011
1012 dir = ndmp_malloc(TLM_MAX_PATH_NAME);
1013 if (dir == NULL) {
1014 local_commands->tc_reader = TLM_STOP;
1015 (void) pthread_barrier_wait(&argp->ba_barrier);
1016 return ((void *)(uintptr_t)-1);
1017 }
1018
1019 (void) strlcpy(job, argp->ba_job, TLM_MAX_BACKUP_JOB_NAME+1);
1020 (void) strlcpy(dir, argp->ba_dir, TLM_MAX_PATH_NAME);
1021
1022 flags |= RSFLG_OVR_ALWAYS;
1023 flags |= RSFLG_IGNORE_CASE;
1024
1025 /*
1026 * do not test for "dir" having no string, since that
1027 * is a legal condition. Restore to origional location
1028 * will not have a restore directory.
1029 */
1030 if (*job == '\0') {
1031 NDMP_LOG(LOG_DEBUG, "No job defined");
1032 local_commands->tc_reader = TLM_STOP;
1033 free(dir);
1034 (void) pthread_barrier_wait(&argp->ba_barrier);
1035 return ((void *)(uintptr_t)-1);
1036 }
1037
1038 sels = argp->ba_sels;
1039 if (sels == NULL) {
1040 local_commands->tc_reader = TLM_STOP;
1041 free(dir);
1042 (void) pthread_barrier_wait(&argp->ba_barrier);
1043 return ((void *)(uintptr_t)-1);
1044 }
1045 exls = &list;
1046
1047 tlm_log_list("selections", sels);
1048 tlm_log_list("exclusions", exls);
1049
1050 if (wildcard_enabled())
1051 flags |= RSFLG_MATCH_WCARD;
1052
1053 local_commands->tc_ref++;
1054 commands->tcs_writer_count++;
1055
1056 /*
1057 * let the launcher continue
1058 */
1059 (void) pthread_barrier_wait(&argp->ba_barrier);
1060
1061 job_stats = tlm_ref_job_stats(job);
1062
1063 rn.rn_fp = catnames;
1064 rn.rn_nlp = dir;
1065
1066 /*
1067 * work
1068 */
1069 NDMP_LOG(LOG_DEBUG, "start restore job %s", job);
1070 erc = tar_getdir(commands, local_commands, job_stats, &rn, 1, 1,
1071 sels, exls, flags, 0, NULL, NULL);
1072
1073 /*
1074 * teardown
1075 */
1076 NDMP_LOG(LOG_DEBUG, "end restore job %s", job);
1077 tlm_un_ref_job_stats(job);
1078 tlm_release_list(sels);
1079 tlm_release_list(exls);
1080
1081 commands->tcs_writer_count--;
1082 local_commands->tc_reader = TLM_STOP;
1083 tlm_release_reader_writer_ipc(local_commands);
1084 free(dir);
1085 return ((void *)(uintptr_t)erc);
1086 }
1087
1088 /*
1089 * Creates the directories all the way down to the
1090 * end if they dont exist
1091 */
1092 int
make_dirs(char * dir)1093 make_dirs(char *dir)
1094 {
1095 char c;
1096 char *cp, *end;
1097 struct stat64 st;
1098
1099 cp = dir;
1100 cp += strspn(cp, "/");
1101 end = dir + strlen(dir);
1102 do {
1103 if (*cp == '\0' || *cp == '/') {
1104 c = *cp;
1105 *cp = '\0';
1106 if (lstat64(dir, &st) < 0)
1107 if (mkdir(dir, 0777) < 0) {
1108 NDMP_LOG(LOG_DEBUG, "Error %d"
1109 " creating directory %s",
1110 errno, dir);
1111 *cp = c;
1112 return (errno);
1113 }
1114
1115 *cp = c;
1116 }
1117 } while (++cp <= end);
1118
1119 return (0);
1120 }
1121
1122 /*
1123 * Creates the directories leading to the given path
1124 */
1125 int
mkbasedir(char * path)1126 mkbasedir(char *path)
1127 {
1128 int rv;
1129 char *cp;
1130 struct stat64 st;
1131
1132 if (!path || !*path) {
1133 NDMP_LOG(LOG_DEBUG, "Invalid argument");
1134 return (-1);
1135 }
1136
1137 cp = strrchr(path, '/');
1138 if (cp)
1139 *cp = '\0';
1140 rv = lstat64(path, &st);
1141 if (rv < 0) /* need new directories */
1142 rv = make_dirs(path);
1143 if (cp)
1144 *cp = '/';
1145
1146 return (rv);
1147 }
1148
1149
1150 /*
1151 * read the file off the tape back onto disk
1152 *
1153 * If the function returns a non-zero return code, it means that fatal error
1154 * was encountered and restore should terminate immediately.
1155 */
1156 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)1157 restore_file(int *fp,
1158 char *real_name,
1159 long size,
1160 longlong_t huge_size,
1161 tlm_acls_t *acls,
1162 boolean_t want_this_file,
1163 tlm_cmd_t *local_commands,
1164 tlm_job_stats_t *job_stats,
1165 long *size_left)
1166 {
1167 struct stat64 attr;
1168 int ret, rv;
1169
1170 *size_left = 0;
1171 if (!real_name) {
1172 if (want_this_file) {
1173 NDMP_LOG(LOG_DEBUG, "No file name but wanted!");
1174 want_this_file = FALSE;
1175 }
1176 } else
1177 NDMP_LOG(LOG_DEBUG, "new file[%s]", real_name);
1178
1179 /*
1180 * OK, some FM is creeping in here ...
1181 * int *fp is used to keep the
1182 * backup file channel open through
1183 * the interruption of EOT and
1184 * processing the headers of the
1185 * next tape. So, if *fp is zero
1186 * then no file is open yet and all
1187 * is normal. If *fp has a number
1188 * then we are returning after an
1189 * EOT break.
1190 *
1191 * *fp is now also open for HUGE files
1192 * that are put back in sections.
1193 */
1194
1195 if (*fp == 0 && want_this_file) {
1196
1197 ret = mkbasedir(real_name);
1198 if (ret != 0) {
1199 job_stats->js_errors++;
1200 if (ERROR_IS_FATAL(ret))
1201 return (ret);
1202 }
1203
1204 ret = stat64(real_name, (struct stat64 *)&attr);
1205 if (ret < 0) {
1206 /*EMPTY*/
1207 /* new file */
1208 } else if (acls->acl_overwrite) {
1209 /*EMPTY*/
1210 /* take this file no matter what */
1211 } else if (acls->acl_update) {
1212 if (attr.st_mtime < acls->acl_attr.st_mtime) {
1213 /*EMPTY*/
1214 /* tape is newer */
1215 } else {
1216 /* disk file is newer */
1217 want_this_file = FALSE;
1218 }
1219 } else {
1220 /*
1221 * no overwrite, no update,
1222 * do not ever replace old files.
1223 */
1224 want_this_file = TRUE;
1225 }
1226 if (want_this_file) {
1227
1228 *fp = open(real_name, O_CREAT | O_TRUNC | O_WRONLY,
1229 S_IRUSR | S_IWUSR);
1230 if (*fp == -1) {
1231 NDMP_LOG(LOG_ERR,
1232 "Could not open %s for restore: %d",
1233 real_name, errno);
1234 job_stats->js_errors++;
1235 want_this_file = FALSE;
1236 /*
1237 * In case of non-fatal error we cannot return
1238 * here, because the file is still on the tape
1239 * and must be skipped over.
1240 */
1241 if (ERROR_IS_FATAL(errno))
1242 return (errno);
1243 }
1244 }
1245 (void) strlcpy(local_commands->tc_file_name, real_name,
1246 TLM_MAX_PATH_NAME);
1247 }
1248
1249 /*
1250 * this is the size left in the next segment
1251 */
1252 huge_size -= size;
1253
1254 /*
1255 * work
1256 */
1257 rv = 0;
1258 while (size > 0 && local_commands->tc_writer == TLM_RESTORE_RUN) {
1259 int actual_size;
1260 int error;
1261 char *rec;
1262 int write_size;
1263
1264 /*
1265 * Use bytes_in_file field to tell reader the amount
1266 * of data still need to be read for this file.
1267 */
1268 job_stats->js_bytes_in_file = size;
1269
1270 error = 0;
1271 rec = get_read_buffer(size, &error, &actual_size,
1272 local_commands);
1273 if (actual_size <= 0) {
1274 NDMP_LOG(LOG_DEBUG,
1275 "RESTORE WRITER> error %d, actual_size %d",
1276 error, actual_size);
1277
1278 /* no more data for this file for now */
1279 job_stats->js_bytes_in_file = 0;
1280 *size_left = size;
1281 return (0);
1282 } else if (error) {
1283 NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
1284 error, local_commands->tc_file_name);
1285 break;
1286 }
1287
1288 write_size = min(size, actual_size);
1289 if (want_this_file) {
1290 ret = write(*fp, rec, write_size);
1291 if (ret < 0) {
1292 NDMP_LOG(LOG_ERR,
1293 "Write error %d for file [%s]", errno,
1294 local_commands->tc_file_name);
1295 job_stats->js_errors++;
1296 if (ERROR_IS_FATAL(errno)) {
1297 rv = errno;
1298 break;
1299 }
1300 } else {
1301 NS_ADD(wdisk, ret);
1302 NS_INC(wfile);
1303 if (ret < write_size) {
1304 NDMP_LOG(LOG_ERR,
1305 "Partial write for file [%s]",
1306 local_commands->tc_file_name);
1307 }
1308 }
1309 }
1310 size -= write_size;
1311 }
1312
1313 /* no more data for this file for now */
1314 job_stats->js_bytes_in_file = 0;
1315
1316 /*
1317 * teardown
1318 */
1319 if (*fp != 0 && huge_size <= 0) {
1320 (void) close(*fp);
1321 *fp = 0;
1322 if (rv == 0) {
1323 ret = set_acl(real_name, acls);
1324 if (ERROR_IS_FATAL(ret))
1325 return (ret);
1326 }
1327 }
1328 return (rv);
1329 }
1330
1331 /*
1332 * Set the extended attributes file attribute
1333 */
1334 static void
set_xattr(int fd,struct stat64 st)1335 set_xattr(int fd, struct stat64 st)
1336 {
1337 struct timeval times[2];
1338
1339 times[0].tv_sec = st.st_atime;
1340 times[1].tv_sec = st.st_mtime;
1341
1342 (void) fchmod(fd, st.st_mode);
1343 (void) fchown(fd, st.st_uid, st.st_gid);
1344 (void) futimesat(fd, ".", times);
1345 }
1346
1347 /*
1348 * Read the system attribute file in a single buffer to write
1349 * it as a single write. A partial write to system attribute would
1350 * cause an EINVAL on write.
1351 */
1352 static char *
get_read_one_buf(char * rec,int actual_size,int size,int * error,tlm_cmd_t * lc)1353 get_read_one_buf(char *rec, int actual_size, int size, int *error,
1354 tlm_cmd_t *lc)
1355 {
1356 char *buf, *p;
1357 int read_size;
1358 int len;
1359
1360 if (actual_size > size)
1361 return (rec);
1362
1363 buf = ndmp_malloc(size);
1364 if (buf == NULL) {
1365 *error = ENOMEM;
1366 return (NULL);
1367 }
1368 (void) memcpy(buf, rec, actual_size);
1369 rec = buf;
1370 buf += actual_size;
1371 while (actual_size < size) {
1372 p = get_read_buffer(size - actual_size, error, &read_size, lc);
1373 len = min(size - actual_size, read_size);
1374 (void) memcpy(buf, p, len);
1375 actual_size += len;
1376 buf += len;
1377 }
1378 return (rec);
1379 }
1380
1381
1382 /*
1383 * read the extended attribute header and write
1384 * it to the file
1385 */
1386 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)1387 restore_xattr_hdr(int *fp,
1388 char *name,
1389 char *fname,
1390 long size,
1391 tlm_acls_t *acls,
1392 tlm_cmd_t *local_commands,
1393 tlm_job_stats_t *job_stats)
1394 {
1395 tlm_tar_hdr_t *tar_hdr;
1396 struct xattr_hdr *xhdr;
1397 struct xattr_buf *xbuf;
1398 int namelen;
1399 char *xattrname;
1400 int actual_size;
1401 int error;
1402
1403 if (!fname) {
1404 NDMP_LOG(LOG_DEBUG, "No file name but wanted!");
1405 } else {
1406 NDMP_LOG(LOG_DEBUG, "new xattr[%s]", fname);
1407 }
1408
1409 error = 0;
1410 xhdr = (struct xattr_hdr *)get_read_buffer(size, &error,
1411 &actual_size, local_commands);
1412 if (xhdr == NULL || error != 0) {
1413 NDMP_LOG(LOG_DEBUG,
1414 "Could not read xattr [%s:%s] for restore. ",
1415 name, fname);
1416 job_stats->js_errors++;
1417 return (0);
1418 }
1419
1420 /* Check extended attribute header */
1421 if (strcmp(xhdr->h_version, XATTR_ARCH_VERS) != 0) {
1422 NDMP_LOG(LOG_DEBUG,
1423 "Unrecognized header format [%s]", xhdr->h_version);
1424 return (0);
1425 }
1426 xbuf = (struct xattr_buf *)(((char *)xhdr) + sizeof (struct xattr_hdr));
1427
1428 (void) sscanf(xbuf->h_namesz, "%7d", &namelen);
1429 xattrname = xbuf->h_names + strlen(xbuf->h_names) + 1;
1430
1431 if (*fp == 0) {
1432 int fd;
1433
1434 fd = attropen(name, xattrname, O_CREAT | O_RDWR, 0755);
1435 if (fd == -1) {
1436 NDMP_LOG(LOG_DEBUG,
1437 "Could not open xattr [%s:%s] for restore err=%d.",
1438 name, xattrname, errno);
1439 job_stats->js_errors++;
1440 return (0);
1441 }
1442 (void) strlcpy(local_commands->tc_file_name, xattrname,
1443 TLM_MAX_PATH_NAME);
1444 *fp = fd;
1445 }
1446
1447 /* Get the actual extended attribute file */
1448 tar_hdr = (tlm_tar_hdr_t *)get_read_buffer(sizeof (*tar_hdr),
1449 &error, &actual_size, local_commands);
1450 if (tar_hdr == NULL || error != 0) {
1451 NDMP_LOG(LOG_DEBUG,
1452 "Could not read xattr data [%s:%s] for restore. ",
1453 fname, xattrname);
1454 job_stats->js_errors++;
1455 return (0);
1456 }
1457 acls->acl_attr.st_mode = oct_atoi(tar_hdr->th_mode);
1458 acls->acl_attr.st_size = oct_atoi(tar_hdr->th_size);
1459 acls->acl_attr.st_uid = oct_atoi(tar_hdr->th_uid);
1460 acls->acl_attr.st_gid = oct_atoi(tar_hdr->th_gid);
1461 acls->acl_attr.st_mtime = oct_atoi(tar_hdr->th_mtime);
1462
1463 NDMP_LOG(LOG_DEBUG, "xattr_hdr: %s size %d mode %06o uid %d gid %d",
1464 xattrname, acls->acl_attr.st_size, acls->acl_attr.st_mode,
1465 acls->acl_attr.st_uid, acls->acl_attr.st_gid);
1466
1467 size = acls->acl_attr.st_size;
1468 while (size > 0 && local_commands->tc_writer == TLM_RESTORE_RUN) {
1469 char *rec;
1470 int write_size;
1471 int sysattr_write = 0;
1472
1473 error = 0;
1474 rec = get_read_buffer(size, &error, &actual_size,
1475 local_commands);
1476
1477 if ((actual_size < size) && sysattr_rw(xattrname)) {
1478 rec = get_read_one_buf(rec, actual_size, size, &error,
1479 local_commands);
1480 if (rec == NULL) {
1481 NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
1482 error, xattrname);
1483 return (size);
1484 }
1485 actual_size = size;
1486 sysattr_write = 1;
1487 }
1488 if (actual_size <= 0) {
1489 NDMP_LOG(LOG_DEBUG,
1490 "RESTORE WRITER> error %d, actual_size %d",
1491 error, actual_size);
1492
1493 return (size);
1494 } else if (error) {
1495 NDMP_LOG(LOG_DEBUG, "Error %d in file [%s]",
1496 error, local_commands->tc_file_name);
1497 break;
1498 } else {
1499 write_size = min(size, actual_size);
1500 if ((write_size = write(*fp, rec, write_size)) < 0) {
1501 if (sysattr_write)
1502 free(rec);
1503
1504 break;
1505 }
1506
1507 NS_ADD(wdisk, write_size);
1508 NS_INC(wfile);
1509 size -= write_size;
1510 }
1511 if (sysattr_write)
1512 free(rec);
1513 }
1514
1515 if (*fp != 0) {
1516 set_xattr(*fp, acls->acl_attr);
1517 (void) close(*fp);
1518 *fp = 0;
1519 }
1520 return (0);
1521 }
1522
1523 /*
1524 * Match the name with the list
1525 */
1526 static int
exact_find(char * name,char ** list)1527 exact_find(char *name, char **list)
1528 {
1529 boolean_t found;
1530 int i;
1531 char *cp;
1532
1533 found = FALSE;
1534 for (i = 0; *list != NULL; list++, i++) {
1535 cp = *list + strspn(*list, "/");
1536 if (match(cp, name)) {
1537 found = TRUE;
1538 NDMP_LOG(LOG_DEBUG, "exact_find> found[%s]", cp);
1539 break;
1540 }
1541 }
1542
1543 return (found);
1544 }
1545
1546 /*
1547 * On error, return FALSE and prevent restoring(probably) unwanted data.
1548 */
1549 static int
is_parent(char * parent,char * child,int flags)1550 is_parent(char *parent, char *child, int flags)
1551 {
1552 char tmp[TLM_MAX_PATH_NAME];
1553 boolean_t rv;
1554
1555 if (IS_SET(flags, RSFLG_MATCH_WCARD)) {
1556 if (!tlm_cat_path(tmp, parent, "*")) {
1557 NDMP_LOG(LOG_DEBUG,
1558 "is_parent> path too long [%s]", parent);
1559 rv = FALSE;
1560 } else
1561 rv = (match(tmp, child) != 0) ? TRUE : FALSE;
1562 } else {
1563 if (!tlm_cat_path(tmp, parent, "/")) {
1564 NDMP_LOG(LOG_DEBUG,
1565 "is_parent> path too long [%s]", parent);
1566 rv = FALSE;
1567 } else
1568 rv = (strncmp(tmp, child, strlen(tmp)) == 0) ?
1569 TRUE : FALSE;
1570 }
1571
1572 return (rv);
1573 }
1574
1575 /*
1576 * Used to match the filename inside the list
1577 */
1578 static boolean_t
strexactcmp(char * s,char * t)1579 strexactcmp(char *s, char *t)
1580 {
1581 return ((strcmp(s, t) == 0) ? TRUE : FALSE);
1582 }
1583
1584 /*
1585 * Check if the file is needed to be restored
1586 */
1587 static boolean_t
is_file_wanted(char * name,char ** sels,char ** exls,int flags,int * mchtype,int * pos)1588 is_file_wanted(char *name,
1589 char **sels,
1590 char **exls,
1591 int flags,
1592 int *mchtype,
1593 int *pos)
1594 {
1595 char *p_sel;
1596 char *uc_name, *retry, *namep;
1597 boolean_t found;
1598 int i;
1599 name_match_fp_t *cmp_fp;
1600
1601 if (name == NULL || sels == NULL || exls == NULL)
1602 return (FALSE);
1603
1604 found = FALSE;
1605 if (mchtype != NULL)
1606 *mchtype = PM_NONE;
1607 if (pos != NULL)
1608 *pos = 0;
1609
1610 /*
1611 * For empty selection, restore everything
1612 */
1613 if (*sels == NULL || **sels == '\0') {
1614 NDMP_LOG(LOG_DEBUG, "is_file_wanted: Restore all");
1615 return (TRUE);
1616 }
1617
1618 retry = ndmp_malloc(TLM_MAX_PATH_NAME);
1619 if (retry == NULL)
1620 return (FALSE);
1621
1622 if (IS_SET(flags, RSFLG_MATCH_WCARD))
1623 cmp_fp = match;
1624 else
1625 cmp_fp = strexactcmp;
1626
1627 namep = name + strspn(name, "/");
1628
1629 if (IS_SET(flags, RSFLG_IGNORE_CASE)) {
1630 uc_name = ndmp_malloc(TLM_MAX_PATH_NAME);
1631 if (uc_name == NULL) {
1632 free(retry);
1633 return (FALSE);
1634 }
1635 (void) strlcpy(uc_name, namep, TLM_MAX_PATH_NAME);
1636 (void) strupr(uc_name);
1637 namep = uc_name;
1638 }
1639 NDMP_LOG(LOG_DEBUG, "is_file_wanted> flg: 0x%x name: [%s]",
1640 flags, name);
1641
1642 for (i = 0; *sels != NULL; sels++, i++) {
1643 p_sel = *sels + strspn(*sels, "/");
1644
1645 /*
1646 * Try exact match.
1647 */
1648 if ((*cmp_fp)(p_sel, namep)) {
1649 NDMP_LOG(LOG_DEBUG, "match1> pos: %d [%s][%s]",
1650 i, p_sel, name);
1651 found = TRUE;
1652 if (mchtype != NULL)
1653 *mchtype = PM_EXACT;
1654 break;
1655 }
1656 /*
1657 * Try "entry/" and the current selection. The
1658 * current selection may be something like "<something>/".
1659 */
1660 (void) tlm_cat_path(retry, namep, "/");
1661 if ((*cmp_fp)(p_sel, retry)) {
1662 NDMP_LOG(LOG_DEBUG, "match2> pos %d [%s][%s]",
1663 i, p_sel, name);
1664 found = TRUE;
1665 if (mchtype != NULL)
1666 *mchtype = PM_EXACT;
1667 break;
1668 }
1669 /*
1670 * If the following check returns true it means that the
1671 * 'name' is an entry below the 'p_sel' hierarchy.
1672 */
1673 if (is_parent(p_sel, namep, flags)) {
1674 NDMP_LOG(LOG_DEBUG, "parent1> pos %d [%s][%s]",
1675 i, p_sel, name);
1676 found = TRUE;
1677 if (mchtype != NULL)
1678 *mchtype = PM_CHILD;
1679 break;
1680 }
1681 /*
1682 * There is a special case for parent directories of a
1683 * selection. If 'p_sel' is something like "*d1", the
1684 * middle directories of the final entry can't be determined
1685 * until the final entry matches with 'p_sel'. At that
1686 * time the middle directories of the entry have been passed
1687 * and they can't be restored.
1688 */
1689 if (is_parent(namep, p_sel, flags)) {
1690 NDMP_LOG(LOG_DEBUG, "parent2> pos %d [%s][%s]",
1691 i, p_sel, name);
1692 found = TRUE;
1693 if (mchtype != NULL)
1694 *mchtype = PM_PARENT;
1695 break;
1696 }
1697 }
1698
1699 /* Check for exclusions. */
1700 if (found && exact_find(namep, exls)) {
1701 if (mchtype != NULL)
1702 *mchtype = PM_NONE;
1703 found = FALSE;
1704 }
1705 if (found && pos != NULL)
1706 *pos = i;
1707
1708 if (IS_SET(flags, RSFLG_IGNORE_CASE))
1709 free(uc_name);
1710 free(retry);
1711 return (found);
1712 }
1713
1714 /*
1715 * Read the specified amount data into the buffer. Detects EOT or EOF
1716 * during read.
1717 *
1718 * Returns the number of bytes actually read. On error returns -1.
1719 */
1720 static int
input_mem(int l,int d,tlm_cmd_t * lcmds,char * mem,int len)1721 input_mem(int l,
1722 int d,
1723 tlm_cmd_t *lcmds,
1724 char *mem,
1725 int len)
1726 {
1727 int err;
1728 int toread, actual_size, rec_size;
1729 char *rec;
1730
1731 if (l <= 0 || d <= 0 || !lcmds || !mem) {
1732 NDMP_LOG(LOG_DEBUG, "Invalid argument");
1733 return (-1);
1734 }
1735
1736 toread = len;
1737 while (toread > 0) {
1738 rec = get_read_buffer(toread, &err, &actual_size, lcmds);
1739 if (actual_size <= 0) {
1740 NDMP_LOG(LOG_DEBUG, "err %d act_size %d detected",
1741 err, actual_size);
1742 break;
1743 } else if (err) {
1744 NDMP_LOG(LOG_DEBUG, "error %d reading data", err);
1745 return (-1);
1746 }
1747 rec_size = min(actual_size, toread);
1748 (void) memcpy(mem, rec, rec_size);
1749 mem += rec_size;
1750 toread -= rec_size;
1751 }
1752
1753 return (len - toread);
1754 }
1755
1756 /*
1757 * pick up the name and size of a HUGE file
1758 */
1759 static int
get_humongus_file_header(int lib,int drv,long recsize,longlong_t * size,char * name,tlm_cmd_t * local_commands)1760 get_humongus_file_header(int lib,
1761 int drv,
1762 long recsize,
1763 longlong_t *size,
1764 char *name,
1765 tlm_cmd_t *local_commands)
1766 {
1767 char *p_record, *value;
1768 int rv;
1769
1770 NDMP_LOG(LOG_DEBUG, "HUGE Record found: %d", recsize);
1771
1772 rv = 0;
1773 if (recsize == 0) {
1774 /*
1775 * The humongus_file_header was written in a
1776 * RECORDSIZE block and the header.size field of this
1777 * record was 0 before this fix. For backward compatiblity
1778 * read only one RECORDSIZE-size block if the header.size
1779 * field is 0. Otherwise the header.size field should show
1780 * the length of the data of this header.
1781 */
1782 NDMP_LOG(LOG_DEBUG, "Old HUGE record found");
1783 recsize = RECORDSIZE;
1784 }
1785
1786 if (input_mem(lib, drv, local_commands, name, recsize) != recsize) {
1787 rv = -1;
1788 *size = 0;
1789 *name = '\0';
1790 NDMP_LOG(LOG_DEBUG, "Error reading a HUGE file name");
1791 } else {
1792 NDMP_LOG(LOG_DEBUG, "HUGE [%s]", name);
1793
1794 p_record = name;
1795 value = parse(&p_record, " ");
1796 *size = atoll(value);
1797 /*
1798 * Note: Since the backed up names are not longer than
1799 * NAME_MAX and the buffer passed to us is
1800 * TLM_MAX_PATH_NAME, it should be safe to use strlcpy
1801 * without check on the buffer size.
1802 */
1803 (void) strlcpy(name, p_record, TLM_MAX_PATH_NAME);
1804 }
1805
1806 NDMP_LOG(LOG_DEBUG, "HUGE Record %lld [%s]", *size, name);
1807
1808 return (rv);
1809 }
1810
1811 /*
1812 * pick up the long name from the special tape file
1813 */
1814 static int
get_long_name(int lib,int drv,long recsize,char * name,long * buf_spot,tlm_cmd_t * local_commands)1815 get_long_name(int lib,
1816 int drv,
1817 long recsize,
1818 char *name,
1819 long *buf_spot,
1820 tlm_cmd_t *local_commands)
1821 {
1822 int nread;
1823
1824 NDMP_LOG(LOG_DEBUG, "LONGNAME Record found rs %d bs %d", recsize,
1825 *buf_spot);
1826
1827 if (*buf_spot < 0)
1828 *buf_spot = 0;
1829
1830 nread = input_mem(lib, drv, local_commands, name + *buf_spot,
1831 recsize);
1832 if (nread < 0) {
1833 nread = recsize; /* return 0 as size left */
1834 name[*buf_spot] = '\0';
1835 NDMP_LOG(LOG_ERR, "Error %d reading a long file name %s.",
1836 nread, name);
1837 } else {
1838 *buf_spot += nread;
1839 name[*buf_spot] = '\0';
1840 NDMP_LOG(LOG_DEBUG, "LONGNAME [%s]", name);
1841 }
1842
1843 return (recsize - nread);
1844 }
1845
1846 /*
1847 * create a new directory
1848 */
1849 static int
create_directory(char * dir,tlm_job_stats_t * job_stats)1850 create_directory(char *dir, tlm_job_stats_t *job_stats)
1851 {
1852 struct stat64 attr;
1853 char *p;
1854 char temp;
1855 int erc;
1856
1857 /*
1858 * Make sure all directories in this path exist, create them if
1859 * needed.
1860 */
1861 NDMP_LOG(LOG_DEBUG, "new dir[%s]", dir);
1862
1863 erc = 0;
1864 p = &dir[1];
1865 do {
1866 temp = *p;
1867 if (temp == '/' || temp == 0) {
1868 *p = 0;
1869 if (stat64(dir, &attr) < 0) {
1870 if (mkdir(dir, 0777) != 0 && errno != EEXIST) {
1871 erc = errno;
1872 job_stats->js_errors++;
1873 NDMP_LOG(LOG_DEBUG,
1874 "Could not create directory %s: %d",
1875 dir, errno);
1876 break;
1877 }
1878 }
1879 *p = temp;
1880 }
1881 p++;
1882 } while (temp != 0);
1883
1884 return (erc);
1885 }
1886
1887 /*
1888 * create a new hardlink
1889 */
1890 static int
create_hard_link(char * name_old,char * name_new,tlm_acls_t * acls,tlm_job_stats_t * job_stats)1891 create_hard_link(char *name_old, char *name_new,
1892 tlm_acls_t *acls, tlm_job_stats_t *job_stats)
1893 {
1894 int erc;
1895
1896 erc = mkbasedir(name_new);
1897 if (erc != 0)
1898 return (erc);
1899
1900 if (link(name_old, name_new) != 0)
1901 erc = errno;
1902
1903 if (erc) {
1904 /* Nothing to do if the destination already exists */
1905 if (erc == EEXIST)
1906 return (0);
1907 job_stats->js_errors++;
1908 NDMP_LOG(LOG_DEBUG, "error %d (errno %d) hardlink [%s] to [%s]",
1909 erc, errno, name_new, name_old);
1910 return (erc);
1911 }
1912 return (set_acl(name_new, acls));
1913 }
1914
1915 /*
1916 * create a new symlink
1917 */
1918 /*ARGSUSED*/
1919 static int
create_sym_link(char * dst,char * target,tlm_acls_t * acls,tlm_job_stats_t * job_stats)1920 create_sym_link(char *dst, char *target, tlm_acls_t *acls,
1921 tlm_job_stats_t *job_stats)
1922 {
1923 int erc;
1924 struct stat64 *st;
1925
1926 erc = mkbasedir(dst);
1927 if (erc != 0)
1928 return (erc);
1929
1930 st = &acls->acl_attr;
1931 if (symlink(target, dst) != 0) {
1932 erc = errno;
1933 job_stats->js_errors++;
1934 NDMP_LOG(LOG_DEBUG, "error %d softlink [%s] to [%s]",
1935 errno, dst, target);
1936 } else {
1937 st->st_mode |= S_IFLNK;
1938 erc = set_acl(dst, acls);
1939 }
1940
1941 return (erc);
1942 }
1943
1944 /*
1945 * create a new FIFO, char/block device special files
1946 */
1947 static int
create_special(char flag,char * name,tlm_acls_t * acls,int major,int minor,tlm_job_stats_t * job_stats)1948 create_special(char flag, char *name, tlm_acls_t *acls, int major, int minor,
1949 tlm_job_stats_t *job_stats)
1950 {
1951 dev_t dev;
1952 mode_t mode;
1953
1954 switch (flag) {
1955 case LF_CHR:
1956 mode = S_IFCHR;
1957 dev = makedev(major, minor);
1958 break;
1959 case LF_BLK:
1960 mode = S_IFBLK;
1961 dev = makedev(major, minor);
1962 break;
1963 case LF_FIFO:
1964 mode = S_IFIFO;
1965 dev = 0;
1966 break;
1967 default:
1968 NDMP_LOG(LOG_ERR, "unsupported flag %d", flag);
1969 return (-1);
1970 }
1971
1972 /* Remove the old entry first */
1973 if (rmdir(name) < 0) {
1974 if (errno == ENOTDIR)
1975 (void) unlink(name);
1976 }
1977 if (mknod(name, 0777 | mode, dev) != 0) {
1978 job_stats->js_errors++;
1979 NDMP_LOG(LOG_DEBUG, "error %d mknod [%s] major"
1980 " %d minor %d", errno, name, major, minor);
1981 return (errno);
1982 }
1983 return (set_acl(name, acls));
1984 }
1985
1986 /*
1987 * read in the ACLs for the next file
1988 */
1989 static long
load_acl_info(int lib,int drv,long file_size,tlm_acls_t * acls,long * acl_spot,tlm_cmd_t * local_commands)1990 load_acl_info(int lib,
1991 int drv,
1992 long file_size,
1993 tlm_acls_t *acls,
1994 long *acl_spot,
1995 tlm_cmd_t *local_commands)
1996 {
1997 char *bp;
1998 int nread;
1999
2000 /*
2001 * If the ACL is spanned on tapes, then the acl_spot should NOT be
2002 * 0 on next calls to this function to read the rest of the ACL
2003 * on next tapes.
2004 */
2005 if (*acl_spot == 0) {
2006 (void) memset(acls, 0, sizeof (tlm_acls_t));
2007 }
2008
2009 bp = ((char *)&acls->acl_info) + *acl_spot;
2010 nread = input_mem(lib, drv, local_commands, (void *)bp, file_size);
2011 if (nread < 0) {
2012 *acl_spot = 0;
2013 (void) memset(acls, 0, sizeof (tlm_acls_t));
2014 NDMP_LOG(LOG_DEBUG, "Error reading ACL data");
2015 return (0);
2016 }
2017 *acl_spot += nread;
2018 acls->acl_non_trivial = TRUE;
2019
2020 return (file_size - nread);
2021 }
2022
2023 static int
ndmp_set_eprivs_least(void)2024 ndmp_set_eprivs_least(void)
2025 {
2026 priv_set_t *priv_set;
2027
2028 if ((priv_set = priv_allocset()) == NULL) {
2029 NDMP_LOG(LOG_ERR, "Out of memory.");
2030 return (-1);
2031 }
2032
2033 priv_basicset(priv_set);
2034
2035 (void) priv_addset(priv_set, PRIV_PROC_AUDIT);
2036 (void) priv_addset(priv_set, PRIV_PROC_SETID);
2037 (void) priv_addset(priv_set, PRIV_PROC_OWNER);
2038 (void) priv_addset(priv_set, PRIV_FILE_CHOWN);
2039 (void) priv_addset(priv_set, PRIV_FILE_CHOWN_SELF);
2040 (void) priv_addset(priv_set, PRIV_FILE_DAC_READ);
2041 (void) priv_addset(priv_set, PRIV_FILE_DAC_SEARCH);
2042 (void) priv_addset(priv_set, PRIV_FILE_DAC_WRITE);
2043 (void) priv_addset(priv_set, PRIV_FILE_OWNER);
2044 (void) priv_addset(priv_set, PRIV_FILE_SETID);
2045 (void) priv_addset(priv_set, PRIV_SYS_LINKDIR);
2046 (void) priv_addset(priv_set, PRIV_SYS_DEVICES);
2047 (void) priv_addset(priv_set, PRIV_SYS_MOUNT);
2048 (void) priv_addset(priv_set, PRIV_SYS_CONFIG);
2049
2050 if (setppriv(PRIV_SET, PRIV_EFFECTIVE, priv_set) == -1) {
2051 NDMP_LOG(LOG_ERR, "Additional privileges required.");
2052 priv_freeset(priv_set);
2053 return (-1);
2054 }
2055 priv_freeset(priv_set);
2056 return (0);
2057 }
2058
2059 static int
ndmp_set_eprivs_all(void)2060 ndmp_set_eprivs_all(void)
2061 {
2062 priv_set_t *priv_set;
2063
2064 if ((priv_set = priv_allocset()) == NULL) {
2065 NDMP_LOG(LOG_ERR, "Out of memory.");
2066 return (-1);
2067 }
2068
2069 priv_fillset(priv_set);
2070
2071 if (setppriv(PRIV_SET, PRIV_EFFECTIVE, priv_set) != 0) {
2072 NDMP_LOG(LOG_ERR, "Additional privileges required.");
2073 return (-1);
2074 }
2075 priv_freeset(priv_set);
2076 return (0);
2077 }
2078
2079 /*
2080 * Set the standard attributes of the file
2081 */
2082 static int
set_attr(char * name,tlm_acls_t * acls)2083 set_attr(char *name, tlm_acls_t *acls)
2084 {
2085 struct utimbuf tbuf;
2086 boolean_t priv_all = FALSE;
2087 struct stat64 *st;
2088 uid_t uid;
2089 gid_t gid;
2090 struct passwd *pwd;
2091 struct group *grp;
2092 int erc = 0;
2093
2094
2095 if (!name || !acls)
2096 return (0);
2097
2098 st = &acls->acl_attr;
2099 NDMP_LOG(LOG_DEBUG, "set_attr: %s uid %d gid %d uname %s gname %s "
2100 "mode %o", name, st->st_uid, st->st_gid, acls->uname, acls->gname,
2101 st->st_mode);
2102
2103 uid = st->st_uid;
2104 if ((pwd = getpwnam(acls->uname)) != NULL) {
2105 NDMP_LOG(LOG_DEBUG, "set_attr: new uid %d old %d",
2106 pwd->pw_uid, uid);
2107 uid = pwd->pw_uid;
2108 }
2109
2110 gid = st->st_gid;
2111 if ((grp = getgrnam(acls->gname)) != NULL) {
2112 NDMP_LOG(LOG_DEBUG, "set_attr: new gid %d old %d",
2113 grp->gr_gid, gid);
2114 gid = grp->gr_gid;
2115 }
2116
2117 erc = lchown(name, uid, gid);
2118 if (erc != 0) {
2119 erc = errno;
2120 NDMP_LOG(LOG_ERR,
2121 "Could not set uid or/and gid for file %s.", name);
2122 }
2123
2124 if ((st->st_mode & (S_ISUID | S_ISGID)) != 0) {
2125 /*
2126 * Change effective privileges to 'all' which is required to
2127 * change setuid bit for 'root' owned files. If fails, just
2128 * send error to log file and proceed.
2129 */
2130 if (ndmp_set_eprivs_all()) {
2131 NDMP_LOG(LOG_ERR,
2132 "Could not set effective privileges to 'all'.");
2133 } else {
2134 priv_all = TRUE;
2135 }
2136 }
2137
2138 if (!S_ISLNK(st->st_mode)) {
2139 erc = chmod(name, st->st_mode);
2140 if (erc != 0) {
2141 erc = errno;
2142 NDMP_LOG(LOG_ERR, "Could not set correct file"
2143 " permission for file %s: %d", name, errno);
2144 }
2145
2146 tbuf.modtime = st->st_mtime;
2147 tbuf.actime = st->st_atime;
2148 (void) utime(name, &tbuf);
2149 }
2150
2151 if (priv_all == TRUE) {
2152 /*
2153 * Give up the 'all' privileges for effective sets and go back
2154 * to least required privileges. If fails, just send error to
2155 * log file and proceed.
2156 */
2157 if (ndmp_set_eprivs_least())
2158 NDMP_LOG(LOG_ERR,
2159 "Could not set least required privileges.");
2160 }
2161
2162 return (erc);
2163 }
2164
2165 /*
2166 * Set the ACL info for the file
2167 */
2168 static int
set_acl(char * name,tlm_acls_t * acls)2169 set_acl(char *name, tlm_acls_t *acls)
2170 {
2171 int erc;
2172 acl_t *aclp = NULL;
2173
2174 if (name)
2175 NDMP_LOG(LOG_DEBUG, "set_acl: %s", name);
2176 if (acls == NULL)
2177 return (0);
2178
2179 /* Need a place to save real modification time */
2180
2181 erc = set_attr(name, acls);
2182 if (ERROR_IS_FATAL(erc))
2183 return (erc);
2184
2185 if (!acls->acl_non_trivial) {
2186 (void) memset(acls, 0, sizeof (tlm_acls_t));
2187 NDMP_LOG(LOG_DEBUG, "set_acl: skipping trivial");
2188 return (erc);
2189 }
2190
2191 erc = acl_fromtext(acls->acl_info.attr_info, &aclp);
2192 if (erc != 0) {
2193 NDMP_LOG(LOG_DEBUG,
2194 "TAPE RESTORE> acl_fromtext errno %d", erc);
2195 }
2196 if (aclp) {
2197 erc = acl_set(name, aclp);
2198 if (erc < 0) {
2199 erc = errno;
2200 NDMP_LOG(LOG_DEBUG,
2201 "TAPE RESTORE> acl_set errno %d", errno);
2202 }
2203 acl_free(aclp);
2204 }
2205 (void) memset(acls, 0, sizeof (tlm_acls_t));
2206 return (erc);
2207 }
2208
2209 /*
2210 * a wrapper to tlm_get_read_buffer so that
2211 * we can cleanly detect ABORT commands
2212 * without involving the TLM library with
2213 * our problems.
2214 */
2215 static char *
get_read_buffer(int want,int * error,int * actual_size,tlm_cmd_t * local_commands)2216 get_read_buffer(int want,
2217 int *error,
2218 int *actual_size,
2219 tlm_cmd_t *local_commands)
2220 {
2221 while (local_commands->tc_writer == TLM_RESTORE_RUN) {
2222 char *rec;
2223 rec = tlm_get_read_buffer(want, error,
2224 local_commands->tc_buffers, actual_size);
2225 if (rec != 0) {
2226 return (rec);
2227 }
2228 }
2229
2230 /*
2231 * the job is ending, give Writer a buffer that will never be read ...
2232 * it does not matter anyhow, we are aborting.
2233 */
2234 *actual_size = RECORDSIZE;
2235 return (NULL);
2236 }
2237
2238 /*
2239 * Enable wildcard for restore options
2240 */
2241 static boolean_t
wildcard_enabled(void)2242 wildcard_enabled(void)
2243 {
2244 char *cp;
2245
2246 cp = ndmpd_get_prop_default(NDMP_RESTORE_WILDCARD_ENABLE, "n");
2247 return ((toupper(*cp) == 'Y') ? TRUE : FALSE);
2248 }
2249
2250
2251 /*
2252 * Concatenate two names
2253 */
2254 /*ARGSUSED*/
2255 static char *
catnames(struct rs_name_maker * rnp,char * buf,int pos,char * path)2256 catnames(struct rs_name_maker *rnp, char *buf, int pos, char *path)
2257 {
2258 char *rv;
2259
2260 rv = NULL;
2261 if (!buf) {
2262 NDMP_LOG(LOG_DEBUG, "buf is NULL");
2263 } else if (!path) {
2264 NDMP_LOG(LOG_DEBUG, "path is NULL");
2265 } else if (!rnp->rn_nlp) {
2266 NDMP_LOG(LOG_DEBUG, "rn_nlp is NULL [%s]", path);
2267 } else if (!tlm_cat_path(buf, rnp->rn_nlp, path)) {
2268 NDMP_LOG(LOG_DEBUG, "Path too long [%s][%s]",
2269 rnp->rn_nlp, path);
2270 } else
2271 rv = buf;
2272
2273 return (rv);
2274 }
2275
2276
2277 /*
2278 * Create a new name path for restore
2279 */
2280 static char *
rs_new_name(struct rs_name_maker * rnp,char * buf,int pos,char * path)2281 rs_new_name(struct rs_name_maker *rnp, char *buf, int pos, char *path)
2282 {
2283 if (!rnp || !rnp->rn_fp)
2284 return (NULL);
2285
2286 return (*rnp->rn_fp)(rnp, buf, pos, path);
2287 }
2288
2289 /*
2290 * Clear the extra "/" in the tar header if exists
2291 */
2292 static void
rs_create_new_bkpath(char * bk_path,char * path,char * pbuf)2293 rs_create_new_bkpath(char *bk_path, char *path, char *pbuf)
2294 {
2295 char *p, *slashp;
2296
2297 if ((p = strstr(path, bk_path)) == NULL) {
2298 (void) strlcpy(pbuf, path, TLM_MAX_PATH_NAME);
2299 return;
2300 }
2301 if (*(p += strlen(bk_path)) == '/')
2302 p++;
2303
2304 slashp = bk_path + strlen(bk_path) - 1;
2305 if (*slashp == '/')
2306 (void) snprintf(pbuf, TLM_MAX_PATH_NAME, "%s%s", bk_path, p);
2307 else
2308 (void) snprintf(pbuf, TLM_MAX_PATH_NAME, "%s/%s", bk_path, p);
2309
2310 NDMP_LOG(LOG_DEBUG, "old path [%s] new path [%s]", path, pbuf);
2311 }
2312
2313
2314 /*
2315 * Iterate over ZFS metadata stored in the backup stream and use the callback
2316 * to restore it.
2317 */
2318 int
ndmp_iter_zfs(ndmp_context_t * nctx,int (* np_restore_property)(nvlist_t *,void *),void * ptr)2319 ndmp_iter_zfs(ndmp_context_t *nctx, int (*np_restore_property)(nvlist_t *,
2320 void *), void *ptr)
2321 {
2322 tlm_commands_t *cmds;
2323 ndmp_metadata_header_t *mhp;
2324 ndmp_metadata_header_ext_t *mhpx;
2325 ndmp_metadata_property_t *mpp;
2326 ndmp_metadata_property_ext_t *mppx;
2327 tlm_cmd_t *lcmd;
2328 int actual_size;
2329 nvlist_t *nvl;
2330 nvlist_t *valp;
2331 nvpair_t *nvp = NULL;
2332 char plname[100];
2333 char *mhbuf, *pp, *tp;
2334 int rv, i;
2335 int size, lsize, sz;
2336 int align = RECORDSIZE - 1;
2337
2338 if (nctx == NULL || (cmds = (tlm_commands_t *)nctx->nc_cmds) == NULL)
2339 return (-1);
2340
2341 if ((lcmd = cmds->tcs_command) == NULL ||
2342 lcmd->tc_buffers == NULL)
2343 return (-1);
2344
2345 /* Default minimum bytes needed */
2346 size = sizeof (ndmp_metadata_header_t) +
2347 ZFS_MAX_PROPS * sizeof (ndmp_metadata_property_t);
2348 size += align;
2349 size &= ~align;
2350
2351 if ((mhbuf = malloc(size)) == NULL)
2352 return (-1);
2353
2354 nctx->nc_plname = plname;
2355
2356 /* LINTED improper alignment */
2357 while ((mhp = (ndmp_metadata_header_t *)get_read_buffer(size, &rv,
2358 &actual_size, lcmd)) != NULL) {
2359 pp = mhbuf;
2360
2361 if (strncmp(mhp->nh_magic, ZFS_META_MAGIC,
2362 sizeof (mhp->nh_magic)) != 0 &&
2363 strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
2364 sizeof (mhp->nh_magic)) != 0) {
2365 /* No more metadata */
2366 tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
2367 free(mhbuf);
2368 return (0);
2369 }
2370
2371 if (strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
2372 sizeof (mhp->nh_magic)) == 0) {
2373 mhpx = (ndmp_metadata_header_ext_t *)mhp;
2374 if (mhpx->nh_total_bytes > size) {
2375 if ((pp = realloc(mhbuf, mhpx->nh_total_bytes))
2376 == NULL) {
2377 free(mhbuf);
2378 return (-1);
2379 }
2380 mhbuf = pp;
2381 }
2382 size = mhpx->nh_total_bytes;
2383 }
2384
2385 (void) memcpy(pp, (char *)mhp, (actual_size < size) ?
2386 actual_size : size);
2387 pp += (actual_size < size) ? actual_size : size;
2388
2389 sz = actual_size;
2390 while (sz < size &&
2391 ((tp = get_read_buffer(size - sz, &rv, &lsize,
2392 lcmd))) != NULL) {
2393 (void) memcpy(pp, tp, lsize);
2394 sz += lsize;
2395 pp += lsize;
2396 }
2397 if (sz > size) {
2398 tlm_unget_read_buffer(lcmd->tc_buffers, sz - size);
2399 }
2400
2401 /* LINTED improper alignment */
2402 mhp = (ndmp_metadata_header_t *)mhbuf;
2403
2404 nvl = NULL;
2405 if (strncmp(mhp->nh_magic, ZFS_META_MAGIC_EXT,
2406 sizeof (mhp->nh_magic)) == 0) {
2407 /* New metadata format */
2408 /* LINTED improper alignment */
2409 mhpx = (ndmp_metadata_header_ext_t *)mhbuf;
2410
2411 if (mhpx->nh_major > META_HDR_MAJOR_VERSION) {
2412 /* Major header mismatch */
2413 NDMP_LOG(LOG_ERR, "metadata header mismatch",
2414 "M%d != M%d", mhpx->nh_major,
2415 META_HDR_MAJOR_VERSION);
2416 free(mhbuf);
2417 return (-1);
2418 }
2419 if (mhpx->nh_major == META_HDR_MAJOR_VERSION &&
2420 mhpx->nh_minor > META_HDR_MINOR_VERSION) {
2421 /* Minor header mismatch */
2422 NDMP_LOG(LOG_ERR, "Warning:"
2423 "metadata header mismatch m%d != m%d",
2424 mhpx->nh_minor,
2425 META_HDR_MINOR_VERSION);
2426 continue;
2427 }
2428
2429 nctx->nc_plversion = mhpx->nh_plversion;
2430 (void) strlcpy(plname, mhpx->nh_plname,
2431 sizeof (plname));
2432
2433 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
2434 goto nvlist_err;
2435
2436 mppx = &mhpx->nh_property[0];
2437 for (i = 0; i < mhpx->nh_count && mppx; i++, mppx++) {
2438 if (!*mppx->mp_name)
2439 continue;
2440 valp = NULL;
2441 if (nvlist_alloc(&valp,
2442 NV_UNIQUE_NAME, 0) != 0 ||
2443 nvlist_add_string(valp, "value",
2444 mppx->mp_value) != 0 ||
2445 nvlist_add_string(valp, "source",
2446 mppx->mp_source) != 0 ||
2447 nvlist_add_nvlist(nvl, mppx->mp_name,
2448 valp) != 0) {
2449 nvlist_free(valp);
2450 goto nvlist_err;
2451 }
2452 nvlist_free(valp);
2453 }
2454 } else {
2455 nctx->nc_plversion = mhp->nh_plversion;
2456 (void) strlcpy(plname, mhp->nh_plname,
2457 sizeof (plname));
2458
2459 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
2460 goto nvlist_err;
2461
2462 mpp = &mhp->nh_property[0];
2463 for (i = 0; i < mhp->nh_count && mpp; i++, mpp++) {
2464 if (!*mpp->mp_name)
2465 continue;
2466 valp = NULL;
2467 if (nvlist_alloc(&valp,
2468 NV_UNIQUE_NAME, 0) != 0 ||
2469 nvlist_add_string(valp, "value",
2470 mpp->mp_value) != 0 ||
2471 nvlist_add_string(valp, "source",
2472 mpp->mp_source) != 0 ||
2473 nvlist_add_nvlist(nvl, mpp->mp_name,
2474 valp) != 0) {
2475 nvlist_free(valp);
2476 goto nvlist_err;
2477 }
2478 nvlist_free(valp);
2479 }
2480 }
2481
2482 if (np_restore_property(nvl, ptr) != 0)
2483 goto nvlist_err;
2484
2485 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL &&
2486 nvpair_value_nvlist(nvp, &valp) == 0) {
2487 nvlist_free(valp);
2488 }
2489 nvlist_free(nvl);
2490 }
2491
2492 free(mhbuf);
2493 return (0);
2494
2495 nvlist_err:
2496 free(mhbuf);
2497
2498 while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL &&
2499 nvpair_value_nvlist(nvp, &valp) == 0) {
2500 nvlist_free(valp);
2501 }
2502 nvlist_free(nvl);
2503 return (-1);
2504 }
2505
2506 /*
2507 * Returns the version number of the plugin which created the metadata
2508 */
2509 uint_t
ndmp_context_get_version(ndmp_context_t * nctx)2510 ndmp_context_get_version(ndmp_context_t *nctx)
2511 {
2512 tlm_commands_t *cmds;
2513 ndmp_metadata_header_t *mhp;
2514 tlm_cmd_t *lcmd;
2515 int actual_size;
2516 int rv;
2517 int size;
2518 int align = RECORDSIZE - 1;
2519
2520 if (nctx == NULL || (cmds = (tlm_commands_t *)nctx->nc_cmds) == NULL)
2521 return (0);
2522
2523 if ((lcmd = cmds->tcs_command) == NULL ||
2524 lcmd->tc_buffers == NULL)
2525 return (0);
2526
2527 size = sizeof (ndmp_metadata_header_t);
2528 size += align;
2529 size &= ~align;
2530
2531 /* LINTED improper alignment */
2532 if ((mhp = (ndmp_metadata_header_t *)get_read_buffer(size, &rv,
2533 &actual_size, lcmd)) != NULL) {
2534 if (strncmp(mhp->nh_magic, ZFS_META_MAGIC,
2535 sizeof (mhp->nh_magic)) != 0) {
2536 /* No more metadata */
2537 tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
2538 return (0);
2539 }
2540
2541 nctx->nc_plversion = mhp->nh_plversion;
2542 tlm_unget_read_buffer(lcmd->tc_buffers, actual_size);
2543 }
2544
2545 return (nctx->nc_plversion);
2546 }
2547