diff --git a/solaris/ChangeLog b/solaris/ChangeLog
index d815c5d..18ad637 100644
--- a/solaris/ChangeLog
+++ b/solaris/ChangeLog
@@ -1,3 +1,14 @@
+2005-04-26 Paul Jakma <paul.jakma@sun.com>
+
+	* quagga.xml.in: New, better, single integrated manifest for all
+	  the services, courtesy of alan.maguire@sun.com.
+	* {{ospf,ospf6,rip,ripng,bgp}d,zebra}.xml.in: removed due to
+	  previous
+	* quagga.init.in: Use the package tarname for properties, use
+	  the correct daemon name variable.
+	* Makefile.am: Updated to match single manifest
+	* prototype.daemons.in: ditto
+
 2005-04-21 Paul Jakma <paul.jakma@sun.com>
 
 	* Makefile.am: pkginfo.%.tmpl is a generated file, srcdir prefix
diff --git a/solaris/Makefile.am b/solaris/Makefile.am
index e7fdf6b..9fc6311 100644
--- a/solaris/Makefile.am
+++ b/solaris/Makefile.am
@@ -1,5 +1,5 @@
 # Solaris packages automake file
-# $Id: Makefile.am,v 1.4 2005/04/21 10:24:43 paul Exp $
+# $Id: Makefile.am,v 1.5 2005/04/26 02:35:03 paul Exp $
 
 .PHONY: packages
 
@@ -12,7 +12,7 @@
 pkg_packages := $(pkg_names:%=@PACKAGE_TARNAME@-%-$(pkg_name_rev).pkg)
 pkg_pkginfos := $(pkg_names:%=pkginfo.%.full)
 pkg_prototypes := $(pkg_names:%=prototype.%)
-pkg_manifests := $(pkg_quagga_daemons:%=%.xml)
+pkg_manifests := quagga.xml
 
 # pkgmk variable substitutions wont grok ${variable} in prototype
 # file, so we cant let autoconf generate the file sadly
