ldap/prldap/ldappr-dns.c

	ldappr-dns.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
 * Copyright 2002-2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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


/*
 * The contents of this file are subject to the Netscape Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is Mozilla Communicator client code, released
 * March 31, 1998.
 *
 * The Initial Developer of the Original Code is Netscape
 * Communications Corporation. Portions created by Netscape are
 * Copyright (C) 1998-1999 Netscape Communications Corporation. All
 * Rights Reserved.
 *
 * Contributor(s):
 */

/*
 * DNS callback functions for libldap that use the NSPR (Netscape
 * Portable Runtime) thread API.
 *
 */

#ifdef _SOLARIS_SDK
#include "solaris-int.h"
#include <libintl.h>
#include <syslog.h>
#include <nsswitch.h>
#include <synch.h>
#include <nss_dbdefs.h>
#include <netinet/in.h>
static char *host_service = NULL;
static DEFINE_NSS_DB_ROOT(db_root_hosts);
#endif

#include "ldappr-int.h"

static LDAPHostEnt *prldap_gethostbyname( const char *name,
    LDAPHostEnt *result, char *buffer, int buflen, int *statusp,
    void *extradata );
static LDAPHostEnt *prldap_gethostbyaddr( const char *addr, int length,
    int type, LDAPHostEnt *result, char *buffer, int buflen,
    int *statusp, void *extradata );
static int prldap_getpeername( LDAP *ld, struct sockaddr *addr,
    char *buffer, int buflen );
static LDAPHostEnt *prldap_convert_hostent( LDAPHostEnt *ldhp,
    PRHostEnt *prhp );

#ifdef _SOLARIS_SDK
static LDAPHostEnt *
prldap_gethostbyname1(const char *name, LDAPHostEnt *result,
    char *buffer, int buflen, int *statusp, void *extradata);
extern int
str2hostent(const char *instr, int lenstr, void *ent, char *buffer,
    int buflen);
#endif /* _SOLARIS_SDK */


/*
 * Install NSPR DNS functions into ld (if ld is NULL, they are installed
 * as the default functions for new LDAP * handles).
 *
 * Returns 0 if all goes well and -1 if not.
 */
int
prldap_install_dns_functions( LDAP *ld )
{
    struct ldap_dns_fns         dnsfns;

    memset( &dnsfns, '\0', sizeof(struct ldap_dns_fns) );
    dnsfns.lddnsfn_bufsize = PR_NETDB_BUF_SIZE;
    dnsfns.lddnsfn_gethostbyname = prldap_gethostbyname;
    dnsfns.lddnsfn_gethostbyaddr = prldap_gethostbyaddr;
        dnsfns.lddnsfn_getpeername = prldap_getpeername;
        if ( ldap_set_option( ld, LDAP_OPT_DNS_FN_PTRS, (void *)&dnsfns ) != 0 ) {
        return( -1 );
        }

    return( 0 );
}


static LDAPHostEnt *
prldap_gethostbyname( const char *name, LDAPHostEnt *result,
    char *buffer, int buflen, int *statusp, void *extradata )
{
    PRHostEnt   prhent;

    if( !statusp || ( *statusp = (int)PR_GetIPNodeByName( name,
        PRLDAP_DEFAULT_ADDRESS_FAMILY, PR_AI_DEFAULT,
        buffer, buflen, &prhent )) == PR_FAILURE ) {
        return( NULL );
    }

    return( prldap_convert_hostent( result, &prhent ));
}


static LDAPHostEnt *
prldap_gethostbyaddr( const char *addr, int length, int type,
    LDAPHostEnt *result, char *buffer, int buflen, int *statusp,
    void *extradata )
{
    PRHostEnt   prhent;
    PRNetAddr   iaddr;

    if ( PR_SetNetAddr(PR_IpAddrNull, PRLDAP_DEFAULT_ADDRESS_FAMILY,
        0, &iaddr) == PR_FAILURE
        || PR_StringToNetAddr( addr, &iaddr ) == PR_FAILURE ) {
        return( NULL );
    }

    if( !statusp || (*statusp = PR_GetHostByAddr(&iaddr, buffer,
         buflen, &prhent )) == PR_FAILURE ) {
    return( NULL );
    }
    return( prldap_convert_hostent( result, &prhent ));
}

