Hallo, dies ist ein Test.

PWD: /www/data-lst1/unixsoft/unixsoft/kaempfer/.public_html

Running in File Mode
Relative path: ./../../.././../../../lib/svc/method/net-install
Real path: /lib/svc/method/net-install
Zurück

#!/usr/sbin/sh
#
# Copyright (c) 2010, 2021, Oracle and/or its affiliates.
#

. /lib/svc/share/smf_include.sh
. /lib/svc/share/net_include.sh

NET_INSTALL_FMRI=$SMF_FMRI

NET_IB_PLINK_TYPE=ib_partlink
NET_V4IF=install_ipv4_interface
NET_V6IF=install_ipv6_interface
NET_V4IF_TYPE=ipv4_interface
NET_V6IF_TYPE=ipv6_interface
NET_V4ROUTE_TYPE=ipv4_route
NET_V6ROUTE_TYPE=ipv6_route

NET_UNDEFINED_STRING_PROP="\"\""

NET_APPLIED_PROP=config/applied
NET_MAX_WAIT_PROP=config/max_wait
NET_DEBUG_PROP=config/debug

NET_INADDR_ANY="0.0.0.0"
NET_IN6ADDR_ANY_INIT="::0"

net_install_debug="false"
net_install_max_wait=2

unset net_install_name net_install_addrtype net_install_addr \
    net_install_dhcpwait net_install_interface_id \
    net_install_stateless net_install_stateful net_install_default_route \
    net_install_ifproto net_install_name_req net_install_ifcnt

net_debug()
{
	[[ $net_install_debug = "false" ]] && return

echo "$1"
}

net_debug_dump()
{
	[[ $net_install_debug = "false" ]] && return

net_debug "$1"

$DLADM
	net_debug
	$IPADM
	$NETSTAT -nr
	net_debug
}

net_get_prop()
{
	$SVCPROP -p $1 $NET_INSTALL_FMRI 2>/dev/null
	return $?
}

net_configure_install_ib_plink()
{
	cmd="$DLADM create-part -P $net_install_pkey -l $net_install_link "
	cmd=$cmd"$net_install_name"

$cmd
	if [ $? -ne 0 ]; then
		net_record_err "Error configuring IB partition link:\n\"$cmd\"" $?
		return $SMF_EXIT_ERR_FATAL
	fi

return $SMF_EXIT_OK
}

net_configure_install_route()
{
	#
	# $1 is the family modifier (i.e., -inet or -inet6)
	# $2 is the route destination
	# $3 is the route gateway
	# $4 is optional and is the interface for the ifp modifier
	#
	details="$1 $2 $3"
	[[ $# -eq 4 ]] && details="$details -ifp $4"
	
	cmd="$ROUTE -p add $details"
	$cmd >/dev/null
	cmd="$ROUTE get $details"
	$cmd >/dev/null 2>&1
	retval=$?
	if [ $retval -ne 0 ]; then
		err=$retval
		msg="Warning: Unable to verify add of static route:\n\"$cmd\""
		net_record_err "$msg" $err
		if [[ $net_install_debug = "true" ]]; then
			$cmd
			$NETSTAT -nr
		fi
	fi

return $SMF_EXIT_OK
}

net_configure_install_if()
{
	ipv6_interface=$1

case $net_install_addrtype in
	static)
		cmd="$IPADM create-addr -T static "
		cmd=$cmd"-a local=$net_install_addr $net_install_name"
		;;

dhcp)
		dhcpwait=""
		if [ "$net_install_dhcpwait" != "" ]; then
			dhcpwait="-w $net_install_dhcpwait"
		fi

cmd="$IPADM create-addr -T dhcp $dhcpwait $net_install_name"
		;;
	addrconf)
		interface_id=""
		if [ "$net_install_interface_id" != "" ]; then
			interface_id="-i $net_install_interface_id"
		fi

state=""
		if [ "$net_install_stateless" != "" ]; then
			state="-p stateless=$net_install_stateless"
		fi

if [ "$net_install_stateful" != "" ]; then
			if [ "$state" = "" ]; then
				state="-p stateful=$net_install_stateful"
			else
				state=$state",stateful=$net_install_stateful"
			fi
		fi

cmd="$IPADM create-addr -T addrconf "
		cmd=$cmd"$interface_id $state $net_install_name"
		;;
	esac

