OpenSolaris_b135/lib/libslp/clib/SLPUtils.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"

/*
 * Public utilities and convenience calls (from the API spec):
 *	SLPFindScopes (queries for all known scopes)
 *	SLPEscape / Unescape
 *	SLPFree
 *	SLPSet/GetProperty
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <netdb.h>
#include <unistd.h>
#include <libintl.h>
#include <slp-internal.h>

struct scopes_tree {
	void *scopes;
	int len;
};

typedef SLPBoolean SLPScopeCallback(SLPHandle, const char *, SLPError, void *);

static SLPSrvURLCallback collate_scopes;
static void collect_scopes(void *, VISIT, int, void *);
static SLPBoolean unpackSAAdvert_scope(slp_handle_impl_t *, char *,
					SLPScopeCallback, void *,
					void **, int *);
static SLPError SAAdvert_for_scopes(SLPHandle, void **);
static SLPError slp_unescape(const char *, char **, SLPBoolean, const char);

/*
 * Finds scopes according the the user administrative model.
 */
SLPError SLPFindScopes(SLPHandle hSLP, char **ppcScopes) {
	SLPError err;
	char *reply, *unesc_reply;
	void *stree = NULL;
	void *collator = NULL;

	if (!hSLP || !ppcScopes) {
		return (SLP_PARAMETER_BAD);
	}

	/* first try administratively configured scopes */
	if ((err = slp_administrative_scopes(ppcScopes, SLP_FALSE))
	    != SLP_OK) {
		return (err);
	}

	if (*ppcScopes) {
	    /* got scopes */
	    return (SLP_OK);
	}

	/* DAs from active and passive discovery */
	if ((err = slp_find_das("", &reply)) != SLP_OK &&
	    err != SLP_NETWORK_ERROR)
		return (err);

	/* Unpack the reply */
	if (reply) {
		int numResults = 0;	/* placeholder; not actually used */

		/* tag call as internal */
		((slp_handle_impl_t *)hSLP)->internal_call = SLP_TRUE;

		(void) slp_unpackSrvReply(
			hSLP, reply, collate_scopes,
			&stree, &collator, &numResults);
		/* invoke last call */
		(void) slp_unpackSrvReply(
			hSLP, NULL, collate_scopes,
			&stree, &collator, &numResults);
		free(reply);

		/* revert internal call tag */
		((slp_handle_impl_t *)hSLP)->internal_call = SLP_FALSE;
	}

	/* Finally, if no results yet, try SA discovery */
	if (!stree) {
	    (void) SAAdvert_for_scopes(hSLP, &stree);
	}

	if (!stree) {
		/* found none, so just return "default" */
		if (!(*ppcScopes = strdup("default"))) {
			slp_err(LOG_CRIT, 0, "SLPFindScopes", "out of memory");
			return (SLP_MEMORY_ALLOC_FAILED);
		}
		return (SLP_OK);
	}

	/* we now have a btree, each leaf of which is a unique scope */
	slp_twalk(stree, collect_scopes, 0, (void *) ppcScopes);

	/* unescape scopes list */
	if ((err = slp_unescape(*ppcScopes, &unesc_reply, SLP_FALSE, '%'))
	    == SLP_OK) {
		free(*ppcScopes);
		*ppcScopes = unesc_reply;
	} else {
		free(unesc_reply);
	}

	return (err);
}

/*
 * Finds scopes according to the adminstrative scoping model. A
 * comma-seperated list of scopes is returned in *ppcScopes; the
 * caller must free *ppcScopes.
 * If the return_default parameter is true, and no scopes are found,
 * *ppcScopes will be set to 'default', otherwise, *ppcScopes will
 * be NULL. This helps simplify internal memory management.
 */
SLPError slp_administrative_scopes(char **ppcScopes,
					SLPBoolean return_default) {
	const char *useScopes;

	*ppcScopes = NULL;

	/* @@@ first try DHCP */
	/* next try the useScopes property */
	useScopes = SLPGetProperty(SLP_CONFIG_USESCOPES);

	if (useScopes && *useScopes) {
		if (!(*ppcScopes = strdup(useScopes))) {
			slp_err(LOG_CRIT, 0, "SLPFindScopes", "out of memory");
			return (SLP_MEMORY_ALLOC_FAILED);
		}
		return (SLP_OK);
	}

	/* found none, so just return "default" */
	if (return_default && !(*ppcScopes = strdup("default"))) {
		slp_err(LOG_CRIT, 0, "SLPFindScopes", "out of memory");
		return (SLP_MEMORY_ALLOC_FAILED);
	}
	return (SLP_OK);
}