static int
prldap_getpeername( LDAP *ld, struct sockaddr *addr, char *buffer, int buflen)
{
    PRLDAPIOSocketArg *sa;
    PRFileDesc  *fd;
    PRNetAddr   iaddr;
    int     ret;

    if (NULL != ld) {
        ret = prldap_socket_arg_from_ld( ld, &sa );
        if (ret != LDAP_SUCCESS) {
        return (-1);
        }
        ret = PR_GetPeerName(sa->prsock_prfd, &iaddr);
        if( ret == PR_FAILURE ) {
        return( -1 );
        }
        *addr = *((struct sockaddr *)&iaddr.raw);
        ret = PR_NetAddrToString(&iaddr, buffer, buflen);
        if( ret == PR_FAILURE ) {
        return( -1 );
        }
        return (0);
    }
    return (-1);
}


/*
 * Function: prldap_convert_hostent()
 * Description: copy the fields of a PRHostEnt struct to an LDAPHostEnt
 * Returns: the LDAPHostEnt pointer passed in.
 */
static LDAPHostEnt *
prldap_convert_hostent( LDAPHostEnt *ldhp, PRHostEnt *prhp )
{
    ldhp->ldaphe_name = prhp->h_name;
    ldhp->ldaphe_aliases = prhp->h_aliases;
    ldhp->ldaphe_addrtype = prhp->h_addrtype;
    ldhp->ldaphe_length =  prhp->h_length;
    ldhp->ldaphe_addr_list =  prhp->h_addr_list;
    return( ldhp );
}

#ifdef _SOLARIS_SDK
/*
 * prldap_x_install_dns_skipdb attempts to prevent recursion in resolving
 * the hostname to an IP address when a host name is given to LDAP user.
 *
 * For example, libsldap cannot use LDAP to resolve the host name to an
 * address because of recursion. The caller is instructing libldap to skip
 * the specified name service when resolving addresses for the specified
 * ldap connection.
 *
 * Note:
 *      This only supports ipv4 addresses currently.
 *
 *      Since host_service applies to all connections, calling
 *      prldap_x_install_dns_skipdb with name services other than
 *      ldap or what uses ldap (for example nis+ might use ldap) to
 *      skip will lead to unpredictable results.
 *
 * Returns:
 *      0       if success and data base found
 *      -1      if failure
 */

int
prldap_x_install_dns_skipdb(LDAP *ld, const char *skip)
{
    enum __nsw_parse_err        pserr;
    struct __nsw_switchconfig       *conf;
    struct __nsw_lookup             *lkp;
    struct ldap_dns_fns             dns_fns;
    char                            *name_list = NULL;
    char                            *tmp;
    const char                      *name;
    int                             len;
    boolean_t                       got_skip = B_FALSE;

    /*
     * db_root_hosts.lock mutex is used to ensure that the name list
     * is not in use by the name service switch while we are updating
     * the host_service
     */

        (void) mutex_lock(&db_root_hosts.lock);
        conf = __nsw_getconfig("hosts", &pserr);
        if (conf == NULL) {
                (void) mutex_unlock(&db_root_hosts.lock);
                return (0);
        }

        /* check for skip and count other backends */
        for (lkp = conf->lookups; lkp != NULL; lkp = lkp->next) {
                name = lkp->service_name;
                if (strcmp(name, skip) == 0) {
                        got_skip = B_TRUE;
                        continue;
                }
                if (name_list == NULL)
                        name_list = strdup(name);
                else {
                        len = strlen(name_list);
                        tmp = realloc(name_list, len + strlen(name) + 2);
                        if (tmp == NULL) {
                                free(name_list);
                                name_list = NULL;
                        } else {
                                name_list = tmp;
                                name_list[len++] = ' ';
                                (void) strcpy(name_list+len, name);
                        }
                }
                if (name_list == NULL) {        /* alloc error */
                        (void) mutex_unlock(&db_root_hosts.lock);
                        __nsw_freeconfig(conf);
                        return (-1);
                }
        }
        __nsw_freeconfig(conf);
        if (!got_skip) {
        /*
         * Since skip name service not used for hosts, we do not need
         * to install our private address resolution function
         */
                (void) mutex_unlock(&db_root_hosts.lock);
                if (name_list != NULL)
                        free(name_list);
                return (0);
        }
        if (host_service != NULL)
                free(host_service);
        host_service = name_list;
        (void) mutex_unlock(&db_root_hosts.lock);

        if (ldap_get_option(ld, LDAP_OPT_DNS_FN_PTRS, &dns_fns) != 0)
                return (-1);
        dns_fns.lddnsfn_bufsize = PR_NETDB_BUF_SIZE;
        dns_fns.lddnsfn_gethostbyname = prldap_gethostbyname1;
        if (ldap_set_option(ld, LDAP_OPT_DNS_FN_PTRS, &dns_fns) != 0)
                return (-1);
        return (0);
}

