ldap/common/gethostent6.c

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

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <netdb.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <inet/ip6.h>
#include <syslog.h>
#include <sys/systeminfo.h>
#include "ns_internal.h"
#include "ldap_common.h"

/* host attributes filters */

/* probably some change in the ipHostNumber field */

#define _H_DN           "dn"
#define _H_NAME         "cn"
#define _H_ADDR         "iphostnumber"
#define _F_GETHOSTS6BYNAME  "(&(objectClass=ipHost)(cn=%s))"
#define _F_GETHOSTS6BYNAME_SSD  "(&(%%s)(cn=%s))"
#define _F_GETHOSTS6DOTTEDBYNAME \
                "(&(objectClass=ipHost)(|(cn=%s)(cn=%s)))"
#define _F_GETHOSTS6DOTTEDBYNAME_SSD \
                "(&(%%s)(|(cn=%s)(cn=%s)))"
#define _F_GETHOSTS6BYADDR  "(&(objectClass=ipHost)(ipHostNumber=%s))"
#define _F_GETHOSTS6BYADDR_SSD  "(&(%%s)(ipHostNumber=%s))"

static const char *ipnodes_attrs[] = {
    _H_NAME,
    _H_ADDR,
    (char *)NULL
};

extern int inet_pton(int, const char *, void *);
const char *inet_ntop(int af, const void *src, char *dst, size_t size);

/*
 * _nss_ldap_hosts2ent is the data marshaling method for the ipnodes getXbyY
 * system call gethostbyname() and gethostbyaddr. The format of this call
 * is a cononical name and alias (alias is cononical name too) and one or
 * more IP addresses in support of multihomed hosts. This method is called
 * after a successful synchronous search has been performed. This method
 * will parse the search results into struct hostent = argp->buf.buffer
 * which gets returned to the frontend process. One of three error
 * conditions is also returned to nsswitch.
 */

