diff --git a/solaris/quagga.xml.in b/solaris/quagga.xml.in
index 3cd402f..50c52c2 100644
--- a/solaris/quagga.xml.in
+++ b/solaris/quagga.xml.in
@@ -18,18 +18,20 @@
 	Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 	02111-1307, USA.
 
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
+	Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 	Use is subject to license terms.
 
 	ident	"@(#)quagga.xml	1.0	05/03/15 SMI"
 -->
 
-<service_bundle type='manifest' name='QUAGGAdaemons:quagga'>
+<service_bundle type='manifest' name='SUNWquagga-daemons:quagga'>
+
 <service
 	name='network/routing/zebra'
 	type='service'
 	version='1'>
-
+	
+	<single_instance />
 	<instance name='quagga' enabled='false'>
 	
 	<dependency name='fs'
@@ -46,24 +48,24 @@
 		type='service'>
 		<service_fmri value='svc:/network/initial' />
 	</dependency>
-
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-			value='file://localhost/@sysconfdir@/zebra.conf' />
-	</dependency>
 	
+	<!-- do not not run unless routing-setup has run -->
+	<dependency
+		name='network_routing_setup'
+		grouping='require_all'
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/routing-setup' />
+	</dependency>
+
 	<exec_method
 		type='method'
 		name='start'
-		exec='/lib/svc/method/quagga zebra %{routing/daemon-args}'
+		exec='/lib/svc/method/quagga zebra'
 		timeout_seconds='60'>
 		<method_context>
 		  <method_credential
-		   user='root' group='root'
-		   privileges='basic,net_icmpaccess,net_rawaccess,sys_admin,sys_net_config'/>
+		   user='root' group='root'/>
  		</method_context>
 	</exec_method>
 
@@ -84,17 +86,55 @@
 		<propval name='ignore_error'
 		    type='astring' value='core,signal' />
 	</property_group>
-
+	
+	<!-- Properties in this group are used by routeadm (1M) -->
+	<property_group name='routeadm' type='application'>
+		<stability value='Unstable' />
+		<!-- Identifies service as a routing service -->
+		<propval name='daemon' type='astring'
+			value='@sbindir@/zebra' />
+		<propval name='value_authorization' type='astring'
+			value='solaris.smf.value.routing' />
+		<!-- zebra should not contribute to ipv4/ipv6 routing state -->
+		<propval name='protocol' type='astring' value='zebra' />
+	</property_group>
+	
+	<!-- Properties in this group are modifiable via routeadm (1M) -->
 	<property_group name='routing' type='application'>
+		<stability value='Evolving' />
 		<propval name='value_authorization' type='astring' 
-		         value='solaris.smf.modify.routing' />
-		<propval name='daemon-args' type='astring' value='-P 0'/>
+		         value='solaris.smf.value.routing' />
+		
+		<!-- Options common to Quagga daemons
+		     Property names are equivalent to the long
+		     option name, consult Quagga documentation -->
+		<!-- The config file to use, if not the default -->
+		<propval name='config_file' type='astring' value=''/>
+		<!-- The vty_port to listen on if not the default.
+		     0 to disable --> 
+		<propval name='vty_port' type='integer' value='0' />
+		<!-- The address to bind the VTY interface to, if not any. -->
+		<propval name='vty_address' type='astring' value='' />
+		<!-- The user to switch to after startup, if not the default -->
+		<propval name='user' type='astring' value='' />
+		<!-- The group to switch to, if not the default.
+		     If user is specified, this defaults to a group with
+		     same name as user -->
+		<propval name='group' type='astring' value='' />
+		<!-- The pidfile to use, if not the default of
+		     @quagga_statedir@ -->
+		<propval name='pid_file' type='astring' value='' />
+		
+		<!-- Options specific to zebra -->
+		<propval name='batch' type='boolean' value='false' />
 	</property_group>
 	
 	<property_group name='general' type='framework'>
 		<!-- to start stop routing services -->
 		<propval name='action_authorization' type='astring'
 			 value='solaris.smf.manage.routing' />
+		<propval name='value_authorization' type='astring'
+			 value='solaris.smf.manage.routing' />
 	</property_group>
 
 	<template>
@@ -111,7 +151,7 @@
 		</documentation>
 	</template>
 	</instance>
-	<stability value='Evolving' />
+	<stability value='Unstable' />
 </service>
 
 <service
@@ -129,39 +169,40 @@
 			value='svc:/system/filesystem/usr:default' />
 	</dependency>
 