diff --git a/solaris/bgpd.xml.in b/solaris/bgpd.xml.in
deleted file mode 100644
index 668e633..0000000
--- a/solaris/bgpd.xml.in
+++ /dev/null
@@ -1,115 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
-<!--
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-	Use is subject to license terms.
-
-	$Id: bgpd.xml.in,v 1.1 2005/04/11 07:05:21 paul Exp $
--->
-
-<service_bundle type='manifest' name='QUAGGAdaemons:bgpd'>
-
-<service
-	name='network/bgp'
-	type='service'
-	version='1'>
-
-	<create_default_instance enabled='false' />
-
-	<single_instance />
-
-	<dependency name='fs'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri
-			value='svc:/system/filesystem/usr:default' />
-	</dependency>
-
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri value='svc:/network/loopback' />
-	</dependency>
-
-	<dependency name='zebra'
-		grouping='require_all'
-		restart_on='restart'
-		type='service'>
-		<service_fmri value='svc:/network/zebra' />
-	</dependency>
-
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-		    value='file://localhost/@sysconfdir@/bgpd.conf' />
-	</dependency>
-
-	<exec_method
-		type='method'
-		name='start'
-		exec='/lib/svc/method/quagga start svc:/network/bgp'
-		timeout_seconds='60'/>
-
-	<exec_method
-		type='method'
-		name='stop'
-		exec='/lib/svc/method/quagga stop svc:/network/bgp'
-		timeout_seconds='60' />
-
-	<exec_method
-		type='method'
-		name='restart'
-		exec='/lib/svc/method/quagga restart svc:/network/bgp'
-		timeout_seconds='60' />
-
-	<property_group name='startd'
-		type='framework'>
-		<!-- sub-process core dumps shouldn't restart session -->
-		<propval name='ignore_error'
-		    type='astring' value='core,signal' />
-	</property_group>
-	
-	<property_group name='bgpd' type='application'>
-		<stability value='Evolving' />
-		<propval name='retain_routes' type='boolean' value='false'/>
-		<propval name='no_kernel' type='boolean' value='false'/>
-		
-	</property_group>
-	<property_group name='@PACKAGE_NAME@' type='application'>
-		<!-- Options common to @PACKAGE_NAME@ daemons -->	
-		<!-- cant make XInclude validate with svccfg -->
-		<propval name='daemon_name' type='astring'
-			value='bgpd' />
-		<propval name='config_file' type='astring'
-			value='@sysconfdir@/bgpd.conf' />
-		<propval name='pid_file' type='astring'
-			value='@localstatedir@/bgpd.pid' />
-		<propval name='vty_addr' type='astring' value='127.1' />
-		<propval name='vty_port' type='integer' value='0'/>
-		<propval name='user' type='astring' value='@enable_user@' />
-		<propval name='group' type='astring' value='@enable_group@' />		
-	</property_group>
-
-	<stability value='Unstable' />
-
-	<template>
-		<common_name>
-			<loctext xml:lang='C'>
-			@PACKAGE_NAME@: bgpd, BGP routing protocol daemon.
-			</loctext>
-		</common_name>
-		<documentation>
-			<manpage title='bgpd' section='1M'
-				manpath='@mandir@' />
-			<doc_link name='quagga.net' 
-				uri='http://www.quagga.net/' />
-		</documentation>
-	</template>
-
-</service>
-
-</service_bundle>
diff --git a/solaris/ospf6d.xml.in b/solaris/ospf6d.xml.in
deleted file mode 100644
index d09c6d2..0000000
--- a/solaris/ospf6d.xml.in
+++ /dev/null
@@ -1,108 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
-<!--
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-	Use is subject to license terms.
-
-	$Id: ospf6d.xml.in,v 1.1 2005/04/11 07:05:21 paul Exp $
--->
-
-<service_bundle type='manifest' name='QUAGGAdaemons:ospf6d'>
-
-<service
-	name='network/ospf6'
-	type='service'
-	version='1'>
-
-	<create_default_instance enabled='false' />
-
-	<single_instance />
-
-	<dependency name='fs'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri
-			value='svc:/system/filesystem/usr:default' />
-	</dependency>
-
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri value='svc:/network/loopback' />
-	</dependency>
-
-	<dependency name='zebra'
-		grouping='require_all'
-		restart_on='restart'
-		type='service'>
-		<service_fmri value='svc:/network/zebra' />
-	</dependency>
-
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-		    value='file://localhost/@sysconfdir@/ospf6d.conf' />
-	</dependency>
-
-	<exec_method
-		type='method'
-		name='start'
-		exec='/lib/svc/method/quagga start svc:/network/ospf6'
-		timeout_seconds='60'/>
-
-	<exec_method
-		type='method'
-		name='stop'
-		exec='/lib/svc/method/quagga stop svc:/network/ospf6'
-		timeout_seconds='60' />
-
-	<exec_method
-		type='method'
-		name='restart'
-		exec='/lib/svc/method/quagga restart svc:/network/ospf6'
-		timeout_seconds='60' />
-
-	<property_group name='startd'
-		type='framework'>
-		<!-- sub-process core dumps shouldn't restart session -->
-		<propval name='ignore_error'
-		    type='astring' value='core,signal' />
-	</property_group>
-	
-	<property_group name='ospf6d' type='application'>
-		<stability value='Evolving' />				
-	</property_group>
-	<property_group name='@PACKAGE_NAME@' type='application'>		
-		<!-- Options common to @PACKAGE_NAME@ daemons -->	
-		<!-- cant make XInclude validate with svccfg -->
-		<propval name='daemon_name' type='astring'
-			value='ospf6d' />
-		<propval name='config_file' type='astring'
-			value='@sysconfdir@/ospf6d.conf' />
-		<propval name='pid_file' type='astring'
-			value='@localstatedir@/ospf6d.pid' />
-		<propval name='vty_addr' type='astring' value='127.1' />
-		<propval name='vty_port' type='integer' value='0'/>
-		<propval name='user' type='astring' value='@enable_user@' />
-		<propval name='group' type='astring' value='@enable_group@' />
-	</property_group>
-	<stability value='Unstable' />
-
-	<template>
-		<common_name>
-			<loctext xml:lang='C'>
-			@PACKAGE_NAME@: ospf6d, OSPFv3 IPv6 routing protocol daemon.
-			</loctext>
-		</common_name>
-		<documentation>
-			<manpage title='ospf6d' section='1M' manpath='@mandir@' />
-		</documentation>
-	</template>
-
-</service>
-
-</service_bundle>
diff --git a/solaris/ospfd.xml.in b/solaris/ospfd.xml.in
deleted file mode 100644
index d4dfd7f..0000000
--- a/solaris/ospfd.xml.in
+++ /dev/null
@@ -1,114 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
-<!--
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-	Use is subject to license terms.
-
-	$Id: ospfd.xml.in,v 1.1 2005/04/11 07:05:21 paul Exp $
--->
-
-<service_bundle type='manifest' name='QUAGGAdaemons:ospfd'>
-
-<service
-	name='network/ospf'
-	type='service'
-	version='1'>
-
-	<create_default_instance enabled='false' />
-
-	<single_instance />
-
-	<dependency name='fs'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri
-			value='svc:/system/filesystem/usr:default' />
-	</dependency>
-
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri value='svc:/network/loopback' />
-	</dependency>
-
-	<dependency name='zebra'
-		grouping='require_all'
-		restart_on='restart'
-		type='service'>
-		<service_fmri value='svc:/network/zebra' />
-	</dependency>
-
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-		    value='file://localhost/@sysconfdir@/ospfd.conf' />
-	</dependency>
-
-	<exec_method
-		type='method'
-		name='start'
-		exec='/lib/svc/method/quagga start svc:/network/ospf'
-		timeout_seconds='60'/>
-
-	<exec_method
-		type='method'
-		name='stop'
-		exec='/lib/svc/method/quagga stop svc:/network/ospf'
-		timeout_seconds='60' />
-
-	<exec_method
-		type='method'
-		name='restart'
-		exec='/lib/svc/method/quagga restart svc:/network/ospf'
-		timeout_seconds='60' />
-
-	<property_group name='startd'
-		type='framework'>
-		<!-- sub-process core dumps shouldn't restart session -->
-		<propval name='ignore_error'
-		    type='astring' value='core,signal' />
-	</property_group>
-	
-	<property_group name='ospfd' type='application'>
-		<stability value='Evolving' />
-		<propval name='apiserver' type='boolean' value='false'/>
-	</property_group>
-	<property_group name='@PACKAGE_NAME@' type='application'>
-		<stability value='Evolving' />
-		<!-- Options common to @PACKAGE_NAME@ daemons -->	
-		<!-- cant make XInclude validate with svccfg -->
-		<propval name='daemon_name' type='astring' value='ospfd'/>
-		<propval name='config_file' type='astring'
-			value='@sysconfdir@/ospfd.conf' />
-		<propval name='pid_file' type='astring'
-			value='@localstatedir@/ospfd.pid' />
-		<propval name='vty_addr' type='astring' value='127.1' />
-		<propval name='vty_port' type='integer' value='0'/>
-		<propval name='user' type='astring' value='@enable_user@' />
-		<propval name='group' type='astring' value='@enable_group@' />
-		
-		<!--
-		<xi:include href='file:/var/svc/profile/@PACKAGE_TARNAME@_options.xml' />
-		-->
-	</property_group>
-
-	<stability value='Unstable' />
-
-	<template>
-		<common_name>
-			<loctext xml:lang='C'>
-			@PACKAGE_NAME@: ospfd, OSPFv2 IPv4 routing protocol daemon.
-			</loctext>
-		</common_name>
-		<documentation>
-			<manpage title='ospfd' section='1M' manpath='@mandir@' />
-		</documentation>
-	</template>
-
-</service>
-
-</service_bundle>
diff --git a/solaris/prototype.daemons.in b/solaris/prototype.daemons.in
index bf87992..b5753be 100644
--- a/solaris/prototype.daemons.in
+++ b/solaris/prototype.daemons.in
@@ -20,11 +20,6 @@
 f none @sysconfdir@/ospfd.conf.sample=$DESTDIR/@sysconfdir@/ospfd.conf.sample 0644 root bin
 f none @sysconfdir@/ospf6d.conf.sample=$DESTDIR/@sysconfdir@/ospf6d.conf.sample 0644 root bin
 d none @quagga_statedir@=$DESTDIR/@quagga_statedir@ 0711 @enable_user@ @enable_group@