static int
_nss_ldap_hosts2ent(ldap_backend_ptr be, nss_XbyY_args_t *argp)
{
    int         i, j;
    int         nss_result;
    int         buflen = (int)0;
    int         firstimename = (int)1;
    int         firstimedn   = (int)1;
    int         firstimeaddr = (int)1;
    unsigned long       len = 0L;
    char            **hn, **ha, **dp;
    char            *cname = (char *)NULL;
    char            *buffer = (char *)NULL;
    char            *ceiling = (char *)NULL;
    struct hostent      *host = (struct hostent *)NULL;
    struct in6_addr     addr6;
    struct in_addr      addr;
    char            *val;
    ns_ldap_result_t    *result = be->result;
    ns_ldap_attr_t      *attrptr;
    int         namecount = 0;
    int         addrcount = 0;
    int         aliascount = 0;
    int         gluelen = 0;
    ns_ldap_entry_t     *entry;
    ns_ldap_attr_t      *attr;

    buffer = argp->buf.buffer;
    buflen = (size_t)argp->buf.buflen;
    if (!argp->buf.result) {
        nss_result = (int)NSS_STR_PARSE_ERANGE;
        goto result_hosts2ent;
    }
    host = (struct hostent *)argp->buf.result;
    ceiling = buffer + buflen;

    nss_result = (int)NSS_STR_PARSE_SUCCESS;
    (void) memset(argp->buf.buffer, 0, buflen);

    attrptr = getattr(result, 0);
    if (attrptr == NULL) {
        nss_result = (int)NSS_STR_PARSE_PARSE;
        goto result_hosts2ent;
    }

    for (entry = result->entry; entry != NULL; entry = entry->next) {
        for (i = 0, attr = entry->attr_pair[i];
                i < entry->attr_count; i++) {
            attr = entry->attr_pair[i];
            if (strcasecmp(attr->attrname, _H_NAME) == 0)
                namecount += attr->value_count;
            if (strcasecmp(attr->attrname, _H_ADDR) == 0)
                addrcount += attr->value_count;
        }
    }

    for (entry = result->entry; entry != NULL; entry = entry->next) {
        for (i = 0; i < entry->attr_count; i++) {
        attrptr = entry->attr_pair[i];
        if (attrptr == NULL) {
            nss_result = (int)NSS_STR_PARSE_PARSE;
            goto result_hosts2ent;
        }
        if (strcasecmp(attrptr->attrname, _H_DN) == 0) {
            for (j = 0; j < attrptr->value_count; j++) {
            if (firstimedn) {
                /* get domain name associated with this dn */
                be->toglue = _get_domain_name(
                    attrptr->attrvalue[j]);
                firstimedn = (int)0;
            }
            }
        }
        if (strcasecmp(attrptr->attrname, _H_NAME) == 0) {
            for (j = 0; j < attrptr->value_count; j++) {
            if (firstimename) {
                /* canonical name */
                cname = __s_api_get_canonical_name(result->entry,
                attrptr, 1);
                if (cname == NULL ||
                (len = strlen(cname)) < 1) {
                nss_result = (int)NSS_STR_PARSE_PARSE;
                goto result_hosts2ent;
                }
                if (be->toglue != NULL &&
                !DOTTEDSUBDOMAIN(cname))
                gluelen = strlen(be->toglue) + 1;
                else
                gluelen = 0;
                host->h_name = buffer;
                buffer += len + gluelen + 1;
                if (buffer >= ceiling) {
                nss_result = (int)NSS_STR_PARSE_ERANGE;
                goto result_hosts2ent;
                }
                (void) strcpy(host->h_name, cname);
                if (gluelen > 0) {
                (void) strcat(host->h_name, ".");
                (void) strcat(host->h_name, be->toglue);
                }
                /* alias name */
                aliascount = (namecount >= 1 ? (namecount - 1) : 0);
                hn = host->h_aliases =
                (char **)ROUND_UP(buffer, sizeof (char **));
                buffer = (char *)host->h_aliases +
                sizeof (char *) * (aliascount + 1);
                buffer = (char *)ROUND_UP(buffer, sizeof (char **));
                if (buffer >= ceiling) {
                nss_result = (int)NSS_STR_PARSE_ERANGE;
                goto result_hosts2ent;
                }
                firstimename = (int)0;
            }
            /* alias list */
            if (aliascount > 0) {
                if ((attrptr->attrvalue[j] == NULL) ||
                    (len = strlen(attrptr->attrvalue[j])) < 1) {
                    nss_result = (int)NSS_STR_PARSE_PARSE;
                    goto result_hosts2ent;
                }
                /* skip canonical name */
                if (strcmp(attrptr->attrvalue[j], cname) == 0)
                    continue;
                /* check for duplicates */
                for (dp = host->h_aliases; *dp != NULL; dp++) {
                    if (strcmp(*dp, attrptr->attrvalue[j]) == 0)
                    goto next_alias;
                }
                if (be->toglue != NULL &&
                    !DOTTEDSUBDOMAIN(attrptr->attrvalue[j]))
                    gluelen = strlen(be->toglue) + 1;
                else
                    gluelen = 0;
                *hn = buffer;
                buffer += len + gluelen + 1;
                if (buffer >= ceiling) {
                    nss_result = (int)NSS_STR_PARSE_ERANGE;
                    goto result_hosts2ent;
                }
                (void) strcpy(*hn, attrptr->attrvalue[j]);
                if (gluelen > 0) {
                    (void) strcat(*hn, ".");
                    (void) strcat(*hn, be->toglue);
                }
                hn++;
            }
next_alias:
            continue;
            }
        }
        }
    }

    for (entry = result->entry; entry != NULL; entry = entry->next) {
        for (i = 0; i < entry->attr_count; i++) {
        attrptr = entry->attr_pair[i];
        if (attrptr == NULL) {
            nss_result = (int)NSS_STR_PARSE_PARSE;
            goto result_hosts2ent;
        }

        if (strcasecmp(attrptr->attrname, _H_ADDR) == 0) {
            for (j = 0; j < attrptr->value_count; j++) {
            if (firstimeaddr) {
                /* allocate 1 address per entry */
                ha = host->h_addr_list = (char **)ROUND_UP(buffer,
                sizeof (char **));
                buffer = (char *)host->h_addr_list +
                sizeof (char *) * (addrcount + 1);
                buffer = (char *)ROUND_UP(buffer, sizeof (char **));
                if (buffer >= ceiling) {
                nss_result = (int)NSS_STR_PARSE_ERANGE;
                goto result_hosts2ent;
                }
                firstimeaddr = (int)0;
            }
            val = (char *)_strip_quotes(attrptr->attrvalue[j]);
            if (inet_pton(AF_INET6, val, (void *) &addr6) != 1) {
                if (inet_pton(AF_INET, val, (void *) &addr) != 1) {
                goto next_addr;
                } else {
                IN6_INADDR_TO_V4MAPPED(&addr, &addr6);
                }
            }

            /* check for duplicates */
            for (dp = host->h_addr_list; *dp != NULL; dp++) {
                if (memcmp(*dp, &addr6, sizeof (struct in6_addr))
                == 0)
                goto next_addr;
            }
            *ha = buffer;
            len = (unsigned long)sizeof (struct in6_addr);
            buffer += len;
            if (buffer >= ceiling) {
                nss_result = (int)NSS_STR_PARSE_ERANGE;
                goto result_hosts2ent;
            }
            (void) memcpy(*ha++, (char *)&addr6, (size_t)len);
next_addr:
            continue;
            }
        }
        }
    }

    host->h_addrtype = AF_INET6;
    host->h_length = IPV6_ADDR_LEN;

#ifdef DEBUG
    (void) fprintf(stdout, "\n[gethostent.c: _nss_ldap_byname2ent]\n");
    (void) fprintf(stdout, "        h_name: [%s]\n", host->h_name);
    if (host->h_aliases != NULL) {
        for (hn = host->h_aliases; *hn != NULL; hn++)
            (void) fprintf(stdout, "     h_aliases: [%s]\n", *hn);
    }
    (void) fprintf(stdout, "    h_addrtype: [%d]\n", host->h_addrtype);
    (void) fprintf(stdout, "      h_length: [%d]\n", host->h_length);

    for (hn = host->h_addr_list; *hn != NULL; hn++) {
        char addrbuf[INET6_ADDRSTRLEN + 1];
        (void) fprintf(stdout, "   haddr_list: [%s]\n",
            inet_ntop(AF_INET6, (void *)hn, (void *)addrbuf,
                INET6_ADDRSTRLEN));
    }
#endif /* DEBUG */

result_hosts2ent:

    (void) __ns_ldap_freeResult(&be->result);
    return ((int)nss_result);
}


