--- old/usr/src/cmd/cmd-inet/usr.lib/in.dhcpd/misc.c	Tue Nov  4 14:39:57 2014
+++ /dev/null	Tue Nov  4 14:31:37 2014
@@ -1,769 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (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 2005 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
-#include <stdio.h>
-#include <string.h>
-#include <stdarg.h>
-#include <syslog.h>
-#include <errno.h>
-#include <sys/types.h>
-#include <sys/sysmacros.h>
-#include <time.h>
-#include <locale.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <assert.h>
-#include <sys/socket.h>
-#include <net/if.h>
-#include <netinet/in.h>
-#include <netinet/if_ether.h>
-#include <arpa/inet.h>
-#include <netinet/dhcp.h>
-#include <netdb.h>
-#include <sys/mman.h>
-#include <locale.h>
-#include <tnf/probe.h>
-#include <resolv.h>
-
-#include "dhcpd.h"
-#include "per_dnet.h"
-#include "interfaces.h"
-
-#ifdef	DEBUG
-/*
- * Datastore debugging functions.
- *
- * A simple datastore simulation, using the magic DBG_MEMORY_NET network,
- * is provided, to test the program with minimal datastore overhead.
- * A concatenated reclist is used to speed record manipulation.
- * Note that other networks continue to pass-thru to libdhcpsvc, to allow
- * live comparison.
- */
-
-/* Simple datastore database. */
-typedef struct db {
-	lease_t dn_lease;
-	char	dn_cid[128];
-	char	dn_macro[2];
-	uchar_t	dn_cid_len;
-	uchar_t	dn_flags;
-} dbg_t;
-
-typedef struct reclist {
-	dn_rec_list_t d_reclist;
-	dn_rec_t d_rec;
-} dbg_rec_t;
-
-#define		DBG_MAXTABLE	16
-static dsvc_handle_t dbg_handle[DBG_MAXTABLE];	/* simulated handle */
-static rwlock_t	dbg_lock[DBG_MAXTABLE];		/* locks */
-static uint32_t	dbg_size = 4096;		/* table size */
-static uint32_t	dbg_msize;			/* mapped size */
-static uint32_t	dbg_mask = 0xFFFF;		/* table mask */
-
-static uint32_t	dbg_cid = 0;			/* starting cid */
-static uint32_t	dbg_flags = 0;			/* starting flags */
-static uint32_t	dbg_lease = 0;			/* starting lease */
-static char	dbg_macro = '1';		/* macro */
-#endif	/* DEBUG */
-
-int
-dhcp_open_dd(dsvc_handle_t *handp, dsvc_datastore_t *ddp, dsvc_contype_t type,
-    const char *name, uint_t flags)
-{
-#ifndef	DEBUG
-	return (open_dd(handp, ddp, type, name, flags));
-
-#else	/* DEBUG */
-	int ret;
-	int hind;
-	int net;
-	int pgmsk = sysconf(_SC_PAGESIZE) - 1;
-
-	if (dbg_net && memcmp(name, dbg_net, strlen(dbg_net)) == 0) {
-		for (net = 0, hind = strlen(dbg_net); name[hind] != '.'; hind++)
-			net += (net * 10) + (name[hind] - '0');
-		if (net > DBG_MAXTABLE)
-			return (DSVC_NO_TABLE);
-
-		if (dbg_handle[net] == NULL) {
-			dbg_msize = (sizeof (dbg_t) * dbg_size + pgmsk) &
-			    ~pgmsk;
-			/* LINTED [alignment ok] */
-			dbg_handle[net] = (dsvc_handle_t)mmap(0, dbg_msize,
-			    PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
-			if ((char *)dbg_handle[net] == MAP_FAILED) {
-				dbg_handle[net] = NULL;
-				return (DSVC_INVAL);
-			}
-		}
-		*handp = (void *)net;
-		ret = DSVC_SUCCESS;
-	} else
-		ret = open_dd(handp, ddp, type, name, flags);
-
-	return (ret);
-#endif	/* DEBUG */
-}
-
-int
-dhcp_close_dd(dsvc_handle_t *handp)
-{
-#ifndef	DEBUG
-	return (close_dd(handp));
-
-#else	/* DEBUG */
-	int ret;
-	int hind = (int)*handp;
-
-	if (dbg_net && hind >= 0 && hind < DBG_MAXTABLE) {
-		if (dbg_handle[hind] != NULL) {
-			(void) munmap((char *)dbg_handle[hind], dbg_msize);
-			dbg_handle[hind] = (dsvc_handle_t)NULL;
-			ret = DSVC_SUCCESS;
-		}
-	} else
-		ret = close_dd(handp);
-
-	return (ret);
-#endif	/* DEBUG */
-}
-
-/*
- * Detach the element from a list, and return it. If the list is empty, NULL is
- * returned.
- */
-dn_rec_list_t *
-detach_dnrec_from_list(dn_rec_list_t *prevp, dn_rec_list_t *elemp,
-    dn_rec_list_t **listpp)
-{
-	if (prevp == NULL) {
-		if (elemp == *listpp && elemp != NULL) {
-			/* head of the list */
-			*listpp = (*listpp)->dnl_next;
-			elemp->dnl_next = NULL;
-		}
-	} else if (prevp->dnl_next != NULL) {
-		/* somewhere in the middle */
-		prevp->dnl_next = elemp->dnl_next;
-		elemp->dnl_next = NULL;
-	} else
-		assert(elemp == NULL);
-
-	return (elemp);
-}
-
-/*
- * Attach an unattached element (elemp) to a list (*listpp).
- */
-static void
-attach_dnrec_to_list(dn_rec_list_t *elemp, dn_rec_list_t **listpp)
-{
-	if (*listpp != NULL)
-		elemp->dnl_next = *listpp;
-	*listpp = elemp;
-}
-
-/*
- * dhcp_lookup_dd: perform lookup_dd.
- */
-static int
-dhcp_lookup_dd(dsvc_handle_t hand, boolean_t partial, uint_t query,
-    int count, const void *targetp, void **recordsp, uint_t *nrecordsp)
-{
-#ifndef	DEBUG
-	return (lookup_dd(hand, partial, query, count, targetp, recordsp,
-	    nrecordsp));
-
-#else	/* DEBUG */
-	int		ret;
-	int 		hind = (int)hand;
-	int 		ind;
-	dn_rec_t	*inp;
-	dn_rec_list_t	**outp = (dn_rec_list_t **)recordsp;
-	dbg_t		*dbp;
-	dbg_t		*endp;
-	dbg_rec_t	*rp;
-	dn_rec_t	*recp;
-	dn_rec_list_t	*reclp;
-	dbg_t		*dbg_db;
-
-	if (dbg_net && hind >= 0 && hind < DBG_MAXTABLE) {
-		dbg_db = (dbg_t *)dbg_handle[hind];
-
-		if (outp)
-			*outp = NULL;
-		if (nrecordsp)
-			*nrecordsp = 0;
-		inp = (dn_rec_t *)targetp;
-
-		(void) rw_rdlock(&dbg_lock[hind]);
-		/*
-		 * Simple linear search, aided by the fact that
-		 * the server currently checks flags.
-		 */
-		if (DSVC_QISEQ(query, DN_QCIP)) {
-			ind = inp->dn_cip.s_addr & dbg_mask;
-			dbp = &dbg_db[ind];
-			endp = &dbg_db[ind + 1];
-		} else {
-			ind = 0;
-			dbp = dbg_db;
-			endp = &dbg_db[dbg_size];
-		}
-		for (; dbp < endp; dbp++, ind++) {
-			/*
-			 * Initialize record. fields will be zero'd
-			 * when initially mmap'd.
-			 */
-			if (dbp->dn_cid_len == 0) {
-				/* Skip server address to avoid arp issues. */
-				if (ind == (ntohl(server_ip.s_addr) % 256))
-					continue;
-				if (dbg_cid)
-					(void) snprintf(dbp->dn_cid,
-					    sizeof (dbp->dn_cid), "%8X",
-					    dbg_cid++);
-				dbp->dn_flags = dbg_flags;
-				dbp->dn_lease = dbg_lease;
-				dbp->dn_macro[0] = dbg_macro;
-				dbp->dn_macro[1] = '\0';
-				dbp->dn_cid_len = 1;
-			}
-			if (DSVC_QISEQ(query, DN_QCID) &&
-			    (inp->dn_cid[0] != dbp->dn_cid[0] ||
-			    memcmp(dbp->dn_cid, inp->dn_cid, inp->dn_cid_len)))
-				continue;
-
-			rp = (dbg_rec_t *)smalloc(sizeof (dbg_rec_t));
-			reclp = &rp->d_reclist;
-			recp = &rp->d_rec;
-
-			if (nrecordsp)
-				(*nrecordsp)++;
-
-			reclp->dnl_rec = recp;
-			recp->dn_lease = dbp->dn_lease;
-			recp->dn_sip.s_addr = ntohl(owner_ip->s_addr);
-			recp->dn_cip.s_addr = 0xd000000 + (hind << 16) + ind;
-			recp->dn_cid_len = dbp->dn_cid_len;
-			recp->dn_flags = dbp->dn_flags;
-			recp->dn_macro[0] = dbp->dn_macro[0];
-			recp->dn_macro[1] = '\0';
-			if ((recp->dn_cid[0] = dbp->dn_cid[0]) != '\0')
-				(void) memcpy(recp->dn_cid, dbp->dn_cid,
-				    dbp->dn_cid_len);
-			if (*outp == NULL)
-				*outp = reclp;
-			else {
-				reclp->dnl_next = *outp;
-				*outp = reclp;
-			}
-			if (count > 0 && nrecordsp && *nrecordsp >= count)
-				break;
-		}
-		(void) rw_unlock(&dbg_lock[hind]);
-		ret = DSVC_SUCCESS;
-	} else
-		ret = lookup_dd(hand, partial, query, count, targetp,
-		    recordsp, nrecordsp);
-
-	return (ret);
-#endif	/* DEBUG */
-}
-
-int
-dhcp_modify_dd_entry(dsvc_handle_t hand, const void *origp, void *newp)
-{
-#ifndef	DEBUG
-	return (modify_dd_entry(hand, origp, newp));
-
-#else	/* DEBUG */
-	int 		ret;
-	int 		hind = (int)hand;
-	int 		ind;
-	dn_rec_t	*dnp;
-	dbg_t		*dbp;
-	dbg_t		*dbg_db;
-
-	if (dbg_net && hind >= 0 && hind < DBG_MAXTABLE) {
-		dbg_db = (dbg_t *)dbg_handle[hind];
-
-		dnp = (dn_rec_t *)newp;
-		ind = dnp->dn_cip.s_addr & dbg_mask;
-		dbp = &dbg_db[ind];
-		(void) rw_wrlock(&dbg_lock[hind]);
-		dbp->dn_lease = dnp->dn_lease;
-		dbp->dn_cid_len = dnp->dn_cid_len;
-		dbp->dn_flags = dnp->dn_flags;
-		/*
-		 * Performance: avoid routine call when NULL string
-		 * is being copied.
-		 */
-		if ((dbp->dn_cid[0] = dnp->dn_cid[0]) != '\0')
-			(void) memcpy(dbp->dn_cid, dnp->dn_cid,
-			    dnp->dn_cid_len);
-		(void) rw_unlock(&dbg_lock[hind]);
-		ret = DSVC_SUCCESS;
-	} else
-		ret = modify_dd_entry(hand, origp, newp);
-
-	return (ret);
-#endif	/* DEBUG */
-}
-
-void
-dhcp_free_dd_list(dsvc_handle_t hand, void *listp)
-{
-#ifndef	DEBUG
-	free_dd_list(hand, listp);
-
-#else	/* DEBUG */
-	dn_rec_list_t *ptr;
-	int hind = (int)hand;
-
-	if (dbg_net && hind >= 0 && hind < DBG_MAXTABLE) {
-		while ((ptr = listp) != NULL) {
-			listp = ptr->dnl_next;
-			free(ptr);
-		}
-	} else
-		free_dd_list(hand, listp);
-#endif	/* DEBUG */
-}
-
-/*
- * cmp_lrusort: qsort() comparison routine to sort lru list.
- */
-static int
-cmp_lrusort(const void *a, const void *b)
-{
-	dn_rec_list_t *r1 = *(dn_rec_list_t **)a;
-	dn_rec_list_t *r2 = *(dn_rec_list_t **)b;
-
-	if (r1->dnl_rec->dn_lease < r2->dnl_rec->dn_lease)
-		return (-1);
-	else if (r1->dnl_rec->dn_lease == r2->dnl_rec->dn_lease)
-		return (0);
-	else
-		return (1);
-}
-
-/*
- * get_lrusort: quick sort of eligible lru container entries.
- */
-static dn_rec_list_t *
-get_lrusort(dsvc_dnet_t *pnd, dn_rec_list_t *lrup, uint_t *lrecords)
-{
-	size_t nel;
-	size_t size = *lrecords * sizeof (dn_rec_list_t *);
-	dn_rec_list_t *from, **to, *next, *freerec = NULL;
-	dn_rec_list_t *lrupage;
-	dn_rec_t *rp;
-	time_t reuse_time = time(NULL) - min_lru;
-	uint_t records = 0;
-#ifndef	NDEBUG
-	int cnt = 0;
-#endif	/* !NDEBUG */
-
-	(void) mutex_lock(&pnd->lrupage_mtx);
-	if (pnd->lrupage == NULL || pnd->lrusize < size) {
-		if (pnd->lrupage != NULL)
-			free(pnd->lrupage);
-		pnd->lrupage = (dn_rec_list_t **)smalloc(size);
-		pnd->lrusize = size;
-	}
-	if ((to = pnd->lrupage) == NULL) {
-		pnd->lrusize = 0;
-		(void) mutex_unlock(&pnd->lrupage_mtx);
-		return (lrup);
-	}
-
-	/*
-	 * Build a list of entries, discarding those which are in use.
-	 */
-	*to = NULL;
-	for (from = lrup; from != NULL; from = next) {
-		next = from->dnl_next;
-		rp = from->dnl_rec;
-		if (rp->dn_lease > reuse_time ||
-		    (rp->dn_flags & DN_FAUTOMATIC) ||
-		    rp->dn_lease == DHCP_PERM) {
-			from->dnl_next = freerec;
-			freerec = from;
-		} else {
-			records++;
-			*(to++) = from;
-		}
-		assert(++cnt <= *lrecords);
-	}
-
-	/*
-	 * Sort any usable elements, and relink.
-	 */
-	nel = (int)(to - pnd->lrupage);
-	if (nel > 0) {
-		if (nel > 1)
-			qsort(pnd->lrupage, nel, sizeof (dn_rec_list_t *),
-			    cmp_lrusort);
-		for (to = pnd->lrupage; nel > 0; to++, nel--)
-			(*to)->dnl_next = *(to + 1);
-		to--;
-		(*to)->dnl_next = NULL;
-	}
-
-	/*
-	 * Free any unusable elements, return any usable elements.
-	 */
-	if (freerec)
-		dhcp_free_dd_list(pnd->dh, freerec);
-	*lrecords = records;
-
-	lrupage = *(pnd->lrupage);
-	(void) mutex_unlock(&pnd->lrupage_mtx);
-	return (lrupage);
-}
-
-/*
- * dhcp_lookup_dd_classify: perform lookup_dd(), or use existing records
- * if supplied, and classify the results based on the type of search criteria
- * being employed. Centralized policy for DN_FMANUAL and DN_FUNUSABLE flag
- * processing are implemented here. Classification is specialized
- * based on these specific search criteria:
- *
- *	S_CID		A CID match is requested. Perform DN_FMANUAL and
- *			DN_FUNUSABLE processing.
- *	S_FREE		A search for free records. Only examine first
- *			matching record.
- *	S_LRU		A search for lru records. Perform sort if needed,
- *			and only examine first matching record.
- *
- * A matching record is detached and returned if found (ok ||
- * manual + unusable). Other successful matches are returned in recordsp as
- * a cache.
- */
-void *
-dhcp_lookup_dd_classify(dsvc_dnet_t *pnd, boolean_t partial, uint_t query,
-    int count, const dn_rec_t *targetp, void **recordsp, int searchtype)
-{
-	int		err;
-	uint_t		rec_cnt = 0, manual = 0;
-	dn_rec_t	*dnp;
-	dn_rec_list_t	*nlp = NULL, *dnlp = NULL;
-	dn_rec_list_t	*unulp = NULL;		/* list of unusables, !manual */
-	dn_rec_list_t	*unu_m_lp = NULL;	/* list of unusable + manual */
-	dn_rec_list_t	*m_lp = NULL;		/* list of manual records */
-	dn_rec_list_t	*cachep = NULL;		/* match cache */
-	struct in_addr	swapaddr;
-	char		ntoab[INET_ADDRSTRLEN];
-
-	/*
-	 * Lookup records matching the specified criteria, or use
-	 * records from a previous lookup supplied for classification.
-	 */
-	if (*recordsp == NULL) {
-
-		TNF_PROBE_1_DEBUG(classify, "classify classify",
-		    "classify_query%debug 'in func classify'",
-		    tnf_long, query, query);
-
-		err = dhcp_lookup_dd(pnd->dh, partial, query, count, targetp,
-		    (void **)recordsp, &rec_cnt);
-
-		TNF_PROBE_1_DEBUG(classify_cid_end, "classify classify_end",
-		    "classify_end%debug 'in func classify'",
-		    tnf_long, rec_cnt, rec_cnt);
-
-		/*
-		 * If any error occurs, mark the dsvc_dnet_t table
-		 * for immediate close and reopen. Let the protocol
-		 * perform recover, rather than attempting time-consuming
-		 * in-place error recovery.
-		 */
-		if (err != DSVC_SUCCESS) {
-			(void) mutex_lock(&pnd->pnd_mtx);
-			pnd->flags |= DHCP_PND_ERROR;
-			hash_Dtime(pnd->hand, 0);
-			(void) mutex_unlock(&pnd->pnd_mtx);
-#ifdef	DEBUG
-			dhcpmsg(LOG_DEBUG, "classify failure %s\n",
-				dhcpsvc_errmsg(err));
-#endif	/* DEBUG */
-			*recordsp = NULL;
-			return (NULL);
-		}
-
-		/*
-		 * For LRU classification, sort returned records based
-		 * on dn_lease field. Discards records with valid lease
-		 * times; adjusts rec_cnt accordingly.
-		 */
-		if (searchtype & S_LRU)
-			*recordsp = get_lrusort(pnd, *recordsp, &rec_cnt);
-
-	}
-
-	/*
-	 * Record classification: scan through all records, performing
-	 * DN_FUNUSABLE and DN_FMANUAL processing. Note that most of the
-	 * work has been performed by the datastore query. Remove the matching
-	 * entry from the singlely-linked record list, for return. Free any
-	 * non-matching entries prior to the match. Pass back any additional
-	 * entries after the match in the recordsp pointer for possible re-use
-	 * by the caching code.
-	 */
-
-	for (nlp = detach_dnrec_from_list(NULL, *recordsp,
-	    (dn_rec_list_t **)recordsp); nlp != NULL;
-	    nlp = detach_dnrec_from_list(NULL, *recordsp,
-	    (dn_rec_list_t **)recordsp)) {
-		/*
-		 * If we find that there is a DN_FMANUAL entry that is
-		 * DN_FUNUSABLE, we fail the request, when performing a
-		 * CID search, even though there may be other CID matches. In
-		 * the CID case, those other CID matches are errors, because
-		 * there should be one and only one record for a client if that
-		 * record is marked as being DN_FMANUALly assigned. We tell
-		 * the user how many of those CID matches there are. If there
-		 * are no DN_FMANUAL records, the first matching record which
-		 * is USABLE wins.
-		 */
-		dnp = nlp->dnl_rec;
-		if (dnp->dn_flags & DN_FUNUSABLE) {
-			if ((searchtype & (S_CID|S_FREE|S_LRU)) == S_CID) {
-				char	cidbuf[DHCP_MAX_OPT_SIZE];
-				uint_t	blen = sizeof (cidbuf);
-
-				(void) octet_to_hexascii(targetp->dn_cid,
-				    targetp->dn_cid_len,
-				    cidbuf, &blen);
-
-				swapaddr.s_addr = htonl(dnp->dn_cip.s_addr);
-
-				dhcpmsg(LOG_NOTICE, "(%1$s,%2$s) "
-				    "currently marked as unusable.\n", cidbuf,
-				    inet_ntop(AF_INET, &swapaddr, ntoab,
-				    sizeof (ntoab)));
-			}
-
-			/* build list of unusable records */
-			if (dnp->dn_flags & DN_FMANUAL) {
-				attach_dnrec_to_list(nlp, &unu_m_lp);
-				manual++;
-			} else
-				attach_dnrec_to_list(nlp, &unulp);
-		} else {
-			if (dnp->dn_flags & DN_FMANUAL) {
-				attach_dnrec_to_list(nlp, &m_lp);
-				manual++;
-			} else
-				attach_dnrec_to_list(nlp, &cachep);
-			/*
-			 * These searches do not require examining all
-			 * matches.
-			 */
-			if (searchtype & (S_FREE|S_LRU))
-				break;
-		}
-	}
-
-	/*
-	 * Warnings are printed for CID searches which end with
-	 * DN_FUNUSABLE|DN_FMANUAL match(es).
-	 */
-	if (m_lp != NULL || unu_m_lp != NULL) {
-		if (manual > 1) {
-			char	cidbuf[DHCP_MAX_OPT_SIZE];
-			uint_t	blen = sizeof (cidbuf);
-
-			(void) octet_to_hexascii(targetp->dn_cid,
-				targetp->dn_cid_len,
-				cidbuf, &blen);
-			dhcpmsg(LOG_WARNING,
-			    "Manual allocation (%1$s) has %2$d other MANUAL"
-			    " records. It should have 0.\n", cidbuf,
-			    manual - 1);
-		}
-		if (unu_m_lp != NULL) {
-			dnlp = detach_dnrec_from_list(NULL, unu_m_lp,
-			    &unu_m_lp);
-		} else
-			dnlp = detach_dnrec_from_list(NULL, m_lp, &m_lp);
-	}
-
-	/* Free any unusable entries */
-	if (unulp != NULL)
-		dhcp_free_dd_list(pnd->dh, unulp);
-
-	/* any other... */
-	if (dnlp == NULL)
-		dnlp = detach_dnrec_from_list(NULL, cachep, &cachep);
-
-	/*
-	 * Return any unused elements for possible caching use. These are
-	 * the  additional manual + unusable (as punishment for having
-	 * multiple items), manual, and and any others.
-	 */
-	if (cachep != NULL)
-		attach_dnrec_to_list(cachep, (dn_rec_list_t **)recordsp);
-	if (m_lp != NULL)
-		attach_dnrec_to_list(m_lp, (dn_rec_list_t **)recordsp);
-	if (unu_m_lp != NULL)
-		attach_dnrec_to_list(unu_m_lp, (dn_rec_list_t **)recordsp);
-
-	/*
-	 * Return one of the matching record(s).
-	 */
-	return (dnlp);
-}
-
-/*
- * Error message function. If debugging off, then logging goes to
- * syslog.
- *
- * Must be MT SAFE - called by various threads as well as the main thread.
- */
-
-/*VARARGS2*/
-void
-dhcpmsg(int errlevel, const char *fmtp, ...)
-{
-	char		buff[BUFSIZ], errbuf[BUFSIZ];
-	const char *f = buff;
-	va_list		ap;
-
-	if (debug < 0)
-		return;
-
-	va_start(ap, fmtp);
-
-	if (debug > 0)  {
-		if (errlevel != LOG_ERR)
-			(void) snprintf(errbuf, sizeof (errbuf),
-			    "%lx: ", time(NULL));
-		else
-			(void) snprintf(errbuf, sizeof (errbuf),
-			    "%lx: (%s)", time(NULL), strerror(errno));
-		(void) snprintf(buff, sizeof (buff), "%s %s", errbuf,
-		    gettext(fmtp));
-		(void) vfprintf(stderr, f, ap);
-	} else if (debug == 0)
-		(void) vsyslog(errlevel, gettext(fmtp), ap);
-
-	va_end(ap);
-}
-
-/*
- * smalloc()  --  safe malloc()
- *
- * Always returns a valid pointer(if it returns at all).  The allocated
- * memory is initialized to all zeros.  If malloc() returns an error, a
- * message is printed using the syslog() function and the program aborts
- * with a status of 1.
- *
- * Must be MT SAFE - called by threads other than the main thread.
- */
-void *
-smalloc(uint_t nbytes)
-{
-	char		*retvalue;
-
-	if ((retvalue = calloc(nbytes, sizeof (char))) == NULL) {
-		dhcpmsg(LOG_ERR, "Cannot allocate memory (%s), exiting\n",
-		    strerror(errno));
-		exit(1);
-	}
-	return (retvalue);
-}
-
-/*
- * srealloc()  --  safe realloc()
- *
- * Always returns a valid pointer(if it returns at all).
- * If realloc() returns an error, a message is printed using the syslog()
- * function and the program aborts with a status of 1.
- * Unlike smalloc(), does not initialize the buffer to all zeros.
- *
- * Must be MT SAFE - called by threads other than the main thread.
- */
-void *
-srealloc(void *arg, uint_t nbytes)
-{
-	if ((arg = realloc(arg, nbytes)) == NULL) {
-		dhcpmsg(LOG_ERR, "Cannot allocate memory (%s), exiting\n",
-		    strerror(errno));
-		exit(1);
-	}
-	return (arg);
-}
-
-/*
- * Matches the speficied ip address with our owner_ip addresses.
- * Returns NULL if no match is found.
- */
-struct in_addr *
-match_ownerip(in_addr_t new)
-{
-	struct in_addr *oip = owner_ip;
-
-	while (oip->s_addr != INADDR_ANY && oip->s_addr != new)
-		oip++;
-	return ((oip->s_addr != INADDR_ANY) ? oip : NULL);
-}
-
-/*
- * qualify_hostname()  --  concatenate host  "."  domain  "."  NULL
- */
-int
-qualify_hostname(char *fqname, const char *host, const char *domain,
-    int host_length, int domain_length)
-{
-	char *fqptr;
-
-	if (domain_length + host_length + 2 > NS_MAXDNAME) {
-		dhcpmsg(LOG_ERR, "qualify_hostname: FQDN too long\n");
-		return (-1);
-	}
-
-	fqptr = fqname;
-
-	(void) memcpy(fqptr, host, host_length);
-	fqptr += host_length;
-
-	*fqptr = '.';
-	fqptr++;
-
-	(void) memcpy(fqptr, domain, domain_length);
-	fqptr += domain_length;
-
-	*fqptr = '.';
-	*(fqptr+1) = '\0';
-
-	return (0);
-}