-	<!-- Depends on Work-In-Progress, not yet in SNV
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
+	<dependency
+		name='ipv4-forwarding'
+		grouping='optional_all'
+		restart_on='refresh'
 		type='service'>
-		<service_fmri value='svc:/network/routing/ipv4-routing' />
+		<service_fmri value='svc:/network/ipv4-forwarding' />
 	</dependency>
-	-->
 	
-	<dependency name='zebra'
-			grouping='require_all'
-			restart_on='restart'
-			type='service'>
-			<service_fmri value='svc:/network/routing/zebra:quagga' />
+	<!-- do not not run unless routing-setup has run -->
+	<dependency
+		name='network_routing_setup'
+		grouping='require_all'
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/routing-setup' />
+	</dependency>
+	
+	<!-- ensure that restart of zebra is propogated to daemon -->
+	<dependency
+		name='zebra'
+		grouping='optional_all'
+		restart_on='restart'
+		type='service'>
+		<service_fmri value='svc:/network/routing/zebra:quagga' />
 	</dependency>
 
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-			value='file://localhost/@sysconfdir@/ripd.conf' />
-	</dependency>
-	
 	<exec_method
 		type='method'
 		name='start'
-		exec='/lib/svc/method/quagga ripd %{routing/daemon-args}'
+		exec='/lib/svc/method/quagga ripd'
 		timeout_seconds='60'>
 		<method_context>
 		  <method_credential
-		   user='root' group='root'
-		   privileges='basic,net_icmpaccess,net_privaddr,net_rawaccess'/>
+		   user='root' group='root'/>
  		</method_context>
 	</exec_method>
 
@@ -179,16 +220,52 @@
 		    type='astring' value='core,signal' />
 	</property_group>
 
+	<!-- Properties in this group are used by routeadm (1M) -->
+	<property_group name='routeadm' type='application'>
+		<stability value='Unstable' />
+		<!-- Identifies service as a routing service -->
+		<propval name='daemon' type='astring'
+			value='@sbindir@/ripd' />
+		<propval name='legacy-daemon' type='astring'
+			value='/usr/sfw/sbin/ripdstart' />
+		<propval name='value_authorization' type='astring'
+			value='solaris.smf.value.routing' />
+		<propval name='protocol' type='astring' value='ipv4' />
+	</property_group>
+	
+	<!-- Properties in this group are modifiable via routeadm (1M) -->
 	<property_group name='routing' type='application'>
 		<propval name='value_authorization' type='astring' 
-		         value='solaris.smf.modify.routing' />
-		<propval name='daemon-args' type='astring' value='-P 0'/>
+		         value='solaris.smf.value.routing' />
+
+		<!-- Options common to Quagga daemons -->
+		<!-- The config file to use, if not the default -->
+		<propval name='config_file' type='astring' value=''/>
+		<!-- The vty_port to listen on if not the default.
+		     0 to disable --> 
+		<propval name='vty_port' type='integer' value='0' />
+		<!-- The address to bind the VTY interface to, if not any. -->
+		<propval name='vty_address' type='astring' value='' />
+		<!-- The user to switch to after startup, if not the default -->
+		<propval name='user' type='astring' value='' />
+		<!-- The group to switch to, if not the default.
+		     If user is specified, this defaults to a group with
+		     same name as user -->
+		<propval name='group' type='astring' value='' />
+		<!-- The pidfile to use, if not the default of
+		     @quagga_statedir@ -->
+		<propval name='pid_file' type='astring' value='' />
+		
+		<!-- Options specific to ripd -->
+		<propval name='retain' type='boolean' value='false' />
 	</property_group>
 
 	<property_group name='general' type='framework'>
 		<!-- to start stop routing services -->
 		<propval name='action_authorization' type='astring'
 			 value='solaris.smf.manage.routing' />
+		<propval name='value_authorization' type='astring'
+			 value='solaris.smf.manage.routing' />
 	</property_group>
 
 	<template>
@@ -205,7 +282,7 @@
 		</documentation>
 	</template>
 	</instance>
-	<stability value='Evolving' />
+	<stability value='Unstable' />
 </service>
 
 <service
@@ -223,39 +300,40 @@
 			value='svc:/system/filesystem/usr:default' />
 	</dependency>
 	
-	<!-- Depends on WIP, not yet in SNV
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
+	<dependency
+		name='ipv6-forwarding'
+		grouping='optional_all'
+		restart_on='refresh'
 		type='service'>