ifp=`echo $net_install_name | /usr/bin/cut -f1 -d'/'`
	$IPADM show-if $ifp >/dev/null 2>&1
	if [ $? -ne 0 ]; then
		$IPADM create-ip $ifp
		if [ $? -ne 0 ]; then
			msg="Error creating interface:\n"
			msg=$msg"\"$IPADM create-ip $ifp\""
			net_record_err "$msg" $?
			return $SMF_EXIT_ERR_FATAL
		fi
	fi

$cmd
	if [ $? -ne 0 ]; then
		net_record_err "Error configuring interface:\n\"$cmd\"" $?
		# iSCSI boot may have created a DHCP address already
		if [ "$net_install_addrtype" == "dhcp" ]; then
			tmpaddr=`$IPADM show-addr -p -o ADDROBJ $ifp | /usr/bin/cut -f2 -d '/'`
			if [ "$tmpaddr" == "?" ]; then
				net_record_err "Temporary DHCP address found, proceed using existing address" 0
				return $SMF_EXIT_OK
			fi
		fi
		return $SMF_EXIT_ERR_FATAL
	fi

#
	# Give the interface time to finish configuring so that the
	# service is less likely to report warnings when adding the
	# default route.
	#
	cnt=$net_install_max_wait
	while [ $cnt -gt 0 ]; do
		state=`$IPADM show-addr -po state $net_install_name 2>/dev/null`
		[[ $state = "ok" ]] && break
		if [[ $state = "down" || $state = "duplicate" ||
		     $state = "disabled" ]]; then
			msg="Error creating address on $net_install_name:\n"
			msg=$msg"state = $state"
			net_record_err "$msg" 0
			return $SMF_EXIT_ERR_FATAL
		fi

net_debug "$net_install_name in \"$state\" state.\n"
		cnt=`expr $cnt - 1` && sleep 1
	done
	if [[ $net_install_debug = "true" ]]; then
		net_debug "Result of configuring $net_install_name ...\n"
		$IPADM show-addr $net_install_name
		net_debug
	fi

if [ "$net_install_default_route" != "" ]; then
		details="default $net_install_default_route"
		if [ $ipv6_interface == 1 ]; then
			details="-inet6 $details"
			#
			# Default routes whose gateway is an IPv6 link-local
			# address should include the interface that should be
			# used to reach the gateway. This will ensure that the
			# route will use the correct subnet.
			typeset -l net_install_default_route_l="$net_install_default_route"
			[[ "$net_install_default_route_l" == fe80:* ]] &&
			    details="$details $ifp"
		else
			details="-inet $details"
		fi
		net_configure_install_route $details
		retval=$?
		[[ $retval -ne $SMF_EXIT_OK ]] && return $retval

return $SMF_EXIT_OK
}

net_process_ib_plink_pg()
{
	net_install_pg="$1"
	net_install_name=""
	net_install_link=""
	net_install_pkey=""

# Retrieve the mandatory name, link, and pkey properties.
	net_get_prop $net_install_pg/name | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"name\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	net_install_name=$prop

net_get_prop $net_install_pg/link | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"link\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	net_install_link=$prop

net_get_prop $net_install_pg/pkey | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"pkey\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	net_install_pkey=$prop

net_configure_install_ib_plink

retval=$?

[[ $retval -eq $SMF_EXIT_OK ]] &&
	    net_install_plinkcnt=`expr $net_install_plinkcnt + 1`

return $retval
}

net_process_route_pg()
{
	net_install_pg="$1"
	net_install_family_modifier="$2"
	net_install_route_dest=""
	net_install_route_gateway=""

# Retrieve the mandatory destination and gateway properties.
	net_get_prop $net_install_pg/destination | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"destination\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	net_install_route_dest=$prop

net_get_prop $net_install_pg/gateway | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"gateway\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	net_install_route_gateway=$prop

details="$net_install_family_modifier $net_install_route_dest"
	details="$details $net_install_route_gateway"

# Retrieve the optional interface property.
	net_get_prop $net_install_pg/interface | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		details="$details $prop"
	fi

net_configure_install_route $details

return $?
}

