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

/*
 * Provides accessors to configuration properties.
 *
 * slp_readConfig:	attempts to locate slp.conf, and reads in all
 *				properties specified therein.
 * slp_get_mtu:		returns the MTU
 * slp_get_next_onlist:	parses a comma separated list of integers (in
 *				string form), returning one at a time.
 * slp_parse_static_das: parses the list of DAs given in the DAAddresses
 *				property.
 *
 * Also see the config wrapper macros in slp-internal.h.
 */

#include <stdio.h>
#include <syslog.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <slp-internal.h>

/*
 * Reads from fp and dynamically reallocates the buffer if necessary.
 * Returns 1 on success, 0 on read completion, and -1 on failure.
 */
static int super_fgets(char **buf, size_t *bufsize, FILE *fp) {
	char *r, *p;
	size_t real_bufsize, readlen = 0;

	p = *buf;
	real_bufsize = *bufsize;
	for (;;) {
		r = fgets(p, (int)real_bufsize, fp);
		if (feof(fp) && !r)
			return (0);
		if (!r)
			return (-1);
		readlen += strlen(r);
		if ((*buf)[readlen - 1] == '\n')
			return (1);

		/* else	buf is too small */
		*bufsize *= 2;
		if (!(*buf = realloc(*buf, *bufsize))) {
			slp_err(LOG_CRIT, 0, "super_fgets", "out of memory");
			return (-1);
		}
		p = *buf + readlen;
		real_bufsize = *bufsize - readlen;
	}
}

static void skip_space(char **p) {
	while (*p && **p != '\n' && isspace(**p))
		(*p)++;
}

static void null_space(char *p) {
	for (; *p; p++)
		if (isspace(*p))
			*p = 0;
}

/*
 * Reads into the local property store all properties defined in
 * the config file.
 */
void slp_readConfig() {
	char *cfile, *buf;
	FILE *fp;
	size_t buflen = 512;

	/* check env for alternate config file */
	fp = NULL;
	if (cfile = getenv("SLP_CONF_FILE"))
		fp = fopen(cfile, "rF");
	if (!fp)
		if (!(fp = fopen(SLP_DEFAULT_CONFIG_FILE, "rF"))) {
			slp_err(LOG_INFO, 0, "readConfig",
				"cannot open config file");
			return;
		}

	if (!(buf = malloc(buflen))) {
		slp_err(LOG_CRIT, 0, "readConfig", "out of memory");
		(void) fclose(fp);
		return;
	}

	while (!feof(fp)) {
		char *val, *p;
		int err;

		/* read a line */
		err = super_fgets(&buf, &buflen, fp);
		if (err == 0) continue;
		if (err == -1) {
			slp_err(LOG_INFO, 0, "readConfig",
				"error reading file: %d",
				ferror(fp));
			(void) fclose(fp);
			free(buf);
			return;
		}

		/* skip comments and newlines */
		p = buf;
		skip_space(&p);
		if (*p == '#' || *p == ';' || *p == '\n')
			continue;

		/* get property and value */
		if (val = strchr(p, '=')) {
			*val++ = 0;
			skip_space(&val);
			/* remove the trailing newline */
			val[strlen(val) - 1] = 0;
		}
		null_space(p);

		SLPSetProperty(p, val ? val : "");
	}

	(void) fclose(fp);
	free(buf);
}

/*
 * Config convenience wrappers
 */
size_t slp_get_mtu() {
	size_t size;
	size = atoi(SLPGetProperty(SLP_CONFIG_MTU));
	size = size ? size : SLP_DEFAULT_SENDMTU;

	return (size);
}

/*
 * On the first invocation, *state should == the value of the property
 * to parse.
 * If there are no more timeouts, returns -1, otherwise the timeout.
 * If the value in the property is invalid, returns the default 2000.
 */
int slp_get_next_onlist(char **state) {
	char *p, buf[33];
	size_t l;
	int answer;

	if (!*state)
		return (-1);

	if (**state == ',') {
		(*state)++;	/* skip the ',' */
	}
	p = *state;
	*state = slp_utf_strchr(*state, ',');
	if (!*state)
		l = strlen(p);
	else {
		l = *state - p;
		l = (l > 32 ? 32 : l);
	}
	(void) strncpy(buf, p, l);
	buf[l] = 0;
	answer = atoi(buf);

	return (answer != 0 ? answer : 2000);
}

int slp_get_maxResults() {
	int num = atoi(SLPGetProperty(SLP_CONFIG_MAXRESULTS));

	return (num <= 0 ? -1 : num);
}