-		<service_fmri value='svc:/network/routing/ipv6-routing' />
-	</dependency>
-	-->
-
-	<dependency name='zebra'
-			grouping='require_all'
-			restart_on='restart'
-			type='service'>
-			<service_fmri value='svc:/network/routing/zebra:quagga' />
+		<service_fmri value='svc:/network/ipv6-forwarding' />
 	</dependency>
 
-	<dependency name='config_data'
+	<!-- do not not run unless routing-setup has run -->
+	<dependency
+		name='network_routing_setup'
 		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-			value='file://localhost/@sysconfdir@/ripngd.conf' />
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/routing-setup' />
 	</dependency>
-	
+
+	<!-- ensure that restart of zebra is propogated to daemon -->
+	<dependency
+		name='zebra'
+		grouping='optional_all'
+		restart_on='restart'
+		type='service'>
+		<service_fmri value='svc:/network/routing/zebra:quagga' />
+	</dependency>
+
 	<exec_method
 		type='method'
 		name='start'
-		exec='/lib/svc/method/quagga ripngd %{routing/daemon-args}'
+		exec='/lib/svc/method/quagga ripngd'
 		timeout_seconds='60'>
 		<method_context>
 		  <method_credential
-		   user='root' group='root'
-		   privileges='basic,net_icmpaccess,net_privaddr,net_rawaccess'/>
+		   user='root' group='root'/>
  		</method_context>
 	</exec_method>
 
@@ -273,16 +351,50 @@
 		    type='astring' value='core,signal' />
 	</property_group>
 
+	<!-- Properties in this group are used by routeadm (1M) -->
+	<property_group name='routeadm' type='application'>
+		<stability value='Unstable' />
+		<!-- Identifies service as a routing service -->
+		<propval name='daemon' type='astring'
+			value='@sbindir@/ripngd' />
+		<propval name='value_authorization' type='astring'
+			value='solaris.smf.value.routing' />
+		<propval name='protocol' type='astring' value='ipv6'/>
+	</property_group>
+	
+	<!-- Properties in this group are modifiable via routeadm (1M) -->
 	<property_group name='routing' type='application'>
 		<propval name='value_authorization' type='astring' 
-		         value='solaris.smf.modify.routing' />
-		<propval name='daemon-args' type='astring' value='-P 0'/>
+		         value='solaris.smf.value.routing' />
+
+		<!-- Options common to Quagga daemons -->
+		<!-- The config file to use, if not the default -->
+		<propval name='config_file' type='astring' value=''/>
+		<!-- The vty_port to listen on if not the default.
+		     0 to disable --> 
+		<propval name='vty_port' type='integer' value='0' />
+		<!-- The address to bind the VTY interface to, if not any. -->
+		<propval name='vty_address' type='astring' value='' />
+		<!-- The user to switch to after startup, if not the default -->
+		<propval name='user' type='astring' value='' />
+		<!-- The group to switch to, if not the default.
+		     If user is specified, this defaults to a group with
+		     same name as user -->
+		<propval name='group' type='astring' value='' />
+		<!-- The pidfile to use, if not the default of
+		     @quagga_statedir@ -->
+		<propval name='pid_file' type='astring' value='' />
+
+		<!-- Options specific to ripngd -->
+		<propval name='retain' type='boolean' value='false' />
 	</property_group>
 
 	<property_group name='general' type='framework'>
 		<!-- to start stop routing services -->
 		<propval name='action_authorization' type='astring'
 			 value='solaris.smf.manage.routing' />
+		<propval name='value_authorization' type='astring'
+			 value='solaris.smf.manage.routing' />
 	</property_group>
 
 	<template>
@@ -299,7 +411,7 @@
 		</documentation>
 	</template>
 	</instance>
-	<stability value='Evolving' />
+	<stability value='Unstable' />
 </service>
 
 <service
@@ -317,47 +429,51 @@
 			value='svc:/system/filesystem/usr:default' />
 	</dependency>
 	
-	<!-- Depends on WIP, not yet in SNV
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
+	<dependency
+		name='ipv4-forwarding'
+		grouping='optional_all'
+		restart_on='refresh'
 		type='service'>
-		<service_fmri value='svc:/network/routing/ipv4-routing' />
-	</dependency>
-	-->
-
-	<dependency name='zebra'
-			grouping='require_all'
-			restart_on='restart'
-			type='service'>
-			<service_fmri value='svc:/network/routing/zebra:quagga' />
+		<service_fmri value='svc:/network/ipv4-forwarding' />
 	</dependency>
 
