sbin/dhcpagent/class_id.c

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

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

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/openpromio.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>			/* sprintf() */
#include <unistd.h>

/*
 * opp_zalloc(): allocates and initializes a struct openpromio
 *
 *   input: size_t: the size of the variable-length part of the openpromio
 *          const char *: an initial value for oprom_array, if non-NULL
 *  output: struct openpromio: the allocated, initialized openpromio
 */

static struct openpromio *
opp_zalloc(size_t size, const char *prop)
{
	struct openpromio *opp = malloc(sizeof (struct openpromio) + size);

	if (opp != NULL) {
		(void) memset(opp, 0, sizeof (struct openpromio) + size);
		opp->oprom_size = size;
		if (prop != NULL)
			(void) strcpy(opp->oprom_array, prop);
	}
	return (opp);
}

/*
 * goto_rootnode(): moves to the root of the devinfo tree
 *
 *   input: int: an open descriptor to /dev/openprom
 *  output: int: nonzero on success
 */

static int
goto_rootnode(int prom_fd)
{
	struct openpromio op = { sizeof (int), 0 };

	/* zero it explicitly since a union is involved */
	op.oprom_node = 0;
	return (ioctl(prom_fd, OPROMNEXT, &op) == 0);
}

/*
 * return_property(): returns the value of a given property
 *
 *   input: int: an open descriptor to /dev/openprom
 *          const char *: the property to look for in the current devinfo node
 *  output: the value of that property (dynamically allocated)
 */

static char *
return_property(int prom_fd, const char *prop)
{
	int 			proplen;
	char			*result;
	struct openpromio	*opp = opp_zalloc(strlen(prop) + 1, prop);

	if (opp == NULL)
		return (NULL);

	if (ioctl(prom_fd, OPROMGETPROPLEN, opp) == -1) {
		free(opp);
		return (NULL);
	}

	proplen = opp->oprom_len;
	if (proplen > (strlen(prop) + 1)) {
		free(opp);
		opp = opp_zalloc(proplen, prop);
		if (opp == NULL)
			return (NULL);
	}

	if (ioctl(prom_fd, OPROMGETPROP, opp) == -1) {
		free(opp);
		return (NULL);
	}

	result = strdup(opp->oprom_array);
	free(opp);
	return (result);
}

/*
 * sanitize_class_id(): translates the class id into a canonical format,
 *			so that it can be used easily with dhcptab(4).
 *
 *   input: char *: the class id to canonicalize
 *  output: void
 */

static void
sanitize_class_id(char *src_ptr)
{
	char	*dst_ptr = src_ptr;

	/* remove all spaces and change all commas to periods */
	while (*src_ptr != '\0') {

		switch (*src_ptr) {

		case ' ':
			break;

		case ',':
			*dst_ptr++ = '.';
			break;

		default:
			*dst_ptr++ = *src_ptr;
			break;
		}
		src_ptr++;
	}
	*dst_ptr = '\0';
}

/*
 * get_class_id(): retrieves the class id from the prom, then canonicalizes it
 *
 *   input: void
 *  output: char *: the class id (dynamically allocated and sanitized)
 */

char *
get_class_id(void)
{
	int	prom_fd;
	char    *name, *class_id = NULL;
	size_t	len;

	prom_fd = open("/dev/openprom", O_RDONLY);
	if (prom_fd == -1)
		return (NULL);

	if (goto_rootnode(prom_fd) == 0) {
		(void) close(prom_fd);
		return (NULL);
	}

	/*
	 * the `name' property is the same as the result of `uname -i', modulo
	 * some stylistic issues we fix up via sanitize_class_id() below.
	 */

	name = return_property(prom_fd, "name");
	(void) close(prom_fd);
	if (name == NULL)
		return (NULL);

	/*
	 * if the name is not prefixed with a vendor name, add "SUNW," to make
	 * it more likely to be globally unique; see PSARC/2004/674.
	 */

	if (strchr(name, ',') == NULL) {
		len = strlen(name) + sizeof ("SUNW,");
		class_id = malloc(len);
		if (class_id == NULL) {
			free(name);
			return (NULL);
		}
		(void) snprintf(class_id, len, "SUNW,%s", name);
		free(name);
	} else {
		class_id = name;
	}

	sanitize_class_id(class_id);
	return (class_id);
}