-f manifest var/svc/manifest/network/zebra.xml 0444 root bin
-f manifest var/svc/manifest/network/bgpd.xml 0444 root bin
-f manifest var/svc/manifest/network/ospfd.xml 0444 root bin
-f manifest var/svc/manifest/network/ospf6d.xml 0444 root bin
-f manifest var/svc/manifest/network/ripd.xml 0444 root bin
-f manifest var/svc/manifest/network/ripngd.xml 0444 root bin
+f manifest var/svc/manifest/network/quagga.xml 0444 root bin
 #f none var/svc/profile/@PACKAGE_TARNAME@_options.xml=$abs_builddir/options.xml 0755 root sys
 f none lib/svc/method/quagga=$abs_builddir/quagga.init 0755 root bin
diff --git a/solaris/quagga.init.in b/solaris/quagga.init.in
index 02fdc60..808fcbe 100755
--- a/solaris/quagga.init.in
+++ b/solaris/quagga.init.in
@@ -3,7 +3,7 @@
 # Copyright 2001,2003 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# $Id: quagga.init.in,v 1.1 2005/04/11 07:05:21 paul Exp $
+# $Id: quagga.init.in,v 1.2 2005/04/26 02:35:03 paul Exp $
 #
 # Starts/stops the appropriate daemon
 