-	<dependency name='config_data'
+	<!-- do not not run unless routing-setup has run -->
+	<dependency
+		name='network_routing_setup'
 		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-			value='file://localhost/@sysconfdir@/ospfd.conf' />
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/routing-setup' />
 	</dependency>
-	
+
+	<!-- ensure that restart of zebra is propogated to daemon -->
+	<dependency
+		name='zebra'
+		grouping='optional_all'
+		restart_on='restart'
+		type='service'>
+		<service_fmri value='svc:/network/routing/zebra:quagga' />
+	</dependency>
+
 	<exec_method
 		type='method'
 		name='start'
-		exec='/lib/svc/method/quagga ospfd %{routing/daemon-args}'
+		exec='/lib/svc/method/quagga ospfd'
 		timeout_seconds='60'>
 		<method_context>
 		  <method_credential
-		   user='root' group='root'
-		   privileges='basic,net_icmpaccess,net_privaddr,net_rawaccess,sys_net_config'/>
+		   user='root' group='root'/>
  		</method_context>
 	</exec_method>
 
+	<!-- ospfd can take a long time to shutdown, due to graceful 
+	     shutdown 
+	 -->
 	<exec_method
 		type='method'
 		name='stop'
 		exec=':kill'
-		timeout_seconds='60'>
+		timeout_seconds='600'>
 	</exec_method>
 
 	<property_group name='startd'
@@ -367,16 +483,49 @@
 		    type='astring' value='core,signal' />
 	</property_group>
 
+	<!-- Properties in this group are used by routeadm (1M) -->
+	<property_group name='routeadm' type='application'>
+		<stability value='Unstable' />
+		<!-- Identifies service as a routing service -->
+		<propval name='daemon' type='astring'
+			value='@sbindir@/ospfd' />
+		<propval name='legacy-daemon' type='astring'
+			value='/usr/sfw/sbin/ospfdstart' />
+		<propval name='value_authorization' type='astring'
+			value='solaris.smf.value.routing' />
+		<propval name='protocol' type='astring' value='ipv4'/>
+	</property_group>
+	
+	<!-- Properties in this group are modifiable via routeadm (1M) -->
 	<property_group name='routing' type='application'>
 		<propval name='value_authorization' type='astring' 
-		         value='solaris.smf.modify.routing' />
-		<propval name='daemon-args' type='astring' value='-P 0'/>
+		         value='solaris.smf.value.routing' />
+
+		<!-- Options common to Quagga daemons -->
+		<!-- The config file to use, if not the default -->
+		<propval name='config_file' type='astring' value=''/>
+		<!-- The vty_port to listen on if not the default.
+		     0 to disable --> 
+		<propval name='vty_port' type='integer' value='0' />
+		<!-- The address to bind the VTY interface to, if not any. -->
+		<propval name='vty_address' type='astring' value='' />
+		<!-- The user to switch to after startup, if not the default -->
+		<propval name='user' type='astring' value='' />
+		<!-- The group to switch to, if not the default.
+		     If user is specified, this defaults to a group with
+		     same name as user -->
+		<propval name='group' type='astring' value='' />
+		<!-- The pidfile to use, if not the default of
+		     @quagga_statedir@ -->
+		<propval name='pid_file' type='astring' value='' />
 	</property_group>
 
 	<property_group name='general' type='framework'>
 		<!-- to start stop routing services -->
 		<propval name='action_authorization' type='astring'
 			 value='solaris.smf.manage.routing' />
+		<propval name='value_authorization' type='astring'
+			 value='solaris.smf.manage.routing' />
 	</property_group>
 
 	<template>
@@ -393,7 +542,7 @@
 		</documentation>
 	</template>
 	</instance>
-	<stability value='Evolving' />
+	<stability value='Unstable' />
 </service>
 
 <service
@@ -411,39 +560,40 @@
 			value='svc:/system/filesystem/usr:default' />
 	</dependency>
 	
-	<!-- Depends on WIP, not yet in SNV
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
+	<dependency
+		name='ipv6-forwarding'
+		grouping='optional_all'
+		restart_on='refresh'
 		type='service'>
-		<service_fmri value='svc:/network/routing/ipv6-routing' />
-	</dependency>
-	-->
-
-	<dependency name='zebra'
-			grouping='require_all'
-			restart_on='restart'
-			type='service'>
-			<service_fmri value='svc:/network/routing/zebra:quagga' />
+		<service_fmri value='svc:/network/ipv6-forwarding' />
 	</dependency>
 