/*
 * getbyname gets a struct hostent by hostname. This function constructs
 * an ldap search filter using the name invocation parameter and the
 * gethostbyname search filter defined. Once the filter is constructed,
 * we search for a matching entry and marshal the data results into
 * struct hostent for the frontend process.  Host name searches will be
 * on fully qualified host names (foo.bar.sun.com)
 */

static nss_status_t
getbyname(ldap_backend_ptr be, void *a)
{
    char        hostname[3 * MAXHOSTNAMELEN];
    char        realdomain[BUFSIZ];
    nss_XbyY_args_t *argp = (nss_XbyY_args_t *)a;
    nss_status_t    lstat;
    char        searchfilter[SEARCHFILTERLEN];
    char        userdata[SEARCHFILTERLEN];
    int     rc;

#ifdef DEBUG
    (void) fprintf(stdout, "\n[gethostent6.c: getbyname]\n");
#endif /* DEBUG */

    if (_ldap_filter_name(hostname, argp->key.ipnode.name,
            sizeof (hostname)) != 0)
        return ((nss_status_t)NSS_NOTFOUND);

    rc = snprintf(searchfilter, sizeof (searchfilter),
        _F_GETHOSTS6BYNAME, hostname);
    if (rc >= sizeof (searchfilter) || rc < 0)
        return ((nss_status_t)NSS_NOTFOUND);
    rc = snprintf(userdata, sizeof (userdata),
        _F_GETHOSTS6BYNAME_SSD, hostname);
    if (rc >= sizeof (userdata) || rc < 0)
        return ((nss_status_t)NSS_NOTFOUND);

    /* get the domain we are in */
    rc = sysinfo(SI_SRPC_DOMAIN, realdomain, BUFSIZ);
    if (rc <= 0)
        return ((nss_status_t)NSS_NOTFOUND);

    /* Is this a request for a host.domain */
    if (DOTTEDSUBDOMAIN(hostname)) {
        char    host[MAXHOSTNAMELEN];
        char    domain[MAXHOSTNAMELEN];
        char    hname[3 * MAXHOSTNAMELEN];

        /* separate host and domain.  this function */
        /* will munge hname, so use argp->keyname */
        /* from here on for original string */

        (void) strcpy(hname, hostname);
        if (chophostdomain(hname, host, domain) == -1) {
            return ((nss_status_t)NSS_NOTFOUND);
        }

        /* if domain is a proper subset of realdomain */
        /* ie. domain = "foo" and realdomain */
        /* = "foor.bar.sun.com", we try to lookup both" */
        /* host.domain and host */

        if (propersubdomain(realdomain, domain) == 1) {
            /* yes, it is a proper domain */
            rc = snprintf(searchfilter, sizeof (searchfilter),
                _F_GETHOSTS6DOTTEDBYNAME, hostname, host);
            if (rc >= sizeof (searchfilter) || rc < 0)
                return ((nss_status_t)NSS_NOTFOUND);

            rc = snprintf(userdata, sizeof (userdata),
                _F_GETHOSTS6DOTTEDBYNAME_SSD, hostname, host);
            if (rc >= sizeof (userdata) || rc < 0)
                return ((nss_status_t)NSS_NOTFOUND);
        } else {
            /* it is not a proper domain, so only try to look up */
            /* host.domain */
            rc = snprintf(searchfilter, sizeof (searchfilter),
                _F_GETHOSTS6BYNAME, hostname);
            if (rc >= sizeof (searchfilter) || rc < 0)
                return ((nss_status_t)NSS_NOTFOUND);

            rc = snprintf(userdata, sizeof (userdata),
                _F_GETHOSTS6BYNAME_SSD, hostname);
            if (rc >= sizeof (userdata) || rc < 0)
                return ((nss_status_t)NSS_NOTFOUND);
        }
    } else {
        rc = snprintf(searchfilter, sizeof (searchfilter),
            _F_GETHOSTS6BYNAME, hostname);
        if (rc >= sizeof (searchfilter) || rc < 0)
            return ((nss_status_t)NSS_NOTFOUND);

        rc = snprintf(userdata, sizeof (userdata),
            _F_GETHOSTS6BYNAME_SSD, hostname);
        if (rc >= sizeof (userdata) || rc < 0)
            return ((nss_status_t)NSS_NOTFOUND);
    }
    lstat = (nss_status_t)_nss_ldap_lookup(be, argp, _HOSTS,
        searchfilter, NULL,
        _merge_SSD_filter, userdata);
    if (lstat == (nss_status_t)NS_LDAP_SUCCESS)
        return ((nss_status_t)NSS_SUCCESS);

    argp->h_errno = __nss2herrno(lstat);
    return ((nss_status_t)lstat);
}