net_process_pg_common()
{
	net_install_pg="$1"

#
	# It is valid for the property value to be undefined for
	# install_ipv4_interface and install_ipv6_interface property
	# groups since they are statically defined. But the property
	# values are required for the dynamically defined property
	# groups since presumably the groups would not have been
	# created if the administrator did not intend for them to
	# be configured.
	#
	net_get_prop $net_install_pg/name | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ] ;then
		if [ "$net_install_name_req" = "yes" ]; then
			msg="No \"name\" property defined in the "
			msg=$msg"\"$net_install_pg\" property group"
			net_record_err "$msg" 0
			return $SMF_EXIT_ERR_CONFIG
		else
			return $SMF_EXIT_OK
		fi
	fi
	net_install_name=$prop
	return $SMF_EXIT_OK
}

net_process_v4_pg()
{
	net_install_pg="$1"
	net_install_name=""
	net_install_addrtype=""
	net_install_addr=""
	net_install_dhcpwait=""
	net_install_default_route=""

#
	# Process the property group name property. If there is no
	# error and the name is not defined, then just return with
	# no error. This means we were processing the install_ipv4_interface
	# property group and no name property value means that it
	# should not be configured.
	#
	net_process_pg_common $net_install_pg
	retval=$?
	[[ $retval -ne $SMF_EXIT_OK ]] && return $retval
	[[ $net_install_name = "" ]] && return $SMF_EXIT_OK

#
	# Retrieve the mandatory address type property value. The two
	# valid values are "static" and "dhcp".
	#
	net_get_prop $net_install_pg/address_type | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"address_type\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	case $prop in
	static | dhcp)
		net_install_addrtype=$prop
		;;
	*)
		msg="Bad value, \"$prop\", defined for the \"address_type\" "
		msg=$msg"property in the \"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
		;;
	esac

#
	# Retrieve the static address property value. The address property
	# only applies to static address type configurations. If not
	# configuring a static address, then the property should still have
	# its default value of 0.0.0.0/0.
	#
	net_get_prop $net_install_pg/static_address | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		if [ "$net_install_addrtype" = "dhcp" ]; then
			if [ "$prop" != "${NET_INADDR_ANY}/0" ]; then
				msg="Warning: static address ignored "
				msg=$msg"in the \"$net_install_pg\" property group"
				net_record_err "$msg" 0
			fi
		else
			if [ "$prop" = "${NET_INADDR_ANY}/0" ]; then
				msg="Error: static address required in the "
				msg=$msg"\"$net_install_pg\" property group"
				net_record_err "$msg" 0
				return $SMF_EXIT_ERR_CONFIG
			fi
			net_install_addr=$prop
		fi
	else
		if [ "$net_install_addrtype" = "static" ]; then
			msg="Error: static address required in the "
			msg=$msg"\"$net_install_pg\" property group"
			net_record_err "$msg" 0
			return $SMF_EXIT_ERR_CONFIG
		fi
	fi

#
	# Retrieve the optional DHCP wait property value.
	#
	net_get_prop $net_install_pg/dhcp_wait | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		if [ "$net_install_addrtype" != "dhcp" ]; then
			if [ "$prop" != "120" ]; then
				msg="Warning: DHCP wait value ignored in the "
				msg=$msg"\"$net_install_pg\" property group"
				net_record_err "$msg" 0
			fi
		else
			net_install_dhcpwait=$prop
		fi
	fi

#
	# Retrieve the optional default route property value.
	#
	net_get_prop $net_install_pg/default_route | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		if [ "$prop" != "$NET_INADDR_ANY" ]; then
			net_install_default_route=$prop
		fi
	fi

net_configure_install_if 0
	retval=$?
	[[ $retval -eq $SMF_EXIT_OK ]] &&
	    net_install_ifcnt=`expr $net_install_ifcnt + 1`

return $retval
}

net_get_v6_pg()
{
	net_install_pg="$1"
	net_install_name=""
	net_install_addrtype=""
	net_install_addr=""
	net_install_stateless=""
	net_install_stateful=""
	net_install_interface_id=""
	net_install_default_route=""

#
	# Process the property group name property. If there is no
	# error and the name is not defined, then just return with
	# no error. This means we were processing the install_ipv6_interface
	# property group and no name property value means that it
	# should not be configured.
	#
	net_process_pg_common $net_install_pg
	retval=$?
	[[ $retval -ne $SMF_EXIT_OK ]] && return $retval
	[[ $net_install_name = "" ]] && return $SMF_EXIT_OK

#
	# Retrieve the mandatory address type property value. The two
	# valid values are "static" and "addrconf".
	#
	net_get_prop $net_install_pg/address_type | read prop
	if [ $? -ne 0 -o "$prop" = "$NET_UNDEFINED_STRING_PROP" ]; then
		msg="No \"address_type\" property defined in the "
		msg=$msg"\"$net_install_pg\" property group"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi
	case $prop in
	static | addrconf)
		net_install_addrtype=$prop
		;;
	*)
		msg="Bad value \"$prop\" defined for \"address_type\""
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
		;;
	esac

