xref: /titanic_52/usr/src/lib/libuuid/common/etheraddr.c (revision bdfc6d18da790deeec2e0eb09c625902defe2498)

/*
 * 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 2000,2002 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include "etheraddr.h"
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <strings.h>
#include <libdevinfo.h>
#include <stropts.h>
#include <unistd.h>
#include <uuid/uuid.h>
#include <sys/sockio.h>
#include <sys/utsname.h>

#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <sys/dlpi.h>
/*
 * debugging flag
 */
static	int	debug = 0;


/* Timeout for DLPI acks */
static	int	dlpi_timeout = DLPI_TIMEOUT;

/*
 * Global functions
 */
int	dlpi_get_address(char *, struct ether_addr *);
int	get_net_if_names(char ***);
void	free_net_if_names(char **);


/*
 * local functions
 */
static	int	dlpi_info_req(int, dl_info_ack_t *);
static	int	timed_getmsg(int, struct strbuf *, int *, int, char *, char *);
static	int	ifrm_num(char *, unsigned int *);
static	int	open_dev(dev_att_t *, int, int *, int);
static	void	pf_dev_att(dev_att_t *);
static	void	parse_ifname(dev_att_t *);
static	int	ifname_open(char *, dev_att_t *);
static	int	dlpi_open_attach(char *);
static	int	dlpi_attach(int, int, int);
static	int	dlpi_get_phys(int, uchar_t *);
static	int	dlpi_info_req(int, dl_info_ack_t *);
static	int	timed_getmsg(int, struct strbuf *, int *, int, char *, char *);

/*
 * get an individual arp entry
 */
int
arp_get(uuid_node_t *node)
{
	struct utsname name;
	struct arpreq ar;
	struct hostent *hp;
	struct sockaddr_in *sin;
	int s;

	if (uname(&name) == -1) {
		return (-1);
	}
	(void) memset(&ar, 0, sizeof (ar));
	ar.arp_pa.sa_family = AF_INET;
	/* LINTED pointer */
	sin = (struct sockaddr_in *)&ar.arp_pa;
	sin->sin_family = AF_INET;
	sin->sin_addr.s_addr = inet_addr(name.nodename);
	if (sin->sin_addr.s_addr == (in_addr_t)-1) {
		hp = gethostbyname(name.nodename);
		if (hp == NULL) {
			return (-1);
		}
		(void) memcpy(&sin->sin_addr, hp->h_addr,
		    sizeof (sin->sin_addr));
	}
	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0) {
		return (-1);
	}
	if (ioctl(s, SIOCGARP, (caddr_t)&ar) < 0) {
		(void) close(s);
		return (-1);
	}
	(void) close(s);
	if (ar.arp_flags & ATF_COM) {
		bcopy(&ar.arp_ha.sa_data, node, 6);
	} else
		return (-1);
	return (0);
}


/* Get all interface names.  This will include IPv6 names. */
int
get_net_if_names(char ***names)
{
	char *buf;		/* buffer for socket info */
	int sd;			/* socket descriptor */
	int ifn;	/* interface count structure */
	struct ifconf ifc;    /* interface config buffer */
	struct ifreq *ifrp;
	int numifs;
	char **tmpnames;
	int n;
	char *tmpname;
	sd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sd < 0)
		return (-1);

	if (ioctl(sd, SIOCGIFNUM, &ifn) < 0) {
		(void) close(sd);
		return (-1);
	}

	if (!(buf = malloc(ifn * sizeof (struct ifreq)))) {
		(void) close(sd);
		return (-1);
	}

	ifc.ifc_len = ifn * sizeof (struct ifreq);
	ifc.ifc_buf = (caddr_t)buf;
	if (ioctl(sd, SIOCGIFCONF, (char *)&ifc) < 0) {
		free(buf);
		(void) close(sd);
		return (-1);
	}
	(void) close(sd);

	ifrp = ifc.ifc_req;
	numifs = ifc.ifc_len / sizeof (struct ifreq);
	tmpnames = (char **)calloc((numifs+1), sizeof (char *));

	if (tmpnames == NULL) {
		free(buf);
		return (-1);
	}
	for (n = 0; n < numifs; n++, ifrp++) {
		if ((tmpnames[n] = strdup(ifrp->ifr_name)) == NULL)
			break;
	}
	free(buf);
	*names = tmpnames;
	return (0);
}