-	<dependency name='config_data'
+	<!-- do not not run unless routing-setup has run -->
+	<dependency
+		name='network_routing_setup'
 		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-			value='file://localhost/@sysconfdir@/ospf6d.conf' />
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/routing-setup' />
 	</dependency>
-	
+
+	<!-- ensure that restart of zebra is propogated to daemon -->
+	<dependency
+		name='zebra'
+		grouping='optional_all'
+		restart_on='restart'
+		type='service'>
+		<service_fmri value='svc:/network/routing/zebra:quagga' />
+	</dependency>
+
 	<exec_method
 		type='method'
 		name='start'
-		exec='/lib/svc/method/quagga ospf6d %{routing/daemon-args}'
+		exec='/lib/svc/method/quagga ospf6d'
 		timeout_seconds='60'>
 		<method_context>
 		  <method_credential
-		   user='root' group='root'
-		   privileges='basic,net_icmpaccess,net_privaddr,net_rawaccess'/>
+		   user='root' group='root'/>
  		</method_context>
 	</exec_method>
 
@@ -461,22 +611,53 @@
 		    type='astring' value='core,signal' />
 	</property_group>
 
+	<!-- Properties in this group are used by routeadm (1M) -->
+	<property_group name='routeadm' type='application'>
+		<stability value='Unstable' />
+		<!-- Identifies service as a routing service -->
+		<propval name='daemon' type='astring'
+			value='@sbindir@/ospf6d' />
+		<propval name='value_authorization' type='astring'
+			value='solaris.smf.value.routing' />
+		<propval name='protocol' type='astring' value='ipv6'/>
+	</property_group>
+	
+	<!-- Properties in this group are modifiable via routeadm (1M) -->
 	<property_group name='routing' type='application'>
 		<propval name='value_authorization' type='astring' 
-		         value='solaris.smf.modify.routing' />
-		<propval name='daemon-args' type='astring' value='-P 0'/>
+		         value='solaris.smf.value.routing' />
+
+		<!-- Options common to Quagga daemons -->
+		<!-- The config file to use, if not the default -->
+		<propval name='config_file' type='astring' value=''/>
+		<!-- The vty_port to listen on if not the default.
+		     0 to disable --> 
+		<propval name='vty_port' type='integer' value='0' />
+		<!-- The address to bind the VTY interface to, if not any. -->
+		<propval name='vty_address' type='astring' value='' />
+		<!-- The user to switch to after startup, if not the default -->
+		<propval name='user' type='astring' value='' />
+		<!-- The group to switch to, if not the default.
+		     If user is specified, this defaults to a group with
+		     same name as user -->
+		<propval name='group' type='astring' value='' />
+		<!-- The pidfile to use, if not the default of
+		     @quagga_statedir@ -->
+		<propval name='pid_file' type='astring' value='' />
 	</property_group>
 
 	<property_group name='general' type='framework'>
 		<!-- to start stop routing services -->
 		<propval name='action_authorization' type='astring'
 			 value='solaris.smf.manage.routing' />
+		<propval name='value_authorization' type='astring'
+			 value='solaris.smf.manage.routing' />
 	</property_group>
 
 	<template>
 		<common_name>
 			<loctext xml:lang='C'>
-			Quagga: ospf6d, OSPFv3 IPv6 routing protocol daemon.
+ 			Quagga: ospf6d, OSPFv3 IPv6 routing protocol daemon.
 			</loctext>
 		</common_name>
 		<documentation>
@@ -487,7 +668,7 @@
 		</documentation>
 	</template>
 	</instance>
-	<stability value='Evolving' />
+	<stability value='Unstable' />
 </service>
 
 
@@ -506,40 +687,48 @@
 			value='svc:/system/filesystem/usr:default' />
 	</dependency>
 	
-	<!-- Depends on WIP, not yet in SNV
-	<dependency name='net'
-		grouping='require_any'
-		restart_on='none'
+	<dependency
+		name='ipv6-forwarding'
+		grouping='optional_all'
+		restart_on='refresh'
 		type='service'>