#
	# Retrieve the static address property value. The address property
	# only applies to static address type configurations. If not
	# configuring a static address, then the property should still have
	# its default value of ::0/0.
	#
	net_get_prop $net_install_pg/static_address | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		if [ "$net_install_addrtype" = "addrconf" ]; then
			if [ "$prop" != "${NET_IN6ADDR_ANY_INIT}/0" ]; then
				msg="Warning: static address ignored in the "
				msg=$msg"\"$net_install_pg\" property group"
				net_record_err "$msg" 0
			fi
		else
			if [ "$prop" = "${NET_IN6ADDR_ANY_INIT}/0" ]; then
				msg="Error: static address required in the "
				msg=$msg"\"$net_install_pg\" property group"
				net_record_err "$msg" 0
				return $SMF_EXIT_ERR_CONFIG
			fi
			net_install_addr=$prop
		fi
	else
		if [ "$net_install_addrtype" = "static" ]; then
			msg="Error: static address required in the "
			msg=$msg"\"$net_install_pg\" property group"
			net_record_err "$msg" 0
			return $SMF_EXIT_ERR_CONFIG
		fi

#
	# Retrieve the optional interface id property value. The
	# property only applies to addrconf address type configurations.
	# If configuring a static address, then the property should still
	# have its default value of ::0/0.
	#
	net_get_prop $net_install_pg/interface_id | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		if [ "$prop" != "${NET_IN6ADDR_ANY_INIT}/0" ]; then
			if [ "$net_install_addrtype" != "addrconf" ]; then
				msg="Warning: interface id value ignored in "
				msg=$msg"the \"$net_install_pg\" property group"
				net_record_err "$msg" 0
			else
				net_install_interface_id=$prop
			fi
		fi
	fi

#
	# Retrieve the optional stateless property value. The property
	# only applies to addrconf address type configurations. If
	# configuring a static address, then the property should still
	# have its default value of "yes".
	#
	net_get_prop $net_install_pg/stateless | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		case $prop in
		yes)
			net_install_stateless=$prop
			;;
		no)
			if [ "$net_install_addrtype" != "addrconf" ]; then
				msg="Warning: stateless value ignored in the "
				msg=$msg"\"$net_install_pg\" property group"
				net_record_err "$msg" 0
			else
				net_install_stateless=$prop
			fi
			;;
		*)
			msg="Bad value \"$prop\" defined for the \"stateless\""
			msg=$msg" property in the \"$net_install_pg\" property group"
			net_record_err "$msg" 0
			return $SMF_EXIT_ERR_CONFIG
		;;
		esac
	fi

#
	# Retrieve the optional stateful property value. The property
	# only applies to addrconf address type configurations. If
	# configuring a static address, then the property should still
	# have its default value of "yes".
	#
	net_get_prop $net_install_pg/stateful | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		case $prop in
		yes)
			net_install_stateful=$prop
			;;
		no)
			if [ "$net_install_addrtype" != "addrconf" ]; then
				msg="Warning: stateless value ignored in the "
				msg=$msg"\"$net_install_pg\" property group"
				net_record_err "$msg" 0
			else
				net_install_stateful=$prop
			fi
			;;
		*)
			msg="Bad value \"$prop\" defined for the \"stateless\""
			msg=$msg" property in the \"$net_install_pg\" property group"
			net_record_err "$msg" 0
			return $SMF_EXIT_ERR_CONFIG
		;;
		esac
	fi

#
	# Retrieve the optional default route property value.
	#
	net_get_prop $net_install_pg/default_route | read prop
	if [ $? -eq 0 -a "$prop" != "$NET_UNDEFINED_STRING_PROP" ]; then
		if [ "$prop" != "$NET_IN6ADDR_ANY_INIT" ]; then
			net_install_default_route=$prop
		fi
	fi

return $SMF_EXIT_OK
}