/*
 * frees previously-allocated array from get_net_if_names
 */
void
free_net_if_names(char **ifnames)
{
	int	i;

	i = 0;
	while (ifnames[i] != NULL) {
		free(ifnames[i]);
		i++;
	}
	free(ifnames);
}


/*
 * attempt to remove ppa from end of file name
 * return -1 if none found
 * return ppa if found and remove the ppa from the filename
 */
static int
ifrm_num(char *fname, unsigned int *ppa)
{
	int	i;
	uint_t	p = 0;
	unsigned int	m = 1;

	i = strlen(fname) - 1;
	while (i >= 0 && '0' <= fname[i] && fname[i] <= '9') {
		p += (fname[i] - '0')*m;
		m *= 10;
		i--;
	}
	if (m == 1) {
		return (-1);
	}
	fname[i + 1] = '\0';
	*ppa = p;
	return (0);
}

/*
 * Open the device defined in dev_att with the given mode starting with
 * the module indicated by mod_cnt (1 indexed).  If mod_cnt > 0, fd must
 * contain the file descriptor that modules are to be pushed on.
 * Returns -1 if device could not be opened, the index of
 * the module that could not be pushed or 0 on success.
 */
static int
open_dev(dev_att_t *dev_att, int mode, int *fd, int mod_cnt)
{
	int	cnt;
	int	local_fd;

	if (debug)
		(void) printf("open_dev: ifname: %s : dev %s fd %d "
		    " mod_cnt %d\n",
		    dev_att->ifname, dev_att->devname, *fd, mod_cnt);
	/*
	 * if no module count is given, try and open the device
	 */
	if (mod_cnt == 0) {
		if (debug)
			(void) printf("open_dev: opening %s\n",
			    dev_att->devname);
		if ((local_fd = open(dev_att->devname, mode)) < 0) {
			if (debug) {
				perror("open_dev: device");
				(void) printf("\n");
			}
			*fd = local_fd;
			return (-1);
		}
		*fd = local_fd;
		cnt = 1;
	} else {
		local_fd = *fd;
		cnt = mod_cnt;
	}

	/*
	 * Try and push modules (if any) onto the device stream
	 */
	for (; cnt <= dev_att->mod_cnt; cnt++) {
		if (debug)
			(void) printf(" pushing: mod %s",
			    dev_att->modlist[cnt - 1]);
		if (ioctl(local_fd, I_PUSH, dev_att->modlist[cnt - 1]) == -1) {
			if (debug) {
				perror("open_dev: push");
				(void) printf("\n");
			}
			return (cnt);
		}
	}
	if (debug)
		(void) printf("\n");
	return (0);
}

/*
 * Debug routine to print out dev_att_t structure
 */
static void
pf_dev_att(dev_att_t *dev_att)
{
	int cnt;

	(void) printf("\tifname: %s\n", dev_att->ifname);
	(void) printf("\t  style: %d\n", dev_att->style);
	(void) printf("\t  ppa: %d\n", dev_att->ppa);
	(void) printf("\t  mod_cnt: %d\n", dev_att->mod_cnt);
	(void) printf("\t  devname: %s\n", dev_att->devname);
	for (cnt = 0; cnt < dev_att->mod_cnt; cnt++) {
		(void) printf("\t      module: %s\n", dev_att->modlist[cnt]);
	}
}

/*
 * This function parses a '.' delimited interface name of the form
 * dev[.module[.module...]][:lun]
 * and places the device and module name into dev_att
 */