/*
 * This function operates on the same btree as the collate_scopes().
 * The difference is that this one is called for each
 * SAAdvert recieved.
 */
/* ARGSUSED */
static SLPBoolean saadvert_callback(SLPHandle hp, char *scopes,
					SLPError err, void **stree) {
	char *s, *tstate;

	if (err != SLP_OK) {
		return (SLP_TRUE);
	}

	for (
		s = strtok_r((char *)scopes, ",", &tstate);
		s;
		s = strtok_r(NULL, ",", &tstate)) {

		char *ascope, **srch;

		if (!(ascope = strdup(s))) {	/* no memory! */
			slp_err(LOG_CRIT, 0, "collate_scopes",
				"out of memory");
			return (SLP_TRUE);
		}

		srch = slp_tsearch(
			(void *) ascope, stree,
			(int (*)(const void *, const void *)) slp_strcasecmp);
		if (*srch != ascope)
			/* scope is already in there, so just free ascope */
			free(ascope);
	}

	return (SLP_TRUE);
}

/*
 * Generates an SAAdvert solicitation, and returns any scopes found
 * from all recieved SAAdverts in stree. stree must be a btree
 * structure.
 */
static SLPError SAAdvert_for_scopes(SLPHandle hSLP, void **stree) {
	SLPError err;
	SLPBoolean sync_state;
	slp_handle_impl_t *hp = (slp_handle_impl_t *)hSLP;
	char *predicate;
	const char *type_hint;

	/* get type hint, if set */
	if ((type_hint = SLPGetProperty(SLP_CONFIG_TYPEHINT)) != NULL &&
		*type_hint != 0) {

		size_t hintlen = strlen(type_hint);
		size_t predlen = strlen("(service-type=)");

		/* check bounds */
		if (hintlen > (SLP_MAX_STRINGLEN - predlen)) {
			return (SLP_PARAMETER_BAD);
		}
		if (!(predicate = malloc(hintlen + predlen + 1))) {
			slp_err(LOG_CRIT, 0, "SAAdvert_for_scopes",
				"out of memory");
			return (SLP_MEMORY_ALLOC_FAILED);
		}
		(void) strcpy(predicate, "(service-type=");
		(void) strcat(predicate, type_hint);
		(void) strcat(predicate, ")");
	} else {
		predicate = "";
		type_hint = NULL;
	}

	/* No callback for SLPFindScopes, so force synchronous mode only */
	sync_state = hp->async;
	hp->async = SLP_FALSE;

	if ((err = slp_start_call(hp)) != SLP_OK)
		return (err);

	err = slp_packSrvRqst("service:service-agent", predicate, hp);

	if (err == SLP_OK)
		err = slp_ua_common(hSLP, "",
				    (SLPGenericAppCB *)saadvert_callback,
				    stree,
				    (SLPMsgReplyCB *)unpackSAAdvert_scope);

	if (type_hint) {
		free(predicate);
	}

	if (err != SLP_OK)
		slp_end_call(hp);

	/* restore sync state */
	hp->async = sync_state;

	return (err);
}

/*
 * Unpack an SAAdvert and pass each set of scopes into cb.
 */
/* ARGSUSED */
static SLPBoolean unpackSAAdvert_scope(slp_handle_impl_t *hSLP, char *reply,
					SLPScopeCallback cb, void *cookie,
					void **collator, int *numResults) {
	char *surl, *scopes, *attrs;
	SLPBoolean cont;

	if (!reply) {
		cb(hSLP, NULL, SLP_LAST_CALL, cookie);
		return (SLP_FALSE);
	}

	/* tag call as internal; gets all scopes, regardless of maxResults */
	hSLP->internal_call = SLP_TRUE;

	if (slp_unpackSAAdvert(reply, &surl, &scopes, &attrs) != SLP_OK) {
		return (SLP_TRUE);
	}

	cont = cb(hSLP, scopes, SLP_OK, cookie);

	/* revert internal_call tag */
	hSLP->internal_call = SLP_FALSE;

	free(surl);
	free(scopes);
	free(attrs);

	return (cont);
}