#
# Determine whether or not the property group is one that defines the
# configuration for an interface. If so, initialize 'net_install_ifproto'
# and 'net_install_name_req'.
#
net_is_if_pg()
{
	if [ "$1" == "$NET_V4IF" ]; then
		net_install_ifproto=$NET_V4IF_TYPE
		net_install_name_req="no"
		return 0
	fi

if [ "$1" == "$NET_V6IF" ]; then
		net_install_ifproto=$NET_V6IF_TYPE
		net_install_name_req="no"
		return 0
	fi

if [ "$2" == "$NET_V4IF_TYPE" -o "$2" == "$NET_V6IF_TYPE" ]; then
		net_install_ifproto=$2
		net_install_name_req="yes"
		return 0
	fi

return 1
}

#
# Configure an IPv6 address given a specific property group name.
#
net_process_v6_pg()
{
	intf=$1
	$SVCCFG -s $NET_INSTALL_FMRI listpg -G $intf | \
	    read pg_intf pg_type pg_flags
	[[ $? -ne 0 ]] && return $SMF_EXIT_ERR_CONFIG

net_is_if_pg $pg_intf $pg_type
	net_get_v6_pg $pg_intf
	retval=$?
	[[ $retval -ne $SMF_EXIT_OK ]] && return $retval

net_configure_install_if 1 
	retval=$?
	[[ $retval -ne $SMF_EXIT_OK ]] && return $retval

net_install_ifcnt=`expr $net_install_ifcnt + 1`

return $SMF_EXIT_OK
}

#
# Get a list of service property groups and process the ones that matter.
# The ones that matter are the two property groups, install_ipv4_interface
# and install_ipv6_interface that are statically defined in the service
# manifest and any property groups of type ipv4_interface or ipv6_interface
# defined dynamically by the SC profile.
#
net_process_install()
{
	vout=`$SVCCFG -s $NET_INSTALL_FMRI validate 2>&1`
	if [ "$vout" != "" ]; then
		msg="Validation errors in $NET_INSTALL_FMRI:\n$vout"
		net_record_err "$msg" 0
		return $SMF_EXIT_ERR_CONFIG
	fi

ecode=$SMF_EXIT_OK
	errs=0
	net_install_plinkcnt=0
	net_install_ifcnt=0

#
	# Retrieve all the property groups from the install service and
	# identify the ones that represent IB partition link configuration.
	# (These need to be processed before IP interface configurations.)
	#
	$SVCCFG -s $NET_INSTALL_FMRI listpg | \
	    while read pg_ib_plink pg_type pg_flags; do
		if [ "$pg_type" != "$NET_IB_PLINK_TYPE" ]; then
			continue
		fi

net_process_ib_plink_pg $pg_ib_plink
		retval=$?
		if [ $retval -ne $SMF_EXIT_OK ]; then
			#
		    	# Last error wins.
			#
			ecode=$retval
			errs=`expr $errs + 1`
		fi
	done

#
	# Retrieve all the property groups from the install service,
	# find those that define interface addresses. Configure IPv4
	# interfaces immediately. Collect property group names for
	# IPv6 addresses by their respective address object types so
	# that they may be configured in the right order.
	#
	linklocal_addr_pgs=""
	addrconf_addr_pgs=""
	ipv6_addr_pgs=""
	$SVCCFG -s $NET_INSTALL_FMRI listpg | \
	    while read pg_intf pg_type pg_flags; do
		net_is_if_pg $pg_intf $pg_type
		[[ $? -ne 0 ]] && continue

if [ "$net_install_ifproto" == "$NET_V4IF_TYPE" ]; then
			net_process_v4_pg $pg_intf
		else
			net_get_v6_pg $pg_intf
		fi
		retval=$?

if [ $retval -ne $SMF_EXIT_OK ]; then
			#
		    	# Last error wins.
			#
			ecode=$retval
			errs=`expr $errs + 1`
			continue
		fi

if [ "$net_install_ifproto" != "$NET_V6IF_TYPE" -o \
		    "$net_install_name" = "" ]; then
			continue
		fi

if [[ "$net_install_addrtype" == "addrconf" ]]; then
			addrconf_addr_pgs="$addrconf_addr_pgs $pg_intf"
		elif [[ "$net_install_addr" == fe80:* ]]; then
			linklocal_addr_pgs="$linklocal_addr_pgs $pg_intf"
		else
			ipv6_addr_pgs="$ipv6_addr_pgs $pg_intf"
		fi
	done

#
	# Configure IPv6 interface addresses in the following order:
	# linklocal IPv6 static, IPv6 addrconf, global IPv6 static.
	#
	for pg_intf in $linklocal_addr_pgs; do
		net_process_v6_pg $pg_intf
		retval=$?
		if [ $retval -ne $SMF_EXIT_OK ]; then
			ecode=$retval
			errs=`expr $errs + 1`
		fi
	done
	for pg_intf in $addrconf_addr_pgs; do
		net_process_v6_pg $pg_intf
		retval=$?
		if [ $retval -ne $SMF_EXIT_OK ]; then
			ecode=$retval
			errs=`expr $errs + 1`
		fi
	done
	for pg_intf in $ipv6_addr_pgs; do
		net_process_v6_pg $pg_intf
		retval=$?
		if [ $retval -ne $SMF_EXIT_OK ]; then
			ecode=$retval
			errs=`expr $errs + 1`
		fi
	done

#
	# Retrieve all the property groups from the install service and
	# identify the ones that represent routing configuration.
	#
	$SVCCFG -s $NET_INSTALL_FMRI listpg | \
	    while read pg_route pg_type pg_flags; do
		if [[ "$pg_type" == "$NET_V4ROUTE_TYPE" ||
		    "$pg_type" == "$NET_V6ROUTE_TYPE" ]]; then
			if [ "$pg_type" == "$NET_V4ROUTE_TYPE" ]; then
				family_modifier="-inet"
			else
				family_modifier="-inet6"
			fi
			net_process_route_pg $pg_route $family_modifier
			retval=$?
			if [ $retval -ne $SMF_EXIT_OK ]; then
				#
			    	# Last error wins.
				#
				ecode=$retval
				errs=`expr $errs + 1`
			fi
		fi
	done

if [ $errs -ne 0 ]; then
		msg="$errs errors encountered configuring network on "
		msg=$msg"behalf of install.\n"
		net_debug "$msg"
	fi

if [ $net_install_plinkcnt -ne 0 ]; then
		msg="$net_install_plinkcnt links configured on behalf "
		msg=$msg"of install.\n"
		net_debug "$msg"
	fi

if [ $net_install_ifcnt -ne 0 ]; then
		msg="$net_install_ifcnt interfaces configured on behalf "
		msg=$msg"of install.\n"
		net_debug "$msg"
	fi

return $ecode
}

