usr/src/cmd/ldapcachemgr/cachemgr_discovery.c

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

#ifdef SLP

/*
 * This file contains all the dynamic server discovery functionality
 * for ldap_cachemgr. SLP is used to query the network for any changes
 * in the set of deployed LDAP servers.
 *
 * The algorithm used is outlined here:
 *
 *   1. Find all naming contexts with SLPFindAttrs. (See
 *      find_all_contexts())
 *   2. For each context, find all servers which serve that context
 *      with SLPFindSrvs. (See foreach_context())
 *   3. For each server, retrieve that server's attributes with
 *      SLPFindAttributes. (See foreach_server())
 *   4. Aggregate the servers' attributes into a config object. There
 *      is one config object associated with each context found in
 *      step 1. (See aggregate_attrs())
 *   5. Update the global config cache for each found context and its
 *      associated servers and attributes. (See update_config())
 *
 * The entry point for ldap_cachemgr is discover(). The actual entry
 * point into the discovery routine is find_all_contexts(); the
 * code thereafter is actually not specific to LDAP, and could also
 * be used to discover YP, or any other server which conforms
 * to the SLP Naming and Directory abstract service type.
 *
 * find_all_attributes() takes as parameters three callback routines
 * which are used to report all information back to the caller. The
 * signatures and synopses of these routines are:
 *
 * void *get_cfghandle(const char *domain);
 *
 *   Returns an opaque handle to a configuration object specific
 *   to the 'domain' parameter. 'domain' will be a naming context
 *   string, i.e. foo.bar.sun.com ( i.e. a secure-RPC domain-
 *   name).
 *
 * void aggregate(void *handle, const char *tag, const char *value);
 *
 *   Adds this tag / value pair to the set of aggregated attributes
 *   associated with the given handle.
 *
 * void set_cfghandle(void *handle);
 *
 *   Sets and destroys the config object; SLP will no longer attempt
 *   to use this handle after this call. Thus, this call marks the
 *   end of configuration information for this handle.
 */

#include <stdio.h>
#include <slp.h>
#include <stdlib.h>
#include <string.h>
#include <door.h>
#include <unistd.h>
#include "ns_sldap.h"
#include "ns_internal.h"
#include "cachemgr.h"

#define	ABSTYPE		"service:naming-directory"
#define	CONTEXT_ATTR	"naming-context"
#define	LDAP_DOMAIN_ATTR "x-sun-rpcdomain"

/* The configuration cookie passed along through all SLP callbacks. */
struct config_cookie {
	SLPHandle	h;		/* An open SLPHandle */
	const char	*type;		/* The full service type to use */
	char		*scopes;	/* A list of scopes to use */
	const char	*context_attr;	/* Which attr to use for the ctx */
	void		*cache_cfg;	/* caller-supplied config object */
	void *(*get_cfghandle)(const char *);
	void (*aggregate)(void *, const char *, const char *);
	void (*set_cfghandle)(void *);
};

extern admin_t current_admin;	/* ldap_cachemgr's admin struct */

/*
 * Utility routine: getlocale():
 * Returns the locale specified by the SLP locale property, or just
 * returns the default SLP locale if the property was not set.
 */
static const char *getlocale() {
	const char *locale = SLPGetProperty("net.slp.locale");
	return (locale ? locale : "en");
}

/*
 * Utility routine: next_attr():
 * Parses an SLP attribute string. On the first call, *type
 * must be set to 0, and *s_inout must point to the beginning
 * of the attr string. The following results are possible:
 *
 *   If the term is of the form 'tag' only, *t_inout is set to tag,
 *     and *v_inout is set to NULL.
 *   If the term is of the form '(tag=val)', *t_inout and *v_inout
 *     are set to the tag and val strings, respectively.
 *   If the term is of the form '(tag=val1,val2,..,valN)', on each
 *     successive call, next_attr will return the next value. On the
 *     first invocation, tag is set to 'tag'; on successive invocations,
 *     tag is set to *t_inout.
 *
 * The string passed in *s_inout is destructively modified; all values
 * returned simply point into the initial string. Hence the caller
 * is responsible for all memory management. The type parameter is
 * for internal use only and should be set to 0 by the caller only
 * on the first invocation.
 *
 * If more attrs are available, returns SLP_TRUE, otherwise returns
 * SLP_FALSE. If SLP_FALSE is returned, all value-result parameters
 * will be undefined, and should not be used.
 */