@@ -45,12 +45,12 @@
 	;;
 esac
 
-CONFFILE=`svcprop -p @PACKAGE_NAME@/config_file ${FMRI}`
-PIDFILE=`svcprop -p @PACKAGE_NAME@/pid_file ${FMRI}`
-USER=`svcprop -p @PACKAGE_NAME@/user ${FMRI}`
-GROUP=`svcprop -p @PACKAGE_NAME@/group ${FMRI}`
-VTYADDR=`svcprop -p @PACKAGE_NAME@/vty_addr ${FMRI}`
-VTYPORT=`svcprop -p @PACKAGE_NAME@/vty_port ${FMRI}`
+CONFFILE=`svcprop -p @PACKAGE_TARNAME@/config_file ${FMRI}`
+PIDFILE=`svcprop -p @PACKAGE_TARNAME@/pid_file ${FMRI}`
+USER=`svcprop -p @PACKAGE_TARNAME@/user ${FMRI}`
+GROUP=`svcprop -p @PACKAGE_TARNAME@/group ${FMRI}`
+VTYADDR=`svcprop -p @PACKAGE_TARNAME@/vty_addr ${FMRI}`
+VTYPORT=`svcprop -p @PACKAGE_TARNAME@/vty_port ${FMRI}`
 
 [ -n "${CONFFILE}" ] && ARGS=" -f ${CONFFILE}"
 [ -n "${PIDFILE}" ] && ARGS="${ARGS} --pid_file ${PIDFILE}"
@@ -76,9 +76,9 @@
 }
 
 restart() {
-	stop ${daemon}
+	stop ${DAEMON}
 	sleep 1
-	start ${daemon}
+	start ${DAEMON}
 }
 
 case $1 in 