static void
parse_ifname(dev_att_t *dev_att)
{
	char		*lunstr;
	char		*modlist = NULL; /* list of modules to push */
	int		cnt = 0; /* number of modules to push */
	char		modbuf[LIFNAMSIZ];
	char		*nxtmod;

	/*
	 * check for specified lun at end of interface and
	 * strip it off.
	 */
	lunstr = strchr(dev_att->ifname, ':');

	if (lunstr) {
		char *endptr;

		*lunstr = '\0';
		lunstr++;
		endptr = lunstr;
		dev_att->lun = strtoul(lunstr, &endptr, 10);

		if (endptr == lunstr || *endptr != '\0') {
			(void) printf("Invalid logical unit number:%s", lunstr);
			exit(-1);
		}
	} else {
		dev_att->lun = 0;
	}

	(void) strlcpy(modbuf, dev_att->ifname, LIFNAMSIZ);

	/* parse '.' delmited module list */
	modlist = strchr(modbuf, '.');
	if (modlist) {
		/* null-terminate interface name (device) */
		*modlist = '\0';
		modlist++;
		if (strlen(modlist) == 0)
			modlist = NULL;
		while (modlist && cnt < MAX_MODS) {
			nxtmod = strchr(modlist, '.');
			if (nxtmod) {
				*nxtmod = '\0';
				nxtmod++;
			}
			(void) strncpy(dev_att->modlist[cnt], modlist,
			    LIFNAMSIZ);
			cnt++;
			modlist = nxtmod;
		}
	}
	(void) snprintf(dev_att->devname, LIFNAMSIZ, "%s/%s", DEVDIR, modbuf);
	dev_att->mod_cnt = cnt;
}

/*
 * given a interface name (with possible modules to push)
 * interface name must have the format of
 * dev[ppa][.module[.module...][ppa]][:lun]
 * where only one ppa may be specified e.g. ip0.foo.tun or ip.foo.tun0
 */
static int
ifname_open(char *dev_name, dev_att_t *dev_att)
{
	int		fd;
	uint_t		ppa;
	int		res;
	int		style;
	dl_info_ack_t	dl_info;
	int		mod_id;

	if (debug)
		(void) printf("ifname_open: %s\n", dev_name);

	if (strlen(dev_name) > LIFNAMSIZ - 1) {
		errno = EINVAL;
		return (-1);
	}

	/* save copy of original device name */
	(void) strncpy(dev_att->ifname, dev_name, LIFNAMSIZ);

	/* parse modules */
	parse_ifname(dev_att);

	/* try DLPI style 1 device first */

	if (debug) {
		pf_dev_att(dev_att);
	}
	mod_id = open_dev(dev_att, O_RDWR, &fd, 0);
	if (mod_id != 0) {
		if (debug) {
			(void) printf("Error on open_dev style 1 mod_id: %d"
			    " attemping style 2\n", mod_id);
			pf_dev_att(dev_att);
		}
		if (mod_id == -1) {
			res = ifrm_num(dev_att->devname, &ppa);
			mod_id = 0;
			if (res < 0) {
				if (debug)
					(void) fprintf(stderr,
					    "%s: No such file or directory\n",
					    dev_att->devname);
				(void) close(fd);
				return (-1);
			}
			/*
			 * ensure that it's the last module
			 * in the list to extract
			 * ppa
			 */
		} else if ((mod_id != dev_att->mod_cnt) ||
		    (res = ifrm_num(dev_att->modlist[dev_att->mod_cnt - 1],
			&ppa)) < 0) {
			if (debug) {
				(void) fprintf(stderr,
				    "Error on open_dev style 2 mod_id: %d \n",
				    mod_id);
			}
			if (mod_id == dev_att->mod_cnt)
				(void) fprintf(stderr, "libuuid: could not "
				    "locate ppa in %s\n",
				    dev_att->ifname);
			(void) close(fd);
			return (-1);
		}
		goto style2;
	}
	dev_att->style = 1;
	dev_att->ppa = 0;
	style = DL_STYLE1;
	goto dl_info_chk;
style2:
	dev_att->ppa = ppa;
	mod_id = open_dev(dev_att, O_RDWR, &fd, mod_id);
	if (mod_id != 0) {
		if (debug) {
			(void) fprintf(stderr,
			    "Error on open_dev style 2 mod_id: %d \n",
			    mod_id);
			if (mod_id > 0) {
				(void) fprintf(stderr, "%s: No such module\n",
				    dev_att->modlist[mod_id - 2]);
			}
			pf_dev_att(dev_att);
		}
		(void) close(fd);
		return (-1);
	}
	dev_att->style = 2;
	style = DL_STYLE2;
dl_info_chk:
	if (dlpi_info_req(fd, &dl_info) < 0) {
		(void) close(fd);
		pf_dev_att(dev_att);
		return (-1);
	}
	if (dl_info.dl_provider_style != style) {
		if (debug) {
			(void) fprintf(stderr, "DLPI provider style mismatch: "
			    "expected style %s got style %s (0x%lx)\n",
			    style == DL_STYLE1 ? "1" : "2",
			    dl_info.dl_provider_style == DL_STYLE1 ? "1" : "2",
			    dl_info.dl_provider_style);
		}
		(void) close(fd);
		return (-1);
	}
	if (debug) {
		(void) printf("pars_dev_att() success\n");
		pf_dev_att(dev_att);
	}
	return (fd);
}