static SLPBoolean next_attr(char **t_inout, char **v_inout,
			    char **s_inout, int *type) {
	char *end = NULL;
	char *tag = NULL;
	char *val = NULL;
	char *state = NULL;

	if (!t_inout || !v_inout)
	    return (SLP_FALSE);

	if (!s_inout || !*s_inout || !**s_inout)
	    return (SLP_FALSE);

	state = *s_inout;

	/* type: 0 = start, 1 = '(tag=val)' type, 2 = 'tag' type */
	switch (*type) {
	case 0:
	    switch (*state) {
	    case '(':
		*type = 1;
		break;
	    case ',':
		state++;
		*type = 0;
		break;
	    default:
		*type = 2;
	    }
	    *s_inout = state;
	    return (next_attr(t_inout, v_inout, s_inout, type));
	    break;
	case 1:
	    switch (*state) {
	    case '(':
		/* start of attr of the form (tag=val[,val]) */
		state++;
		tag = state;
		end = strchr(state, ')');	/* for sanity checking */
		if (!end)
		    return (SLP_FALSE);	/* fatal parse error */

		state = strchr(tag, '=');
		if (state) {
		    if (state > end)
			return (SLP_FALSE);  /* fatal parse err */
		    *state++ = 0;
		} else {
		    return (SLP_FALSE);	/* fatal parse error */
		}
		/* fallthru to default case, which handles multivals */
	    default:
		/* somewhere in a multivalued attr */
		if (!end) {	/* did not fallthru from '(' case */
		    tag = *t_inout;	/* leave tag as it was */
		    end = strchr(state, ')');
		    if (!end)
			return (SLP_FALSE);	/* fatal parse error */
		}

		val = state;
		state = strchr(val, ',');	/* is this attr multivalued? */
		if (!state || state > end) {
		    /* no, so skip to the next attr */
		    state = end;
		    *type = 0;
		}	/* else attr is multivalued */
		*state++ = 0;
		break;
	    }
	    break;
	case 2:
	    /* attr term with tag only */
	    tag = state;
	    state = strchr(tag, ',');
	    if (state) {
		*state++ = 0;
	    }
	    val = NULL;
	    *type = 0;
	    break;
	default:
	    return (SLP_FALSE);
	}

	*t_inout = tag;
	*v_inout = val;
	*s_inout = state;

	return (SLP_TRUE);
}

/*
 * The SLP callback routine for foreach_server(). Aggregates each
 * server's attributes into the caller-specified config object.
 */
/*ARGSUSED*/
static SLPBoolean aggregate_attrs(SLPHandle h, const char *attrs_in,
				    SLPError errin, void *cookie) {
	char *tag, *val, *state;
	char *unesc_tag, *unesc_val;
	int type = 0;
	char *attrs;
	SLPError err;
	struct config_cookie *cfg = (struct config_cookie *)cookie;

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

	attrs = strdup(attrs_in);
	state = attrs;

	while (next_attr(&tag, &val, &state, &type)) {
	    unesc_tag = unesc_val = NULL;

	    if (tag) {
		if ((err = SLPUnescape(tag, &unesc_tag, SLP_TRUE)) != SLP_OK) {
		    unesc_tag = NULL;
		    if (current_admin.debug_level >= DBG_ALL) {
			(void) logit("aggregate_attrs: ",
				"could not unescape attr tag %s:%s\n",
				tag, slp_strerror(err));
		    }
		}
	    }
	    if (val) {
		if ((err = SLPUnescape(val, &unesc_val, SLP_FALSE))
		    != SLP_OK) {
		    unesc_val = NULL;
		    if (current_admin.debug_level >= DBG_ALL) {
			(void) logit("aggregate_attrs: ",
				"could not unescape attr val %s:%s\n",
				val, slp_strerror(err));
		    }
		}
	    }

	    if (current_admin.debug_level >= DBG_ALL) {
		(void) logit("discovery:\t\t%s=%s\n",
			(unesc_tag ? unesc_tag : "NULL"),
			(unesc_val ? unesc_val : "NULL"));
	    }

	    cfg->aggregate(cfg->cache_cfg, unesc_tag, unesc_val);

	    if (unesc_tag) free(unesc_tag);
	    if (unesc_val) free(unesc_val);
	}

	if (attrs) free(attrs);

	return (SLP_TRUE);
}