/*
 * Creates a service request for finding DAs or SAs (based on 'filter'),
 * and sends it to slpd, returning the reply in 'reply'.
 */
SLPError slp_find_das(const char *filter, char **reply) {
	SLPError err;
	char *msg, hostname[MAXHOSTNAMELEN];

	/* Try the cache first */
	if (*reply = slp_find_das_cached(filter)) {
		return (SLP_OK);
	}

	/*
	 * create a find scopes message:
	 * this is a SrvRqst for the type directory-agent.sun.
	 */
	/* use the local host's name for the scope */
	(void) gethostname(hostname, MAXHOSTNAMELEN);

	err = slp_packSrvRqst_single(
		SLP_SUN_DA_TYPE, hostname, filter, &msg, "en");

	if (err == SLP_OK) {
		err = slp_send2slpd(msg, reply);
		free(msg);
	}

	/* Add the reply to the cache */
	if (err == SLP_OK) {
		slp_put_das_cached(filter, *reply, slp_get_length(*reply));
	}

	return (err);
}

/*
 * This is called for each URL entry in the DA service reply (sun private).
 * Contained within the cookie is a btree, to which it adds new
 * scopes from the URL entry. The scopes are retrieved from the btree
 * by traversing the tree in SLPFindScopes().
 * SLPHandle h is NULL, so don't touch it!
 */
/*ARGSUSED*/
static SLPBoolean collate_scopes(SLPHandle h, const char *u,
					unsigned short lifetime,
					SLPError errCode, void *cookie) {
	SLPSrvURL *surl;
	char *s, *tstate, *p, *url;
	void **collator = cookie;

	if (errCode != SLP_OK)
		return (SLP_TRUE);

	/* dup url so as not to corrupt da cache */
	if (!(url = strdup(u))) {
		slp_err(LOG_CRIT, 0, "collate_scopes", "out of memory");
		return (SLP_FALSE);
	}

	/* parse url into a SLPSrvURL struct */
	if (SLPParseSrvURL(url, &surl) != SLP_OK)
		return (SLP_TRUE);	/* bad URL; skip it */

	/* collate the scopes using the btree stree->scopes: */
	/* skip the 'scopes=' part */
	if (!(p = strchr(surl->s_pcSrvPart, '='))) {
		free(surl);
		return (SLP_TRUE);	/* bad URL; skip it */
	}
	p++;

	for (
		s = strtok_r(p, ",", &tstate);
		s;
		s = strtok_r(NULL, ",", &tstate)) {

		char *ascope, **srch;

		if (!(ascope = strdup(s))) {	/* no memory! */
			slp_err(LOG_CRIT, 0, "collate_scopes",
				"out of memory");
			free(surl);
			return (SLP_TRUE);
		}

		srch = slp_tsearch(
			(void *) ascope, collator,
			(int (*)(const void *, const void *)) slp_strcasecmp);
		if (*srch != ascope)
			/* scope is already in there, so just free ascope */
			free(ascope);
	}

	free(url);
	free(surl);

	return (SLP_TRUE);
}

/*
 * Each time we visit a node for the last time, copy that scope into
 * the scope collection and free the scope string and the node.
 */
/*ARGSUSED*/
static void collect_scopes(void *node, VISIT order, int level, void *cookie) {
	char **scopes = (char **)cookie;

	if (order == endorder || order == leaf) {
		char *s = *(char **)node;
		slp_add2list(s, scopes, SLP_FALSE);
		free(s);
		free(node);
	}
}

void SLPFree(void *pvMem) {
	if (pvMem)
		free(pvMem);
}

/*
 * Escape / Unescape
 */

#define	isBadTagChar(c)	((c) == '*' || (c) == '_' || \
			(c) == '\n' || (c) == '\t' || (c) == '\r')