/*
 * getbyaddr gets a struct hostent by host address. This function
 * constructs an ldap search filter using the host address invocation
 * parameter and the gethostbyaddr search filter defined. Once the
 * filter is constructed, we search for a matching entry and marshal
 * the data results into struct hostent for the frontend process.
 */

static nss_status_t
getbyaddr(ldap_backend_ptr be, void *a)
{
    nss_XbyY_args_t *argp = (nss_XbyY_args_t *)a;
    struct in6_addr addr;
    char        addrbuf[INET6_ADDRSTRLEN + 1];
    nss_status_t    lstat;
    char        searchfilter[SEARCHFILTERLEN];
    char        userdata[SEARCHFILTERLEN];
    int     ret;

#ifdef DEBUG
    (void) fprintf(stdout, "\n[gethostent6.c: getbyaddr]\n");
#endif /* DEBUG */
    argp->h_errno = 0;
    if ((argp->key.hostaddr.type != AF_INET6) ||
        (argp->key.hostaddr.len != sizeof (addr)))
        return (NSS_NOTFOUND);

    (void) memcpy(&addr, argp->key.hostaddr.addr, sizeof (addr));
    if (IN6_IS_ADDR_V4MAPPED(&addr)) {
        if (inet_ntop(AF_INET, (void *) &addr.s6_addr[12],
                (void *)addrbuf, INET_ADDRSTRLEN) == NULL) {
            return (NSS_NOTFOUND);
        }
    } else {
        if (inet_ntop(AF_INET6, (void *)&addr, (void *)addrbuf,
                INET6_ADDRSTRLEN) == NULL)
            return (NSS_NOTFOUND);
    }
    ret = snprintf(searchfilter, sizeof (searchfilter),
        _F_GETHOSTS6BYADDR, addrbuf);
    if (ret >= sizeof (searchfilter) || ret < 0)
        return ((nss_status_t)NSS_NOTFOUND);

    ret = snprintf(userdata, sizeof (userdata),
        _F_GETHOSTS6BYADDR_SSD, addrbuf);
    if (ret >= sizeof (userdata) || ret < 0)
        return ((nss_status_t)NSS_NOTFOUND);

    lstat = (nss_status_t)_nss_ldap_lookup(be, argp,
        _HOSTS6, searchfilter, NULL,
        _merge_SSD_filter, userdata);
    if (lstat == (nss_status_t)NS_LDAP_SUCCESS)
        return ((nss_status_t)NSS_SUCCESS);

    argp->h_errno = __nss2herrno(lstat);
    return ((nss_status_t)lstat);
}

static ldap_backend_op_t ipnodes_ops[] = {
    _nss_ldap_destr,
    0,
    0,
    0,
    getbyname,
    getbyaddr
};


/*
 * _nss_ldap_hosts_constr is where life begins. This function calls the generic
 * ldap constructor function to define and build the abstract data types
 * required to support ldap operations.
 */

/*ARGSUSED0*/
nss_backend_t *
_nss_ldap_ipnodes_constr(const char *dummy1, const char *dummy2,
            const char *dummy3)
{

#ifdef DEBUG
    (void) fprintf(stdout, "\n[gethostent6.c: _nss_ldap_host6_constr]\n");
#endif /* DEBUG */
    return ((nss_backend_t *)_nss_ldap_constr(ipnodes_ops,
        sizeof (ipnodes_ops)/sizeof (ipnodes_ops[0]), _HOSTS6,
        ipnodes_attrs, _nss_ldap_hosts2ent));
}