1#
2# CDDL HEADER START
3#
4# The contents of this file are subject to the terms of the
5# Common Development and Distribution License (the "License").
6# You may not use this file except in compliance with the License.
7#
8# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9# or http://www.opensolaris.org/os/licensing.
10# See the License for the specific language governing permissions
11# and limitations under the License.
12#
13# When distributing Covered Code, include this CDDL HEADER in each
14# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15# If applicable, add the following below this CDDL HEADER, with the
16# fields enclosed by brackets "[]" replaced with your own identifying
17# information: Portions Copyright [yyyy] [name of copyright owner]
18#
19# CDDL HEADER END
20#
21# Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
22#
23
24#
25# Send the error message to the screen and to the logfile.
26#
27error()
28{
29        typeset fmt="$1"
30        shift
31
32        printf "${MSG_PREFIX}ERROR: ${fmt}\n" "$@"
33        [[ -n $LOGFILE ]] && printf "[$(date)] ERROR: ${fmt}\n" "$@" >&2
34}
35
36fatal()
37{
38        typeset fmt="$1"
39        shift
40
41	error "$fmt" "$@"
42	exit $EXIT_CODE
43}
44
45fail_fatal() {
46        typeset fmt="$1"
47        shift
48
49	error "$fmt" "$@"
50	exit $ZONE_SUBPROC_FATAL
51}
52
53#
54# Send the provided printf()-style arguments to the screen and to the logfile.
55#
56log()
57{
58        typeset fmt="$1"
59        shift
60
61        printf "${MSG_PREFIX}${fmt}\n" "$@"
62        [[ -n $LOGFILE ]] && printf "[$(date)] ${MSG_PREFIX}${fmt}\n" "$@" >&2
63}
64
65#
66# Print provided text to the screen if the shell variable "OPT_V" is set.
67# The text is always sent to the logfile.
68#
69vlog()
70{
71        typeset fmt="$1"
72        shift
73
74        [[ -n $OPT_V ]] && printf "${MSG_PREFIX}${fmt}\n" "$@"
75        [[ -n $LOGFILE ]] && printf "[$(date)] ${MSG_PREFIX}${fmt}\n" "$@" >&2
76}
77
78#
79# Validate that the directory is safe.
80#
81# It is possible for a malicious zone root user to modify a zone's filesystem
82# so that modifications made to the zone's filesystem by administrators in the
83# global zone modify the global zone's filesystem.  We can prevent this by
84# ensuring that all components of paths accessed by scripts are real (i.e.,
85# non-symlink) directories.
86#
87# NOTE: The specified path should be an absolute path as would be seen from
88# within the zone.  Also, this function does not check parent directories.
89# If, for example, you need to ensure that every component of the path
90# '/foo/bar/baz' is a directory and not a symlink, then do the following:
91#
92#	safe_dir /foo
93#	safe_dir /foo/bar
94#	safe_dir /foo/bar/baz
95#
96safe_dir()
97{
98	typeset dir="$1"
99
100	if [[ -h $ZONEROOT/$dir || ! -d $ZONEROOT/$dir ]]; then
101		fatal "$e_baddir" "$dir"
102	fi
103}
104
105# Like safe_dir except the dir doesn't have to exist.
106safe_opt_dir()
107{
108	typeset dir="$1"
109
110	[[ ! -e $ZONEROOT/$dir ]] && return
111
112	if [[ -h $ZONEROOT/$dir || ! -d $ZONEROOT/$dir ]]; then
113		fatal "$e_baddir" "$dir"
114	fi
115}
116
117# Only make a copy if we haven't already done so.
118safe_backup()
119{
120	typeset src="$1"
121	typeset dst="$2"
122
123	if [[ ! -h $src && ! -h $dst && ! -d $dst && ! -f $dst ]]; then
124		/usr/bin/cp -p $src $dst || fatal "$e_badfile" "$src"
125	fi
126}
127
128# Make a copy even if the destination already exists.
129safe_copy()
130{
131	typeset src="$1"
132	typeset dst="$2"
133
134	if [[ ! -h $src && ! -h $dst && ! -d $dst ]]; then
135		/usr/bin/cp -p $src $dst || fatal "$e_badfile" "$src"
136	fi
137}
138
139# Move a file
140safe_move()
141{
142	typeset src="$1"
143	typeset dst="$2"
144
145	if [[ ! -h $src && ! -h $dst && ! -d $dst ]]; then
146		/usr/bin/mv $src $dst || fatal "$e_badfile" "$src"
147	fi
148}
149
150safe_rm()
151{
152	if [[ ! -h $ZONEROOT/$1 && -f $ZONEROOT/$1 ]]; then
153		rm -f "$ZONEROOT/$1"
154	fi
155}
156
157#
158# Replace the file with a wrapper pointing to the native brand code.
159# However, we only do the replacement if the file hasn't already been
160# replaced with our wrapper.  This function expects the cwd to be the
161# location of the file we're replacing.
162#
163# Some of the files we're replacing are hardlinks to isaexec so we need to 'rm'
164# the file before we setup the wrapper while others are hardlinks to rc scripts
165# that we need to maintain.
166#
167safe_replace()
168{
169	typeset filename="$1"
170	typeset runname="$2"
171	typeset mode="$3"
172	typeset own="$4"
173	typeset rem="$5"
174
175	if [ -h $filename -o ! -f $filename ]; then
176		return
177	fi
178
179	egrep -s "Solaris Brand Replacement" $filename
180	if [ $? -eq 0 ]; then
181		return
182	fi
183
184	safe_backup $filename $filename.pre_p2v
185	if [ $rem = "remove" ]; then
186		rm -f $filename
187	fi
188
189	cat <<-END >$filename || exit 1
190	#!/bin/sh -p
191	#
192	# Solaris Brand Replacement
193	#
194	# Attention.  This file has been replaced with a new version for
195	# use in a virtualized environment.  Modification of this script is not
196	# supported and all changes will be lost upon reboot.  The
197	# {name}.pre_p2v version of this file is a backup copy of the
198	# original and should not be deleted.
199	#
200	END
201
202	echo ". $runname \"\$@\"" >>$filename || exit 1
203
204	chmod $mode $filename
205	chown $own $filename
206}
207
208safe_wrap()
209{
210	typeset filename="$1"
211	typeset runname="$2"
212	typeset mode="$3"
213	typeset own="$4"
214
215	if [ -f $filename ]; then
216		log "$e_cannot_wrap" "$filename"
217		exit 1
218	fi
219
220	cat <<-END >$filename || exit 1
221	#!/bin/sh
222	#
223	# Solaris Brand Wrapper
224	#
225	# Attention.  This file has been created for use in a
226	# virtualized environment.  Modification of this script
227	# is not supported and all changes will be lost upon reboot.
228	#
229	END
230
231	echo ". $runname \"\$@\"" >>$filename || exit 1
232
233	chmod $mode $filename
234	chown $own $filename
235}
236
237#
238# Read zonecfg fs entries and save the relevant data, one entry per
239# line.
240# This assumes the properties from the zonecfg output, e.g.:
241#	fs:
242#		dir: /opt
243#		special: /opt
244#		raw not specified
245#		type: lofs
246#		options: [noexec,ro,noatime]
247#
248# and it assumes the order of the fs properties as above.
249#
250get_fs_info()
251{
252	zonecfg -z $zonename info fs | nawk '{
253		if ($1 == "options:") {
254			# Remove brackets.
255			options=substr($2, 2, length($2) - 2);
256			printf("%s %s %s %s\n", dir, type, special, options);
257		} else if ($1 == "dir:") {
258			dir=$2;
259		} else if ($1 == "special:") {
260			special=$2;
261		} else if ($1 == "type:") {
262			type=$2
263		}
264	}' >> $fstmpfile
265}
266
267#
268# Mount zonecfg fs entries into the zonepath.
269#
270mnt_fs()
271{
272	if [ ! -s $fstmpfile ]; then
273		return;
274	fi
275
276	# Sort the fs entries so we can handle nested mounts.
277	sort $fstmpfile | nawk -v zonepath=$zonepath '{
278		if (NF == 4)
279			options="-o " $4;
280		else
281			options=""
282
283		# Create the mount point.  Ignore errors since we might have
284		# a nested mount with a pre-existing mount point.
285		cmd="/usr/bin/mkdir -p " zonepath "/root" $1 " >/dev/null 2>&1"
286		system(cmd);
287
288		cmd="/usr/sbin/mount -F " $2 " " options " " $3 " " \
289		    zonepath "/root" $1;
290		if (system(cmd) != 0) {
291			printf("command failed: %s\n", cmd);
292			exit 1;
293		}
294	}' >>$LOGFILE
295}
296
297#
298# Unmount zonecfg fs entries from the zonepath.
299#
300umnt_fs()
301{
302	if [ ! -s $fstmpfile ]; then
303		return;
304	fi
305
306	# Reverse sort the fs entries so we can handle nested unmounts.
307	sort -r $fstmpfile | nawk -v zonepath=$zonepath '{
308		cmd="/usr/sbin/umount " zonepath "/root" $1
309		if (system(cmd) != 0) {
310			printf("command failed: %s\n", cmd);
311		}
312	}' >>$LOGFILE
313}
314
315# Find the dataset mounted on the zonepath.
316get_zonepath_ds() {
317	ZONEPATH_DS=`/usr/sbin/zfs list -H -t filesystem -o name,mountpoint | \
318	    /usr/bin/nawk -v zonepath=$1 '{
319		if ($2 == zonepath)
320			print $1
321	}'`
322
323	if [ -z "$ZONEPATH_DS" ]; then
324		fail_fatal "$f_no_ds"
325	fi
326}
327
328#
329# Perform validation and cleanup in the zoneroot after unpacking the archive.
330#
331post_unpack()
332{
333	#
334	# Check if the image was created with a valid libc.so.1.
335	#
336	hwcap=`moe -v -32 $ZONEROOT/lib/libc.so.1 2>&1`
337	if (( $? != 0 )); then
338		vlog "$f_hwcap_info" "$hwcap"
339		fail_fatal "$f_sanity_hwcap"
340	fi
341
342	( cd "$ZONEROOT" && \
343	    find . \( -type b -o -type c \) -exec rm -f "{}" \; )
344}
345
346#
347# Determine flar compression style from identification file.
348#
349get_compression()
350{
351	typeset ident=$1
352	typeset line=$(grep "^files_compressed_method=" $ident)
353
354	print ${line##*=}
355}
356
357#
358# Determine flar archive style from identification file.
359#
360get_archiver()
361{
362        typeset ident=$1
363        typeset line=$(grep "^files_archived_method=" $ident)
364
365        print ${line##*=}
366}
367
368#
369# Unpack flar into current directory (which should be zoneroot).  The flash
370# archive is standard input.  See flash_archive(4) man page.
371# 
372# We can't use "flar split" since it will only unpack into a directory called
373# "archive".  We need to unpack in place in order to properly handle nested
374# fs mounts within the zone root.  This function does the unpacking into the
375# current directory.
376#
377# This code is derived from the gen_split() function in /usr/sbin/flar so
378# we keep the same style as the original.
379#
380install_flar()
381{
382	typeset result
383        typeset archiver_command
384        typeset archiver_arguments
385
386	vlog "cd $ZONEROOT && $stage1 "$insrc" | install_flar"
387
388	# Read cookie
389	read -r input_line
390	if (( $? != 0 )); then
391		log "$not_readable" "$install_media"
392		return 1
393	fi
394	# The cookie has format FlAsH-aRcHiVe-m.n where m and n are integers.
395	if [[ ${input_line%%-[0-9]*.[0-9]*} != "FlAsH-aRcHiVe" ]]; then
396		log "$not_flar"
397		return 1
398	fi
399
400	while [ true ]
401	do
402		# We should always be at the start of a section here
403		read -r input_line
404		if [[ ${input_line%%=*} != "section_begin" ]]; then
405			log "$bad_flar"
406			return 1
407		fi
408		section_name=${input_line##*=}
409
410		# If we're at the archive, we're done skipping sections.
411		if [[ "$section_name" == "archive" ]]; then
412			break
413		fi
414		
415		#
416		# Save identification section to a file so we can determine
417		# how to unpack the archive.
418		#
419		if [[ "$section_name" == "identification" ]]; then
420			/usr/bin/rm -f identification
421			while read -r input_line
422			do
423				if [[ ${input_line%%=*} == \
424				    "section_begin" ]]; then
425					/usr/bin/rm -f identification
426					log "$bad_flar"
427					return 1
428				fi
429
430				if [[ $input_line == \
431				    "section_end=$section_name" ]]; then
432					break;
433				fi
434				echo $input_line >> identification
435			done
436
437			continue
438		fi
439
440		#
441		# Otherwise skip past this section; read lines until detecting
442		# section_end.  According to flash_archive(4) we can have
443		# an arbitrary number of sections but the archive section
444		# must be last.
445		#
446		success=0
447		while read -r input_line
448		do
449			if [[ $input_line == "section_end=$section_name" ]];
450			then
451				success=1
452				break
453			fi
454			# Fail if we miss the end of the section
455			if [[ ${input_line%%=*} == "section_begin" ]]; then
456				/usr/bin/rm -f identification
457				log "$bad_flar"
458				return 1
459			fi
460		done
461		if (( $success == 0 )); then
462			#
463			# If we get here we read to the end of the file before
464			# seeing the end of the section we were reading.
465			#
466			/usr/bin/rm -f identification
467			log "$bad_flar"
468			return 1
469		fi
470	done
471
472	# Check for an archive made from a ZFS root pool.
473	egrep -s "^rootpool=" identification
474        if (( $? == 0 )); then
475		/usr/bin/rm -f identification
476                log "$bad_zfs_flar"
477                return 1
478        fi
479
480	# Get the information needed to unpack the archive.
481	archiver=$(get_archiver identification)
482	if [[ $archiver == "pax" ]]; then
483		# pax archiver specified
484		archiver_command="/usr/bin/pax"
485		if [[ -s $fspaxfile ]]; then
486			archiver_arguments="-r -p e -c \
487			    $(/usr/bin/cat $fspaxfile)"
488		else
489			archiver_arguments="-r -p e"
490		fi
491	elif [[ $archiver == "cpio" || -z $archiver ]]; then
492		# cpio archived specified OR no archiver specified - use default
493		archiver_command="/usr/bin/cpio"
494		archiver_arguments="-icdumfE $fscpiofile"
495	else
496		# unknown archiver specified
497		log "$unknown_archiver" $archiver
498		return 1
499	fi
500
501	if [[ ! -x $archiver_command ]]; then
502		/usr/bin/rm -f identification
503		log "$cmd_not_exec" $archiver_command
504		return 1
505	fi 
506
507	compression=$(get_compression identification)
508
509	# We're done with the identification file
510	/usr/bin/rm -f identification
511
512	# Extract archive
513	if [[ $compression == "compress" ]]; then
514		/usr/bin/zcat | \
515		    $archiver_command $archiver_arguments 2>/dev/null
516	else
517		$archiver_command $archiver_arguments 2>/dev/null
518	fi
519	result=$?
520
521	post_unpack
522
523	(( $result != 0 )) && return 1
524
525	return 0 
526}
527
528#
529# Get the archive base.
530#
531# We must unpack the archive in the right place within the zonepath so
532# that files are installed into the various mounted filesystems that are set
533# up in the zone's configuration.  These are already mounted for us by the
534# mntfs function.
535#
536# Archives can be made of either a physical host's root file system or a
537# zone's zonepath.  For a physical system, if the archive is made using an
538# absolute path (/...) we can't use it.  For a zone the admin can make the
539# archive from a variety of locations;
540#
541#   a) zonepath itself: This will be a single dir, probably named with the
542#      zone name, it will contain a root dir and under the root we'll see all
543#      the top level dirs; etc, var, usr...  We must be above the ZONEPATH
544#      when we unpack the archive but this will only work if the the archive's
545#      top-level dir name matches the ZONEPATH base-level dir name.  If not,
546#      this is an error.
547#
548#   b) inside the zonepath: We'll see root and it will contain all the top
549#      level dirs; etc, var, usr....  We must be in the ZONEPATH when we unpack
550#      the archive.
551#
552#   c) inside the zonepath root: We'll see all the top level dirs, ./etc,
553#      ./var, ./usr....  This is also the case we see when we get an archive
554#      of a physical system.  We must be in ZONEROOT when we unpack the archive.
555#
556# Note that there can be a directory named "root" under the ZONEPATH/root
557# directory.
558#
559# This function handles the above possibilities so that we reject absolute
560# path archives and figure out where in the file system we need to be to
561# properly unpack the archive into the zone.  It sets the ARCHIVE_BASE
562# variable to the location where the achive should be unpacked.
563#
564get_archive_base()
565{
566	stage1=$1
567	archive=$2
568	stage2=$3
569
570	vlog "$m_analyse_archive"
571
572	base=`$stage1 $archive | $stage2 2>/dev/null | nawk -F/ '{
573		# Check for an absolute path archive
574		if (substr($0, 1, 1) == "/")
575			exit 1
576
577		if ($1 != ".")
578			dirs[$1] = 1
579		else
580			dirs[$2] = 1
581	}
582	END {
583		for (d in dirs) {
584			cnt++
585			if (d == "bin")  sawbin = 1
586			if (d == "etc")  sawetc = 1
587			if (d == "root") sawroot = 1
588			if (d == "var")  sawvar = 1
589                }
590
591		if (cnt == 1) {
592			# If only one top-level dir named root, we are in the
593			# zonepath, otherwise this must be an archive *of*
594			# the zonepath so print the top-level dir name.
595			if (sawroot)
596				print "*zonepath*"
597			else
598				for (d in dirs) print d
599		} else {
600			# We are either in the zonepath or in the zonepath/root
601			# (or at the top level of a full system archive which
602			# looks like the zonepath/root case).  Figure out which
603			# one.
604			if (sawroot && !sawbin && !sawetc && !sawvar)
605				print "*zonepath*"
606			else
607				print "*zoneroot*"
608		}
609	}'`
610
611	if (( $? != 0 )); then
612		umnt_fs
613		fatal "$e_absolute_archive"
614	fi
615
616	if [[ "$base" == "*zoneroot*" ]]; then
617		ARCHIVE_BASE=$ZONEROOT
618	elif [[ "$base" == "*zonepath*" ]]; then
619		ARCHIVE_BASE=$ZONEPATH
620	else
621		# We need to be in the dir above the ZONEPATH but we need to
622		# validate that $base matches the final component of ZONEPATH.
623		bname=`basename $ZONEPATH`
624
625		if [[ "$bname" != "$base" ]]; then
626			umnt_fs
627			fatal "$e_mismatch_archive" "$base" "$bname"
628		fi
629		ARCHIVE_BASE=`dirname $ZONEPATH`
630	fi
631}
632
633#
634# Unpack cpio archive into zoneroot.
635#
636install_cpio()
637{
638	stage1=$1
639	archive=$2
640
641	get_archive_base "$stage1" "$archive" "cpio -it"
642
643	cpioopts="-idmfE $fscpiofile"
644
645	vlog "cd \"$ARCHIVE_BASE\" && $stage1 \"$archive\" | cpio $cpioopts"
646
647	# Ignore errors from cpio since we expect some errors depending on
648	# how the archive was made.
649	( cd "$ARCHIVE_BASE" && $stage1 "$archive" | cpio $cpioopts )
650
651	post_unpack
652
653	return 0
654}
655
656#
657# Unpack pax archive into zoneroot.
658#
659install_pax()
660{
661	archive=$1
662
663	get_archive_base "cat" "$archive" "pax"
664
665	if [[ -s $fspaxfile ]]; then
666		filtopt="-c $(/usr/bin/cat $fspaxfile)"
667	fi
668
669	vlog "cd \"$ARCHIVE_BASE\" && pax -r -f \"$archive\" $filtopt"
670
671	# Ignore errors from pax since we expect some errors depending on
672	# how the archive was made.
673	( cd "$ARCHIVE_BASE" && pax -r -f "$archive" $filtopt )
674
675	post_unpack
676
677	return 0
678}
679
680#
681# Unpack UFS dump into zoneroot.
682#
683install_ufsdump()
684{
685	archive=$1
686
687	vlog "cd \"$ZONEROOT\" && ufsrestore rf \"$archive\""
688
689	#
690	# ufsrestore goes interactive if you ^C it.  To prevent that,
691	# we make sure its stdin is not a terminal.
692	#
693	( cd "$ZONEROOT" && ufsrestore rf "$archive" < /dev/null )
694	result=$?
695
696	post_unpack
697
698	return $result
699}
700
701#
702# Copy directory hierarchy into zoneroot.
703#
704install_dir()
705{
706	source_dir=$1
707
708	cpioopts="-pdm"
709
710	first=1
711	filt=$(for i in $(cat $fspaxfile)
712		do
713			echo $i | egrep -s "/" && continue
714			if [[ $first == 1 ]]; then
715				printf "^%s" $i
716				first=0
717			else
718				printf "|^%s" $i
719			fi
720		done)
721
722	list=$(cd "$source_dir" && ls -d * | egrep -v "$filt")
723	flist=$(for i in $list
724	do
725		printf "%s " "$i"
726	done)
727	findopts="-xdev ( -type d -o -type f -o -type l ) -print"
728
729	vlog "cd \"$source_dir\" && find $flist $findopts | "
730	vlog "cpio $cpioopts \"$ZONEROOT\""
731
732	# Ignore errors from cpio since we expect some errors depending on
733	# how the archive was made.
734	( cd "$source_dir" && find $flist $findopts | \
735	    cpio $cpioopts "$ZONEROOT" )
736
737	post_unpack
738
739	return 0
740}
741
742#
743# This is a common function for laying down a zone image from a variety of
744# different sources.  This can be used to either install a fresh zone or as
745# part of zone migration during attach.
746#
747# The first argument specifies the type of image: archive, directory or stdin.
748# The second argument specifies the image itself.  In the case of stdin, the
749# second argument specifies the format of the stream (cpio, flar, etc.).
750# Any validation or post-processing on the image is done elsewhere.
751#
752# This function calls a 'sanity_check' function which must be provided by
753# the script which includes this code.
754#
755install_image()
756{
757	intype=$1
758	insrc=$2
759
760	if [[ -z "$intype" || -z "$insrc" ]]; then
761		return 1
762	fi
763
764	filetype="unknown"
765	filetypename="unknown"
766	stage1="cat"
767
768	if [[ "$intype" == "directory" ]]; then
769		if [[ "$insrc" == "-" ]]; then
770			# Indicates that the existing zonepath is prepopulated.
771			filetype="existing"
772			filetypename="existing"
773		else
774			if [[ "$(echo $insrc | cut -c 1)" != "/" ]]; then
775				fatal "$e_path_abs" "$insrc"
776			fi
777
778			if [[ ! -e "$insrc" ]]; then
779				log "$e_not_found" "$insrc"
780				fatal "$e_install_abort"
781			fi
782
783			if [[ ! -r "$insrc" ]]; then
784				log "$e_not_readable" "$insrc"
785				fatal "$e_install_abort"
786			fi
787
788			if [[ ! -d "$insrc" ]]; then
789				log "$e_not_dir"
790				fatal "$e_install_abort"
791			fi
792
793			sanity_check $insrc
794
795			filetype="directory"
796			filetypename="directory"
797		fi
798
799	else
800		# Common code for both archive and stdin stream.
801
802		if [[ "$intype" == "archive" ]]; then
803			if [[ ! -f "$insrc" ]]; then
804				log "$e_unknown_archive"
805				fatal "$e_install_abort"
806			fi
807			ftype="$(LC_ALL=C file $insrc | cut -d: -f 2)"
808		else
809			# For intype == stdin, the insrc parameter specifies
810			# the stream format coming on stdin.
811			ftype="$insrc"
812			insrc="-"
813		fi
814
815		# Setup vars for the archive type we have.
816		case "$ftype" in
817		*cpio*)		filetype="cpio"
818				filetypename="cpio archive"
819			;;
820		*bzip2*)	filetype="bzip2"
821				filetypename="bzipped cpio archive"
822			;;
823		*gzip*)		filetype="gzip"
824				filetypename="gzipped cpio archive"
825			;;
826		*ufsdump*)	filetype="ufsdump"
827				filetypename="ufsdump archive"
828			;;
829		"flar")
830				filetype="flar"
831				filetypename="flash archive"
832			;;
833		"flash")
834				filetype="flar"
835				filetypename="flash archive"
836			;;
837		*Flash\ Archive*)
838				filetype="flar"
839				filetypename="flash archive"
840			;;
841		"tar")
842				filetype="tar"
843				filetypename="tar archive"
844			;;
845		*USTAR\ tar\ archive)
846				filetype="tar"
847				filetypename="tar archive"
848			;;
849		"pax")
850				filetype="xustar"
851				filetypename="pax (xustar) archive"
852			;;
853		*USTAR\ tar\ archive\ extended\ format*)
854				filetype="xustar"
855				filetypename="pax (xustar) archive"
856			;;
857		"zfs")
858				filetype="zfs"
859				filetypename="ZFS send stream"
860			;;
861		*ZFS\ snapshot\ stream*)
862				filetype="zfs"
863				filetypename="ZFS send stream"
864			;;
865		*)		log "$e_unknown_archive"
866				fatal "$e_install_abort"
867			;;
868		esac
869	fi
870
871	vlog "$filetypename"
872
873	# Check for a non-empty root if no '-d -' option. 
874	if [[ "$filetype" != "existing" ]]; then
875		cnt=$(ls $ZONEROOT | wc -l)
876		if (( $cnt != 0 )); then
877			fatal "$e_root_full" "$ZONEROOT"
878		fi
879	fi
880
881	fstmpfile=$(/usr/bin/mktemp -t -p /var/tmp)
882	if [[ -z "$fstmpfile" ]]; then
883		fatal "$e_tmpfile"
884	fi
885
886	# Make sure we always have the files holding the directories to filter
887	# out when extracting from a CPIO or PAX archive.  We'll add the fs
888	# entries to these files in get_fs_info()
889	fscpiofile=$(/usr/bin/mktemp -t -p /var/tmp fs.cpio.XXXXXX)
890	if [[ -z "$fscpiofile" ]]; then
891		rm -f $fstmpfile
892		fatal "$e_tmpfile"
893	fi
894
895	# Filter out these directories.
896	echo 'dev/*' >>$fscpiofile
897	echo 'devices/*' >>$fscpiofile
898	echo 'devices' >>$fscpiofile
899	echo 'proc/*' >>$fscpiofile
900	echo 'tmp/*' >>$fscpiofile
901	echo 'var/run/*' >>$fscpiofile
902	echo 'system/contract/*' >>$fscpiofile
903	echo 'system/object/*' >>$fscpiofile
904
905	fspaxfile=$(/usr/bin/mktemp -t -p /var/tmp fs.pax.XXXXXX)
906	if [[ -z "$fspaxfile" ]]; then
907		rm -f $fstmpfile $fscpiofile
908		fatal "$e_tmpfile"
909	fi
910
911	printf "%s " \
912	    "dev devices proc tmp var/run system/contract system/object" \
913	    >>$fspaxfile
914
915	# Set up any fs mounts so the archive will install into the correct
916	# locations.
917	get_fs_info
918	mnt_fs
919	if (( $? != 0 )); then
920		umnt_fs >/dev/null 2>&1
921		rm -f $fstmpfile $fscpiofile $fspaxfile
922		fatal "$mount_failed"
923	fi
924
925	if [[ "$filetype" == "existing" ]]; then
926		log "$no_installing"
927	else
928		log "$installing"
929	fi
930
931	#
932	# Install the image into the zonepath.
933	#
934	unpack_result=0
935	stage1="cat"
936	if [[ "$filetype" == "gzip" ]]; then
937		stage1="gzcat"
938		filetype="cpio"
939	elif [[ "$filetype" == "bzip2" ]]; then
940		stage1="bzcat"
941		filetype="cpio"
942	fi
943
944	if [[ "$filetype" == "cpio" ]]; then
945		install_cpio "$stage1" "$insrc"
946		unpack_result=$?
947
948	elif [[ "$filetype" == "flar" ]]; then
949		( cd "$ZONEROOT" && $stage1 $insrc | install_flar )
950		unpack_result=$?
951
952	elif [[ "$filetype" == "xustar" ]]; then
953		install_pax "$insrc"
954		unpack_result=$?
955
956	elif [[ "$filetype" = "tar" ]]; then
957		vlog "cd \"$ZONEROOT\" && tar -xf \"$insrc\""
958		# Ignore errors from tar since we expect some errors depending
959		# on how the archive was made.
960		( cd "$ZONEROOT" && tar -xf "$insrc" )
961		unpack_result=0
962		post_unpack
963
964	elif [[ "$filetype" == "ufsdump" ]]; then
965		install_ufsdump "$insrc"
966		unpack_result=$?
967
968	elif [[ "$filetype" == "directory" ]]; then
969		install_dir "$insrc"
970		unpack_result=$?
971
972	elif [[ "$filetype" == "zfs" ]]; then
973		#
974		# Given a 'zfs send' stream file, receive the snapshot into
975		# the zone's dataset.  We're getting the original system's
976		# zonepath dataset.  Destroy the existing dataset created
977		# above since this recreates it.
978		#
979		if [[ -z "$DATASET" ]]; then
980			fatal "$f_nodataset"
981		fi
982		/usr/sbin/zfs destroy "$DATASET"
983		if (( $? != 0 )); then
984			log "$f_zfsdestroy" "$DATASET"
985		fi
986
987		vlog "$stage1 $insrc | zfs receive -F $DATASET"
988		( $stage1 $insrc | /usr/sbin/zfs receive -F $DATASET )
989		unpack_result=$?
990	fi
991
992	# Clean up any fs mounts used during unpacking.
993	umnt_fs
994	rm -f $fstmpfile $fscpiofile $fspaxfile
995
996	chmod 700 $zonepath
997
998	(( $unpack_result != 0 )) && fatal "$f_unpack_failed"
999
1000	# Verify this is a valid image.
1001	sanity_check $ZONEROOT
1002
1003	return 0
1004}
1005
1006# Setup i18n output
1007TEXTDOMAIN="SUNW_OST_OSCMD"
1008export TEXTDOMAIN
1009
1010e_cannot_wrap=$(gettext "%s: error: wrapper file already exists")
1011e_baddir=$(gettext "Invalid '%s' directory within the zone")
1012e_badfile=$(gettext "Invalid '%s' file within the zone")
1013e_path_abs=$(gettext "Pathname specified to -a '%s' must be absolute.")
1014e_not_found=$(gettext "%s: error: file or directory not found.")
1015e_install_abort=$(gettext "Installation aborted.")
1016e_not_readable=$(gettext "Cannot read directory '%s'")
1017e_not_dir=$(gettext "Error: must be a directory")
1018e_unknown_archive=$(gettext "Error: Unknown archive format. Must be a flash archive, a cpio archive (can also be gzipped or bzipped), a pax XUSTAR archive, or a level 0 ufsdump archive.")
1019e_absolute_archive=$(gettext "Error: archive contains absolute paths instead of relative paths.")
1020e_mismatch_archive=$(gettext "Error: the archive top-level directory (%s) does not match the zonepath (%s).")
1021e_tmpfile=$(gettext "Unable to create temporary file")
1022e_root_full=$(gettext "Zonepath root %s exists and contains data; remove or move aside prior to install.")
1023f_mkdir=$(gettext "Unable to create directory %s.")
1024f_chmod=$(gettext "Unable to chmod directory %s.")
1025f_chown=$(gettext "Unable to chown directory %s.")
1026f_hwcap_info=$(gettext "HWCAP: %s\n")
1027f_sanity_hwcap=$(gettext \
1028"The image was created with an incompatible libc.so.1 hwcap lofs mount.\n"\
1029"       The zone will not boot on this platform.  See the zone's\n"\
1030"       documentation for the recommended way to create the archive.")
1031
1032m_analyse_archive=$(gettext "Analysing the archive")
1033
1034not_readable=$(gettext "Cannot read file '%s'")
1035not_flar=$(gettext "Input is not a flash archive")
1036bad_flar=$(gettext "Flash archive is a corrupt")
1037bad_zfs_flar=$(gettext "Flash archive contains a ZFS send stream.\n\tRecreate the flar using the -L option with cpio or pax.")
1038f_unpack_failed=$(gettext "Unpacking the archive failed")
1039unknown_archiver=$(gettext "Archiver %s is not supported")
1040cmd_not_exec=$(gettext "Required command '%s' not executable!")
1041
1042#
1043# Exit values used by the script, as #defined in <sys/zone.h>
1044#
1045#	ZONE_SUBPROC_OK
1046#	===============
1047#	Installation was successful
1048#
1049#	ZONE_SUBPROC_USAGE
1050#	==================
1051#	Improper arguments were passed, so print a usage message before exiting
1052#
1053#	ZONE_SUBPROC_NOTCOMPLETE
1054#	========================
1055#	Installation did not complete, but another installation attempt can be
1056#	made without an uninstall
1057#
1058#	ZONE_SUBPROC_FATAL
1059#	==================
1060#	Installation failed and an uninstall will be required before another
1061#	install can be attempted
1062#
1063ZONE_SUBPROC_OK=0
1064ZONE_SUBPROC_USAGE=253
1065ZONE_SUBPROC_NOTCOMPLETE=254
1066ZONE_SUBPROC_FATAL=255
1067
1068