8322 nl: misleading-indentation

[unleashed/tickless.git] / 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 */