-		<service_fmri value='svc:/network/routing/ipv6-routing' />
-		<service_fmri value='svc:/network/routing/ipv4-routing' />
-	</dependency>
-	-->
-	
-	<dependency name='zebra'
-			grouping='optional_all'
-			restart_on='restart'
-			type='service'>
-			<service_fmri value='svc:/network/routing/zebra:quagga' />
+		<service_fmri value='svc:/network/ipv6-forwarding' />
 	</dependency>
 
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-			value='file://localhost/@sysconfdir@/bgpd.conf' />
+	<dependency
+		name='ipv4-forwarding'
+		grouping='optional_all'
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/ipv4-forwarding' />
 	</dependency>
 	
+	<!-- do not not run unless routing-setup has run -->
+	<dependency
+		name='network_routing_setup'
+		grouping='require_all'
+		restart_on='refresh'
+		type='service'>
+		<service_fmri value='svc:/network/routing-setup' />
+	</dependency>
+
+	<!-- ensure that restart of zebra is propogated to daemon -->
+	<dependency
+		name='zebra'
+		grouping='optional_all'
+		restart_on='restart'
+		type='service'>
+		<service_fmri value='svc:/network/routing/zebra:quagga' />
+	</dependency>
+
 	<exec_method
 		type='method'
 		name='start'
-		exec='/lib/svc/method/quagga bgpd %{routing/daemon-args}'
+		exec='/lib/svc/method/quagga bgpd'
 		timeout_seconds='60'>
 		<method_context>
 		  <method_credential
-		   user='root' group='root'
-		   privileges='basic,net_icmpaccess,net_privaddr,net_rawaccess'/>
+		   user='root' group='root'/>
  		</method_context>
 	</exec_method>
 
@@ -557,16 +746,65 @@
 		    type='astring' value='core,signal' />
 	</property_group>
 
+	<!-- Properties in this group are used by routeadm (1M) -->
+	<property_group name='routeadm' type='application'>
+		<stability value='Unstable' />
+		<!-- Identifies service as a routing service -->
+		<propval name='daemon' type='astring'
+			value='@sbindir@/bgpd' />
+		<propval name='legacy-daemon' type='astring'
+			value='/usr/sfw/sbin/bgpdstart' />
+		<propval name='value_authorization' type='astring'
+			value='solaris.smf.value.routing' />
+		<property name='protocol' type='astring'>
+			<astring_list>
+				<value_node value='ipv4'/>
+				<value_node value='ipv6'/>
+			</astring_list>
+		</property>
+	</property_group>
+	
+	<!-- Properties in this group are modifiable via routeadm (1M) -->
 	<property_group name='routing' type='application'>
 		<propval name='value_authorization' type='astring' 
-		         value='solaris.smf.modify.routing' />
-		<propval name='daemon-args' type='astring' value='-P 0'/>
+		         value='solaris.smf.value.routing' />
+
+		<!-- Options common to Quagga daemons. -->
+		<!-- The config file to use, if not the default -->
+		<propval name='config_file' type='astring' value=''/>
+		<!-- The vty_port to listen on if not the default.
+		     0 to disable --> 
+		<propval name='vty_port' type='integer' value='0' />
+		<!-- The address to bind the VTY interface to, if not any. -->
+		<propval name='vty_address' type='astring' value='' />
+		<!-- The user to switch to after startup, if not the default -->
+		<propval name='user' type='astring' value='' />
+		<!-- The group to switch to, if not the default.
+		     If user is specified, this defaults to a group with
+		     same name as user -->
+		<propval name='group' type='astring' value='' />
+		<!-- The pidfile to use, if not the default of
+		     @quagga_statedir@ -->
+		<propval name='pid_file' type='astring' value='' />
+
+		<!-- Options specific to bgpd -->
+		<propval name='retain' type='boolean' value='false' />
+		<propval name='no_kernel' type='boolean' value='false' />
+		<propval name='bgp_port' type='astring' value='' />
+		
+		<!--
+			If enable_zebra is false, it will not be switched
+			on by the start method.
+		-->
+		<propval name='enable_zebra' type='boolean' value='true' />
 	</property_group>
 
 	<property_group name='general' type='framework'>
 		<!-- to start stop routing services -->
 		<propval name='action_authorization' type='astring'
 			 value='solaris.smf.manage.routing' />
+		<propval name='value_authorization' type='astring'
+			 value='solaris.smf.manage.routing' />
 	</property_group>
 
 	<template>
@@ -583,6 +821,6 @@
 		</documentation>
 	</template>
 	</instance>
-	<stability value='Evolving' />
+	<stability value='Unstable' />
 </service>
 </service_bundle>