static int
dlpi_open_attach(char *ifname)
{
	int			fd;
	dev_att_t		dev_att;

	if (debug)
		(void) printf("dlpi_open_attach %s\n", ifname);

	/* if lun is specified fail (backwards compat) */
	if (strchr(ifname, ':') != NULL) {
		return (-1);
	}
	if ((fd = ifname_open(ifname, &dev_att)) < 0) {
		/* Not found */
		errno = ENXIO;
		return (-1);
	}
	if (dlpi_attach(fd, dev_att.ppa, dev_att.style) < 0) {
		(void) close(fd);
		return (-1);
	}
	return (fd);
}

static int
dlpi_attach(int fd, int ppa, int style)
{
	union DL_primitives	*dlp;
	char			*buf;
	struct strbuf		ctl;
	int			flags;

	if (style != 2)
		return (0);

	/* Allocate required buffers */
	if ((buf = malloc(BUFSIZ)) == NULL) {
		(void) fprintf(stderr, "libuuid: malloc() failed\n");
		return (-1);
	}

	/* Issue DL_ATTACH_REQ */
	/* LINTED: malloc returns a pointer aligned for any use */
	dlp = (union DL_primitives *)buf;
	dlp->attach_req.dl_primitive = DL_ATTACH_REQ;
	dlp->attach_req.dl_ppa = ppa;
	ctl.buf = (char *)dlp;
	ctl.len = DL_ATTACH_REQ_SIZE;
	if (putmsg(fd, &ctl, NULL, 0) < 0) {
		perror("libuuid: putmsg");
		free(buf);
		return (-1);
	}

	/* read reply */
	ctl.buf = (char *)dlp;
	ctl.len = 0;
	ctl.maxlen = BUFSIZ;
	flags = 0;

	/* start timeout for DL_OK_ACK reply */
	if (timed_getmsg(fd, &ctl, &flags, dlpi_timeout,
	    "DL_OK_ACK", "DL_ATTACH_REQ") == 0) {
		free(buf);
		return (-1);
	}

	if (debug) {
		(void) printf("ok_ack: ctl.len[%d] flags[%d]\n", ctl.len,
		    flags);
	}

	/* Validate DL_OK_ACK reply.  */
	if (ctl.len < sizeof (t_uscalar_t)) {
		(void) fprintf(stderr,
		    "libuuid: attach failed: short reply to attach request\n");
		free(buf);
		return (-1);
	}

	if (dlp->dl_primitive == DL_ERROR_ACK) {
		if (debug)
			(void) fprintf(stderr,
			    "attach failed:  dl_errno %lu errno %lu\n",
			    dlp->error_ack.dl_errno,
			    dlp->error_ack.dl_unix_errno);
		free(buf);
		errno = ENXIO;
		return (-1);
	}
	if (dlp->dl_primitive != DL_OK_ACK) {
		(void) fprintf(stderr,
		    "libuuid: attach failed: "
		    "unrecognizable dl_primitive %lu received",
		    dlp->dl_primitive);
		free(buf);
		return (-1);
	}
	if (ctl.len < DL_OK_ACK_SIZE) {
		(void) fprintf(stderr,
		    "libuuid: attach failed: "
		    "short attach acknowledgement received\n");
		free(buf);
		return (-1);
	}
	if (dlp->ok_ack.dl_correct_primitive != DL_ATTACH_REQ) {
		(void) fprintf(stderr,
		    "libuuid: attach failed: "
		    "returned prim %lu != requested prim %lu\n",
		    dlp->ok_ack.dl_correct_primitive,
		    (t_uscalar_t)DL_ATTACH_REQ);
		free(buf);
		return (-1);
	}
	if (debug)
		(void) printf("attach done\n");

	free(buf);
	return (0);
}