/*
 * The SLP callback routine for update_config(). For each
 * server found, retrieves that server's attributes.
 */
/*ARGSUSED*/
static SLPBoolean foreach_server(SLPHandle hin, const char *u,
				unsigned short life,
				SLPError errin, void *cookie) {
	SLPError err;
	struct config_cookie *cfg = (struct config_cookie *)cookie;
	SLPHandle h = cfg->h;	/* an open handle */
	SLPSrvURL *surl = NULL;
	char *url = NULL;

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

	/* dup url so we can slice 'n dice */
	if (!(url = strdup(u))) {
	    (void) logit("foreach_server: no memory");
	    return (SLP_FALSE);
	}

	if ((err = SLPParseSrvURL(url, &surl)) != SLP_OK) {
	    free(url);
	    if (current_admin.debug_level >= DBG_NETLOOKUPS) {
		(void) logit("foreach_server: ",
				"dropping unparsable URL %s: %s\n",
				url, slp_strerror(err));
		return (SLP_TRUE);
	    }
	}

	if (current_admin.debug_level >= DBG_ALL) {
	    (void) logit("discovery:\tserver: %s\n", surl->s_pcHost);
	}

	/* retrieve all attrs for this server */
	err = SLPFindAttrs(h, u, cfg->scopes, "", aggregate_attrs, cookie);
	if (err != SLP_OK) {
	    if (current_admin.debug_level >= DBG_NETLOOKUPS) {
		(void) logit("foreach_server: FindAttrs failed: %s\n",
				slp_strerror(err));
	    }
	    goto cleanup;
	}

	/* add this server and its attrs to the config object */
	cfg->aggregate(cfg->cache_cfg, "_,_xservers_,_", surl->s_pcHost);

cleanup:
	if (url) free(url);
	if (surl) SLPFree(surl);

	return (SLP_TRUE);
}

/*
 * This routine does the dirty work of finding all servers for a
 * given domain and injecting this information into the caller's
 * configuration namespace via callbacks.
 */
static void update_config(const char *context, struct config_cookie *cookie) {
	SLPHandle h = NULL;
	SLPHandle persrv_h = NULL;
	SLPError err;
	char *search = NULL;
	char *unesc_domain = NULL;

	/* Unescape the naming context string */
	if ((err = SLPUnescape(context, &unesc_domain, SLP_FALSE)) != SLP_OK) {
	    if (current_admin.debug_level >= DBG_ALL) {
		(void) logit("update_config: ",
				"dropping unparsable domain: %s: %s\n",
				context, slp_strerror(err));
	    }
	    return;
	}

	cookie->cache_cfg = cookie->get_cfghandle(unesc_domain);

	/* Open a handle which all attrs calls can use */
	if ((err = SLPOpen(getlocale(), SLP_FALSE, &persrv_h)) != SLP_OK) {
	    if (current_admin.debug_level >= DBG_NETLOOKUPS) {
		(void) logit("update_config: SLPOpen failed: %s\n",
				slp_strerror(err));
	    }
	    goto cleanup;
	}

	cookie->h = persrv_h;

	if (current_admin.debug_level >= DBG_ALL) {
	    (void) logit("discovery: found naming context %s\n", context);
	}

	/* (re)construct the search filter form the input context */
	search = malloc(strlen(cookie->context_attr) +
			strlen(context) +
			strlen("(=)") + 1);
	if (!search) {
	    (void) logit("update_config: no memory\n");
	    goto cleanup;
	}
	(void) sprintf(search, "(%s=%s)", cookie->context_attr, context);

	/* Find all servers which serve this context */
	if ((err = SLPOpen(getlocale(), SLP_FALSE, &h)) != SLP_OK) {
	    if (current_admin.debug_level >= DBG_NETLOOKUPS) {
		(void) logit("upate_config: SLPOpen failed: %s\n",
				slp_strerror(err));
	    }
	    goto cleanup;
	}

	err = SLPFindSrvs(h, cookie->type, cookie->scopes,
				search, foreach_server, cookie);
	if (err != SLP_OK) {
	    if (current_admin.debug_level >= DBG_NETLOOKUPS) {
		(void) logit("update_config: SLPFindSrvs failed: %s\n",
				slp_strerror(err));
	    }
	    goto cleanup;
	}

	/* update the config cache with the new info */
	cookie->set_cfghandle(cookie->cache_cfg);

cleanup:
	if (h) SLPClose(h);
	if (persrv_h) SLPClose(persrv_h);
	if (search) free(search);
	if (unesc_domain) free(unesc_domain);
}