#define	isReserved(c)	((c) <= 31 || (c) == '(' || (c) == ')' || \
			(c) == ',' || (c) == '\\' || (c) == '!' || \
			(c) == '<' || (c) == '=' || (c) == '>' || \
			(c) == '~')

SLPError SLPEscape(const char *pcInbuf, char **ppcOutBuf, SLPBoolean isTag) {
	char *buf, *pin, *pout;

	if (!pcInbuf || !ppcOutBuf)
		return (SLP_PARAMETER_BAD);

	if (!(buf = malloc(strlen(pcInbuf) * 3 + 1))) {
		slp_err(LOG_CRIT, 0, "SLPEscape", "out of memory");
		return (SLP_MEMORY_ALLOC_FAILED);
	}
	*ppcOutBuf = buf;

	for (pin = (char *)pcInbuf, pout = buf; *pin; ) {
		int len;

		/* If char is start of multibyte char, just copy it in */
		if ((len = mblen(pin, MB_CUR_MAX)) > 1) {
			int i;
			for (i = 0; i < len && *pin; i++)
				*pout++ = *pin++;
			continue;
		}

		/* check for bad tag */
		if (isTag && isBadTagChar(*pin))
			return (SLP_PARSE_ERROR);

		if (isReserved(*pin)) {
			if (isTag)
				return (SLP_PARSE_ERROR);
			(void) sprintf(pout, "\\%.2x", *pin);
			pout += 3;
			pin++;
		} else {
			*pout++ = *pin++;
		}
	}
	*pout = 0;

	return (SLP_OK);
}

SLPError SLPUnescape(const char *pcInbuf, char **ppcOutBuf, SLPBoolean isTag) {
	if (!pcInbuf || !ppcOutBuf)
		return (SLP_PARAMETER_BAD);

	return (slp_unescape(pcInbuf, ppcOutBuf, isTag, '\\'));
}


/*
 * The actual unescaping routine; allows for different escape chars.
 */
static SLPError slp_unescape(const char *pcInbuf, char **ppcOutBuf,
				SLPBoolean isTag, const char esc_char) {
	char *buf, *pin, *pout, conv[3];

	if (!(buf = malloc(strlen(pcInbuf) * 3 + 1))) {
		slp_err(LOG_CRIT, 0, "SLPEscape", "out of memory");
		return (SLP_MEMORY_ALLOC_FAILED);
	}
	*ppcOutBuf = buf;

	conv[2] = 0;
	for (pin = (char *)pcInbuf, pout = buf; *pin; ) {
		int len;

		/* If char is start of multibyte char, just copy it in */
		if ((len = mblen(pin, MB_CUR_MAX)) > 1) {
			int i;
			for (i = 0; i < len && *pin; i++)
				*pout++ = *pin++;
			continue;
		}

		if (*pin == esc_char) {
			if (!pin[1] || !pin[2])
				return (SLP_PARSE_ERROR);
			pin++;
			conv[0] = *pin++;
			conv[1] = *pin++;
			*pout++ = (char)strtol(conv, NULL, 16);
			if (isTag && isBadTagChar(*pout))
				return (SLP_PARSE_ERROR);
		} else {
			*pout++ = *pin++;
		}
	}
	*pout = 0;

	return (SLP_OK);
}

/*
 * Properties
 *
 * All properties are stored in a global tree (prop_table). This
 * tree is created and accessed by slp_tsearch and slp_tfind.
 */
struct prop_entry {
	const char *key, *val;
};
typedef struct prop_entry slp_prop_entry_t;

/* Global properties table */
static void *slp_props = NULL;
static mutex_t prop_table_lock = DEFAULTMUTEX;

static void setDefaults();

static int compare_props(const void *a, const void *b) {
	return (strcmp(
		((slp_prop_entry_t *)a)->key,
		((slp_prop_entry_t *)b)->key));
}