#
# By default, the service should not be too chatty. But since install time
# problems are often hard to debug, the 'debug' property can be used to
# increase the level of verbosity.
#
prop=$($SVCPROP -p $NET_DEBUG_PROP $NET_INSTALL_FMRI)
[[ $? -eq 0 ]] && net_install_debug=$prop

#
# The network/install service will configure interfaces using the
# property values supplied by the install profile. Once the configuration
# has been applied, the service will not apply another configuration
# unless an unconfiguration has been performed first.
#
config_applied=$($SVCPROP -p $NET_APPLIED_PROP $NET_INSTALL_FMRI)
if [ $? -ne 0 ]; then
	msg="Failed to retrieve value of $NET_APPLIED_PROP.\n"
	msg=$msg"Network install aborted."
	net_record_err "$msg" 0
	return $SMF_EXIT_ERR_FATAL
fi

if [[ $config_applied = "true" ]]; then
	net_debug "Network install already applied."
	exit $SMF_EXIT_OK
fi

if $SVCCFG -s $NET_INSTALL_FMRI setprop $NET_APPLIED_PROP=true; then
	$SVCCFG -s $NET_INSTALL_FMRI refresh
else
	msg="Failed to set $NET_APPLIED_PROP.\n"
	msg=$msg"Network install aborted."
	net_record_err "$msg" 0
	exit $SMF_EXIT_ERR_FATAL
fi

#
# When the non-global shared-IP stack zone boots, it tries to bring up this
# service as well. We just want to exit successfully.
#
if smf_dont_configure_ip; then
	exit $SMF_EXIT_OK
fi

#
# The amount of time that the service will wait for an interface to
# transition to a usable state (i.e., "ok") is configurable.
#
prop=$($SVCPROP -p $NET_MAX_WAIT_PROP $NET_INSTALL_FMRI)
[[ $? -eq 0 ]] && net_install_max_wait=$prop

#
# When debugging, it is nice to know what things looked like
# in the beginning.
#
net_debug_dump "Configuration prior to service processing ...\n"

net_process_install
retval=$?

#
# When debugging, it is nice to know what things looked like
# at the end.
#
net_debug_dump "Configuration post service processing ...\n"

exit $retval