/*
 * The SLP callback routine for find_all_contexts(). For each context
 * found, finds all the servers and their attributes.
 */
/*ARGSUSED*/
static SLPBoolean foreach_context(SLPHandle h, const char *attrs_in,
				    SLPError err, void *cookie) {
	char *attrs, *tag, *val, *state;
	int type = 0;

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

	/*
	 * Parse out each context. Attrs will be of the following form:
	 *   (naming-context=dc\3deng\2c dc\3dsun\2c dc\3dcom)
	 * Note that ',' and '=' are reserved in SLP, so they are escaped.
	 */
	attrs = strdup(attrs_in);	/* so we can slice'n'dice */
	if (!attrs) {
	    (void) logit("foreach_context: no memory\n");
	    return (SLP_FALSE);
	}
	state = attrs;

	while (next_attr(&tag, &val, &state, &type)) {
	    update_config(val, cookie);
	}

	free(attrs);

	return (SLP_TRUE);
}

/*
 * Initiates server and attribute discovery for the concrete type
 * 'type'. Currently the only useful type is "ldap", but perhaps
 * "nis" and "nisplus" will also be useful in the future.
 *
 * get_cfghandle, aggregate, and set_cfghandle are callback routines
 * used to pass any discovered configuration information back to the
 * caller. See the introduction at the top of this file for more info.
 */
static void find_all_contexts(const char *type,
				void *(*get_cfghandle)(const char *),
				void (*aggregate)(
					void *, const char *, const char *),
				void (*set_cfghandle)(void *)) {
	SLPHandle h = NULL;
	SLPError err;
	struct config_cookie cookie[1];
	char *fulltype = NULL;
	char *scope = (char *)SLPGetProperty("net.slp.useScopes");

	if (!scope || !*scope) {
	    scope = "default";
	}

	/* construct the full type from the partial type parameter */
	fulltype = malloc(strlen(ABSTYPE) + strlen(type) + 2);
	if (!fulltype) {
	    (void) logit("find_all_contexts: no memory");
	    goto done;
	}
	(void) sprintf(fulltype, "%s:%s", ABSTYPE, type);

	/* set up the cookie for this discovery operation */
	memset(cookie, 0, sizeof (*cookie));
	cookie->type = fulltype;
	cookie->scopes = scope;
	if (strcasecmp(type, "ldap") == 0) {
		/* Sun LDAP is special */
	    cookie->context_attr = LDAP_DOMAIN_ATTR;
	} else {
	    cookie->context_attr = CONTEXT_ATTR;
	}
	cookie->get_cfghandle = get_cfghandle;
	cookie->aggregate = aggregate;
	cookie->set_cfghandle = set_cfghandle;

	if ((err = SLPOpen(getlocale(), SLP_FALSE, &h)) != SLP_OK) {
	    if (current_admin.debug_level >= DBG_CANT_FIND) {
		(void) logit("discover: %s",
			    "Aborting discovery: SLPOpen failed: %s\n",
			    slp_strerror(err));
	    }
	    goto done;
	}

	/* use find attrs to get a list of all available contexts */
	err = SLPFindAttrs(h, fulltype, scope, cookie->context_attr,
			    foreach_context, cookie);
	if (err != SLP_OK) {
	    if (current_admin.debug_level >= DBG_CANT_FIND) {
		(void) logit(
		"discover: Aborting discovery: SLPFindAttrs failed: %s\n",
			slp_strerror(err));
	    }
	    goto done;
	}

done:
	if (h) SLPClose(h);
	if (fulltype) free(fulltype);
}

/*
 * This is the ldap_cachemgr entry point into SLP dynamic discovery. The
 * parameter 'r' should be a pointer to an unsigned int containing
 * the requested interval at which the network should be queried.
 */
void discover(void *r) {
	unsigned short reqrefresh = *((unsigned int *)r);

	for (;;) {
	    find_all_contexts("ldap",
				__cache_get_cfghandle,
				__cache_aggregate_params,
				__cache_set_cfghandle);

	    if (current_admin.debug_level >= DBG_ALL) {
		(void) logit(
			"dynamic discovery: using refresh interval %d\n",
			reqrefresh);
	    }

	    (void) sleep(reqrefresh);
	}
}

#endif /* SLP */