void SLPSetProperty(const char *pcName, const char *pcValue) {
	slp_prop_entry_t *pe, **pe2;

	if (!slp_props) setDefaults();

	if (!pcName || !pcValue) {
		return;
	}

	if (!(pe = malloc(sizeof (*pe)))) {
		slp_err(LOG_CRIT, 0, "SLPSetProperty", "out of memory");
		return;
	}

	/* place the strings under library ownership */
	if (!(pe->key = strdup(pcName))) {
		free(pe);
		slp_err(LOG_CRIT, 0, "SLPSetProperty", "out of memory");
		return;
	}

	if (!(pe->val = strdup(pcValue))) {
		free((void *) pe->key);
		free(pe);
		slp_err(LOG_CRIT, 0, "SLPSetProperty", "out of memory");
		return;
	}

	/* is pcName already set? */
	(void) mutex_lock(&prop_table_lock);
	pe2 = slp_tsearch((void *) pe, &slp_props, compare_props);
	if (pe != *pe2) {
		/* this prop is already set; overwrite the old value */
		free((void *) (*pe2)->val);
		(*pe2)->val = pe->val;
		free((void *) pe->key);
		free(pe);
	}
	(void) mutex_unlock(&prop_table_lock);
}

const char *SLPGetProperty(const char *pcName) {
	slp_prop_entry_t pe[1], **ans;

	if (!slp_props) setDefaults();

	if (!pcName) {
		return (NULL);
	}

	pe->key = pcName;

	(void) mutex_lock(&prop_table_lock);
	ans = slp_tfind(pe, &slp_props, compare_props);
	(void) mutex_unlock(&prop_table_lock);
	if (ans)
		return ((*ans)->val);
	return (NULL);
}

static void setDefaults() {
	slp_prop_entry_t *pe;
	static mutex_t lock = DEFAULTMUTEX;

	(void) mutex_lock(&lock);
	if (slp_props) {
		(void) mutex_unlock(&lock);
		return;
	}

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_ISBROADCASTONLY);
	pe->val = strdup("false");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_MULTICASTTTL);
	pe->val = strdup("255");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_MULTICASTMAXWAIT);
	pe->val = strdup("15000");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_DATAGRAMTIMEOUTS);
	pe->val = strdup("2000,2000,2000");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_MULTICASTTIMEOUTS);
	pe->val = strdup("1000,3000,3000,3000,3000");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = SLP_CONFIG_MTU; pe->val = "1400";
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_MAXRESULTS);
	pe->val = strdup("-1");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_SECURITY_ON);
	pe->val = strdup("false");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	pe = malloc(sizeof (*pe));
	pe->key = strdup(SLP_CONFIG_BYPASS_AUTH);
	pe->val = strdup("false");
	(void) slp_tsearch((void *) pe, &slp_props, compare_props);

	slp_readConfig();

	(void) mutex_unlock(&lock);
}

static const char *error_strings[] = {
	"OK",				/* 0 */
	"Language not supported",	/* -1 */
	"Parse error",			/* -2 */
	"Invalid registration",		/* -3 */
	"Scope not supported",		/* -4 */
	"Invalid error number",		/* -5 */
	"Authentication absent",	/* -6 */
	"Authentication failed",	/* -7 */
	"Invalid error number",		/* -8 */
	"Invalid error number",		/* -9 */
	"Invalid error number",		/* -10 */
	"Invalid error number",		/* -11 */
	"Invalid error number",		/* -12 */
	"Invalid update",		/* -13 */
	"Invalid error number",		/* -14 */
	"Invalid error number",		/* -15 */
	"Invalid error number",		/* -16 */
	"Not implemented",		/* -17 */
	"Buffer overflow",		/* -18 */
	"Network timed out",		/* -19 */
	"Network init failed",		/* -20 */
	"Memory alloc failed",		/* -21 */
	"Parameter bad",		/* -22 */
	"Network error",		/* -23 */
	"Internal system error",	/* -24 */
	"Handle in use",		/* -25 */
	"Type error"			/* -26 */
};

#define	SLP_MAX_ERR_CNT	26

const char *slp_strerror(SLPError err) {
	int abserr;
	const char *str;

	if (err == SLP_LAST_CALL) {
		str = "Last call";
	} else if (err == SLP_SECURITY_UNAVAILABLE) {
		str = "Security Implementation Unavailable";
	} else {
		abserr = abs(err);
		if (abserr > SLP_MAX_ERR_CNT) {
			str = "Invalid error number";
		} else {
			str = error_strings[abserr];
		}
	}

	return (dgettext("libslp", str));
}