--- a/exception_lists/packaging	Fri Mar 26 14:31:08 2010 -0700
+++ b/exception_lists/packaging	Fri Mar 26 17:53:11 2010 -0400
@@ -113,6 +113,19 @@
 usr/include/sys/vnic.h
 usr/include/sys/vnic_impl.h
 #
+# Private libipadm lint library and header files
+#
+usr/include/ipadm_ipmgmt.h
+usr/include/ipadm_ndpd.h
+usr/include/libipadm.h
+lib/llib-lipadm
+lib/llib-lipadm.ln
+lib/libipadm.so
+#
+# Private libsocket header file
+#
+usr/include/libsocket_priv.h
+#
 # IKE and IPsec support library exceptions.  The IKE support
 # library contains exclusively private interfaces, as does
 # libipsecutil.  My apologies for the glut of header files here.

--- a/usr/src/Makefile.lint	Fri Mar 26 14:31:08 2010 -0700
+++ b/usr/src/Makefile.lint	Fri Mar 26 17:53:11 2010 -0400
@@ -376,6 +376,7 @@
 	lib/libinetsvc \
 	lib/libinetutil \
 	lib/libinstzones \
+	lib/libipadm \
 	lib/libipmi \
 	lib/libipmp \
 	lib/libipp \

--- a/usr/src/Targetdirs	Fri Mar 26 14:31:08 2010 -0700
+++ b/usr/src/Targetdirs	Fri Mar 26 17:53:11 2010 -0400
@@ -118,6 +118,7 @@
 	/etc/hal/fdi/preprobe/10osvendor \
 	/etc/hal/fdi/preprobe/20thirdparty \
 	/etc/hal/fdi/preprobe/30user \
+	/etc/ipadm \
 	/etc/iscsi \
 	/etc/rpcsec	\
 	/etc/security	\

--- a/usr/src/cmd/cmd-inet/lib/Makefile	Fri Mar 26 14:31:08 2010 -0700
+++ b/usr/src/cmd/cmd-inet/lib/Makefile	Fri Mar 26 17:53:11 2010 -0400
@@ -23,12 +23,12 @@
 # Use is subject to license terms.
 #
 
-SUBDIRS=	nwamd netcfgd
-MSGSUBDIRS=	nwamd
+SUBDIRS=	ipmgmtd nwamd netcfgd
+MSGSUBDIRS=	ipmgmtd nwamd
 
-include 	../../Makefile.cmd
+include         ../../Makefile.cmd
 
-POFILES=	$(MSGSUBDIRS:%=%/%.po)
+POFILES=        $(MSGSUBDIRS:%=%/%.po)
 POFILE=		lib.po
 
 all:=		TARGET= all
@@ -46,4 +46,4 @@
 
 FRC:
 