static int
dlpi_get_phys(int fd, uchar_t *eaddr)
{
	union DL_primitives	*dlp;
	char			*buf;
	struct strbuf		ctl;
	int			flags;

	/* Allocate required buffers */
	if ((buf = malloc(BUFSIZ)) == NULL) {
		(void) fprintf(stderr, "libuuid: malloc() failed\n");
		return (-1);
	}
	/* Issue DL_PHYS_ADDR_REQ */
	/* LINTED: malloc returns a pointer aligned for any use */
	dlp = (union DL_primitives *)buf;
	dlp->physaddr_req.dl_primitive = DL_PHYS_ADDR_REQ;
	dlp->physaddr_req.dl_addr_type = DL_CURR_PHYS_ADDR;
	ctl.buf = (char *)dlp;
	ctl.len = DL_PHYS_ADDR_REQ_SIZE;
	if (putmsg(fd, &ctl, NULL, 0) < 0) {
		perror("libuuid: putmsg");
		free(buf);
		return (-1);
	}

	/* read reply */
	ctl.buf = (char *)dlp;
	ctl.len = 0;
	ctl.maxlen = BUFSIZ;
	flags = 0;

	if (timed_getmsg(fd, &ctl, &flags, dlpi_timeout,
	    "DL_PHYS_ADDR_ACK", "DL_PHYS_ADDR_REQ (DL_CURR_PHYS_ADDR)") == 0) {
		free(buf);
		return (-1);
	}

	if (debug) {
		(void) printf("phys_addr_ack: ctl.len[%d] flags[%d]\n", ctl.len,
		    flags);
	}

	/* Validate DL_PHYS_ADDR_ACK reply.  */
	if (ctl.len < sizeof (t_uscalar_t)) {
		(void) fprintf(stderr, "libuuid: phys_addr failed: "
		    "short reply to phys_addr request\n");
		free(buf);
		return (-1);
	}

	if (dlp->dl_primitive == DL_ERROR_ACK) {
		/*
		 * Do not print errors for DL_UNSUPPORTED and DL_NOTSUPPORTED
		 */
		if (dlp->error_ack.dl_errno != DL_UNSUPPORTED &&
		    dlp->error_ack.dl_errno != DL_NOTSUPPORTED) {
			(void) fprintf(stderr, "libuuid: phys_addr failed: "
			    "dl_errno %lu errno %lu\n",
			    dlp->error_ack.dl_errno,
			    dlp->error_ack.dl_unix_errno);
		}
		free(buf);
		return (-1);
	}
	if (dlp->dl_primitive != DL_PHYS_ADDR_ACK) {
		(void) fprintf(stderr, "libuuid: phys_addr failed: "
		    "unrecognizable dl_primitive %lu received\n",
		    dlp->dl_primitive);
		free(buf);
		return (-1);
	}
	if (ctl.len < DL_PHYS_ADDR_ACK_SIZE) {
		(void) fprintf(stderr, "libuuid: phys_addr failed: "
		    "short phys_addr acknowledgement received\n");
		free(buf);
		return (-1);
	}
	/* Check length of address. */
	if (dlp->physaddr_ack.dl_addr_length != ETHERADDRL) {
		free(buf);
		return (-1);
	}

	/* copy Ethernet address */
	(void) memcpy(eaddr, &buf[dlp->physaddr_ack.dl_addr_offset],
	    ETHERADDRL);

	free(buf);
	return (0);
}



