dhcp_inittab.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* 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
* 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 <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include <limits.h>
#include <ctype.h>
#include <libgen.h>
#include <sys/isa_defs.h>
#include <sys/sysmacros.h>
#include <libinetutil.h>
#include "dhcp_symbol.h"
#include "dhcp_inittab.h"
static void inittab_msg(const char *, ...);
static uchar_t category_to_code(const char *);
const char *, uint8_t *, int *);
const uint8_t *, char *, int *);
size_t *);
static boolean_t parse_entry(char *, char **);
/*
* forward declaration of our internal inittab_table[]. too bulky to put
* up front -- check the end of this file for its definition.
*/
static dhcp_symbol_t inittab_table[];
/*
* the number of fields in the inittab and names for the fields. note that
* this order is meaningful to parse_entry(); other functions should just
* use them as indexes into the array returned from parse_entry().
*/
#define ITAB_FIELDS 7
ITAB_CAT };
/*
* the category_map_entry_t is used to map the inittab category codes to
* the dsym codes. the reason the codes are different is that the inittab
* needs to have the codes be ORable such that queries can retrieve more
* than one category at a time. this map is also used to map the inittab
* string representation of a category to its numerical code.
*/
typedef struct category_map_entry {
char *cme_name;
static category_map_entry_t category_map[] = {
};
/*
* inittab_load(): returns all inittab entries with the specified criteria
*
* input: uchar_t: the categories the consumer is interested in
* char: the consumer type of the caller
* size_t *: set to the number of entries returned
* output: dhcp_symbol_t *: an array of dynamically allocated entries
* on success, NULL upon failure
*/
{
}
/*
* inittab_getbyname(): returns an inittab entry with the specified criteria
*
* input: int: the categories the consumer is interested in
* char: the consumer type of the caller
* char *: the name of the inittab entry the consumer wants
* output: dhcp_symbol_t *: a dynamically allocated dhcp_symbol structure
* on success, NULL upon failure
*/
{
}
/*
* inittab_getbycode(): returns an inittab entry with the specified criteria
*
* input: uchar_t: the categories the consumer is interested in
* char: the consumer type of the caller
* uint16_t: the code of the inittab entry the consumer wants
* output: dhcp_symbol_t *: a dynamically allocated dhcp_symbol structure
* on success, NULL upon failure
*/
{
}
/*
* inittab_lookup(): returns inittab entries with the specified criteria
*
* input: uchar_t: the categories the consumer is interested in
* char: the consumer type of the caller
* const char *: the name of the entry the caller is interested
* in, or NULL if the caller doesn't care
* int32_t: the code the caller is interested in, or -1 if the
* caller doesn't care
* size_t *: set to the number of entries returned
* output: dhcp_symbol_t *: dynamically allocated dhcp_symbol structures
* on success, NULL upon failure
*/
static dhcp_symbol_t *
{
char buffer[ITAB_MAX_LINE_LEN];
char *fields[ITAB_FIELDS];
unsigned long line = 0;
char *inittab_path;
if (inittab_path == NULL)
if (inittab_fp == NULL) {
inittab_msg("inittab_lookup: fopen: %s: %s",
return (NULL);
}
line++;
/*
* make sure the string didn't overflow our buffer
*/
inittab_msg("inittab_lookup: line %li: too long, "
"skipping", line);
continue;
}
/*
* skip `pure comment' lines
*/
for (i = 0; buffer[i] != '\0'; i++)
break;
continue;
/*
* parse the entry out into fields.
*/
inittab_msg("inittab_lookup: line %li: syntax error, "
"skipping", line);
continue;
}
/*
* validate the values in the entries; skip if invalid.
*/
inittab_msg("inittab_lookup: line %li: granularity `%s'"
continue;
}
inittab_msg("inittab_lookup: line %li: maximum `%s' "
continue;
}
DSYM_SUCCESS) {
inittab_msg("inittab_lookup: line %li: type `%s' "
continue;
}
/*
* find out whether this entry of interest to our consumer,
* and if so, throw it onto the set of entries we'll return.
* check categories last since it's the most expensive check.
*/
continue;
continue;
continue;
if ((category_code & categories) == 0)
continue;
/*
* looks like a match. allocate an entry and fill it in
*/
sizeof (dhcp_symbol_t));
/*
* if we run out of memory, might as well return what we can
*/
if (new_entries == NULL) {
inittab_msg("inittab_lookup: ran out of memory "
"allocating dhcp_symbol_t's");
break;
}
}
if (ferror(inittab_fp) != 0) {
inittab_msg("inittab_lookup: error on inittab stream");
}
(void) fclose(inittab_fp);
if (n_entriesp != NULL)
*n_entriesp = n_entries;
return (entries);
}
/*
* parse_entry(): parses an entry out into its constituent fields
*
* input: char *: the entry
* char **: an array of ITAB_FIELDS length which contains
* pointers into the entry on upon return
* output: boolean_t: B_TRUE on success, B_FALSE on failure
*/
static boolean_t
{
/*
* due to a mistake made long ago, the first and second fields of
* each entry are not separated by a comma, but rather by
* whitespace -- have bufsplit() treat the two fields as one, then
* pull them apart afterwards.
*/
return (B_FALSE);
/*
* pull the first and second fields apart. this is complicated
* since the first field can contain embedded whitespace (so we
* must separate the two fields by the last span of whitespace).
*
* first, find the initial span of whitespace. if there isn't one,
* then the entry is malformed.
*/
return (B_FALSE);
/*
* find the last span of whitespace.
*/
do {
category++;
/*
* NUL-terminate the first byte of the last span of whitespace, so
* that the first field doesn't have any residual trailing
* whitespace.
*/
spacep--;
return (B_FALSE);
*++spacep = '\0';
/*
* remove any whitespace from the fields.
*/
for (i = 0; i < n_fields; i++) {
fields[i]++;
}
return (B_TRUE);
}
/*
* inittab_verify(): verifies that a given inittab entry matches an internal
* definition
*
* input: dhcp_symbol_t *: the inittab entry to verify
* dhcp_symbol_t *: if non-NULL, a place to store the internal
* inittab entry upon return
* output: int: ITAB_FAILURE, ITAB_SUCCESS, or ITAB_UNKNOWN
*/
int
{
unsigned int i;
continue;
if (internal_ent != NULL)
*internal_ent = inittab_table[i];
return (ITAB_FAILURE);
return (ITAB_SUCCESS);
}
}
return (ITAB_UNKNOWN);
}
/*
* inittab_encode_e(): converts a string representation of a given datatype into
* binary; used for encoding ascii values into a form that
* can be put in DHCP packets to be sent on the wire.
*
* input: dhcp_symbol_t *: the entry describing the value option
* const char *: the value to convert
* uint16_t *: set to the length of the binary data returned
* boolean_t: if false, return a full DHCP option
* output: uchar_t *: a dynamically allocated byte array with converted data
*/
uchar_t *
{
const char *valuep;
char *currp;
unsigned int i;
*ierrnop = 0;
if (type_size == 0) {
return (NULL);
}
} else {
/*
* figure out the number of entries by counting the spaces
* in the value string
*/
}
/*
* if we're gonna return a complete option, then include the
* option length and code in the size of the packet we allocate
*/
if (just_payload == B_FALSE)
length += 2;
if (length > 0)
case DSYM_ASCII:
*ierrnop = ITAB_NOMEM;
return (NULL);
}
return (NULL);
}
break;
case DSYM_OCTET:
return (NULL);
}
/* Call libinetutil function to decode */
return (NULL);
}
break;
case DSYM_IP:
return (NULL);
}
*ierrnop = ITAB_BAD_GRAN;
inittab_msg("inittab_encode: number of entries "
"not compatible with option granularity");
return (NULL);
}
*currp = '\0';
inittab_msg("inittab_encode: bogus ip address");
return (NULL);
}
if (i < (n_entries - 1)) {
inittab_msg("inittab_encode: too few "
"ip addresses");
return (NULL);
}
break;
}
}
break;
case DSYM_NUMBER: /* FALLTHRU */
case DSYM_UNUMBER8: /* FALLTHRU */
case DSYM_SNUMBER8: /* FALLTHRU */
case DSYM_UNUMBER16: /* FALLTHRU */
case DSYM_SNUMBER16: /* FALLTHRU */
case DSYM_UNUMBER32: /* FALLTHRU */
case DSYM_SNUMBER32: /* FALLTHRU */
case DSYM_UNUMBER64: /* FALLTHRU */
case DSYM_SNUMBER64:
return (NULL);
}
return (NULL);
}
break;
default:
else
inittab_msg("inittab_encode: unsupported type `%d'",
return (NULL);
}
/*
* if just_payload is false, then we need to slide the option
* code and length fields in. (length includes them in its
* count, so we have to subtract 2)
*/
if (just_payload == B_FALSE) {
}
return (result);
}
/*
* inittab_decode_e(): converts a binary representation of a given datatype into
* a string; used for decoding DHCP options in a packet off
* the wire into ascii
*
* input: dhcp_symbol_t *: the entry describing the payload option
* uchar_t *: the payload to convert
* uint16_t: the payload length (only used if just_payload is true)
* boolean_t: if false, payload is assumed to be a DHCP option
* int *: set to extended error code if error occurs.
* output: char *: a dynamically allocated string containing the converted data
*/
char *
{
char *currp;
*ierrnop = 0;
if (type_size == 0) {
return (NULL);
}
if (just_payload == B_FALSE) {
payload += 2;
}
/*
* figure out the number of elements to convert. note that
* for ds_type NUMBER, the granularity is really 1 since the
* value of ds_gran is the number of bytes in the number.
*/
else
if (n_entries == 0)
inittab_msg("inittab_decode: length of string not compatible "
return (NULL);
}
case DSYM_ASCII:
*ierrnop = ITAB_NOMEM;
return (NULL);
}
break;
case DSYM_OCTET:
*ierrnop = ITAB_NOMEM;
return (NULL);
}
return (NULL);
}
}
break;
case DSYM_IP:
*ierrnop = ITAB_BAD_GRAN;
inittab_msg("inittab_decode: number of entries "
"not compatible with option granularity");
return (NULL);
}
*ierrnop = ITAB_NOMEM;
return (NULL);
}
sizeof (ipaddr_t));
return (NULL);
}
}
break;
case DSYM_NUMBER: /* FALLTHRU */
case DSYM_UNUMBER8: /* FALLTHRU */
case DSYM_SNUMBER8: /* FALLTHRU */
case DSYM_UNUMBER16: /* FALLTHRU */
case DSYM_SNUMBER16: /* FALLTHRU */
case DSYM_UNUMBER32: /* FALLTHRU */
case DSYM_SNUMBER32: /* FALLTHRU */
case DSYM_UNUMBER64: /* FALLTHRU */
case DSYM_SNUMBER64:
*ierrnop = ITAB_NOMEM;
return (NULL);
}
return (NULL);
}
break;
default:
inittab_msg("inittab_decode: unsupported type `%d'",
break;
}
return (result);
}
/*
* inittab_encode(): converts a string representation of a given datatype into
* binary; used for encoding ascii values into a form that
* can be put in DHCP packets to be sent on the wire.
*
* input: dhcp_symbol_t *: the entry describing the value option
* const char *: the value to convert
* uint16_t *: set to the length of the binary data returned
* boolean_t: if false, return a full DHCP option
* output: uchar_t *: a dynamically allocated byte array with converted data
*/
uchar_t *
{
int ierrno;
}
/*
* inittab_decode(): converts a binary representation of a given datatype into
* a string; used for decoding DHCP options in a packet off
* the wire into ascii
*
* input: dhcp_symbol_t *: the entry describing the payload option
* uchar_t *: the payload to convert
* uint16_t: the payload length (only used if just_payload is true)
* boolean_t: if false, payload is assumed to be a DHCP option
* output: char *: a dynamically allocated string containing the converted data
*/
char *
{
int ierrno;
}
/*
* inittab_msg(): prints diagnostic messages if INITTAB_DEBUG is set
*
* const char *: a printf-like format string
* ...: arguments to the format string
* output: void
*/
/*PRINTFLIKE1*/
static void
inittab_msg(const char *fmt, ...)
{
char buf[512];
static int action = INITTAB_MSG_CHECK;
/*
* check DHCP_INITTAB_DEBUG the first time in; thereafter, use
* the the cached result (stored in `action').
*/
switch (action) {
case INITTAB_MSG_CHECK:
return;
}
/* FALLTHRU into INITTAB_MSG_OUTPUT */
case INITTAB_MSG_OUTPUT:
break;
case INITTAB_MSG_RETURN:
return;
}
}
/*
* decode_number(): decodes a sequence of numbers from binary into ascii;
* binary is coming off of the network, so it is in nbo
*
* input: uint8_t: the number of "granularity" numbers to decode
* uint8_t: the length of each number
* boolean_t: whether the numbers should be considered signed
* uint8_t: the number of numbers per granularity
* const uint8_t *: where to decode the numbers from
* char *: where to decode the numbers to
* output: boolean_t: true on successful conversion, false on failure
*/
static boolean_t
{
if (granularity != 0) {
if ((granularity % n_entries) != 0) {
inittab_msg("decode_number: number of entries "
"not compatible with option granularity");
*ierrnop = ITAB_BAD_GRAN;
return (B_FALSE);
}
}
switch (size) {
case 1:
break;
case 2:
break;
case 4:
break;
case 8:
break;
default:
inittab_msg("decode_number: unknown integer size `%d'",
size);
return (B_FALSE);
}
}
return (B_TRUE);
}
/*
* encode_number(): encodes a sequence of numbers from ascii into binary;
* number will end up on the wire so it needs to be in nbo
*
* input: uint8_t: the number of "granularity" numbers to encode
* uint8_t: the length of each number
* boolean_t: whether the numbers should be considered signed
* uint8_t: the number of numbers per granularity
* const uint8_t *: where to encode the numbers from
* char *: where to encode the numbers to
* int *: set to extended error code if error occurs.
* output: boolean_t: true on successful conversion, false on failure
*/
static boolean_t /* ARGSUSED */
{
uint8_t i;
char *endptr;
if (granularity != 0) {
if ((granularity % n_entries) != 0) {
*ierrnop = ITAB_BAD_GRAN;
inittab_msg("encode_number: number of entries "
"not compatible with option granularity");
return (B_FALSE);
}
}
/*
* totally obscure c factoid: it is legal to pass a
* string representing a negative number to strtoul().
* in this case, strtoul() will return an unsigned
* long that if cast to a long, would represent the
* negative number. we take advantage of this to
* cut down on code here.
*/
errno = 0;
switch (size) {
case 1:
goto error;
}
break;
case 2:
goto error;
}
break;
case 4:
goto error;
}
break;
case 8:
goto error;
}
break;
default:
inittab_msg("encode_number: unsupported integer "
"size `%d'", size);
return (B_FALSE);
}
break;
}
return (B_TRUE);
inittab_msg("encode_number: cannot convert to integer");
return (B_FALSE);
}
/*
* inittab_type_to_size(): given an inittab entry, returns size of one entry of
* its type
*
* input: dhcp_symbol_t *: an entry of the given type
* output: uint8_t: the size in bytes of an entry of that type
*/
{
case DSYM_ASCII:
case DSYM_OCTET:
case DSYM_SNUMBER8:
case DSYM_UNUMBER8:
return (1);
case DSYM_SNUMBER16:
case DSYM_UNUMBER16:
return (2);
case DSYM_SNUMBER32:
case DSYM_UNUMBER32:
case DSYM_IP:
return (4);
case DSYM_SNUMBER64:
case DSYM_UNUMBER64:
return (8);
case DSYM_NUMBER:
}
return (0);
}
/*
* itabcode_to_dsymcode(): maps an inittab category code to its dsym
* representation
*
* input: uchar_t: the inittab category code
* output: dsym_category_t: the dsym category code
*/
static dsym_category_t
{
unsigned int i;
for (i = 0; i < ITAB_CAT_COUNT; i++)
return (category_map[i].cme_dsymcode);
return (DSYM_BAD_CAT);
}
/*
* category_to_code(): maps a category name to its numeric representation
*
* input: const char *: the category name
* output: uchar_t: its internal code (numeric representation)
*/
static uchar_t
category_to_code(const char *category)
{
unsigned int i;
for (i = 0; i < ITAB_CAT_COUNT; i++)
return (category_map[i].cme_itabcode);
return (0);
}
/*
* dhcp_htonll(): converts a 64-bit number from host to network byte order
*
* input: uint64_t: the number to convert
* output: uint64_t: its value in network byte order
*/
static uint64_t
{
return (dhcp_ntohll(uint64_hbo));
}
/*
* dhcp_ntohll(): converts a 64-bit number from network to host byte order
*
* input: uint64_t: the number to convert
* output: uint64_t: its value in host byte order
*/
static uint64_t
{
#ifdef _LITTLE_ENDIAN
#else
return (uint64_nbo);
#endif
}
/*
* our internal table of DHCP option values, used by inittab_verify()
*/
static dhcp_symbol_t inittab_table[] =
{
{ 0, 0, "", 0, 0, 0 }
};