-include		../Makefile.msg
+include         ../Makefile.msg

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/Makefile	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,90 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+
+# Needed for ROOTFS_LIBDIR definition
+include		../../../../lib/Makefile.lib
+
+PROG=		ipmgmtd
+OBJS=		ipmgmt_main.o ipmgmt_door.o ipmgmt_persist.o ipmgmt_util.o
+SRCS=		$(OBJS:.o=.c)
+SVCMETHOD=	net-ipmgmt
+MANIFEST=	network-ipmgmt.xml
+CFGFILES=	ipadm.conf
+
+# Needed for ROOTETC definition
+include		../../../Makefile.cmd
+
+POFILE=		$(PROG).po
+POFILES=	ipmgmt_main.po ipmgmt_door.po
+
+ROOTCFGDIR=		$(ROOTETC)/ipadm
+ROOTCFGFILES=		$(CFGFILES:%=$(ROOTCFGDIR)/%)
+ROOTMANIFESTDIR=	$(ROOTSVCNETWORK)
+
+$(ROOTCFGFILES)	:= OWNER= ipadm
+$(ROOTCFGFILES)	:= GROUP= sys
+$(ROOTCFGFILES)	:= FILEMODE= 644
+
+ROOTCMDDIR=	$(ROOTFS_LIBDIR)/inet
+
+LDLIBS += -lipadm -lnvpair -lsecdb -lnsl -lumem
+
+#
+# Instrument ipmgmtd with CTF data to ease debugging.
+#
+CTFCONVERT_HOOK = && $(CTFCONVERT_O)
+CTFMERGE_HOOK = && $(CTFMERGE) -L VERSION -o $@ $(OBJS)
+$(OBJS) := CFLAGS += $(CTF_FLAGS)
+
+.KEEP_STATE:
+
+.PARALLEL:
+
+all: $(PROG)
+
+$(PROG): $(OBJS)
+	$(LINK.c) -o $@ $(OBJS) $(LDLIBS) $(CTFMERGE_HOOK)
+	$(POST_PROCESS)
+
+install: $(ROOTCMD) $(ROOTMANIFEST) $(ROOTSVCMETHOD) $(ROOTCFGDIR) \
+	$(ROOTCFGFILES)
+
+check:  $(SRCS) $(HEADERS) $(CHKMANIFEST)
+	$(CSTYLE) -cpP $(SRCS) $(HEADERS)
+
+$(ROOTCMD): $(PROG)
+
+clean:
+	$(RM) $(OBJS)
+
+lint:	lint_SRCS
+
+$(ROOTCFGDIR):
+	$(INS.dir)
+
+$(ROOTCFGDIR)/%: $(ROOTCFGDIR) %
+	$(INS.file)
+
+include 	../../../Makefile.targ
+include		../../Makefile.msg

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/ipadm.conf	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,26 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+# DO NOT EDIT OR PARSE THIS FILE!
+#
+# Use the ipadm(1m) command to change the contents of this file.

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/ipmgmt_door.c	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,845 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Main door handler functions used by ipmgmtd to process the different door
+ * call requests, issued by the library libipadm.so.
+ */
+
+#include <alloca.h>
+#include <pwd.h>
+#include <auth_attr.h>
+#include <secdb.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <errno.h>
+#include <assert.h>
+#include <libnvpair.h>
+#include "ipmgmt_impl.h"
+
+/* Handler declaration for each door command */
+typedef void ipmgmt_door_handler_t(void *argp);
+
+static ipmgmt_door_handler_t	ipmgmt_getaddr_handler,
+				ipmgmt_getprop_handler,
+				ipmgmt_getif_handler,
+				ipmgmt_initif_handler,
+				ipmgmt_aobjop_handler,
+				ipmgmt_resetaddr_handler,
+				ipmgmt_setif_handler,
+				ipmgmt_resetif_handler,
+				ipmgmt_resetprop_handler,
+				ipmgmt_setaddr_handler,
+				ipmgmt_setprop_handler;
+
+typedef struct ipmgmt_door_info_s {
+	uint_t			idi_cmd;
+	boolean_t		idi_set;
+	ipmgmt_door_handler_t	*idi_handler;
+} ipmgmt_door_info_t;
+
+/* maps door commands to door handler functions */
+static ipmgmt_door_info_t i_ipmgmt_door_info_tbl[] = {
+	{ IPMGMT_CMD_SETPROP,		B_TRUE,  ipmgmt_setprop_handler },
+	{ IPMGMT_CMD_SETIF,		B_TRUE,  ipmgmt_setif_handler },
+	{ IPMGMT_CMD_SETADDR,		B_TRUE,  ipmgmt_setaddr_handler },
+	{ IPMGMT_CMD_GETPROP,		B_FALSE, ipmgmt_getprop_handler },
+	{ IPMGMT_CMD_GETIF,		B_FALSE, ipmgmt_getif_handler },
+	{ IPMGMT_CMD_GETADDR,		B_FALSE, ipmgmt_getaddr_handler },
+	{ IPMGMT_CMD_RESETIF,		B_TRUE,  ipmgmt_resetif_handler },
+	{ IPMGMT_CMD_RESETADDR,		B_TRUE,  ipmgmt_resetaddr_handler },
+	{ IPMGMT_CMD_RESETPROP,		B_TRUE,  ipmgmt_resetprop_handler },
+	{ IPMGMT_CMD_INITIF,		B_TRUE,  ipmgmt_initif_handler },
+	{ IPMGMT_CMD_ADDROBJ_LOOKUPADD,	B_TRUE,  ipmgmt_aobjop_handler },
+	{ IPMGMT_CMD_ADDROBJ_ADD,	B_TRUE,  ipmgmt_aobjop_handler },
+	{ IPMGMT_CMD_AOBJNAME2ADDROBJ,	B_FALSE, ipmgmt_aobjop_handler },
+	{ IPMGMT_CMD_LIF2ADDROBJ,	B_FALSE, ipmgmt_aobjop_handler },
+	{ 0, 0, NULL },
+};
+
+/*
+ * The main server procedure function that gets invoked for any of the incoming
+ * door commands. Inside this function we identify the incoming command and
+ * invoke the right door handler function.
+ */
+/* ARGSUSED */
+void
+ipmgmt_handler(void *cookie, char *argp, size_t argsz, door_desc_t *dp,
+    uint_t n_desc)
+{
+	ipmgmt_door_info_t	*infop = NULL;
+	ipmgmt_retval_t		retval;
+	int			i;
+	uint_t			err;
+	ucred_t			*cred = NULL;
+
+	for (i = 0; i_ipmgmt_door_info_tbl[i].idi_cmd != 0; i++) {
+		if (i_ipmgmt_door_info_tbl[i].idi_cmd ==
+		    ((ipmgmt_arg_t *)(void *)argp)->ia_cmd) {
+			infop = &i_ipmgmt_door_info_tbl[i];
+			break;
+		}
+	}
+
+	if (infop == NULL) {
+		ipmgmt_log(LOG_ERR, "Invalid door command specified");
+		err = EINVAL;
+		goto fail;
+	}
+
+	/* check for solaris.network.interface.config authorization */
+	if (infop->idi_set) {
+		uid_t		uid;
+		struct passwd	pwd;
+		char		buf[1024];
+
+		if (door_ucred(&cred) != 0) {
+			err = errno;
+			ipmgmt_log(LOG_ERR, "Could not get user credentials.");
+			goto fail;
+		}
+		uid = ucred_getruid(cred);
+		if ((int)uid < 0) {
+			err = errno;
+			ipmgmt_log(LOG_ERR, "Could not get user id.");
+			goto fail;
+		}
+		if (getpwuid_r(uid, &pwd, buf, sizeof (buf)) ==
+		    NULL) {
+			err = errno;
+			ipmgmt_log(LOG_ERR, "Could not get password entry.");
+			goto fail;
+		}
+		if (chkauthattr(NETWORK_INTERFACE_CONFIG_AUTH,
+		    pwd.pw_name) != 1) {
+			err = EPERM;
+			ipmgmt_log(LOG_ERR, "Not authorized for operation.");
+			goto fail;
+		}
+		ucred_free(cred);
+	}
+
+	/* individual handlers take care of calling door_return */
+	infop->idi_handler((void *)argp);
+	return;
+fail:
+	ucred_free(cred);
+	retval.ir_err = err;
+	(void) door_return((char *)&retval, sizeof (retval), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_GETPROP. It retrieves the persisted
+ * property value for the given property.
+ */
+static void
+ipmgmt_getprop_handler(void *argp)
+{
+	ipmgmt_prop_arg_t	*pargp = argp;
+	ipmgmt_getprop_rval_t	rval, *rvalp = &rval;
+
+	assert(pargp->ia_cmd == IPMGMT_CMD_GETPROP);
+
+	rvalp->ir_err = ipmgmt_db_walk(ipmgmt_db_getprop, pargp, IPADM_DB_READ);
+	if (rvalp->ir_err == 0)
+		(void) strlcpy(rvalp->ir_pval, pargp->ia_pval,
+		    sizeof (rvalp->ir_pval));
+	(void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_SETPROP. It persists the property value
+ * for the given property in the DB.
+ */
+static void
+ipmgmt_setprop_handler(void *argp)
+{
+	ipmgmt_prop_arg_t	*pargp = argp;
+	ipmgmt_retval_t		rval;
+	ipadm_dbwrite_cbarg_t	cb;
+	nvlist_t		*nvl = NULL;
+	int			err;
+
+	assert(pargp->ia_cmd == IPMGMT_CMD_SETPROP);
+
+	if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0)
+		goto fail;
+	if (pargp->ia_module[0] != '\0' &&
+	    (err = nvlist_add_string(nvl, IPADM_NVP_PROTONAME,
+	    pargp->ia_module)) != 0) {
+		goto fail;
+	}
+	if (pargp->ia_ifname[0] != '\0' &&
+	    (err = nvlist_add_string(nvl, IPADM_NVP_IFNAME,
+	    pargp->ia_ifname)) != 0)
+		goto fail;
+	if (pargp->ia_aobjname[0] != '\0' &&
+	    (err = nvlist_add_string(nvl, IPADM_NVP_AOBJNAME,
+	    pargp->ia_aobjname)) != 0)
+		goto fail;
+	if ((err = nvlist_add_string(nvl, pargp->ia_pname,
+	    pargp->ia_pval)) != 0)
+		goto fail;
+
+	cb.dbw_nvl = nvl;
+	cb.dbw_flags = pargp->ia_flags;
+	err = ipmgmt_db_walk(ipmgmt_db_update, &cb, IPADM_DB_WRITE);
+fail:
+	nvlist_free(nvl);
+	rval.ir_err = err;
+	(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+}
+
+/*
+ * Helper function for ipmgmt_setaddr_handler().
+ * It converts the nvlist_t, `nvl', to aobjmap node `nodep'.
+ */
+static int
+i_ipmgmt_nvl2aobjnode(nvlist_t *nvl, ipmgmt_aobjmap_t *nodep)
+{
+	char			*aobjname = NULL, *ifname = NULL;
+	int32_t			lnum;
+	nvlist_t		*nvladdr;
+	struct sockaddr_storage	addr;
+	uint_t			n;
+	sa_family_t		af = AF_UNSPEC;
+	ipadm_addr_type_t	addrtype = IPADM_ADDR_NONE;
+	int			err = 0;
+
+	/*
+	 * Retrieve all the information needed to build '*nodep' from
+	 * nvlist_t nvl.
+	 */
+	if ((err = nvlist_lookup_string(nvl, IPADM_NVP_AOBJNAME,
+	    &aobjname)) != 0 ||
+	    (err = nvlist_lookup_string(nvl, IPADM_NVP_IFNAME, &ifname)) != 0 ||
+	    (err = nvlist_lookup_int32(nvl, IPADM_NVP_LIFNUM, &lnum)) != 0) {
+		return (err);
+	}
+	if (nvlist_exists(nvl, IPADM_NVP_IPV4ADDR)) {
+		af = AF_INET;
+		addrtype = IPADM_ADDR_STATIC;
+	} else if (nvlist_exists(nvl, IPADM_NVP_DHCP)) {
+		af = AF_INET;
+		addrtype = IPADM_ADDR_DHCP;
+	} else if (nvlist_exists(nvl, IPADM_NVP_IPV6ADDR)) {
+		af = AF_INET6;
+		addrtype = IPADM_ADDR_STATIC;
+	} else if (nvlist_lookup_nvlist(nvl, IPADM_NVP_INTFID, &nvladdr) == 0) {
+		struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&addr;
+		uint8_t	*addr6;
+		uint32_t plen;
+
+		af = AF_INET6;
+		addrtype = IPADM_ADDR_IPV6_ADDRCONF;
+		if (nvlist_lookup_uint32(nvladdr, IPADM_NVP_PREFIXLEN,
+		    &plen) != 0)
+			return (EINVAL);
+		if (plen != 0) {
+			if (nvlist_lookup_uint8_array(nvladdr,
+			    IPADM_NVP_IPNUMADDR, &addr6, &n) != 0)
+				return (EINVAL);
+			bcopy(addr6, &sin6->sin6_addr, n);
+		} else {
+			bzero(&sin6->sin6_addr, sizeof (sin6->sin6_addr));
+		}
+	}
+
+	/*
+	 * populate the `*nodep' with retrieved values.
+	 */
+	(void) strlcpy(nodep->am_ifname, ifname, sizeof (nodep->am_ifname));
+	(void) strlcpy(nodep->am_aobjname, aobjname,
+	    sizeof (nodep->am_aobjname));
+	nodep->am_lnum = lnum;
+	nodep->am_family = af;
+	nodep->am_atype = addrtype;
+	if (addrtype == IPADM_ADDR_IPV6_ADDRCONF) {
+		nodep->am_linklocal = B_TRUE;
+		nodep->am_ifid = addr;
+	}
+	nodep->am_next = NULL;
+
+	/*
+	 * Do not store logical interface number in persistent store as it
+	 * takes different value on reboot. So remove it from `nvl'.
+	 */
+	if (nvlist_exists(nvl, IPADM_NVP_LIFNUM))
+		(void) nvlist_remove(nvl, IPADM_NVP_LIFNUM, DATA_TYPE_INT32);
+
+	return (0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_SETADDR. It adds a new address object
+ * node to the list `aobjmap' and then persists the address information in the
+ * DB.
+ */
+static void
+ipmgmt_setaddr_handler(void *argp)
+{
+	ipmgmt_setaddr_arg_t	*sargp = argp;
+	ipmgmt_retval_t		rval;
+	ipmgmt_aobjmap_t	node;
+	nvlist_t		*nvl = NULL;
+	char			*nvlbuf;
+	size_t			nvlsize = sargp->ia_nvlsize;
+	uint32_t		flags = sargp->ia_flags;
+	int			err = 0;
+
+	nvlbuf = (char *)argp + sizeof (ipmgmt_setaddr_arg_t);
+	if ((err = nvlist_unpack(nvlbuf, nvlsize, &nvl, NV_ENCODE_NATIVE)) != 0)
+		goto ret;
+	if (flags & (IPMGMT_ACTIVE|IPMGMT_INIT)) {
+		if ((err = i_ipmgmt_nvl2aobjnode(nvl, &node)) != 0)
+			goto ret;
+		if (flags & IPMGMT_INIT)
+			node.am_flags = (IPMGMT_ACTIVE|IPMGMT_PERSIST);
+		else
+			node.am_flags = flags;
+		if ((err = ipmgmt_aobjmap_op(&node, ADDROBJ_ADD)) != 0)
+			goto ret;
+	}
+	if (flags & IPMGMT_PERSIST) {
+		ipadm_dbwrite_cbarg_t	cb;
+
+		cb.dbw_nvl = nvl;
+		cb.dbw_flags = 0;
+		err = ipmgmt_db_walk(ipmgmt_db_add, &cb, IPADM_DB_WRITE);
+	}
+ret:
+	nvlist_free(nvl);
+	rval.ir_err = err;
+	(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+}
+
+/*
+ * Handles the door commands that modify the `aobjmap' structure.
+ *
+ * IPMGMT_CMD_ADDROBJ_LOOKUPADD - places a stub address object in `aobjmap'
+ *	after ensuring that the namespace is not taken. If required, also
+ *	generates an `aobjname' for address object for the library to use.
+ * IPMGMT_CMD_ADDROBJ_ADD - add/update address object in `aobjmap'
+ * IPMGMT_CMD_LIF2ADDROBJ - given a logical interface, return address object
+ *	associated with that logical interface.
+ * IPMGMT_CMD_AOBJNAME2ADDROBJ - given an address object name return logical
+ *	interface associated with that address object.
+ */
+static void
+ipmgmt_aobjop_handler(void *argp)
+{
+	ipmgmt_aobjop_arg_t	*largp = argp;
+	ipmgmt_retval_t		rval;
+	ipmgmt_aobjop_rval_t	aobjrval;
+	void			*rvalp;
+	size_t			rsize;
+	ipmgmt_aobjmap_t	node;
+	int			err = 0;
+	char			*ifname = largp->ia_ifname;
+	char			*aobjname = largp->ia_aobjname;
+	int32_t			lnum = largp->ia_lnum;
+	sa_family_t		af = largp->ia_family;
+	ipadm_addr_type_t	atype = largp->ia_atype;
+	ipmgmt_aobjmap_t	*head;
+
+	switch (largp->ia_cmd) {
+	case IPMGMT_CMD_ADDROBJ_LOOKUPADD:
+		rsize = sizeof (ipmgmt_aobjop_rval_t);
+		rvalp = &aobjrval;
+		bzero(&node, sizeof (node));
+		(void) strlcpy(node.am_aobjname, aobjname,
+		    sizeof (node.am_aobjname));
+		(void) strlcpy(node.am_ifname, ifname,
+		    sizeof (node.am_ifname));
+		node.am_family = af;
+		/* no logical number is associated with this addrobj yet */
+		node.am_lnum = -1;
+		/* The address object is not persisted yet. */
+		node.am_flags = IPMGMT_ACTIVE;
+		err = ipmgmt_aobjmap_op(&node, ADDROBJ_LOOKUPADD);
+		if (err == 0) {
+			(void) strlcpy(aobjrval.ir_aobjname, node.am_aobjname,
+			    sizeof (aobjrval.ir_aobjname));
+		}
+		break;
+	case IPMGMT_CMD_ADDROBJ_ADD:
+		rsize = sizeof (ipmgmt_retval_t);
+		rvalp = &rval;
+		if (aobjname[0] == '\0' || ifname[0] == '\0' || lnum == -1 ||
+		    af == AF_UNSPEC) {
+			err = EINVAL;
+			break;
+		}
+		bzero(&node, sizeof (node));
+		(void) strlcpy(node.am_aobjname, aobjname,
+		    sizeof (node.am_aobjname));
+		(void) strlcpy(node.am_ifname, ifname,
+		    sizeof (node.am_ifname));
+		node.am_atype = atype;
+		node.am_lnum = lnum;
+		node.am_family = af;
+		/* The address object is not persisted. */
+		node.am_flags = IPMGMT_ACTIVE;
+		err = ipmgmt_aobjmap_op(&node, ADDROBJ_ADD);
+		break;
+	case IPMGMT_CMD_AOBJNAME2ADDROBJ:
+		rsize = sizeof (ipmgmt_aobjop_rval_t);
+		rvalp = &aobjrval;
+		bzero(&aobjrval, sizeof (aobjrval));
+		if (aobjname[0] == '\0') {
+			err = EINVAL;
+			break;
+		}
+		(void) pthread_rwlock_rdlock(&aobjmap.aobjmap_rwlock);
+		head = aobjmap.aobjmap_head;
+		for (; head; head = head->am_next) {
+			if (strcmp(head->am_aobjname, aobjname) != 0)
+				continue;
+			/*
+			 * For an auto-configured interface, return
+			 * the lifnum that has the link-local on it.
+			 * Other logical interfaces were created for
+			 * prefixes and dhcpv6 addresses and do not
+			 * have am_ifid set.
+			 */
+			if (head->am_atype != IPADM_ADDR_IPV6_ADDRCONF ||
+			    head->am_linklocal) {
+				break;
+			}
+		}
+		if (head == NULL) {
+			err = ENOENT;
+			(void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock);
+			break;
+		}
+		(void) strlcpy(aobjrval.ir_ifname, head->am_ifname,
+		    sizeof (aobjrval.ir_ifname));
+		aobjrval.ir_lnum = head->am_lnum;
+		aobjrval.ir_family = head->am_family;
+		aobjrval.ir_flags = head->am_flags;
+		aobjrval.ir_atype = head->am_atype;
+		if (head->am_atype == IPADM_ADDR_IPV6_ADDRCONF &&
+		    head->am_linklocal)
+			aobjrval.ir_ifid = head->am_ifid;
+		(void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock);
+		break;
+	case IPMGMT_CMD_LIF2ADDROBJ:
+		rsize = sizeof (ipmgmt_aobjop_rval_t);
+		rvalp = &aobjrval;
+		bzero(&aobjrval, sizeof (aobjrval));
+		if (ifname[0] == '\0') {
+			err = EINVAL;
+			break;
+		}
+		(void) pthread_rwlock_rdlock(&aobjmap.aobjmap_rwlock);
+		head = aobjmap.aobjmap_head;
+		for (; head; head = head->am_next) {
+			if (strcmp(head->am_ifname, ifname) == 0 &&
+			    head->am_lnum == lnum &&
+			    head->am_family == af) {
+				break;
+			}
+		}
+		if (head == NULL) {
+			err = ENOENT;
+			(void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock);
+			break;
+		}
+		(void) strlcpy(aobjrval.ir_aobjname, head->am_aobjname,
+		    sizeof (aobjrval.ir_aobjname));
+		aobjrval.ir_atype = head->am_atype;
+		aobjrval.ir_flags = head->am_flags;
+		(void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock);
+		break;
+	default:
+		rsize = sizeof (ipmgmt_retval_t);
+		rvalp = &rval;
+		err = EINVAL;
+	}
+	((ipmgmt_retval_t *)rvalp)->ir_err = err;
+	(void) door_return((char *)rvalp, rsize, NULL, 0);
+}
+
+/*
+ * Given an interface name and family, deletes all the address objects
+ * associated with it.
+ */
+void
+i_ipmgmt_delif_aobjs(char *ifname, sa_family_t af, uint32_t flags)
+{
+	ipmgmt_aobjmap_t	*head, *next, *prev;
+	ipadm_db_op_t		db_op;
+
+	prev = NULL;
+
+	(void) pthread_rwlock_wrlock(&aobjmap.aobjmap_rwlock);
+	head = aobjmap.aobjmap_head;
+	for (; head; head = next) {
+		next = head->am_next;
+		if (strcmp(head->am_ifname, ifname) != 0 ||
+		    head->am_family != af) {
+			prev = head;
+			continue;
+		}
+
+		if (head->am_flags == (IPMGMT_ACTIVE|IPMGMT_PERSIST) &&
+		    flags == IPMGMT_ACTIVE) {
+			/*
+			 * If the addres is present in both active and
+			 * persistent store, and if we are performing
+			 * a temporary delete, we update the node to
+			 * indicate that the address is only present in
+			 * persistent store and we proceed. Otherwise
+			 * we always delete the node from aobjmap.
+			 */
+			head->am_flags &= ~IPMGMT_ACTIVE;
+			head->am_lnum = -1;
+			db_op = IPADM_DB_WRITE;
+		} else {
+			db_op = IPADM_DB_DELETE;
+			if (prev == NULL)
+				aobjmap.aobjmap_head = next;
+			else
+				prev->am_next = next;
+		}
+		(void) ipmgmt_persist_aobjmap(head, db_op);
+		if (db_op == IPADM_DB_DELETE)
+			free(head);
+	}
+	(void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_SETIF. It persists the interface
+ * information in the DB.
+ */
+static void
+ipmgmt_setif_handler(void *argp)
+{
+	ipmgmt_if_arg_t		*sargp = argp;
+	ipmgmt_retval_t		rval;
+	ipadm_dbwrite_cbarg_t	cb;
+	uint32_t		flags = sargp->ia_flags;
+	nvlist_t		*nvl = NULL;
+	int			err = 0;
+	char			strval[IPMGMT_STRSIZE];
+
+	if (!(flags & IPMGMT_PERSIST) || sargp->ia_family == AF_UNSPEC ||
+	    sargp->ia_ifname[0] == '\0') {
+		err = EINVAL;
+		goto ret;
+	}
+	if ((err = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0)) != 0)
+		goto ret;
+	if ((err = nvlist_add_string(nvl, IPADM_NVP_IFNAME,
+	    sargp->ia_ifname)) != 0)
+		goto ret;
+	(void) snprintf(strval, IPMGMT_STRSIZE, "%d", sargp->ia_family);
+	if ((err = nvlist_add_string(nvl, IPADM_NVP_FAMILY, strval)) != 0)
+		goto ret;
+	cb.dbw_nvl = nvl;
+	cb.dbw_flags = 0;
+	err = ipmgmt_db_walk(ipmgmt_db_add, &cb, IPADM_DB_WRITE);
+ret:
+	rval.ir_err = err;
+	nvlist_free(nvl);
+	(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_RESETIF. For the given interface,
+ * deletes all the persisted interface configuration. It also deletes, from
+ * `aobjmap', all the address objects configured on the given interface.
+ */
+static void
+ipmgmt_resetif_handler(void *argp)
+{
+	ipmgmt_if_arg_t		*rargp = argp;
+	ipmgmt_retval_t		rval;
+	ipmgmt_if_cbarg_t	cbarg;
+	uint32_t		flags = rargp->ia_flags;
+	int			err = 0;
+
+	cbarg.cb_family = rargp->ia_family;
+	cbarg.cb_ifname = rargp->ia_ifname;
+	if (flags & IPMGMT_PERSIST)
+		err = ipmgmt_db_walk(ipmgmt_db_resetif, &cbarg,
+		    IPADM_DB_DELETE);
+
+	if (flags & IPMGMT_ACTIVE)
+		i_ipmgmt_delif_aobjs(rargp->ia_ifname, rargp->ia_family,
+		    flags);
+
+	rval.ir_err = err;
+	(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_RESETADDR. For the given addrobj
+ * deletes all the persisted addrobj configuration. It also deletes the
+ * corresponding node, from `aobjmap'.
+ */
+static void
+ipmgmt_resetaddr_handler(void *argp)
+{
+	ipmgmt_addr_arg_t	*rargp = argp;
+	ipmgmt_retval_t		rval;
+	ipmgmt_aobjmap_t	node;
+	uint32_t		flags = rargp->ia_flags;
+	int			err = 0;
+	ipmgmt_resetaddr_cbarg_t cbarg;
+
+	cbarg.cb_aobjname = rargp->ia_aobjname;
+
+	if (flags & IPMGMT_PERSIST)
+		err = ipmgmt_db_walk(ipmgmt_db_resetaddr, &cbarg,
+		    IPADM_DB_DELETE);
+
+	if (flags & IPMGMT_ACTIVE) {
+		bzero(&node, sizeof (node));
+		(void) strlcpy(node.am_aobjname, rargp->ia_aobjname,
+		    sizeof (node.am_aobjname));
+
+		/*
+		 * am_lnum is used only for IPv6 autoconf case, since there
+		 * can be multiple nodes with the same aobjname.
+		 */
+		node.am_lnum = rargp->ia_lnum;
+		node.am_flags = flags;
+		(void) ipmgmt_aobjmap_op(&node, ADDROBJ_DELETE);
+	}
+
+	rval.ir_err = err;
+	(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_GETADDR. It retrieves the persisted
+ * address for a given `gargp->ia_aobjname'. If it is not defined then it
+ * retrieves all the addresses configured on `gargp->ia_ifname'. The
+ * "ipadm show-addr addrobj" or "ipadm show-addr <ifname>/\*" will call this
+ * handler through library.
+ */
+static void
+ipmgmt_getaddr_handler(void *argp)
+{
+	size_t			buflen, onvlsize;
+	char			*buf, *onvlbuf;
+	ipmgmt_getaddr_arg_t	*gargp = argp;
+	ipmgmt_getaddr_cbarg_t	cbarg;
+	ipmgmt_get_rval_t 	rval, *rvalp = &rval;
+	int			err = 0;
+
+	cbarg.cb_ifname = gargp->ia_ifname;
+	cbarg.cb_aobjname = gargp->ia_aobjname;
+	cbarg.cb_ocnt = 0;
+	if (nvlist_alloc(&cbarg.cb_onvl, NV_UNIQUE_NAME, 0) != 0)
+		goto fail;
+	err = ipmgmt_db_walk(ipmgmt_db_getaddr, &cbarg, IPADM_DB_READ);
+	if (err == ENOENT && cbarg.cb_ocnt > 0) {
+		/*
+		 * If there is atleast one entry in the nvlist,
+		 * do not return error.
+		 */
+		err = 0;
+	}
+	if (err != 0)
+		goto fail;
+
+	if ((err = nvlist_size(cbarg.cb_onvl, &onvlsize,
+	    NV_ENCODE_NATIVE)) != 0) {
+		goto fail;
+	}
+	buflen = onvlsize + sizeof (ipmgmt_get_rval_t);
+	/*
+	 * We cannot use malloc() here because door_return never returns, and
+	 * memory allocated by malloc() would get leaked. Use alloca() instead.
+	 */
+	buf = alloca(buflen);
+	onvlbuf = buf + sizeof (ipmgmt_get_rval_t);
+	if ((err = nvlist_pack(cbarg.cb_onvl, &onvlbuf, &onvlsize,
+	    NV_ENCODE_NATIVE, 0)) != 0) {
+		goto fail;
+	}
+	nvlist_free(cbarg.cb_onvl);
+	rvalp = (ipmgmt_get_rval_t *)(void *)buf;
+	rvalp->ir_err = 0;
+	rvalp->ir_nvlsize = onvlsize;
+
+	(void) door_return(buf, buflen, NULL, 0);
+	return;
+fail:
+	nvlist_free(cbarg.cb_onvl);
+	rvalp->ir_err = err;
+	(void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_RESETPROP. It deletes the property line
+ * from the DB.
+ */
+static void
+ipmgmt_resetprop_handler(void *argp)
+{
+	ipmgmt_prop_arg_t	*pargp = argp;
+	ipmgmt_retval_t		rval;
+
+	assert(pargp->ia_cmd == IPMGMT_CMD_RESETPROP);
+
+	rval.ir_err = ipmgmt_db_walk(ipmgmt_db_resetprop, pargp,
+	    IPADM_DB_DELETE);
+	(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_GETIF. It retrieves the name of all the
+ * persisted interfaces and the IP protocols (IPv4 or IPv6) they support.
+ */
+static void
+ipmgmt_getif_handler(void *argp)
+{
+	ipmgmt_getif_arg_t	*getif = argp;
+	ipmgmt_getif_rval_t	*rvalp;
+	ipmgmt_retval_t		rval;
+	ipmgmt_getif_cbarg_t	cbarg;
+	ipadm_if_info_t		*ifp, *rifp, *curifp;
+	int			i, err = 0, count = 0;
+	size_t			rbufsize;
+
+	assert(getif->ia_cmd == IPMGMT_CMD_GETIF);
+
+	bzero(&cbarg, sizeof (cbarg));
+	cbarg.cb_ifname = getif->ia_ifname;
+	err = ipmgmt_db_walk(ipmgmt_db_getif, &cbarg, IPADM_DB_READ);
+	if (err == ENOENT && cbarg.cb_ifinfo) {
+		/*
+		 * If there is atleast one entry in the nvlist,
+		 * do not return error.
+		 */
+		err = 0;
+	}
+	if (err != 0) {
+		rval.ir_err = err;
+		(void) door_return((char *)&rval, sizeof (rval), NULL, 0);
+		return;
+	}
+
+	/* allocate sufficient buffer to return the interface info */
+	for (ifp = cbarg.cb_ifinfo; ifp != NULL; ifp = ifp->ifi_next)
+		++count;
+	rbufsize = sizeof (*rvalp) + count * sizeof (*ifp);
+	rvalp = alloca(rbufsize);
+	bzero(rvalp, rbufsize);
+
+	rvalp->ir_ifcnt = count;
+	rifp = rvalp->ir_ifinfo;
+	ifp = cbarg.cb_ifinfo;
+
+	/*
+	 * copy the interface info to buffer allocated on stack. The reason
+	 * we do this is to avoid memory leak, as door_return() would never
+	 * return
+	 */
+	for (i = 0; i < count; i++) {
+		rifp = rvalp->ir_ifinfo + i;
+		(void) bcopy(ifp, rifp, sizeof (*rifp));
+		rifp->ifi_next = NULL;
+		curifp = ifp->ifi_next;
+		free(ifp);
+		ifp = curifp;
+	}
+	rvalp->ir_err = err;
+	(void) door_return((char *)rvalp, rbufsize, NULL, 0);
+}
+
+/*
+ * Handles the door command IPMGMT_CMD_INITIF. It retrieves all the persisted
+ * interface configuration (interface properties and addresses), for all those
+ * interfaces that need to be initialized.
+ */
+static void
+ipmgmt_initif_handler(void *argp)
+{
+	ipmgmt_initif_arg_t	*initif = argp;
+	size_t			buflen, nvlsize;
+	char			*buf = NULL, *onvlbuf, *invlbuf;
+	ipmgmt_get_rval_t	rval, *rvalp = &rval;
+	ipmgmt_initif_cbarg_t	cbarg;
+	int			err;
+
+	assert(initif->ia_cmd == IPMGMT_CMD_INITIF);
+
+	bzero(&cbarg, sizeof (cbarg));
+	invlbuf = (char *)argp + sizeof (ipmgmt_initif_arg_t);
+	nvlsize = initif->ia_nvlsize;
+	err = nvlist_unpack(invlbuf, nvlsize, &cbarg.cb_invl, NV_ENCODE_NATIVE);
+	if (err != 0)
+		goto fail;
+
+	cbarg.cb_family = initif->ia_family;
+	if (nvlist_alloc(&cbarg.cb_onvl, NV_UNIQUE_NAME, 0) != 0)
+		goto fail;
+
+	err = ipmgmt_db_walk(ipmgmt_db_initif, &cbarg, IPADM_DB_READ);
+	if (err == ENOENT && cbarg.cb_ocnt > 0) {
+		/*
+		 * If there is atleast one entry in the nvlist,
+		 * do not return error.
+		 */
+		err = 0;
+	}
+	if (err != 0)
+		goto fail;
+
+	if ((err = nvlist_size(cbarg.cb_onvl, &nvlsize, NV_ENCODE_NATIVE)) != 0)
+		goto fail;
+	buflen = nvlsize + sizeof (ipmgmt_get_rval_t);
+	/*
+	 * We cannot use malloc() here because door_return never returns, and
+	 * memory allocated by malloc() would get leaked. Use alloca() instead.
+	 */
+	buf = alloca(buflen);
+	onvlbuf = buf + sizeof (ipmgmt_get_rval_t);
+	if ((err = nvlist_pack(cbarg.cb_onvl, &onvlbuf, &nvlsize,
+	    NV_ENCODE_NATIVE, 0)) != 0) {
+		goto fail;
+	}
+	nvlist_free(cbarg.cb_invl);
+	nvlist_free(cbarg.cb_onvl);
+	rvalp = (ipmgmt_get_rval_t *)(void *)buf;
+	rvalp->ir_err = 0;
+	rvalp->ir_nvlsize = nvlsize;
+
+	(void) door_return(buf, buflen, NULL, 0);
+	return;
+fail:
+	nvlist_free(cbarg.cb_invl);
+	nvlist_free(cbarg.cb_onvl);
+	rvalp->ir_err = err;
+	(void) door_return((char *)rvalp, sizeof (*rvalp), NULL, 0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/ipmgmt_impl.h	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,152 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+#ifndef	_IPMGMT_IMPL_H
+#define	_IPMGMT_IMPL_H
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+#include <net/if.h>
+#include <libnvpair.h>
+#include <libipadm.h>
+#include <ipadm_ipmgmt.h>
+#include <syslog.h>
+#include <pthread.h>
+
+#define	IPMGMT_STRSIZE		256
+
+/* ipmgmt_door.c */
+extern void	ipmgmt_handler(void *, char *, size_t, door_desc_t *, uint_t);
+
+/* ipmgmt_util.c */
+extern void	ipmgmt_log(int, const char *, ...);
+
+/* ipmgmt_persist.c */
+
+/*
+ * following are the list of DB walker callback functions and the callback
+ * arguments for each of the callback functions used by the daemon
+ */
+/* following functions take 'ipmgmt_prop_arg_t' as the callback argument */
+extern db_wfunc_t	ipmgmt_db_getprop, ipmgmt_db_resetprop;
+
+/* following functions take ipadm_dbwrite_cbarg_t as callback argument */
+extern db_wfunc_t	ipmgmt_db_add, ipmgmt_db_update;
+
+typedef struct {
+	char		*cb_ifname;
+	ipadm_if_info_t	*cb_ifinfo;
+} ipmgmt_getif_cbarg_t;
+extern db_wfunc_t	ipmgmt_db_getif;
+
+typedef struct {
+	char		*cb_aobjname;
+	char		*cb_ifname;
+	nvlist_t	*cb_onvl;
+	int		cb_ocnt;
+} ipmgmt_getaddr_cbarg_t;
+extern db_wfunc_t	ipmgmt_db_getaddr;
+
+typedef struct {
+	sa_family_t	cb_family;
+	char		*cb_ifname;
+} ipmgmt_if_cbarg_t;
+extern db_wfunc_t	ipmgmt_db_setif, ipmgmt_db_resetif;
+
+typedef struct {
+	char		*cb_aobjname;
+} ipmgmt_resetaddr_cbarg_t;
+extern db_wfunc_t	ipmgmt_db_resetaddr;
+
+typedef struct {
+	sa_family_t	cb_family;
+	nvlist_t	*cb_invl;
+	nvlist_t	*cb_onvl;
+	int		cb_ocnt;
+} ipmgmt_initif_cbarg_t;
+extern db_wfunc_t	ipmgmt_db_initif;
+
+/*
+ * A linked list of address object nodes. Each node in the list tracks
+ * following information for the address object identified by `am_aobjname'.
+ *	- interface on which the address is created
+ * 	- logical interface number on which the address is created
+ *	- address family
+ *	- `am_nextnum' identifies the next number to use to generate user part
+ *	  of `aobjname'.
+ *	- address type (static, dhcp or addrconf)
+ *	- `am_flags' indicates if this addrobj in active and/or persist config
+ *	- if `am_atype' is IPADM_ADDR_IPV6_ADDRCONF then `am_ifid' holds the
+ *	  interface-id used to configure auto-configured addresses
+ */
+typedef struct ipmgmt_aobjmap_s {
+	struct ipmgmt_aobjmap_s	*am_next;
+	char			am_aobjname[IPADM_AOBJSIZ];
+	char			am_ifname[LIFNAMSIZ];
+	int32_t			am_lnum;
+	sa_family_t		am_family;
+	ipadm_addr_type_t	am_atype;
+	uint32_t		am_nextnum;
+	uint32_t		am_flags;
+	boolean_t		am_linklocal;
+	struct sockaddr_storage	am_ifid;
+} ipmgmt_aobjmap_t;
+
+/* linked list of `aobjmap' nodes, protected by RW lock */
+typedef struct ipmgmt_aobjmap_list_s {
+	ipmgmt_aobjmap_t	*aobjmap_head;
+	pthread_rwlock_t	aobjmap_rwlock;
+} ipmgmt_aobjmap_list_t;
+
+/* global `aobjmap' defined in ipmgmt_main.c */
+extern ipmgmt_aobjmap_list_t aobjmap;
+
+/* operations on the `aobjmap' linked list */
+#define	ADDROBJ_ADD		0x00000001
+#define	ADDROBJ_DELETE		0x00000002
+#define	ADDROBJ_LOOKUPADD	0x00000004
+
+/*
+ * A temporary file created in SMF volatile filesystem. This file captures the
+ * in-memory copy of list `aobjmap' on disk. This is done to recover from
+ * daemon reboot (using svcadm) or crashes.
+ */
+#define	ADDROBJ_MAPPING_DB_FILE	IPADM_TMPFS_DIR"/aobjmap.conf"
+
+extern int		ipmgmt_db_walk(db_wfunc_t *, void *, ipadm_db_op_t);
+extern int		ipmgmt_aobjmap_op(ipmgmt_aobjmap_t *, uint32_t);
+extern boolean_t	ipmgmt_aobjmap_init(void *, nvlist_t *, char *,
+			    size_t, int *);
+extern int 		ipmgmt_persist_aobjmap(ipmgmt_aobjmap_t *,
+			    ipadm_db_op_t);
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif	/* _IPMGMT_IMPL_H */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/ipmgmt_main.c	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,382 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * The ipmgmtd daemon is started by ip-interface-management SMF service. This
+ * daemon is used to manage, mapping of 'address object' to 'interface name' and
+ * 'logical interface number', on which the address is created. It also provides
+ * a means to update the ipadm persistent data-store.
+ *
+ * The daemon tracks the <addrobj, lifname> mapping in-memory using a linked
+ * list `aobjmap'. Access to this list is synchronized using a readers-writers
+ * lock. The active <addrobj, lifname> mapping is kept in
+ * /etc/svc/volatile/ipadm/aobjmap.conf cache file, so that the mapping can be
+ * recovered when ipmgmtd exits for some reason (e.g., when ipmgmtd is restarted
+ * using svcadm or accidentally killed).
+ *
+ * Today, the persistent configuration of interfaces, addresses and protocol
+ * properties is kept in /etc/ipadm/ipadm.conf. The access to the persistent
+ * data store is synchronized using reader-writers lock `ipmgmt_dbconf_lock'.
+ *
+ * The communication between the library, libipadm.so and the daemon, is through
+ * doors RPC. The library interacts with the daemon using the commands defined
+ * by `ipmgmt_door_cmd_type_t'. Further any 'write' operation would require
+ * the `NETWORK_INTERFACE_CONFIG_AUTH' authorization.
+ *
+ * On reboot, the aforementioned SMF service starts the daemon before any other
+ * networking service that configures network IP interfaces is started.
+ * Afterwards, the network/physical SMF script instantiates the persisted
+ * network interfaces, interface properties and addresses.
+ */
+
+#include <errno.h>
+#include <fcntl.h>
+#include <priv_utils.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <strings.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include "ipmgmt_impl.h"
+
+const char		*progname;
+
+/* readers-writers lock for reading/writing daemon data store */
+pthread_rwlock_t	ipmgmt_dbconf_lock;
+
+/* tracks address object to {ifname|logical number|interface id} mapping */
+ipmgmt_aobjmap_list_t	aobjmap;
+
+/* used to communicate failure to parent process, which spawned the daemon */
+static int		pfds[2];
+
+/* file descriptor to IPMGMT_DOOR */
+static int		ipmgmt_door_fd = -1;
+
+static void		ipmgmt_exit(int);
+static int		ipmgmt_init();
+static int		ipmgmt_init_privileges();
+
+static int
+ipmgmt_db_init()
+{
+	int		fd, err;
+
+	/* creates the address object data store, if it doesn't exist */
+	if ((fd = open(ADDROBJ_MAPPING_DB_FILE, O_CREAT|O_RDONLY,
+	    IPADM_FILE_MODE)) == -1) {
+		err = errno;
+		ipmgmt_log(LOG_ERR, "could not open %s: %s",
+		    ADDROBJ_MAPPING_DB_FILE, strerror(err));
+		return (err);
+	}
+	(void) close(fd);
+
+	aobjmap.aobjmap_head = NULL;
+	(void) pthread_rwlock_init(&aobjmap.aobjmap_rwlock, NULL);
+
+	/*
+	 * If the daemon is recovering from a crash or restart, read the
+	 * address object to logical interface mapping and build an in-memory
+	 * representation of the mapping. That is, build `aobjmap' structure
+	 * from address object data store.
+	 */
+	if ((err = ipadm_rw_db(ipmgmt_aobjmap_init, NULL,
+	    ADDROBJ_MAPPING_DB_FILE, 0, IPADM_DB_READ)) != 0) {
+		/* if there was nothing to initialize, it's fine */
+		if (err != ENOENT)
+			return (err);
+		err = 0;
+	}
+
+	(void) pthread_rwlock_init(&ipmgmt_dbconf_lock, NULL);
+	return (err);
+}
+
+static int
+ipmgmt_door_init()
+{
+	int fd;
+	int err;
+
+	/* create the door file for ipmgmtd */
+	if ((fd = open(IPMGMT_DOOR, O_CREAT|O_RDONLY, IPADM_FILE_MODE)) == -1) {
+		err = errno;
+		ipmgmt_log(LOG_ERR, "could not open %s: %s",
+		    IPMGMT_DOOR, strerror(err));
+		return (err);
+	}
+	(void) close(fd);
+
+	if ((ipmgmt_door_fd = door_create(ipmgmt_handler, NULL,
+	    DOOR_REFUSE_DESC | DOOR_NO_CANCEL)) == -1) {
+		err = errno;
+		ipmgmt_log(LOG_ERR, "failed to create door: %s", strerror(err));
+		return (err);
+	}
+	/*
+	 * fdetach first in case a previous daemon instance exited
+	 * ungracefully.
+	 */
+	(void) fdetach(IPMGMT_DOOR);
+	if (fattach(ipmgmt_door_fd, IPMGMT_DOOR) != 0) {
+		err = errno;
+		ipmgmt_log(LOG_ERR, "failed to attach door to %s: %s",
+		    IPMGMT_DOOR, strerror(err));
+		goto fail;
+	}
+	return (0);
+fail:
+	(void) door_revoke(ipmgmt_door_fd);
+	ipmgmt_door_fd = -1;
+	return (err);
+}
+
+static void
+ipmgmt_door_fini()
+{
+	if (ipmgmt_door_fd == -1)
+		return;
+
+	(void) fdetach(IPMGMT_DOOR);
+	if (door_revoke(ipmgmt_door_fd) == -1) {
+		ipmgmt_log(LOG_ERR, "failed to revoke access to door %s: %s",
+		    IPMGMT_DOOR, strerror(errno));
+	}
+}
+
+static int
+ipmgmt_init()
+{
+	int err;
+
+	if (signal(SIGTERM, ipmgmt_exit) == SIG_ERR ||
+	    signal(SIGINT, ipmgmt_exit) == SIG_ERR) {
+		err = errno;
+		ipmgmt_log(LOG_ERR, "signal() for SIGTERM/INT failed: %s",
+		    strerror(err));
+		return (err);
+	}
+	if ((err = ipmgmt_db_init()) != 0 || (err = ipmgmt_door_init()) != 0)
+		return (err);
+	return (0);
+}
+
+/*
+ * This is called by the child process to inform the parent process to
+ * exit with the given return value.
+ */
+static void
+ipmgmt_inform_parent_exit(int rv)
+{
+	if (write(pfds[1], &rv, sizeof (int)) != sizeof (int)) {
+		ipmgmt_log(LOG_WARNING,
+		    "failed to inform parent process of status: %s",
+		    strerror(errno));
+		(void) close(pfds[1]);
+		exit(EXIT_FAILURE);
+	}
+	(void) close(pfds[1]);
+}
+
+/*ARGSUSED*/
+static void
+ipmgmt_exit(int signo)
+{
+	(void) close(pfds[1]);
+	ipmgmt_door_fini();
+	exit(EXIT_FAILURE);
+}
+
+/*
+ * Set the uid of this daemon to the "ipadm" user. Finish the following
+ * operations before setuid() because they need root privileges:
+ *
+ *    - create the /etc/svc/volatile/ipadm directory;
+ *    - change its uid/gid to "ipadm"/"sys";
+ */
+static int
+ipmgmt_init_privileges()
+{
+	struct stat	statbuf;
+	int err;
+
+	/* create the IPADM_TMPFS_DIR directory */
+	if (stat(IPADM_TMPFS_DIR, &statbuf) < 0) {
+		if (mkdir(IPADM_TMPFS_DIR, (mode_t)0755) < 0) {
+			err = errno;
+			goto fail;
+		}
+	} else {
+		if ((statbuf.st_mode & S_IFMT) != S_IFDIR) {
+			err = ENOTDIR;
+			goto fail;
+		}
+	}
+
+	if ((chmod(IPADM_TMPFS_DIR, 0755) < 0) ||
+	    (chown(IPADM_TMPFS_DIR, UID_NETADM, GID_NETADM) < 0)) {
+		err = errno;
+		goto fail;
+	}
+
+	/*
+	 * limit the privileges of this daemon and set the uid of this
+	 * daemon to UID_NETADM
+	 */
+	if (__init_daemon_priv(PU_RESETGROUPS|PU_CLEARLIMITSET, UID_NETADM,
+	    GID_NETADM, NULL) == -1) {
+		err = EPERM;
+		goto fail;
+	}
+
+	return (0);
+fail:
+	(void) ipmgmt_log(LOG_ERR, "failed to initialize the daemon: %s",
+	    strerror(err));
+	return (err);
+}
+
+/*
+ * Keep the pfds fd open, close other fds.
+ */
+/*ARGSUSED*/
+static int
+closefunc(void *arg, int fd)
+{
+	if (fd != pfds[1])
+		(void) close(fd);
+	return (0);
+}
+
+/*
+ * We cannot use libc's daemon() because the door we create is associated with
+ * the process ID. If we create the door before the call to daemon(), it will
+ * be associated with the parent and it's incorrect. On the other hand if we
+ * create the door later, after the call to daemon(), parent process exits
+ * early and gives a false notion to SMF that 'ipmgmtd' is up and running,
+ * which is incorrect. So, we have our own daemon() equivalent.
+ */
+static boolean_t
+ipmgmt_daemonize(void)
+{
+	pid_t pid;
+	int rv;
+
+	if (pipe(pfds) < 0) {
+		(void) fprintf(stderr, "%s: pipe() failed: %s\n",
+		    progname, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
+
+	if ((pid = fork()) == -1) {
+		(void) fprintf(stderr, "%s: fork() failed: %s\n",
+		    progname, strerror(errno));
+		exit(EXIT_FAILURE);
+	} else if (pid > 0) { /* Parent */
+		(void) close(pfds[1]);
+
+		/*
+		 * Parent should not exit early, it should wait for the child
+		 * to return Success/Failure. If the parent exits early, then
+		 * SMF will think 'ipmgmtd' is up and would start all the
+		 * depended services.
+		 *
+		 * If the child process exits unexpectedly, read() returns -1.
+		 */
+		if (read(pfds[0], &rv, sizeof (int)) != sizeof (int)) {
+			(void) kill(pid, SIGKILL);
+			rv = EXIT_FAILURE;
+		}
+
+		(void) close(pfds[0]);
+		exit(rv);
+	}
+
+	/* Child */
+	(void) close(pfds[0]);
+	(void) setsid();
+
+	/* close all files except pfds[1] */
+	(void) fdwalk(closefunc, NULL);
+	(void) chdir("/");
+	openlog(progname, LOG_PID, LOG_DAEMON);
+	return (B_TRUE);
+}
+
+int
+main(int argc, char *argv[])
+{
+	int opt;
+	boolean_t fg = B_FALSE;
+
+	progname = strrchr(argv[0], '/');
+	if (progname != NULL)
+		progname++;
+	else
+		progname = argv[0];
+
+	/* Process options */
+	while ((opt = getopt(argc, argv, "f")) != EOF) {
+		switch (opt) {
+		case 'f':
+			fg = B_TRUE;
+			break;
+		default:
+			(void) fprintf(stderr, "Usage: %s [-f]\n", progname);
+			return (EXIT_FAILURE);
+		}
+	}
+
+	if (!fg && getenv("SMF_FMRI") == NULL) {
+		(void) fprintf(stderr,
+		    "ipmgmtd is a smf(5) managed service and cannot be run "
+		    "from the command line.\n");
+		return (EINVAL);
+	}
+
+	if (!fg && !ipmgmt_daemonize())
+		return (EXIT_FAILURE);
+
+	if (ipmgmt_init_privileges() != 0)
+		goto child_out;
+
+	if (ipmgmt_init() != 0)
+		goto child_out;
+
+	/* Inform the parent process that it can successfully exit */
+	ipmgmt_inform_parent_exit(EXIT_SUCCESS);
+
+	for (;;)
+		(void) pause();
+
+child_out:
+	/* return from main() forcibly exits an MT process */
+	ipmgmt_inform_parent_exit(EXIT_FAILURE);
+	return (EXIT_FAILURE);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/ipmgmt_persist.c	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,1136 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Contains DB walker functions, which are of type `db_wfunc_t';
+ *
+ * typedef boolean_t db_wfunc_t(void *cbarg, nvlist_t *db_nvl, char *buf,
+ *				size_t bufsize, int *errp);
+ *
+ * ipadm_rw_db() walks through the data store, one line at a time and calls
+ * these call back functions with:
+ *	`cbarg'  - callback argument
+ *	`db_nvl' - representing a line from DB in nvlist_t form
+ *	`buf'	 - character buffer to hold modified line
+ *	`bufsize'- size of the buffer
+ *	`errp' - captures any error inside the walker function.
+ *
+ * All the 'write' callback functions modify `db_nvl' based on `cbarg' and
+ * copy string representation of `db_nvl' (using ipadm_nvlist2str()) into `buf'.
+ * To delete a line from the DB, buf[0] is set to `\0'. Inside ipadm_rw_db(),
+ * the modified `buf' is written back into DB.
+ *
+ * All the 'read' callback functions, retrieve the information from the DB, by
+ * reading `db_nvl' and then populate the `cbarg'.
+ */
+
+#include <stdlib.h>
+#include <strings.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include "ipmgmt_impl.h"
+
+#define	ATYPE	"_atype"		/* name of the address type nvpair */
+#define	FLAGS	"_flags"		/* name of the flags nvpair */
+
+/*
+ * flag used by ipmgmt_persist_aobjmap() to indicate address type is
+ * IPADM_ADDR_IPV6_ADDRCONF.
+ */
+#define	IPMGMT_ATYPE_V6ACONF	0x1
+
+extern pthread_rwlock_t ipmgmt_dbconf_lock;
+
+/*
+ * Checks if the database nvl, `db_nvl' contains and matches ALL of the passed
+ * in private nvpairs `proto', `ifname' & `aobjname'.
+ */
+static boolean_t
+ipmgmt_nvlist_match(nvlist_t *db_nvl, const char *proto, const char *ifname,
+    const char *aobjname)
+{
+	char		*db_proto = NULL, *db_ifname = NULL;
+	char		*db_aobjname = NULL;
+	nvpair_t	*nvp;
+	char		*name;
+
+	/* walk through db_nvl and retrieve all its private nvpairs */
+	for (nvp = nvlist_next_nvpair(db_nvl, NULL); nvp != NULL;
+	    nvp = nvlist_next_nvpair(db_nvl, nvp)) {
+		name = nvpair_name(nvp);
+		if (strcmp(IPADM_NVP_PROTONAME, name) == 0)
+			(void) nvpair_value_string(nvp, &db_proto);
+		else if (strcmp(IPADM_NVP_IFNAME, name) == 0)
+			(void) nvpair_value_string(nvp, &db_ifname);
+		else if (strcmp(IPADM_NVP_AOBJNAME, name) == 0)
+			(void) nvpair_value_string(nvp, &db_aobjname);
+	}
+
+	if (proto != NULL && proto[0] == '\0')
+		proto = NULL;
+	if (ifname != NULL && ifname[0] == '\0')
+		ifname = NULL;
+	if (aobjname != NULL && aobjname[0] == '\0')
+		aobjname = NULL;
+
+	if ((proto == NULL && db_proto != NULL) ||
+	    (proto != NULL && db_proto == NULL) ||
+	    strcmp(proto, db_proto) != 0) {
+		/* no intersection - different protocols. */
+		return (B_FALSE);
+	}
+	if ((ifname == NULL && db_ifname != NULL) ||
+	    (ifname != NULL && db_ifname == NULL) ||
+	    strcmp(ifname, db_ifname) != 0) {
+		/* no intersection - different interfaces. */
+		return (B_FALSE);
+	}
+	if ((aobjname == NULL && db_aobjname != NULL) ||
+	    (aobjname != NULL && db_aobjname == NULL) ||
+	    strcmp(aobjname, db_aobjname) != 0) {
+		/* no intersection - different address objects */
+		return (B_FALSE);
+	}
+
+	return (B_TRUE);
+}
+
+/*
+ * Checks if the database nvl, `db_nvl' and the input nvl, `in_nvl' intersects.
+ */
+static boolean_t
+ipmgmt_nvlist_intersects(nvlist_t *db_nvl, nvlist_t *in_nvl)
+{
+	nvpair_t	*nvp;
+	char		*name;
+	char		*proto = NULL, *ifname = NULL, *aobjname = NULL;
+
+	/* walk through in_nvl and retrieve all its private nvpairs */
+	for (nvp = nvlist_next_nvpair(in_nvl, NULL); nvp != NULL;
+	    nvp = nvlist_next_nvpair(in_nvl, nvp)) {
+		name = nvpair_name(nvp);
+		if (strcmp(IPADM_NVP_PROTONAME, name) == 0)
+			(void) nvpair_value_string(nvp, &proto);
+		else if (strcmp(IPADM_NVP_IFNAME, name) == 0)
+			(void) nvpair_value_string(nvp, &ifname);
+		else if (strcmp(IPADM_NVP_AOBJNAME, name) == 0)
+			(void) nvpair_value_string(nvp, &aobjname);
+	}
+
+	return (ipmgmt_nvlist_match(db_nvl, proto, ifname, aobjname));
+}
+
+/*
+ * Checks if the database nvl, `db_nvl', contains and matches ANY of the passed
+ * in private nvpairs `proto', `ifname' & `aobjname'.
+ */
+static boolean_t
+ipmgmt_nvlist_contains(nvlist_t *db_nvl, const char *proto,
+    const char *ifname, char *aobjname)
+{
+	char		*db_ifname = NULL, *db_proto = NULL;
+	char		*db_aobjname = NULL;
+	nvpair_t	*nvp;
+	char		*name;
+
+	/* walk through db_nvl and retrieve all private nvpairs */
+	for (nvp = nvlist_next_nvpair(db_nvl, NULL); nvp != NULL;
+	    nvp = nvlist_next_nvpair(db_nvl, nvp)) {
+		name = nvpair_name(nvp);
+		if (strcmp(IPADM_NVP_PROTONAME, name) == 0)
+			(void) nvpair_value_string(nvp, &db_proto);
+		else if (strcmp(IPADM_NVP_IFNAME, name) == 0)
+			(void) nvpair_value_string(nvp, &db_ifname);
+		else if (strcmp(IPADM_NVP_AOBJNAME, name) == 0)
+			(void) nvpair_value_string(nvp, &db_aobjname);
+	}
+
+	if (proto != NULL && proto[0] != '\0') {
+		if ((db_proto == NULL || strcmp(proto, db_proto) != 0))
+			return (B_FALSE);
+	}
+	if (ifname != NULL && ifname[0] != '\0') {
+		if ((db_ifname == NULL || strcmp(ifname, db_ifname) != 0))
+			return (B_FALSE);
+	}
+	if (aobjname != NULL && aobjname[0] != '\0') {
+		if ((db_aobjname == NULL || strcmp(aobjname, db_aobjname) != 0))
+			return (B_FALSE);
+	}
+
+	return (B_TRUE);
+}
+
+/*
+ * Retrieves the property value from the DB. The property whose value is to be
+ * retrieved is in `pargp->ia_pname'.
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_getprop(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_prop_arg_t	*pargp = arg;
+	boolean_t		cont = B_TRUE;
+	char			*pval;
+	int			err = 0;
+
+	*errp = 0;
+
+	if (!ipmgmt_nvlist_match(db_nvl, pargp->ia_module,
+	    pargp->ia_ifname, pargp->ia_aobjname))
+		return (B_TRUE);
+
+	if ((err = nvlist_lookup_string(db_nvl, pargp->ia_pname,
+	    &pval)) == 0) {
+		(void) strlcpy(pargp->ia_pval, pval, sizeof (pargp->ia_pval));
+		/*
+		 * We have retrieved what we are looking for.
+		 * Stop the walker.
+		 */
+		cont = B_FALSE;
+	} else {
+		if (err == ENOENT)
+			err = 0;
+		*errp = err;
+	}
+
+	return (cont);
+}
+
+/*
+ * Removes the property value from the DB. The property whose value is to be
+ * removed is in `pargp->ia_pname'.
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_resetprop(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_prop_arg_t	*pargp = arg;
+
+	*errp = 0;
+	if (!ipmgmt_nvlist_match(db_nvl, pargp->ia_module,
+	    pargp->ia_ifname, pargp->ia_aobjname))
+		return (B_TRUE);
+
+	if (!nvlist_exists(db_nvl, pargp->ia_pname))
+		return (B_TRUE);
+
+	/*
+	 * We found the property in the DB. If IPMGMT_REMOVE is not set then
+	 * delete the entry from the db. If it is set, then the property is a
+	 * multi-valued property so just remove the specified values from DB.
+	 */
+	if (pargp->ia_flags & IPMGMT_REMOVE) {
+		char	*dbpval = NULL;
+		char	*inpval = pargp->ia_pval;
+		char	pval[MAXPROPVALLEN];
+		char	*val, *lasts;
+
+		*errp = nvlist_lookup_string(db_nvl, pargp->ia_pname, &dbpval);
+		if (*errp != 0)
+			return (B_FALSE);
+
+		/*
+		 * multi-valued properties are represented as comma separated
+		 * values. Use string tokenizer functions to split them and
+		 * search for the value to be removed.
+		 */
+		bzero(pval, sizeof (pval));
+		if ((val = strtok_r(dbpval, ",", &lasts)) != NULL) {
+			if (strcmp(val, inpval) != 0)
+				(void) strlcat(pval, val, MAXPROPVALLEN);
+			while ((val = strtok_r(NULL, ",", &lasts)) != NULL) {
+				if (strcmp(val, inpval) != 0) {
+					if (pval[0] != '\0')
+						(void) strlcat(pval, ",",
+						    MAXPROPVALLEN);
+					(void) strlcat(pval, val,
+					    MAXPROPVALLEN);
+				}
+			}
+		} else {
+			if (strcmp(dbpval, inpval) != 0)
+				*errp = ENOENT;
+			else
+				buf[0] =  '\0';
+			return (B_FALSE);
+		}
+		*errp = nvlist_add_string(db_nvl, pargp->ia_pname, pval);
+		if (*errp != 0)
+			return (B_FALSE);
+
+		(void) memset(buf, 0, buflen);
+		if (ipadm_nvlist2str(db_nvl, buf, buflen) == 0) {
+			/* buffer overflow */
+			*errp = ENOBUFS;
+		}
+	} else {
+		buf[0] = '\0';
+	}
+
+	/* stop the search */
+	return (B_FALSE);
+}
+
+/*
+ * Input arguments can have IPADM_NVP_AOBJNAME or IPADM_NVP_IFNAME. A match is
+ * found, when one of the following occurs first.
+ * - the input aobjname matches the db aobjname. Return the db address.
+ * - the input interface matches the db interface. Return all the
+ *   matching db lines with addresses.
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_getaddr(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_getaddr_cbarg_t	*cbarg = arg;
+	char		*db_aobjname = NULL;
+	char		*db_ifname = NULL;
+	nvlist_t	*db_addr = NULL;
+	char		name[IPMGMT_STRSIZE];
+	nvpair_t	*nvp;
+	boolean_t	add_nvl = B_FALSE;
+
+	/* Parse db nvlist */
+	for (nvp = nvlist_next_nvpair(db_nvl, NULL); nvp != NULL;
+	    nvp = nvlist_next_nvpair(db_nvl, nvp)) {
+		if (nvpair_type(nvp) == DATA_TYPE_NVLIST)
+			(void) nvpair_value_nvlist(nvp, &db_addr);
+		else if (strcmp(nvpair_name(nvp), IPADM_NVP_IFNAME) == 0)
+			(void) nvpair_value_string(nvp, &db_ifname);
+		else if (strcmp(nvpair_name(nvp), IPADM_NVP_AOBJNAME) == 0)
+			(void) nvpair_value_string(nvp, &db_aobjname);
+	}
+
+	if (db_aobjname == NULL) /* Not an address */
+		return (B_TRUE);
+
+	/* Check for a match between the aobjnames or the interface name */
+	if (cbarg->cb_aobjname[0] != '\0') {
+		if (strcmp(cbarg->cb_aobjname, db_aobjname) == 0)
+			add_nvl = B_TRUE;
+	} else if (cbarg->cb_ifname[0] != '\0') {
+		if (strcmp(cbarg->cb_ifname, db_ifname) == 0)
+			add_nvl = B_TRUE;
+	} else {
+		add_nvl = B_TRUE;
+	}
+
+	if (add_nvl) {
+		(void) snprintf(name, sizeof (name), "%s_%d", db_ifname,
+		    cbarg->cb_ocnt);
+		*errp = nvlist_add_nvlist(cbarg->cb_onvl, name, db_nvl);
+		if (*errp == 0)
+			cbarg->cb_ocnt++;
+	}
+	return (B_TRUE);
+}
+
+/*
+ * This function takes the appropriate lock, read or write, based on the
+ * `db_op' and then calls DB walker ipadm_rw_db().
+ */
+extern int
+ipmgmt_db_walk(db_wfunc_t *db_walk_func, void *db_warg, ipadm_db_op_t db_op)
+{
+	int		err;
+	boolean_t	writeop;
+	mode_t		mode;
+
+	writeop = (db_op != IPADM_DB_READ);
+
+	if (writeop) {
+		(void) pthread_rwlock_wrlock(&ipmgmt_dbconf_lock);
+		mode = IPADM_FILE_MODE;
+	} else {
+		(void) pthread_rwlock_rdlock(&ipmgmt_dbconf_lock);
+		mode = 0;
+	}
+
+	err = ipadm_rw_db(db_walk_func, db_warg, IPADM_DB_FILE, mode, db_op);
+	(void) pthread_rwlock_unlock(&ipmgmt_dbconf_lock);
+	return (err);
+}
+
+/*
+ * Used to add an entry towards the end of DB. It just returns B_TRUE for
+ * every line of the DB. When we reach the end, ipadm_rw_db() adds the
+ * line at the end.
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_add(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen, int *errp)
+{
+	return (B_TRUE);
+}
+
+/*
+ * This function is used to update or create an entry in DB. The nvlist_t,
+ * `in_nvl', represents the line we are looking for. Once we ensure the right
+ * line from DB, we update that entry.
+ */
+boolean_t
+ipmgmt_db_update(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipadm_dbwrite_cbarg_t	*cb = arg;
+	uint_t			flags = cb->dbw_flags;
+	nvlist_t		*in_nvl = cb->dbw_nvl;
+	nvpair_t		*nvp;
+	char			*name, *instrval = NULL, *dbstrval = NULL;
+	char			pval[MAXPROPVALLEN];
+
+	if (!ipmgmt_nvlist_intersects(db_nvl, in_nvl))
+		return (B_TRUE);
+
+	for (nvp = nvlist_next_nvpair(in_nvl, NULL); nvp != NULL;
+	    nvp = nvlist_next_nvpair(in_nvl, nvp)) {
+		name = nvpair_name(nvp);
+		if (!IPADM_PRIV_NVP(name) && nvlist_exists(db_nvl, name))
+			break;
+	}
+
+	if (nvp == NULL)
+		return (B_TRUE);
+
+	assert(nvpair_type(nvp) == DATA_TYPE_STRING);
+
+	if ((*errp = nvpair_value_string(nvp, &instrval)) != 0)
+		return (B_FALSE);
+
+	/*
+	 * If IPMGMT_APPEND is set then we are dealing with multi-valued
+	 * properties. We append to the entry from the db, with the new value.
+	 */
+	if (flags & IPMGMT_APPEND) {
+		if ((*errp = nvlist_lookup_string(db_nvl, name,
+		    &dbstrval)) != 0)
+			return (B_FALSE);
+		(void) snprintf(pval, MAXPROPVALLEN, "%s,%s", dbstrval,
+		    instrval);
+		if ((*errp = nvlist_add_string(db_nvl, name, pval)) != 0)
+			return (B_FALSE);
+	} else {
+		/* case	of in-line update of a db entry */
+		if ((*errp = nvlist_add_string(db_nvl, name, instrval)) != 0)
+			return (B_FALSE);
+	}
+
+	(void) memset(buf, 0, buflen);
+	if (ipadm_nvlist2str(db_nvl, buf, buflen) == 0) {
+		/* buffer overflow */
+		*errp = ENOBUFS;
+	}
+	*errp = 0;
+
+	/* we updated the DB entry, so do not continue */
+	return (B_FALSE);
+}
+
+/*
+ * For the given `cbarg->cb_ifname' interface, retrieves any persistent
+ * interface information (used in 'ipadm show-if')
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_getif(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_getif_cbarg_t	*cbarg = arg;
+	char			*ifname = cbarg->cb_ifname;
+	char			*intf = NULL;
+	ipadm_if_info_t		*ifp = NULL;
+	sa_family_t		af;
+	char			*afstr;
+
+	*errp = 0;
+	if (nvlist_lookup_string(db_nvl, IPADM_NVP_FAMILY, &afstr) != 0 ||
+	    nvlist_lookup_string(db_nvl, IPADM_NVP_IFNAME, &intf) != 0 ||
+	    (ifname[0] != '\0' && strcmp(ifname, intf) != 0)) {
+		return (B_TRUE);
+	}
+	af = atoi(afstr);
+	for (ifp = cbarg->cb_ifinfo; ifp != NULL; ifp = ifp->ifi_next) {
+		if (strcmp(ifp->ifi_name, intf) == 0)
+			break;
+	}
+	if (ifp == NULL) {
+		ipadm_if_info_t *new;
+
+		if ((new = calloc(1, sizeof (*new))) == NULL) {
+			*errp = ENOMEM;
+			return (B_FALSE); /* don't continue the walk */
+		}
+		new->ifi_next = cbarg->cb_ifinfo;
+		cbarg->cb_ifinfo = new;
+		ifp = new;
+		(void) strlcpy(ifp->ifi_name, intf, sizeof (ifp->ifi_name));
+	}
+
+	if (af == AF_INET) {
+		ifp->ifi_pflags |= IFIF_IPV4;
+	} else {
+		assert(af == AF_INET6);
+		ifp->ifi_pflags |= IFIF_IPV6;
+	}
+
+	/* Terminate the walk if we found both v4 and v6 interfaces. */
+	if (ifname[0] != '\0' && (ifp->ifi_pflags & IFIF_IPV4) &&
+	    (ifp->ifi_pflags & IFIF_IPV6))
+		return (B_FALSE);
+
+	return (B_TRUE);
+}
+
+/*
+ * Deletes those entries from the database for which interface name
+ * matches with the given `cbarg->cb_ifname'
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_resetif(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_if_cbarg_t *cbarg = arg;
+	boolean_t	isv6 = (cbarg->cb_family == AF_INET6);
+	char		*ifname = cbarg->cb_ifname;
+	char		*modstr = NULL;
+	char		*afstr;
+	char		*aobjname;
+	uint_t		proto;
+	ipmgmt_aobjmap_t *head;
+	boolean_t	aobjfound = B_FALSE;
+
+	*errp = 0;
+
+	if (!ipmgmt_nvlist_contains(db_nvl, NULL, ifname, NULL))
+		return (B_TRUE);
+
+	if (nvlist_lookup_string(db_nvl, IPADM_NVP_FAMILY, &afstr) == 0) {
+		if (atoi(afstr) == cbarg->cb_family)
+			goto delete;
+		return (B_TRUE);
+	}
+
+	/* Reset all the interface configurations for 'ifname' */
+	if (isv6 && (nvlist_exists(db_nvl, IPADM_NVP_IPV6ADDR) ||
+	    nvlist_exists(db_nvl, IPADM_NVP_INTFID))) {
+		goto delete;
+	}
+	if (!isv6 &&
+	    (nvlist_exists(db_nvl, IPADM_NVP_IPV4ADDR) ||
+	    nvlist_exists(db_nvl, IPADM_NVP_DHCP))) {
+		goto delete;
+	}
+
+	if (nvlist_lookup_string(db_nvl, IPADM_NVP_AOBJNAME, &aobjname) == 0) {
+		/*
+		 * This must be an address property. Delete this
+		 * line if there is a match in the address family.
+		 */
+		head = aobjmap.aobjmap_head;
+		while (head != NULL) {
+			if (strcmp(head->am_aobjname, aobjname) == 0) {
+				aobjfound = B_TRUE;
+				if (head->am_family == cbarg->cb_family)
+					goto delete;
+			}
+			head = head->am_next;
+		}
+		/*
+		 * If aobjfound = B_FALSE, then this address is not
+		 * available in active configuration. We should go ahead
+		 * and delete it.
+		 */
+		if (!aobjfound)
+			goto delete;
+	}
+
+	/*
+	 * If we are removing both v4 and v6 interface, then we get rid of
+	 * all the properties for that interface. On the other hand, if we
+	 * are deleting only v4 instance of an interface, then we delete v4
+	 * properties only.
+	 */
+	if (nvlist_lookup_string(db_nvl, IPADM_NVP_PROTONAME, &modstr) == 0) {
+		proto = ipadm_str2proto(modstr);
+		switch (proto) {
+		case MOD_PROTO_IPV6:
+			if (isv6)
+				goto delete;
+			break;
+		case MOD_PROTO_IPV4:
+			if (!isv6)
+				goto delete;
+			break;
+		case MOD_PROTO_IP:
+			/* this should never be the case, today */
+			assert(0);
+			break;
+		}
+	}
+	/* Not found a match yet. Continue processing the db */
+	return (B_TRUE);
+delete:
+	/* delete the line from the db */
+	buf[0] = '\0';
+	return (B_TRUE);
+}
+
+/*
+ * Deletes those entries from the database for which address object name
+ * matches with the given `cbarg->cb_aobjname'
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_resetaddr(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_resetaddr_cbarg_t *cbarg = arg;
+	char		*aobjname = cbarg->cb_aobjname;
+
+	*errp = 0;
+	if (!ipmgmt_nvlist_contains(db_nvl, NULL, NULL, aobjname))
+		return (B_TRUE);
+
+	/* delete the line from the db */
+	buf[0] = '\0';
+	return (B_TRUE);
+}
+
+/*
+ * Retrieves all interface props, including addresses, for given interface(s).
+ * `invl' contains the list of interfaces, for which information need to be
+ * retrieved.
+ */
+/* ARGSUSED */
+boolean_t
+ipmgmt_db_initif(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	ipmgmt_initif_cbarg_t	*cbarg = arg;
+	nvlist_t		*onvl = cbarg->cb_onvl;
+	nvlist_t		*invl = cbarg->cb_invl;
+	sa_family_t		in_af = cbarg->cb_family;
+	char			*db_ifname;
+
+	*errp = 0;
+	if (nvlist_lookup_string(db_nvl, IPADM_NVP_IFNAME, &db_ifname) == 0 &&
+	    nvlist_exists(invl, db_ifname)) {
+		char		name[IPMGMT_STRSIZE];
+		sa_family_t	db_af = in_af;
+		uint_t		proto;
+		char		*pstr;
+
+		if (in_af != AF_UNSPEC) {
+			if (nvlist_lookup_string(db_nvl, IPADM_NVP_PROTONAME,
+			    &pstr) == 0) {
+				proto = ipadm_str2proto(pstr);
+				if (proto == MOD_PROTO_IPV4)
+					db_af = AF_INET;
+				else if (proto == MOD_PROTO_IPV6)
+					db_af = AF_INET6;
+				else
+					db_af = in_af;
+			} else {
+				if (nvlist_exists(db_nvl, IPADM_NVP_IPV4ADDR) ||
+				    nvlist_exists(db_nvl, IPADM_NVP_DHCP))
+					db_af = AF_INET;
+				else
+					db_af = AF_INET6;
+			}
+		}
+		if (in_af == db_af) {
+			(void) snprintf(name, sizeof (name), "%s_%d", db_ifname,
+			    cbarg->cb_ocnt);
+			*errp = nvlist_add_nvlist(onvl, name, db_nvl);
+			if (*errp == 0)
+				cbarg->cb_ocnt++;
+		}
+	}
+	return (B_TRUE);
+}
+
+/*
+ * helper function for ipmgmt_aobjmap_op(). Adds the node pointed by `nodep'
+ * into `aobjmap' structure.
+ */
+static int
+i_ipmgmt_add_amnode(ipmgmt_aobjmap_t *nodep)
+{
+	ipmgmt_aobjmap_t	*new, *head;
+
+	head = aobjmap.aobjmap_head;
+	if ((new = malloc(sizeof (ipmgmt_aobjmap_t))) == NULL)
+		return (ENOMEM);
+	*new = *nodep;
+	new->am_next = NULL;
+
+	/* Add the node at the beginning of the list */
+	if (head == NULL) {
+		aobjmap.aobjmap_head = new;
+	} else {
+		new->am_next = aobjmap.aobjmap_head;
+		aobjmap.aobjmap_head = new;
+	}
+	return (0);
+}
+
+/*
+ * A recursive function to generate alphabetized number given a decimal number.
+ * Decimal 0 to 25 maps to 'a' to 'z' and then the counting continues with 'aa',
+ * 'ab', 'ac', et al.
+ */
+static void
+i_ipmgmt_num2priv_aobjname(uint32_t num, char **cp, char *endp)
+{
+	if (num >= 26)
+		i_ipmgmt_num2priv_aobjname(num / 26 - 1, cp, endp);
+	if (*cp != endp) {
+		*cp[0] = 'a' + (num % 26);
+		(*cp)++;
+	}
+}
+
+/*
+ * This function generates an `aobjname', when required, and then does
+ * lookup-add. If `nodep->am_aobjname' is not an empty string, then it walks
+ * through the `aobjmap' to check if an address object with the same
+ * `nodep->am_aobjname' exists. If it exists, EEXIST is returned as duplicate
+ * `aobjname's are not allowed.
+ *
+ * If `nodep->am_aobjname' is an empty string then the daemon generates an
+ * `aobjname' using the `am_nextnum', which contains the next number to be
+ * used to generate `aobjname'. `am_nextnum' is converted to base26 using
+ * `a-z' alphabets in i_ipmgmt_num2priv_aobjname().
+ *
+ * `am_nextnum' will be 0 to begin with. Every time an address object that
+ * needs `aobjname' is added it's incremented by 1. So for the first address
+ * object on net0 the `am_aobjname' will be net0/_a and `am_nextnum' will be 1.
+ * For the second address object on that interface `am_aobjname' will be net0/_b
+ * and  `am_nextnum' will incremented to 2.
+ */
+static int
+i_ipmgmt_lookupadd_amnode(ipmgmt_aobjmap_t *nodep)
+{
+	ipmgmt_aobjmap_t	*head;
+	uint32_t		nextnum;
+
+	for (head = aobjmap.aobjmap_head; head != NULL; head = head->am_next)
+		if (strcmp(head->am_ifname, nodep->am_ifname) == 0)
+			break;
+	nextnum = (head == NULL ? 0 : head->am_nextnum);
+
+	/*
+	 * if `aobjname' is empty, then the daemon has to generate the
+	 * next `aobjname' for the given interface and family.
+	 */
+	if (nodep->am_aobjname[0] == '\0') {
+		char tmpstr[IPADM_AOBJ_USTRSIZ - 1];  /* 1 for leading  '_' */
+		char *cp = tmpstr;
+		char *endp = tmpstr + sizeof (tmpstr);
+
+		i_ipmgmt_num2priv_aobjname(nextnum, &cp, endp);
+
+		if (cp == endp)
+			return (EINVAL);
+		cp[0] = '\0';
+
+		if (snprintf(nodep->am_aobjname, IPADM_AOBJSIZ, "%s/_%s",
+		    nodep->am_ifname, tmpstr) >= IPADM_AOBJSIZ) {
+			return (EINVAL);
+		}
+		nodep->am_nextnum = ++nextnum;
+	} else {
+		for (head = aobjmap.aobjmap_head; head != NULL;
+		    head = head->am_next) {
+			if (strcmp(head->am_aobjname, nodep->am_aobjname) == 0)
+				return (EEXIST);
+		}
+		nodep->am_nextnum = nextnum;
+	}
+	return (i_ipmgmt_add_amnode(nodep));
+}
+
+/*
+ * Performs following operations on the global `aobjmap' linked list.
+ * (a) ADDROBJ_ADD: add or update address object in `aobjmap'
+ * (b) ADDROBJ_DELETE: delete address object from `aobjmap'
+ * (c) ADDROBJ_LOOKUPADD: place a stub address object in `aobjmap'
+ */
+int
+ipmgmt_aobjmap_op(ipmgmt_aobjmap_t *nodep, uint32_t op)
+{
+	ipmgmt_aobjmap_t	*head, *prev;
+	boolean_t		update = B_TRUE;
+	int			err = 0;
+	ipadm_db_op_t		db_op;
+
+	(void) pthread_rwlock_wrlock(&aobjmap.aobjmap_rwlock);
+
+	head = aobjmap.aobjmap_head;
+	switch (op) {
+	case ADDROBJ_ADD:
+		/*
+		 * check for stub nodes (added by ADDROBJ_LOOKUPADD) and
+		 * update, else add the new node.
+		 */
+		for (; head != NULL; head = head->am_next) {
+			if (strcmp(head->am_aobjname,
+			    nodep->am_aobjname) == 0 && head->am_lnum == -1)
+				break;
+		}
+
+		if (head != NULL) {
+			/* update the node */
+			(void) strlcpy(head->am_ifname, nodep->am_ifname,
+			    sizeof (head->am_ifname));
+			head->am_lnum = nodep->am_lnum;
+			head->am_family = nodep->am_family;
+			head->am_flags = nodep->am_flags;
+			head->am_atype = nodep->am_atype;
+			if (head->am_atype == IPADM_ADDR_IPV6_ADDRCONF) {
+				head->am_ifid = nodep->am_ifid;
+				head->am_linklocal = nodep->am_linklocal;
+			}
+		} else {
+			for (head = aobjmap.aobjmap_head; head != NULL;
+			    head = head->am_next) {
+				if (strcmp(head->am_ifname,
+				    nodep->am_ifname) == 0)
+					break;
+			}
+			nodep->am_nextnum = (head == NULL ? 0 :
+			    head->am_nextnum);
+			err = i_ipmgmt_add_amnode(nodep);
+		}
+		db_op = IPADM_DB_WRITE;
+		break;
+	case ADDROBJ_DELETE:
+		prev = head;
+		while (head != NULL) {
+			if (strcmp(head->am_aobjname,
+			    nodep->am_aobjname) == 0) {
+				nodep->am_atype = head->am_atype;
+				/*
+				 * There could be multiple IPV6_ADDRCONF nodes,
+				 * with same address object name, so check for
+				 * logical number also.
+				 */
+				if (head->am_atype !=
+				    IPADM_ADDR_IPV6_ADDRCONF ||
+				    nodep->am_lnum == head->am_lnum)
+					break;
+			}
+			prev = head;
+			head = head->am_next;
+		}
+		if (head != NULL) {
+			/*
+			 * If the address object is in both active and
+			 * persistent configuration and the user is deleting it
+			 * only from active configuration then mark this node
+			 * for deletion by reseting IPMGMT_ACTIVE bit.
+			 * With this the same address object name cannot
+			 * be reused until it is permanently removed.
+			 */
+			if (head->am_flags == (IPMGMT_ACTIVE|IPMGMT_PERSIST) &&
+			    nodep->am_flags == IPMGMT_ACTIVE) {
+				/* Update flags in the in-memory map. */
+				head->am_flags &= ~IPMGMT_ACTIVE;
+				head->am_lnum = -1;
+
+				/* Update info in file. */
+				db_op = IPADM_DB_WRITE;
+				*nodep = *head;
+			} else {
+				(void) strlcpy(nodep->am_ifname,
+				    head->am_ifname,
+				    sizeof (nodep->am_ifname));
+				/* otherwise delete the node */
+				if (head == aobjmap.aobjmap_head)
+					aobjmap.aobjmap_head = head->am_next;
+				else
+					prev->am_next = head->am_next;
+				free(head);
+				db_op = IPADM_DB_DELETE;
+			}
+		} else {
+			err = ENOENT;
+		}
+		break;
+	case ADDROBJ_LOOKUPADD:
+		err = i_ipmgmt_lookupadd_amnode(nodep);
+		update = B_FALSE;
+		break;
+	default:
+		assert(0);
+	}
+
+	if (err == 0 && update)
+		err = ipmgmt_persist_aobjmap(nodep, db_op);
+
+	(void) pthread_rwlock_unlock(&aobjmap.aobjmap_rwlock);
+
+	return (err);
+}
+
+/*
+ * Given a node in `aobjmap', this function converts it into nvlist_t structure.
+ * The content to be written to DB must be represented as nvlist_t.
+ */
+static int
+i_ipmgmt_node2nvl(nvlist_t **nvl, ipmgmt_aobjmap_t *np)
+{
+	int	err;
+	char	strval[IPMGMT_STRSIZE];
+
+	*nvl = NULL;
+	if ((err = nvlist_alloc(nvl, NV_UNIQUE_NAME, 0)) != 0)
+		goto fail;
+
+	if ((err = nvlist_add_string(*nvl, IPADM_NVP_AOBJNAME,
+	    np->am_aobjname)) != 0)
+		goto fail;
+
+	if ((err = nvlist_add_string(*nvl, IPADM_NVP_IFNAME,
+	    np->am_ifname)) != 0)
+		goto fail;
+
+	(void) snprintf(strval, IPMGMT_STRSIZE, "%d", np->am_lnum);
+	if ((err = nvlist_add_string(*nvl, IPADM_NVP_LIFNUM, strval)) != 0)
+		goto fail;
+
+	(void) snprintf(strval, IPMGMT_STRSIZE, "%d", np->am_family);
+	if ((err = nvlist_add_string(*nvl, IPADM_NVP_FAMILY, strval)) != 0)
+		goto fail;
+
+	(void) snprintf(strval, IPMGMT_STRSIZE, "%d", np->am_flags);
+	if ((err = nvlist_add_string(*nvl, FLAGS, strval)) != 0)
+		goto fail;
+
+	(void) snprintf(strval, IPMGMT_STRSIZE, "%d", np->am_atype);
+	if ((err = nvlist_add_string(*nvl, ATYPE, strval)) != 0)
+		goto fail;
+
+	if (np->am_atype == IPADM_ADDR_IPV6_ADDRCONF) {
+		struct sockaddr_in6	*in6;
+
+		in6 = (struct sockaddr_in6 *)&np->am_ifid;
+		if (np->am_linklocal &&
+		    IN6_IS_ADDR_UNSPECIFIED(&in6->sin6_addr)) {
+			if ((err = nvlist_add_string(*nvl, IPADM_NVP_IPNUMADDR,
+			    "default")) != 0)
+				goto fail;
+		} else {
+			if (inet_ntop(AF_INET6, &in6->sin6_addr, strval,
+			    IPMGMT_STRSIZE) == NULL) {
+				err = errno;
+				goto fail;
+			}
+			if ((err = nvlist_add_string(*nvl, IPADM_NVP_IPNUMADDR,
+			    strval)) != 0)
+				goto fail;
+		}
+	} else {
+		if ((err = nvlist_add_string(*nvl, IPADM_NVP_IPNUMADDR,
+		    "")) != 0)
+			goto fail;
+	}
+	return (err);
+fail:
+	nvlist_free(*nvl);
+	return (err);
+}
+
+/*
+ * Read the aobjmap data store and build the in-memory representation
+ * of the aobjmap. We don't need to hold any locks while building this as
+ * we do this in very early stage of daemon coming up, even before the door
+ * is opened.
+ */
+/* ARGSUSED */
+extern boolean_t
+ipmgmt_aobjmap_init(void *arg, nvlist_t *db_nvl, char *buf, size_t buflen,
+    int *errp)
+{
+	nvpair_t		*nvp = NULL;
+	char			*name, *strval = NULL;
+	ipmgmt_aobjmap_t 	node;
+	struct sockaddr_in6	*in6;
+
+	*errp = 0;
+	node.am_next = NULL;
+	for (nvp = nvlist_next_nvpair(db_nvl, NULL); nvp != NULL;
+	    nvp = nvlist_next_nvpair(db_nvl, nvp)) {
+		name = nvpair_name(nvp);
+
+		if ((*errp = nvpair_value_string(nvp, &strval)) != 0)
+			return (B_TRUE);
+		if (strcmp(IPADM_NVP_AOBJNAME, name) == 0) {
+			(void) strlcpy(node.am_aobjname, strval,
+			    sizeof (node.am_aobjname));
+		} else if (strcmp(IPADM_NVP_IFNAME, name) == 0) {
+			(void) strlcpy(node.am_ifname, strval,
+			    sizeof (node.am_ifname));
+		} else if (strcmp(IPADM_NVP_LIFNUM, name) == 0) {
+			node.am_lnum = atoi(strval);
+		} else if (strcmp(IPADM_NVP_FAMILY, name) == 0) {
+			node.am_family = (sa_family_t)atoi(strval);
+		} else if (strcmp(FLAGS, name) == 0) {
+			node.am_flags = atoi(strval);
+		} else if (strcmp(ATYPE, name) == 0) {
+			node.am_atype = (ipadm_addr_type_t)atoi(strval);
+		} else if (strcmp(IPADM_NVP_IPNUMADDR, name) == 0) {
+			if (node.am_atype == IPADM_ADDR_IPV6_ADDRCONF) {
+				in6 = (struct sockaddr_in6 *)&node.am_ifid;
+				if (strcmp(strval, "default") == 0) {
+					bzero(in6, sizeof (node.am_ifid));
+					node.am_linklocal = B_TRUE;
+				} else {
+					(void) inet_pton(AF_INET6, strval,
+					    &in6->sin6_addr);
+					if (IN6_IS_ADDR_UNSPECIFIED(
+					    &in6->sin6_addr))
+						node.am_linklocal = B_TRUE;
+				}
+			}
+		}
+	}
+
+	/* we have all the information we need, add the node */
+	*errp = i_ipmgmt_add_amnode(&node);
+
+	return (B_TRUE);
+}
+
+/*
+ * Updates an entry from the temporary cache file, which matches the given
+ * address object name.
+ */
+/* ARGSUSED */
+static boolean_t
+ipmgmt_update_aobjmap(void *arg, nvlist_t *db_nvl, char *buf,
+    size_t buflen, int *errp)
+{
+	ipadm_dbwrite_cbarg_t	*cb = arg;
+	nvlist_t		*in_nvl = cb->dbw_nvl;
+	uint32_t		flags = cb->dbw_flags;
+	char			*db_lifnumstr = NULL, *in_lifnumstr = NULL;
+
+	*errp = 0;
+	if (!ipmgmt_nvlist_intersects(db_nvl, in_nvl))
+		return (B_TRUE);
+
+	if (flags & IPMGMT_ATYPE_V6ACONF) {
+		if (nvlist_lookup_string(db_nvl, IPADM_NVP_LIFNUM,
+		    &db_lifnumstr) != 0 ||
+		    nvlist_lookup_string(in_nvl, IPADM_NVP_LIFNUM,
+		    &in_lifnumstr) != 0 ||
+		    (atoi(db_lifnumstr) != -1 && atoi(in_lifnumstr) != -1 &&
+		    strcmp(db_lifnumstr, in_lifnumstr) != 0))
+			return (B_TRUE);
+	}
+
+	/* we found the match */
+	(void) memset(buf, 0, buflen);
+	if (ipadm_nvlist2str(in_nvl, buf, buflen) == 0) {
+		/* buffer overflow */
+		*errp = ENOBUFS;
+	}
+
+	/* stop the walker */
+	return (B_FALSE);
+}
+
+/*
+ * Deletes an entry from the temporary cache file, which matches the given
+ * address object name.
+ */
+/* ARGSUSED */
+static boolean_t
+ipmgmt_delete_aobjmap(void *arg, nvlist_t *db_nvl, char *buf,
+    size_t buflen, int *errp)
+{
+	ipmgmt_aobjmap_t	*nodep = arg;
+	char			*db_lifnumstr = NULL;
+
+	*errp = 0;
+	if (!ipmgmt_nvlist_match(db_nvl, NULL, nodep->am_ifname,
+	    nodep->am_aobjname))
+		return (B_TRUE);
+
+	if (nodep->am_atype == IPADM_ADDR_IPV6_ADDRCONF) {
+		if (nvlist_lookup_string(db_nvl, IPADM_NVP_LIFNUM,
+		    &db_lifnumstr) != 0 || atoi(db_lifnumstr) != nodep->am_lnum)
+			return (B_TRUE);
+	}
+
+	/* we found the match, delete the line from the db */
+	buf[0] = '\0';
+
+	/* stop the walker */
+	return (B_FALSE);
+}
+
+/*
+ * Adds or deletes aobjmap node information into a temporary cache file.
+ */
+extern int
+ipmgmt_persist_aobjmap(ipmgmt_aobjmap_t *nodep, ipadm_db_op_t op)
+{
+	int			err;
+	ipadm_dbwrite_cbarg_t	cb;
+	nvlist_t		*nvl = NULL;
+
+	if (op == IPADM_DB_WRITE) {
+		if ((err = i_ipmgmt_node2nvl(&nvl, nodep)) != 0)
+			return (err);
+		cb.dbw_nvl = nvl;
+		if (nodep->am_atype == IPADM_ADDR_IPV6_ADDRCONF)
+			cb.dbw_flags = IPMGMT_ATYPE_V6ACONF;
+		else
+			cb.dbw_flags = 0;
+
+		err = ipadm_rw_db(ipmgmt_update_aobjmap, &cb,
+		    ADDROBJ_MAPPING_DB_FILE, IPADM_FILE_MODE, IPADM_DB_WRITE);
+		nvlist_free(nvl);
+	} else {
+		assert(op == IPADM_DB_DELETE);
+
+		err = ipadm_rw_db(ipmgmt_delete_aobjmap, nodep,
+		    ADDROBJ_MAPPING_DB_FILE, IPADM_FILE_MODE, IPADM_DB_DELETE);
+	}
+	return (err);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/ipmgmt_util.c	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,46 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ * or http://www.opensolaris.org/os/licensing.
+ * See the License for the specific language governing permissions
+ * and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+/*
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+ * Use is subject to license terms.
+ */
+
+/*
+ * Utility functions used by the ipmgmtd daemon.
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <syslog.h>
+#include <stdarg.h>
+#include "ipmgmt_impl.h"
+
+void
+ipmgmt_log(int pri, const char *fmt, ...)
+{
+	va_list alist;
+
+	va_start(alist, fmt);
+	vsyslog(pri, fmt, alist);
+	va_end(alist);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/net-ipmgmt	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,62 @@
+#!/sbin/sh
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+#
+# Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+# Use is subject to license terms.
+#
+# This daemon stores address object to logical interface number mappings
+# (among other things) and reads/writes from/to ipmgmtd data store.
+#
+
+. /lib/svc/share/smf_include.sh
+
+if [ -z "$SMF_FMRI" ]; then
+        echo "this script can only be invoked by smf(5)"        
+        exit $SMF_EXIT_ERR_NOSMF
+fi
+
+#
+# network/ip-interface-management:default service is always enabled by default.
+# When the non-global shared-IP stack zone boots, it tries to bring up this
+# service as well. If we don't start a background process and simply exit the
+# service, the service will go into maintenance mode and so will all it's
+# dependents.
+#
+if smf_is_nonglobalzone; then
+	if [ `/sbin/zonename -t` = shared ]; then
+		(while true ; do sleep 3600 ; done) & 
+		exit $SMF_EXIT_OK
+	fi
+fi
+
+# Apply any persistent protocol (IP/TCP/SCTP/UDP/ICMP) properties
+/sbin/ipadm init-prop
+
+#
+# We must be now in a global zone or non-global zone with exclusive-IP stack.
+# Start the ipmgmtd daemon.
+#
+if /lib/inet/ipmgmtd ; then
+	exit $SMF_EXIT_OK
+else
+        exit $SMF_EXIT_ERR_FATAL
+fi

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usr/src/cmd/cmd-inet/lib/ipmgmtd/network-ipmgmt.xml	Fri Mar 26 17:53:11 2010 -0400
@@ -0,0 +1,95 @@
+<?xml version="1.0"?>
+<!DOCTYPE service_bundle SYSTEM "/usr/share/lib/xml/dtd/service_bundle.dtd.1">
+<!--
+ Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
+ Use is subject to license terms.
+
+ CDDL HEADER START
+
+ The contents of this file are subject to the terms of the
+ Common Development and Distribution License (the "License").
+ You may not use this file except in compliance with the License.
+
+ You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+ or http://www.opensolaris.org/os/licensing.
+ See the License for the specific language governing permissions
+ and limitations under the License.
+
+ When distributing Covered Code, include this CDDL HEADER in each
+ file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+ If applicable, add the following below this CDDL HEADER, with the
+ fields enclosed by brackets "[]" replaced with your own identifying
+ information: Portions Copyright [yyyy] [name of copyright owner]
+
+ CDDL HEADER END
+
+	NOTE:  This service manifest is not editable; its contents will
+	be overwritten by package or patch operations, including
+	operating system upgrade.  Make customizations in a different
+	file.
+-->
+
+<service_bundle type='manifest' name='SUNWcsr:ipmgmtd'>
+
+<service
+	name='network/ip-interface-management'
+	type='service'
+	version='1'>
+
+	<create_default_instance enabled='true' />
+
+	<single_instance />
+
+	<dependent name='ipmgmt-loopback'
+		grouping='require_all'
+		restart_on='none'>
+		<service_fmri value='svc:/network/loopback' />
+	</dependent>
+
+        <dependent name='ipmgmt-physical'
+                grouping='require_all'
+                restart_on='none'>
+                <service_fmri value='svc:/network/physical' />
+        </dependent>
+
+        <dependent name='ipmgmt-iptun'
+                grouping='require_all'
+                restart_on='none'>
+                <service_fmri value='svc:/network/iptun' />
+        </dependent>
+
+	<exec_method
+		type='method'
+		name='start'
+		exec='/lib/svc/method/net-ipmgmt'
+		timeout_seconds='60' />
+
+	<exec_method
+		type='method'
+		name='stop'
+		exec=':kill'
+		timeout_seconds='5' />
+
+	<stability value='Unstable' />
+
+	<template>
+		<common_name>
+			<loctext xml:lang='C'>
+				IP interface management
+			</loctext>
+		</common_name>
+		<description>
+			<loctext xml:lang='C'>
+				Create IP interfaces, apply
+				TCP/IP properties and manage
+				address object mappings.
+			</loctext>
+		</description>
+		<documentation>
+			<manpage title='ipadm' section='1M'
+				manpath='/usr/share/man' />
+		</documentation>
+	</template>
+</service>
+
+</service_bundle>

--- a/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/Makefile	Fri Mar 26 14:31:08 2010 -0700
+++ b/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/Makefile	Fri Mar 26 17:53:11 2010 -0400
@@ -18,11 +18,9 @@
 #
 # CDDL HEADER END
 #
-# Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+# Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 # Use is subject to license terms.
 #
-# ident	"%Z%%M%	%I%	%E% SMI"
-#
 # cmd/cmd-inet/usr.lib/in.ndpd/Makefile
 #
 
@@ -41,12 +39,12 @@
 # be accessed by -lxnet. In addition -lsocket and -lnsl are used to
 # capture new not-yet-standard interfaces. Someday -lxnet alone should be enough
 # when IPv6 inspired new interfaces are part of standards.
-LDLIBS +=	-ldhcpagent -lxnet -lsocket -lnsl
+LDLIBS +=	-ldhcpagent -lxnet -lsocket -lnsl -lipadm
 
 # these #defines are required to use UNIX 98 interfaces
 _D_UNIX98_EXTN= -D_XOPEN_SOURCE=500 -D__EXTENSIONS__
 
-$(OBJS)		:= CPPFLAGS +=	$(_D_UNIX98_EXTN)
+$(OBJS)		:= CPPFLAGS +=  $(_D_UNIX98_EXTN)
 
 LINTFLAGS +=	$(_D_UNIX98_EXTN)
 
@@ -58,6 +56,10 @@
 # perfect would require a bigger rewrite.
 LINTFLAGS +=	-erroff=E_BAD_PTR_CAST_ALIGN
 
+CTFCONVERT_HOOK = && $(CTFCONVERT_O)
+CTFMERGE_HOOK = && $(CTFMERGE) -L VERSION -o $@ $(OBJS)
+$(OBJS) := CFLAGS += $(CTF_FLAGS)
+
 .KEEP_STATE:
 
 .PARALLEL:  $(OBJS)
@@ -65,7 +67,7 @@
 all: $(PROG)
 
 $(PROG): $(OBJS)
-	$(LINK.c) $(OBJS) -o $@ $(LDLIBS)
+	$(LINK.c) $(OBJS) -o $@ $(LDLIBS) $(CTFMERGE_HOOK)
 	$(POST_PROCESS)
 
 include		../Makefile.lib

--- a/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/defs.h	Fri Mar 26 14:31:08 2010 -0700
+++ b/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/defs.h	Fri Mar 26 17:53:11 2010 -0400
@@ -19,15 +19,13 @@
  * CDDL HEADER END
  */
 /*
- * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
 #ifndef	_NDPD_DEFS_H
 #define	_NDPD_DEFS_H
 
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <strings.h>
@@ -62,6 +60,8 @@
 #include <netinet/ip6.h>
 #include <netinet/icmp6.h>
 #include <net/route.h>
+#include <libipadm.h>
+#include <ipadm_ndpd.h>
 
 #include "tables.h"
 

--- a/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/main.c	Fri Mar 26 14:31:08 2010 -0700
+++ b/usr/src/cmd/cmd-inet/usr.lib/in.ndpd/main.c	Fri Mar 26 17:53:11 2010 -0400
@@ -18,7 +18,7 @@
  *
  * CDDL HEADER END
  *
- * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
+ * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  * Use is subject to license terms.
  */
 
@@ -91,7 +91,22 @@
 struct	rt_msghdr	*rt_msg;	/* Routing socket message */
 struct	sockaddr_in6	*rta_gateway;	/* RTA_GATEWAY sockaddr */
 struct	sockaddr_dl	*rta_ifp;	/* RTA_IFP sockaddr */
-int	mibsock = -1;			/* mib request socket */
+
+/*
+ * These sockets are used internally in this file.
+ */
+static int	mibsock = -1;			/* mib request socket */
+static int	cmdsock = -1;			/* command socket */
+
+static	int	ndpd_setup_cmd_listener(void);
+static	void	ndpd_cmd_handler(int);
+static	int	ndpd_process_cmd(int, ipadm_ndpd_msg_t *);
+static	int	ndpd_send_error(int, int);
+static	int	ndpd_set_autoconf(const char *, boolean_t);
+static	int	ndpd_create_addrs(const char *, struct sockaddr_in6, int,
+    boolean_t, boolean_t, char *);
+static	int	ndpd_delete_addrs(const char *);
+static	int	phyint_check_ipadm_intfid(struct phyint *);
 
 /*
  * Return the current time in milliseconds truncated to
@@ -361,7 +376,7 @@
 	new_num = pollfd_num + 32;
 	newfds = realloc(pollfds, new_num * sizeof (struct pollfd));
 	if (newfds == NULL) {
-		logperror("poll_add: realloc");
+		logperror("realloc");
 		return (-1);
 	}
 
@@ -449,20 +464,27 @@
 
 	pi = phyint_lookup(phyintname);
 	if (pi == NULL) {
-		/*
-		 * Do not add anything for new interfaces until they are UP.
-		 * For existing interfaces we track the up flag.
-		 */
-		if (!(lifr.lifr_flags & IFF_UP))
-			return;
-
 		pi = phyint_create(phyintname);
 		if (pi == NULL) {
 			logmsg(LOG_ERR, "if_process: out of memory\n");
 			return;
 		}
+		/*
+		 * if in.ndpd is restarted, check with ipmgmtd if there is any
+		 * interface id to be configured for this interface.
+		 */
+		if (first) {
+			if (phyint_check_ipadm_intfid(pi) == -1)
+				logmsg(LOG_ERR, "Could not get ipadm info\n");
+		}
+	} else {
+		/*
+		 * if the phyint already exists, synchronize it with
+		 * the kernel state. For a newly created phyint, phyint_create
+		 * calls phyint_init_from_k().
+		 */
+		(void) phyint_init_from_k(pi);
 	}
-	(void) phyint_init_from_k(pi);
 	if (pi->pi_sock == -1 && !(pi->pi_kernel_state & PI_PRESENT)) {
 		/* Interface is not yet present */
 		if (debug & D_PHYINT) {
@@ -1088,7 +1110,7 @@
 				    "found on %s; assuming default flags\n",
 				    pi->pi_name);
 			}
-			if (pi->pi_StatefulAddrConf) {
+			if (pi->pi_autoconf && pi->pi_StatefulAddrConf) {
 				pi->pi_ra_flags |= ND_RA_FLAG_MANAGED |
 				    ND_RA_FLAG_OTHER;
 				start_dhcp(pi);
@@ -1376,6 +1398,12 @@
 			if (pi->pi_AdvSendAdvertisements)
 				check_to_advertise(pi, START_FINAL_ADV);
 
+			/*
+			 * Remove all the configured addresses.
+			 * Remove the addrobj names created with ipmgmtd.
+			 * Release the dhcpv6 addresses if any.
+			 * Cleanup the phyints.
+			 */
 			phyint_delete(pi);
 		}
 
@@ -1411,7 +1439,7 @@
 		/* NOTREACHED */
 	case 255:
 		/*
-		 * Special "signal" from looback_ra_enqueue.
+		 * Special "signal" from loopback_ra_enqueue.
 		 * Handle any queued loopback router advertisements.
 		 */
 		loopback_ra_dequeue();
@@ -1838,6 +1866,8 @@
 		if (!pr->pr_in_use) {
 			/* Clear everything except PR_STATIC */
 			pr->pr_kernel_state &= PR_STATIC;
+			if (pr->pr_state & PR_STATIC)
+				prefix_update_ipadm_addrobj(pr, _B_FALSE);
 			pr->pr_name[0] = '\0';
 			if (pr->pr_state & PR_STATIC) {
 				prefix_delete(pr);
@@ -1870,6 +1900,7 @@
 		for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
 			next_pr = pr->pr_next;
 			if (pr->pr_state & PR_AUTO)
+				prefix_update_ipadm_addrobj(pr, _B_FALSE);
 				prefix_delete(pr);
 		}
 
@@ -2033,10 +2064,10 @@
 	if (show_ifs)
 		phyint_print_all();
 
-	if (debug == 0) {
+	if (debug == 0)
 		initlog();
-	}
 
+	cmdsock = ndpd_setup_cmd_listener();
 	setup_eventpipe();
 	rtsock = setup_rtsock();
 	mibsock = setup_mibsock();
@@ -2067,6 +2098,10 @@
 				process_mibsock(mibsock);
 				break;
 			}
+			if (pollfds[i].fd == cmdsock) {
+				ndpd_cmd_handler(cmdsock);
+				break;
+			}
 			/*
 			 * Run timer routine to advance clock if more than
 			 * half a second since the clock was advanced.
@@ -2167,3 +2202,417 @@
 		    strerror(errno));
 	}
 }
+
+static int
+ndpd_setup_cmd_listener(void)
+{
+	int sock;
+	int ret;
+	struct sockaddr_un servaddr;
+
+	sock = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (sock < 0) {
+		logperror("socket");
+		exit(1);
+	}
+
+	bzero(&servaddr, sizeof (servaddr));
+	servaddr.sun_family = AF_UNIX;
+	(void) strlcpy(servaddr.sun_path, IPADM_UDS_PATH,
+	    sizeof (servaddr.sun_path));
+	(void) unlink(servaddr.sun_path);
+	ret = bind(sock, (struct sockaddr *)&servaddr, sizeof (servaddr));
+	if (ret < 0) {
+		logperror("bind");
+		exit(1);
+	}
+	if (listen(sock, 30) < 0) {
+		logperror("listen");
+		exit(1);
+	}
+	if (poll_add(sock) == -1) {
+		logmsg(LOG_ERR, "command socket could not be added to the "
+		    "polling set\n");
+		exit(1);
+	}
+
+	return (sock);
+}
+
+/*
+ * Commands received over the command socket come here
+ */
+static void
+ndpd_cmd_handler(int sock)
+{
+	int			newfd;
+	struct sockaddr_storage	peer;
+	socklen_t		peerlen;
+	ipadm_ndpd_msg_t	ndpd_msg;
+	int			retval;
+
+	peerlen = sizeof (peer);
+	newfd = accept(sock, (struct sockaddr *)&peer, &peerlen);
+	if (newfd < 0) {
+		logperror("accept");
+		return;
+	}
+
+	retval = ipadm_ndpd_read(newfd, &ndpd_msg, sizeof (ndpd_msg));
+	if (retval != 0)
+		logperror("Could not read ndpd command");
+
+	retval = ndpd_process_cmd(newfd, &ndpd_msg);
+	if (retval != 0) {
+		logmsg(LOG_ERR, "ndpd command on interface %s failed with "
+		    "error %s\n", ndpd_msg.inm_ifname, strerror(retval));
+	}
+	(void) close(newfd);
+}
+
+/*
+ * Process the commands received from the cmd listener socket.
+ */
+static int
+ndpd_process_cmd(int newfd, ipadm_ndpd_msg_t *msg)
+{
+	int err;
+
+	if (!ipadm_check_auth()) {
+		logmsg(LOG_ERR, "User not authorized to send the command\n");
+		(void) ndpd_send_error(newfd, EPERM);
+		return (EPERM);
+	}
+	switch (msg->inm_cmd) {
+	case IPADM_DISABLE_AUTOCONF:
+		err = ndpd_set_autoconf(msg->inm_ifname, _B_FALSE);
+		break;
+
+	case IPADM_ENABLE_AUTOCONF:
+		err = ndpd_set_autoconf(msg->inm_ifname, _B_TRUE);
+		break;
+
+	case IPADM_CREATE_ADDRS:
+		err = ndpd_create_addrs(msg->inm_ifname, msg->inm_intfid,
+		    msg->inm_intfidlen, msg->inm_stateless,
+		    msg->inm_stateful, msg->inm_aobjname);
+		break;
+
+	case IPADM_DELETE_ADDRS:
+		err = ndpd_delete_addrs(msg->inm_ifname);
+		break;
+
+	default:
+		err = EINVAL;
+		break;
+	}
+
+	(void) ndpd_send_error(newfd, err);
+
+	return (err);
+}
+
+static int
+ndpd_send_error(int fd, int error)
+{
+	return (ipadm_ndpd_write(fd, &error, sizeof (error)));
+}
+
+/*
+ * Disables/Enables autoconfiguration of addresses on the
+ * given physical interface.
+ * This is provided to support the legacy method of configuring IPv6
+ * addresses. i.e. `ifconfig bge0 inet6 plumb` will plumb the interface
+ * and start stateless and stateful autoconfiguration. If this function is
+ * not called with enable=_B_FALSE, no autoconfiguration will be done until
+ * ndpd_create_addrs() is called with an Interface ID.
+ */
+static int
+ndpd_set_autoconf(const char *ifname, boolean_t enable)
+{
+	struct phyint *pi;
+
+	pi = phyint_lookup((char *)ifname);
+	if (pi == NULL) {
+		/*
+		 * If the physical interface was plumbed but no
+		 * addresses were configured yet, phyint will not exist.
+		 */
+		pi = phyint_create((char *)ifname);
+		if (pi == NULL) {
+			logmsg(LOG_ERR, "could not create phyint for "
+			    "interface %s", ifname);
+			return (ENOMEM);
+		}
+	}
+	pi->pi_autoconf = enable;
+
+	if (debug & D_PHYINT) {
+		logmsg(LOG_DEBUG, "ndpd_set_autoconf: %s autoconf for "
+		    "interface %s\n", (enable ? "enabled" : "disabled"),
+		    pi->pi_name);
+	}
+	return (0);
+}
+
+/*
+ * Create auto-configured addresses on the given interface using
+ * the given token as the interface id during the next Router Advertisement.
+ * Currently, only one token per interface is supported.
+ */
+static int
+ndpd_create_addrs(const char *ifname, struct sockaddr_in6 intfid, int intfidlen,
+    boolean_t stateless, boolean_t stateful, char *addrobj)
+{
+	struct phyint *pi;
+	struct lifreq lifr;
+	struct sockaddr_in6 *sin6;
+	int err;
+
+	pi = phyint_lookup((char *)ifname);
+	if (pi == NULL) {
+		/*
+		 * If the physical interface was plumbed but no
+		 * addresses were configured yet, phyint will not exist.
+		 */
+		pi = phyint_create((char *)ifname);
+		if (pi == NULL) {
+			if (debug & D_PHYINT)
+				logmsg(LOG_ERR, "could not create phyint "
+				    "for interface %s", ifname);
+			return (ENOMEM);
+		}
+	} else if (pi->pi_autoconf) {
+		logmsg(LOG_ERR, "autoconfiguration already in progress\n");
+		return (EEXIST);
+	}
+	check_autoconf_var_consistency(pi, stateless, stateful);
+
+	if (intfidlen == 0) {
+		pi->pi_default_token = _B_TRUE;
+		if (ifsock < 0) {
+			ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
+			if (ifsock < 0) {
+				err = errno;
+				logperror("ndpd_create_addrs: socket");
+				return (err);
+			}
+		}
+		(void) strncpy(lifr.lifr_name, ifname, sizeof (lifr.lifr_name));
+		sin6 = (struct sockaddr_in6 *)&lifr.lifr_addr;
+		if (ioctl(ifsock, SIOCGLIFTOKEN, (char *)&lifr) < 0) {
+			err = errno;
+			logperror("SIOCGLIFTOKEN");
+			return (err);
+		}
+		pi->pi_token = sin6->sin6_addr;
+		pi->pi_token_length = lifr.lifr_addrlen;
+	} else {
+		pi->pi_default_token = _B_FALSE;
+		pi->pi_token = intfid.sin6_addr;
+		pi->pi_token_length = intfidlen;
+	}
+	pi->pi_stateless = stateless;
+	pi->pi_stateful = stateful;
+	(void) strlcpy(pi->pi_ipadm_aobjname, addrobj,
+	    sizeof (pi->pi_ipadm_aobjname));
+
+	/* We can allow autoconfiguration now. */
+	pi->pi_autoconf = _B_TRUE;
+
+	/* Restart the solicitations. */
+	if (pi->pi_sol_state == DONE_SOLICIT)
+		pi->pi_sol_state = NO_SOLICIT;
+	if (pi->pi_sol_state == NO_SOLICIT)
+		check_to_solicit(pi, START_INIT_SOLICIT);
+	if (debug & D_PHYINT)
+		logmsg(LOG_DEBUG, "ndpd_create_addrs: "
+		    "added token to interface %s\n", pi->pi_name);
+	return (0);
+}
+
+/*
+ * This function deletes all addresses on the given interface
+ * with the given Interface ID.
+ */
+static int
+ndpd_delete_addrs(const char *ifname)
+{
+	struct phyint *pi;
+	struct prefix *pr, *next_pr;
+	struct lifreq lifr;
+	int err;
+
+	pi = phyint_lookup((char *)ifname);
+	if (pi == NULL) {
+		logmsg(LOG_ERR, "no phyint found for %s", ifname);
+		return (ENXIO);
+	}
+	if (IN6_IS_ADDR_UNSPECIFIED(&pi->pi_token)) {
+		logmsg(LOG_ERR, "token does not exist for %s", ifname);
+		return (EINVAL);
+	}
+
+	if (ifsock < 0) {
+		ifsock = socket(AF_INET6, SOCK_DGRAM, 0);
+		if (ifsock < 0) {
+			err = errno;
+			logperror("ndpd_create_addrs: socket");
+			return (err);
+		}
+	}
+	/* Remove the prefixes for this phyint if they exist */
+	for (pr = pi->pi_prefix_list; pr != NULL; pr = next_pr) {
+		next_pr = pr->pr_next;
+		if (pr->pr_name[0] == '\0') {
+			prefix_delete(pr);
+			continue;
+		}
+		/*
+		 * Delete all the prefixes for the auto-configured
+		 * addresses as well as the DHCPv6 addresses.
+		 */
+		(void) strncpy(lifr.lifr_name, pr->pr_name,
+		    sizeof (lifr.lifr_name));
+		if (ioctl(ifsock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
+			err = errno;
+			logperror("SIOCGLIFFLAGS");
+			return (err);
+		}
+		if ((lifr.lifr_flags & IFF_ADDRCONF) ||
+		    (lifr.lifr_flags & IFF_DHCPRUNNING)) {
+			prefix_update_ipadm_addrobj(pr, _B_FALSE);
+		}
+		prefix_delete(pr);
+	}
+
+	/*
+	 * If we had started dhcpagent, we need to release the leases
+	 * if any are required.
+	 */
+	if (pi->pi_stateful) {
+		(void) strncpy(lifr.lifr_name, pi->pi_name,
+		    sizeof (lifr.lifr_name));
+		if (ioctl(ifsock, SIOCGLIFFLAGS, (char *)&lifr) < 0) {
+			err = errno;
+			logperror("SIOCGLIFFLAGS");
+			return (err);
+		}
+		if (lifr.lifr_flags & IFF_DHCPRUNNING)
+			release_dhcp(pi);
+	}
+
+	/*
+	 * Reset the Interface ID on this phyint and stop autoconfigurations
+	 * until a new interface ID is provided.
+	 */
+	pi->pi_token = in6addr_any;
+	pi->pi_token_length = 0;
+	pi->pi_autoconf = _B_FALSE;
+	pi->pi_ipadm_aobjname[0] = '\0';
+
+	/* Reset the stateless and stateful settings to default. */
+	pi->pi_stateless = pi->pi_StatelessAddrConf;
+	pi->pi_stateful = pi->pi_StatefulAddrConf;
+
+	if (debug & D_PHYINT) {
+		logmsg(LOG_DEBUG, "ndpd_delete_addrs: "
+		    "removed token from interface %s\n", pi->pi_name);
+	}
+	return (0);
+}
+
+void
+check_autoconf_var_consistency(struct phyint *pi, boolean_t stateless,
+    boolean_t stateful)
+{
+	/*
+	 * If StatelessAddrConf and StatelessAddrConf are set in
+	 * /etc/inet/ndpd.conf, check if the new values override those
+	 * settings. If so, log a warning.
+	 */
+	if ((pi->pi_StatelessAddrConf !=
+	    ifdefaults[I_StatelessAddrConf].cf_value &&
+	    stateless != pi->pi_StatelessAddrConf) ||
+	    (pi->pi_StatefulAddrConf !=
+	    ifdefaults[I_StatefulAddrConf].cf_value &&
+	    stateful != pi->pi_StatefulAddrConf)) {
+		logmsg(LOG_ERR, "check_autoconf_var_consistency: "
+		    "Overriding the StatelessAddrConf or StatefulAddrConf "
+		    "settings in ndpd.conf with the new values for "
+		    "interface %s\n", pi->pi_name);
+	}
+}
+
+/*
+ * If ipadm was used to start autoconfiguration and in.ndpd was restarted
+ * for some reason, in.ndpd has to resume autoconfiguration when it comes up.
+ * In this function, it scans the ipadm_addr_info() output to find a link-local
+ * on this interface with address type "addrconf" and extracts the interface id.
+ * It also stores the addrobj name to be used later when new addresses are
+ * created for the prefixes advertised by the router.
+ * If autoconfiguration was never started on this interface before in.ndpd
+ * was killed, then in.ndpd should refrain from configuring prefixes, even if
+ * there is a valid link-local on this interface, created by ipadm (identified
+ * if there is a valid addrobj name).
+ */
+static int
+phyint_check_ipadm_intfid(struct phyint *pi)
+{
+	ipadm_status_t		status;
+	ipadm_addr_info_t	*addrinfo;
+	struct ifaddrs		*ifap;
+	ipadm_addr_info_t	*ainfop;
+	struct sockaddr_in6	*sin6;
+	ipadm_handle_t		iph;
+
+	if (ipadm_open(&iph, 0) != IPADM_SUCCESS) {
+		logmsg(LOG_ERR, "could not open handle to libipadm\n");
+		return (-1);
+	}
+
+	status = ipadm_addr_info(iph, pi->pi_name, &addrinfo,
+	    IPADM_OPT_ZEROADDR, LIFC_NOXMIT|LIFC_TEMPORARY);
+	if (status != IPADM_SUCCESS) {
+		ipadm_close(iph);
+		return (-1);
+	}
+	pi->pi_autoconf = _B_TRUE;
+	for (ainfop = addrinfo; ainfop != NULL; ainfop = IA_NEXT(ainfop)) {
+		ifap = &ainfop->ia_ifa;
+		if (ifap->ifa_addr->ss_family != AF_INET6 ||
+		    ainfop->ia_state == IFA_DISABLED)
+			continue;
+		sin6 = (struct sockaddr_in6 *)ifap->ifa_addr;
+		if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
+			if (ainfop->ia_atype == IPADM_ADDR_IPV6_ADDRCONF) {
+				pi->pi_token = sin6->sin6_addr;
+				pi->pi_token._S6_un._S6_u32[0] = 0;
+				pi->pi_token._S6_un._S6_u32[1] = 0;
+				pi->pi_autoconf = _B_TRUE;
+				(void) strlcpy(pi->pi_ipadm_aobjname,
+				    ainfop->ia_aobjname,
+				    sizeof (pi->pi_ipadm_aobjname));
+				break;
+			}
+			/*
+			 * If IFF_NOLINKLOCAL is set, then the link-local
+			 * was created using ipadm. Do not autoconfigure until
+			 * ipadm is explicitly used for autoconfiguration.
+			 */
+			if (ifap->ifa_flags & IFF_NOLINKLOCAL)
+				pi->pi_autoconf = _B_FALSE;
+		} else if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr) &&
+		    strrchr(ifap->ifa_name, ':') == NULL) {
+			/* The interface was created using ipadm. */
+			pi->pi_autoconf = _B_FALSE;
+		}
+	}
+	ipadm_free_addr_info(addrinfo);
+	if (!pi->pi_autoconf) {
+		pi->pi_token = in6addr_any;
+		pi->pi_token_length = 0;
+	}
+	ipadm_close(iph);
+	return (0);
+}