static int
dlpi_info_req(int fd, dl_info_ack_t *info_ack)
{
	dl_info_req_t   info_req;
	int	buf[BUFSIZ/sizeof (int)];
	union DL_primitives	*dlp = (union DL_primitives *)buf;
	struct  strbuf  ctl;
	int	flags;

	info_req.dl_primitive = DL_INFO_REQ;

	ctl.len = DL_INFO_REQ_SIZE;
	ctl.buf = (char *)&info_req;

	flags = RS_HIPRI;

	if (putmsg(fd, &ctl, (struct strbuf *)NULL, flags) < 0) {
		perror("libuuid: putmsg");
		return (-1);
	}

	/* read reply */
	ctl.buf = (char *)dlp;
	ctl.len = 0;
	ctl.maxlen = BUFSIZ;
	flags = 0;
	/* start timeout for DL_BIND_ACK reply */
	if (timed_getmsg(fd, &ctl, &flags, dlpi_timeout, "DL_INFO_ACK",
	    "DL_INFO_ACK") == 0) {
		return (-1);
	}

	if (debug) {
		(void) printf("info_ack: ctl.len[%d] flags[%d]\n", ctl.len,
		    flags);
	}

	/* Validate DL_BIND_ACK reply.  */
	if (ctl.len < sizeof (t_uscalar_t)) {
		(void) fprintf(stderr,
		    "libuuid: info req failed: short reply to info request\n");
		return (-1);
	}

	if (dlp->dl_primitive == DL_ERROR_ACK) {
		(void) fprintf(stderr,
		    "libuuid: info req failed:  dl_errno %lu errno %lu\n",
		    dlp->error_ack.dl_errno, dlp->error_ack.dl_unix_errno);
		return (-1);
	}
	if (dlp->dl_primitive != DL_INFO_ACK) {
		(void) fprintf(stderr,
		    "libuuid: info req failed: "
		    "unrecognizable dl_primitive %lu received\n",
		    dlp->dl_primitive);
		return (-1);
	}
	if (ctl.len < DL_INFO_ACK_SIZE) {
		(void) fprintf(stderr,
		    "libuuid: info req failed: "
		    "short info acknowledgement received\n");
		return (-1);
	}
	*info_ack = *(dl_info_ack_t *)dlp;
	return (0);
}


/*
 * interface called from libuuid to get the ethernet address - jhf
 */
int
dlpi_get_address(char *ifname, struct ether_addr *ea)
{
	int 	fd;

	if (debug)
		(void) printf("dlpi_get_address: dlpi_open_attach\t");
	fd = dlpi_open_attach(ifname);
	if (fd < 0) {
		/* Do not report an error */
		return (-1);
	}

	if (debug)
		(void) printf("dlpi_get_address: dlpi_get_phys %s\n", ifname);
	if (dlpi_get_phys(fd, (uchar_t *)ea) < 0) {
		(void) close(fd);
		return (-1);
	}
	(void) close(fd);
	return (0);
}

static int
timed_getmsg(int fd, struct strbuf *ctlp, int *flagsp, int timeout, char *kind,
    char *request)
{
	char		perrorbuf[BUFSIZ];
	struct pollfd	pfd;
	int		ret;

	pfd.fd = fd;

	pfd.events = POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI;
	if ((ret = poll(&pfd, 1, timeout * 1000)) == 0) {
		(void) fprintf(stderr, "libuuid: %s timed out\n", kind);
		return (0);
	} else if (ret == -1) {
		(void) snprintf(perrorbuf, sizeof (perrorbuf),
		    "libuuid: poll for %s from %s", kind, request);
		perror(perrorbuf);
		return (0);
	}

	/* poll returned > 0 for this fd so getmsg should not block */
	if ((ret = getmsg(fd, ctlp, NULL, flagsp)) < 0) {
		(void) snprintf(perrorbuf, sizeof (perrorbuf),
		    "libuuid: getmsg expecting %s for %s", kind, request);
		perror(perrorbuf);
		return (0);
	}

	return (1);
}

/*
 * Name:	get_ethernet_address
 *
 * Description:	Obtains the system ethernet address.
 *
 * Returns:	0 on success, non-zero otherwise.  The system ethernet
 *		address is copied into the passed-in variable.
 */
int
get_ethernet_address(uuid_node_t *node)
{
	char			**ifnames;
	char			*ifname;
	int			i;
	struct ether_addr	addr;
	int			found;

	if (arp_get(node) == 0)
		return (0);

	/*
	 * go get all interface names
	 */
	if (get_net_if_names(&ifnames) == 0) {
		return (0);
	}

	/*
	 * Assume failure
	 */
	found = -1;

	/*
	 * for each interface, query it through dlpi to get its physical
	 * (ethernet) address
	 */
	if (ifnames != NULL) {
		i = 0;
		while ((ifnames[i] != NULL) && found) {
			ifname = ifnames[i];
			/* Gross hack to avoid getting errors from /dev/lo0 */
			if (strcmp(ifname, LOOPBACK_IF) != 0) {
			    if (dlpi_get_address(ifname, &addr) == 0) {
				bcopy(&addr, node, 6);
				/*
				 * found one, set result to successful
				 */
				found = 0;
				continue;
			    }
			}
			i++;
		}
		free_net_if_names(ifnames);
	}

	/*
	 * Couldn't get ethernet address from any interfaces...
	 */
	return (found);
}