diff --git a/solaris/quagga.xml.in b/solaris/quagga.xml.in
new file mode 100644
index 0000000..95aa009
--- /dev/null
+++ b/solaris/quagga.xml.in
@@ -0,0 +1,323 @@
+<?xml version="1.0"?>
+<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
+<!--
+	Copyright 2005 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
+	name='network/routing/quagga'
+	type='service'
+	version='1'>
+	<!-- 
+		common service-level dependencies, inherited by each instance
+	-->
+	<dependency name='fs'
+		grouping='require_all'
+		restart_on='none'
+		type='service'>
+		<service_fmri
+			value='svc:/system/filesystem/usr:default' />
+	</dependency>
+	<dependency name='net'
+		grouping='require_all'
+		restart_on='none'
+		type='service'>
+		<service_fmri value='svc:/network/loopback' />
+	</dependency>
+
+	<!--
+		we define exec methods at the top level, and the
+		instance name is substituted for the %i on calling.
+		See smf_method(1M) for more switches.
+	-->
+	<exec_method
+		type='method'
+		name='start'
+		exec='/lib/svc/method/quagga start %i'
+		timeout_seconds='60'/>
+
+	<exec_method
+		type='method'
+		name='stop'
+		exec='/lib/svc/method/quagga stop %i'
+		timeout_seconds='60' />
+
+	<exec_method
+		type='method'
+		name='restart'
+		exec='/lib/svc/method/quagga restart %i'
+		timeout_seconds='60' />
+	<!-- 
+		if we define these properties at the service level, each instance
+		inherits them, and it can override with desired values. 
+	-->
+	<property_group name='startd'
+		type='framework'>
+		<!-- sub-process core dumps shouldn't restart session -->
+		<propval name='ignore_error'
+		    type='astring' value='core,signal' />
+	</property_group>
+	<property_group name='quagga' type='application'>
+		<!-- Options common to Quagga daemons -->	
+		<propval name='config_file' type='astring' value='' />
+		<propval name='pid_file' type='astring' value='' />
+		<propval name='vty_addr' type='astring' value='127.1' />
+		<propval name='vty_port' type='integer' value='0'/>
+		<propval name='user' type='astring' value='@enable_user@' />
+		<propval name='group' type='astring' value='@enable_group@' />
+		<propval name='retain' type='boolean' value='false'/>
+	</property_group>
+	
+	<instance name='zebra' enabled='false'>
+		<!-- 
+			now define it's own dependencies/properties etc here, it'll
+			inherit the rest...
+		-->
+		<dependency name='config_data'
+			grouping='require_all'
+			restart_on='restart'
+			type='path'>
+			<service_fmri
+			    value='file://localhost/@sysconfdir@/zebra.conf' />
+		</dependency>
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='keep_kernel' type='boolean' 
+				value='false'/>
+			<propval name='daemon_name' type='astring'
+				value='zebra'/>
+		</property_group>
+		<template>
+			<common_name>
+				<loctext xml:lang='C'>
+				Quagga: zebra, RIB, kernel intermediary and misc daemon
+				</loctext>
+			</common_name>
+			<documentation>
+				<manpage title='zebra' section='1M'
+					manpath='@mandir@' />
+			</documentation>
+		</template>
+
+	</instance>
+	
+	<instance name='bgpd' enabled='false'>
+		<!-- 
+			now define it's own dependencies/properties etc here, it'll
+			inherit the rest...
+		-->
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='daemon_name' type='astring'
+				value='bgpd'/>
+			<propval name='daemon_name' type='boolean'
+				value='false'/>
+		</property_group>
+		<dependency name='zebra'
+			grouping='require_all'
+			restart_on='restart'
+			type='service'>
+			<service_fmri value='svc:/network/routing/quagga:zebra' />
+		</dependency>
+		<dependency name='config_data'
+			grouping='require_all'
+			restart_on='restart'
+			type='path'>
+			<service_fmri
+			    value='file://localhost/@sysconfdir@/bgpd.conf' />
+		</dependency>
+		<template>
+			<common_name>
+				<loctext xml:lang='C'>
+				Quagga: bgpd, BGP routing protocol daemon.
+				</loctext>
+			</common_name>
+			<documentation>
+				<manpage title='bgpd' section='1M'
+					manpath='@mandir@' />
+				<doc_link name='quagga.net' 
+					uri='http://www.quagga.net/' />
+			</documentation>
+		</template>
+
+	</instance>
+	
+	<instance name='ospf6d' enabled='false'>
+		<!-- 
+			now define it's own dependencies/properties etc here, it'll
+			inherit the rest...
+		-->
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='daemon_name' type='astring'
+				value='ospf6d'/>
+		</property_group>
+		<dependency name='zebra'
+			grouping='require_all'
+			restart_on='restart'
+			type='service'>
+			<service_fmri value='svc:/network/routing/quagga:zebra' />
+		</dependency>
+		<dependency name='config_data'
+			grouping='require_all'
+			restart_on='restart'
+			type='path'>
+			<service_fmri
+			    value='file://localhost/@sysconfdir@/ospf6d.conf' />
+		</dependency>
+		<template>
+			<common_name>
+				<loctext xml:lang='C'>
+				Quagga: ospf6d, OSPFv3 IPv6 routing protocol daemon.
+				</loctext>
+			</common_name>
+			<documentation>
+				<manpage title='ospf6d' section='1M'
+					manpath='@mandir@' />
+				<doc_link name='quagga.net' 
+					uri='http://www.quagga.net/' />
+			</documentation>
+		</template>
+
+	</instance>
+
+	<instance name='ospfd' enabled='false'>
+		<!-- 
+			now define it's own dependencies/properties etc here, it'll
+			inherit the rest...
+		-->
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='daemon_name' type='astring'
+				value='ospfd'/>
+		</property_group>
+		<dependency name='zebra'
+			grouping='require_all'
+			restart_on='restart'
+			type='service'>
+			<service_fmri value='svc:/network/routing/quagga:zebra' />
+		</dependency>
+		<dependency name='config_data'
+			grouping='require_all'
+			restart_on='restart'
+			type='path'>
+			<service_fmri
+			    value='file://localhost/@sysconfdir@/ospfd.conf' />
+		</dependency>
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='retain_routes' type='boolean' value='false'/>
+		</property_group>
+		<template>
+			<common_name>
+				<loctext xml:lang='C'>
+				Quagga: ospfd, OSPFv2 IPv4 routing protocol daemon.
+				</loctext>
+			</common_name>
+			<documentation>
+				<manpage title='ospfd' section='1M'
+					manpath='@mandir@' />
+				<doc_link name='quagga.net' 
+					uri='http://www.quagga.net/' />
+			</documentation>
+		</template>
+
+	</instance>
+
+	<instance name='ripd' enabled='false'>
+		<!-- 
+			now define it's own dependencies/properties etc here, it'll
+			inherit the rest...
+		-->
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='daemon_name' type='astring'
+				value='ripd'/>
+		</property_group>
+		<dependency name='zebra'
+			grouping='require_all'
+			restart_on='restart'
+			type='service'>
+			<service_fmri value='svc:/network/routing/quagga:zebra' />
+		</dependency>
+		<dependency name='config_data'
+			grouping='require_all'
+			restart_on='restart'
+			type='path'>
+			<service_fmri
+			    value='file://localhost/@sysconfdir@/ripd.conf' />
+		</dependency>
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='retain_routes' type='boolean' value='false'/>
+		</property_group>
+		<template>
+			<common_name>
+				<loctext xml:lang='C'>
+				Quagga: ripd, RIPv1/2 IPv4 routing protocol daemon.
+				</loctext>
+			</common_name>
+			<documentation>
+				<manpage title='ripd' section='1M'
+					manpath='@mandir@' />
+				<doc_link name='quagga.net' 
+					uri='http://www.quagga.net/' />
+			</documentation>
+		</template>
+
+	</instance>
+
+	<instance name='ripngd' enabled='false'>
+		<!-- 
+			now define it's own dependencies/properties etc here, it'll
+			inherit the rest...
+		-->
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='daemon_name' type='astring'
+				value='ripngd'/>
+		</property_group>
+		<dependency name='zebra'
+			grouping='require_all'
+			restart_on='restart'
+			type='service'>
+			<service_fmri value='svc:/network/routing/quagga:zebra' />
+		</dependency>
+		<dependency name='config_data'
+			grouping='require_all'
+			restart_on='restart'
+			type='path'>
+			<service_fmri
+			    value='file://localhost/@sysconfdir@/ripngd.conf' />
+		</dependency>
+		<property_group name='quagga' type='application'>
+			<stability value='Evolving' />
+			<propval name='retain_routes' type='boolean' value='false'/>
+		</property_group>
+		<template>
+			<common_name>
+				<loctext xml:lang='C'>
+				Quagga: ripngd, RIPng IPv6 routing protocol daemon.
+				</loctext>
+			</common_name>
+			<documentation>
+				<manpage title='ripngd' section='1M'
+					manpath='@mandir@' />
+				<doc_link name='quagga.net' 
+					uri='http://www.quagga.net/' />
+			</documentation>
+		</template>
+
+	</instance>
+
+
+	<stability value='Unstable' />
+
+</service>
+
+</service_bundle>
diff --git a/solaris/ripd.xml.in b/solaris/ripd.xml.in
deleted file mode 100644
index e659836..0000000
--- a/solaris/ripd.xml.in
+++ /dev/null
@@ -1,114 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
-<!--
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-	Use is subject to license terms.
-
-	$Id: ripd.xml.in,v 1.1 2005/04/11 07:05:21 paul Exp $
--->
-
-<service_bundle type='manifest' name='QUAGGAdaemons:ripd'>
-
-<service
-	name='network/rip'
-	type='service'
-	version='1'>
-
-	<create_default_instance enabled='false' />
-
-	<single_instance />
-
-	<dependency name='fs'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri
-			value='svc:/system/filesystem/usr:default' />
-	</dependency>
-
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri value='svc:/network/loopback' />
-	</dependency>
-
-	<dependency name='zebra'
-		grouping='require_all'
-		restart_on='restart'
-		type='service'>
-		<service_fmri value='svc:/network/zebra' />
-	</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 start svc:/network/rip'
-		timeout_seconds='60'/>
-
-	<exec_method
-		type='method'
-		name='stop'
-		exec='/lib/svc/method/quagga stop svc:/network/rip'
-		timeout_seconds='60' />
-
-	<exec_method
-		type='method'
-		name='restart'
-		exec='/lib/svc/method/quagga restart svc:/network/rip'
-		timeout_seconds='60' />
-
-	<property_group name='startd'
-		type='framework'>
-		<!-- sub-process core dumps shouldn't restart session -->
-		<propval name='ignore_error'
-		    type='astring' value='core,signal' />
-	</property_group>
-	
-	<property_group name='ripd' type='application'>
-		<stability value='Evolving' />
-		<propval name='retain_routes' type='boolean' value='false'/>
-	</property_group>
-
-	<property_group name='@PACKAGE_NAME@' type='application'>
-		<!-- Options common to @PACKAGE_NAME@ daemons -->	
-		<!-- cant make XInclude validate with svccfg -->
-		<propval name='daemon_name' type='astring' value='ripd' />
-		<propval name='config_file' type='astring'
-			value='@sysconfdir@/ripd.conf' />
-		<propval name='pid_file' type='astring'
-			value='@localstatedir@/ripd.pid' />
-		<propval name='vty_addr' type='astring' value='127.1' />
-		<propval name='vty_port' type='integer' value='0'/>
-		<propval name='user' type='astring' value='@enable_user@' />
-		<propval name='group' type='astring' value='@enable_group@' />
-		
-		<!--
-		<xi:include href='file:/var/svc/profile/@PACKAGE_TARNAME@_options.xml' />
-		-->
-	</property_group>
-
-	<stability value='Unstable' />
-
-	<template>
-		<common_name>
-			<loctext xml:lang='C'>
-			@PACKAGE_NAME@: ripd, RIPv1/2 IPv4 routing protocol daemon.
-			</loctext>
-		</common_name>
-		<documentation>
-			<manpage title='ripd' section='1M' manpath='@mandir@' />
-		</documentation>
-	</template>
-
-</service>
-
-</service_bundle>
diff --git a/solaris/ripngd.xml.in b/solaris/ripngd.xml.in
deleted file mode 100644
index 879b02d..0000000
--- a/solaris/ripngd.xml.in
+++ /dev/null
@@ -1,115 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
-<!--
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-	Use is subject to license terms.
-
-	$Id: ripngd.xml.in,v 1.2 2005/04/20 09:38:17 jardin Exp $
--->
-
-<service_bundle type='manifest' name='QUAGGAdaemons:ripngd'>
-
-<service
-	name='network/rip6'
-	type='service'
-	version='1'>
-
-	<create_default_instance enabled='false' />
-
-	<single_instance />
-
-	<dependency name='fs'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri
-			value='svc:/system/filesystem/usr:default' />
-	</dependency>
-
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri value='svc:/network/loopback' />
-	</dependency>
-
-	<dependency name='zebra'
-		grouping='require_all'
-		restart_on='restart'
-		type='service'>
-		<service_fmri value='svc:/network/zebra' />
-	</dependency>
-
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-		    value='file://localhost/@sysconfdir@/ripngd.conf' />
-	</dependency>
-
-	<exec_method
-		type='method'
-		name='start'
-		exec='/lib/svc/method/quagga start svc:/network/rip6'
-		timeout_seconds='60'/>
-
-	<exec_method
-		type='method'
-		name='stop'
-		exec='/lib/svc/method/quagga stop svc:/network/rip6'
-		timeout_seconds='60' />
-
-	<exec_method
-		type='method'
-		name='restart'
-		exec='/lib/svc/method/quagga restart svc:/network/rip6'
-		timeout_seconds='60' />
-
-	<property_group name='startd'
-		type='framework'>
-		<!-- sub-process core dumps shouldn't restart session -->
-		<propval name='ignore_error'
-		    type='astring' value='core,signal' />
-	</property_group>
-	
-	<property_group name='ripngd' type='application'>
-		<stability value='Evolving' />
-		<propval name='retain_routes' type='boolean' value='false'/>
-	</property_group>
-	
-	<property_group name='@PACKAGE_NAME@' type='application'>
-		<stability value='Evolving' />
-		<!-- Options common to @PACKAGE_NAME@ daemons -->	
-		<!-- cant make XInclude validate with svccfg -->
-		<propval name='daemon_name' type='astring' value='ripngd' />
-		<propval name='config_file' type='astring'
-			value='@sysconfdir@/ripngd.conf' />
-		<propval name='pid_file' type='astring'
-			value='@localstatedir@/ripngd.pid' />
-		<propval name='vty_addr' type='astring' value='127.1' />
-		<propval name='vty_port' type='integer' value='0'/>
-		<propval name='user' type='astring' value='@enable_user@' />
-		<propval name='group' type='astring' value='@enable_group@' />
-		
-		<!--
-		<xi:include href='file:/var/svc/profile/@PACKAGE_TARNAME@_options.xml' />
-		-->
-	</property_group>
-
-	<stability value='Unstable' />
-
-	<template>
-		<common_name>
-			<loctext xml:lang='C'>
-			@PACKAGE_NAME@: ripngd, RIPng IPv6 routing protocol daemon.
-			</loctext>
-		</common_name>
-		<documentation>
-			<manpage title='ripngd' section='1M' manpath='@mandir@' />
-		</documentation>
-	</template>
-
-</service>
-
-</service_bundle>
diff --git a/solaris/zebra.xml.in b/solaris/zebra.xml.in
deleted file mode 100644
index fefc5e1..0000000
--- a/solaris/zebra.xml.in
+++ /dev/null
@@ -1,111 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
-<!--
-	Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
-	Use is subject to license terms.
-
-	$Id: zebra.xml.in,v 1.1 2005/04/11 07:05:21 paul Exp $
--->
-
-<service_bundle type='manifest' name='QUGGAdaemons:zebra'>
-
-<service
-	name='network/zebra'
-	type='service'
-	version='1'>
-
-	<create_default_instance enabled='false' />
-
-	<single_instance />
-
-	<dependency name='fs'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri
-			value='svc:/system/filesystem/usr:default' />
-	</dependency>
-
-	<dependency name='net'
-		grouping='require_all'
-		restart_on='none'
-		type='service'>
-		<service_fmri value='svc:/network/loopback' />
-	</dependency>
-
-	<dependency name='config_data'
-		grouping='require_all'
-		restart_on='restart'
-		type='path'>
-		<service_fmri
-		    value='file://localhost/@sysconfdir@/zebra.conf' />
-	</dependency>
-
-	<exec_method
-		type='method'
-		name='start'
-		exec='/lib/svc/method/quagga start svc:/network/zebra'
-		timeout_seconds='60'/>
-
-	<exec_method
-		type='method'
-		name='stop'
-		exec='/lib/svc/method/quagga stop svc:/network/zebra'
-		timeout_seconds='60' />
-
-	<exec_method
-		type='method'
-		name='restart'
-		exec='/lib/svc/method/quagga restart svc:/network/zebra'
-		timeout_seconds='60' />
-
-	<property_group name='startd'
-		type='framework'>
-		<!-- sub-process core dumps shouldn't restart session -->
-		<propval name='ignore_error'
-		    type='astring' value='core,signal' />
-	</property_group>
-
-	<property_group name='zebra' type='application'>
-		<stability value='Evolving' />
-		<propval name='retain_routes' type='boolean' value='false'/>
-		<propval name='keep_kernel' type='boolean' value='false'/>
-	</property_group>
-	
-	<property_group name='@PACKAGE_NAME@' type='application'>
-		<stability value='Evolving' />
-		<!-- Options common to @PACKAGE_NAME@ daemons -->	
-		<!-- cant make XInclude validate with svccfg -->
-		<propval name='daemon_name' type='astring'
-			value='zebra' />
-		<propval name='config_file' type='astring' 
-			value='@sysconfdir@/zebra.conf' />
-		<propval name='pid_file' type='astring'
-			value='@localstatedir@/zebra.pid' />
-		<propval name='vty_addr' type='astring' value='127.1' />
-		<propval name='vty_port' type='integer' value='0'/>
-		<propval name='user' type='astring' value='@enable_user@' />
-		<propval name='group' type='astring' value='@enable_group@' />
-		
-		<!--
-		<xi:include href='file:/var/svc/profile/@PACKAGE_TARNAME@_options.xml' />
-		-->
-	</property_group>
-
-	<stability value='Unstable' />
-
-	<template>
-		<common_name>
-			<loctext xml:lang='C'>
-			@PACKAGE_NAME@: zebra, RIB, kernel intermediary and misc daemon
-			</loctext>
-		</common_name>
-		<documentation>
-			<manpage title='zebra' section='1M' manpath='@mandir@' />
-		</documentation>
-	</template>
-
-</service>
-
-</service_bundle>
-	