/*
 * prldap_initf_hosts is passed to and called by nss_search() as a
 * service routine.
 *
 * Returns:
 *      None
 */

static void
prldap_initf_hosts(nss_db_params_t *p)
{
        static char *no_service = "";

        p->name = NSS_DBNAM_HOSTS;
        p->flags |= NSS_USE_DEFAULT_CONFIG;
        p->default_config = host_service == NULL ? no_service : host_service;
}

/*
 * called by prldap_gethostbyname1()
 */
/*
 * prldap_switch_gethostbyname_r is called by prldap_gethostbyname1 as a
 * substitute for gethostbyname_r(). A method which prevents recursion. see
 * prldap_gethostbyname1() and prldap_x_install_dns_skipdb().
 *
 * Returns:
 *      Valid pointer to hostent      if success
 *      PR_FAILURE                    if failure
 */

static struct hostent *
prldap_switch_gethostbyname_r(const char *name,
        struct hostent *result, char *buffer, int buflen,
        int *h_errnop)
{
        nss_XbyY_args_t arg;
        nss_status_t    res;

    /*
     * Log the information indicating that we are trying to
     * resolve the LDAP server name.
     */
    syslog(LOG_INFO, "libldap: Resolving server name \"%s\"", name);

        NSS_XbyY_INIT(&arg, result, buffer, buflen, str2hostent);

        arg.key.name = name;
        arg.stayopen = 0;

        res = nss_search(&db_root_hosts, prldap_initf_hosts,
            NSS_DBOP_HOSTS_BYNAME, &arg);
        arg.status = res;
        *h_errnop = arg.h_errno;
        return (struct hostent *)NSS_XbyY_FINI(&arg);
}

/*
 * prldap_gethostbyname1 is used to be a substitute gethostbyname_r for
 * libldap when it is unsafe to use the normal nameservice functions.
 *
 * Returns:
 *      pointer to LDAPHostEnt:         if success contains the address
 *      NULL pointer:                   if failure
 */

static LDAPHostEnt *
prldap_gethostbyname1(const char *name, LDAPHostEnt *result,
    char *buffer, int buflen, int *statusp, void *extradata)
{
        int         h_errno;
    LDAPHostEnt prhent;

        if (!statusp || ( *statusp = prldap_switch_gethostbyname_r(name,
                        &prhent, buffer, buflen, &h_errno )) == PR_FAILURE) {
        /*
         * If we got here, it means that we are not able to
         * resolve the LDAP server name and so warn the system
         * adminstrator accordingly.
         */
        syslog(LOG_WARNING, "libldap: server name \"%s\" could not "
        "be resolved", name);
        return (NULL);
        }

        return (prldap_convert_hostent(result, &prhent));
}

#endif  /* _SOLARIS_SDK */