OpenSolaris_b135/lib/libldap4/common/request.c
/*
* Copyright 1998-2002 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Copyright (c) 1995 Regents of the University of Michigan.
* All rights reserved.
*
* request.c - sending of ldap requests; handling of referrals
*/
#ifndef lint
static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n";
#endif
#include <stdio.h>
#include <string.h>
#ifdef MACOS
#include <stdlib.h>
#include <time.h>
#include "macos.h"
#else /* MACOS */
#if defined( DOS ) || defined( _WIN32 )
#include "msdos.h"
#include <time.h>
#include <stdlib.h>
#ifdef PCNFS
#include <tklib.h>
#include <tk_errno.h>
#include <bios.h>
#endif /* PCNFS */
#ifdef NCSA
#include "externs.h"
#endif /* NCSA */
#else /* DOS */
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#ifdef _AIX
#include <sys/select.h>
#endif /* _AIX */
#include "portable.h"
#endif /* DOS */
#endif /* MACOS */
#ifdef VMS
#include "ucx_select.h"
#endif
#include "lber.h"
#include "ldap.h"
#include "ldap-private.h"
#include "ldap-int.h"
#ifdef USE_SYSCONF
#include <unistd.h>
#endif /* USE_SYSCONF */
#ifdef NEEDPROTOS
static LDAPConn *find_connection( LDAP *ld, LDAPServer *srv, int any );
static void use_connection( LDAP *ld, LDAPConn *lc );
static void free_servers( LDAPServer *srvlist );
#else /* NEEDPROTOS */
static LDAPConn *find_connection();
static void use_connection();
static void free_servers();
#endif /* NEEDPROTOS */
#ifdef LDAP_DNS
#ifdef NEEDPROTOS
static LDAPServer *dn2servers( LDAP *ld, char *dn );
#else /* NEEDPROTOS */
static LDAPServer *dn2servers();
#endif /* NEEDPROTOS */
#endif /* LDAP_DNS */
BerElement *
alloc_ber_with_options( LDAP *ld )
{
BerElement *ber;
if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULLBER ) {
ld->ld_errno = LDAP_NO_MEMORY;
#ifdef STR_TRANSLATION
} else {
set_ber_options( ld, ber );
#endif /* STR_TRANSLATION */
}
return( ber );
}
void
set_ber_options( LDAP *ld, BerElement *ber )
{
ber->ber_options = ld->ld_lberoptions;
#ifdef STR_TRANSLATION
if (( ld->ld_lberoptions & LBER_TRANSLATE_STRINGS ) != 0 ) {
ber_set_string_translators( ber,
ld->ld_lber_encode_translate_proc,
ld->ld_lber_decode_translate_proc );
}
#endif /* STR_TRANSLATION */
}
int
send_initial_request( LDAP *ld, unsigned int msgtype, char *dn,
BerElement *ber )
{
LDAPServer *servers;
int rv;
#ifdef _REENTRANT
LOCK_LDAP(ld);
#endif
Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 209, "send_initial_request\n"), 0, 0, 0 );
#ifdef LDAP_DNS
if (( ld->ld_options & LDAP_OPT_DNS ) != 0 && ldap_is_dns_dn( dn )) {
if (( servers = dn2servers( ld, dn )) == NULL ) {
ber_free( ber, 1 );
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( -1 );
}
#ifdef LDAP_DEBUG
if ( ldap_debug & LDAP_DEBUG_TRACE ) {
LDAPServer *srv;
for ( srv = servers; srv != NULL;
srv = srv->lsrv_next ) {
fprintf( stderr,
"LDAP server %s: dn %s, port %d\n",
srv->lsrv_host, ( srv->lsrv_dn == NULL ) ?
"(default)" : srv->lsrv_dn,
srv->lsrv_port );
}
}
#endif /* LDAP_DEBUG */
} else {
#endif /* LDAP_DNS */
/*
* use of DNS is turned off or this is an X.500 DN...
* use our default connection
*/
servers = NULL;
#ifdef LDAP_DNS
}
#endif /* LDAP_DNS */
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
rv = send_server_request( ld, ber, ld->ld_msgid, NULL, servers,
NULL, 0 );
return ( rv );
}
int
send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest
*parentreq, LDAPServer *srvlist, LDAPConn *lc, int bind )
{
LDAPRequest *lr;
int err;
#ifdef _REENTRANT
LOCK_LDAP(ld);
#endif
Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 210, "send_server_request\n"), 0, 0, 0 );
ld->ld_errno = LDAP_SUCCESS; /* optimistic */
/* Be optimistic : increment parentreq initially.
If it fails we must decrement it */
if (parentreq != NULL){
parentreq->lr_outrefcnt++;
}
if ( lc == NULL ) {
if ( srvlist == NULL ) {
if (ld->ld_defconn == NULL){ /* Not connected yet on the default connection, ie init was called not open */
if ((err = open_default_ldap_connection(ld)) != LDAP_SUCCESS){
ld->ld_errno = err;
ber_free(ber, 1);
if (parentreq != NULL){
parentreq->lr_outrefcnt--;
}
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( -1 );
}
}
lc = ld->ld_defconn;
} else {
if (( lc = find_connection( ld, srvlist, 1 )) ==
NULL ) {
lc = new_connection( ld, &srvlist, 0, 1, bind );
}
free_servers( srvlist );
}
}
if ( lc == NULL || lc->lconn_status != LDAP_CONNST_CONNECTED ) {
ber_free( ber, 1 );
if ( ld->ld_errno == LDAP_SUCCESS ) {
ld->ld_errno = LDAP_SERVER_DOWN;
}
if (parentreq != NULL){
parentreq->lr_outrefcnt--;
}
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( -1 );
}
use_connection( ld, lc );
if (( lr = (LDAPRequest *)calloc( 1, sizeof( LDAPRequest ))) ==
NULL ) {
ld->ld_errno = LDAP_NO_MEMORY;
free_connection( ld, lc, 0, 0 );
ber_free( ber, 1 );
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( -1 );
}
lr->lr_msgid = msgid;
lr->lr_status = LDAP_REQST_INPROGRESS;
lr->lr_res_errno = LDAP_SUCCESS; /* optimistic */
lr->lr_ber = ber;
lr->lr_conn = lc;
if ( parentreq != NULL ) { /* sub-request */
/* ++parentreq->lr_outrefcnt; */
lr->lr_origid = parentreq->lr_origid;
lr->lr_parentcnt = parentreq->lr_parentcnt + 1;
lr->lr_parent = parentreq;
lr->lr_refnext = parentreq->lr_refnext;
parentreq->lr_refnext = lr;
} else { /* original request */
lr->lr_origid = lr->lr_msgid;
}
if (( lr->lr_next = ld->ld_requests ) != NULL ) {
lr->lr_next->lr_prev = lr;
}
ld->ld_requests = lr;
lr->lr_prev = NULL;
if ( ber_flush( lc->lconn_sb, ber, 0 ) != 0 ) {
#ifdef notyet
extern int errno;
if ( errno == EWOULDBLOCK ) {
/* need to continue write later */
lr->lr_status = LDAP_REQST_WRITING;
mark_select_write( ld, lc->lconn_sb );
} else {
#else /* notyet */
ld->ld_errno = LDAP_SERVER_DOWN;
free_request( ld, lr );
free_connection( ld, lc, 0, 0 );
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( -1 );
#endif /* notyet */
#ifdef notyet
}
#endif /* notyet */
} else {
if ( parentreq == NULL ) {
ber->ber_end = ber->ber_ptr;
ber->ber_ptr = ber->ber_buf;
}
/* sent -- waiting for a response */
mark_select_read( ld, lc->lconn_sb );
}
ld->ld_errno = LDAP_SUCCESS;
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( msgid );
}
LDAPConn *
new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb,
int connect, int bind )
{
LDAPConn *lc;
LDAPServer *prevsrv, *srv;
Sockbuf *sb;
/*
* make a new LDAP server connection
* XXX open connection synchronously for now
*/
if (( lc = (LDAPConn *)calloc( 1, sizeof( LDAPConn ))) == NULL ||
( !use_ldsb && ( sb = (Sockbuf *)calloc( 1, sizeof( Sockbuf )))
== NULL )) {
if ( lc != NULL ) {
free( (char *)lc );
}
ld->ld_errno = LDAP_NO_MEMORY;
return( NULL );
}
#ifdef _REENTRANT
LOCK_LDAP(ld);
#endif
lc->lconn_sb = ( use_ldsb ) ? &ld->ld_sb : sb;
if ( connect ) {
prevsrv = NULL;
for ( srv = *srvlistp; srv != NULL; srv = srv->lsrv_next ) {
if ( open_ldap_connection( ld, lc->lconn_sb,
srv->lsrv_host, srv->lsrv_port,
&lc->lconn_krbinstance, 0 ) != -1 ) {
break;
}
prevsrv = srv;
}
if ( srv == NULL ) {
if ( !use_ldsb ) {
free( (char *)lc->lconn_sb );
}
free( (char *)lc );
ld->ld_errno = LDAP_SERVER_DOWN;
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( NULL );
}
if ( prevsrv == NULL ) {
*srvlistp = srv->lsrv_next;
} else {
prevsrv->lsrv_next = srv->lsrv_next;
}
lc->lconn_server = srv;
}
lc->lconn_status = LDAP_CONNST_CONNECTED;
lc->lconn_next = ld->ld_conns;
ld->ld_conns = lc;
/*
* XXX for now, we always do a synchronous bind. This will have
* to change in the long run...
*/
if ( bind ) {
int err, freepasswd, authmethod;
char *binddn, *passwd;
LDAPConn *savedefconn;
freepasswd = err = 0;
if ( ld->ld_version == LDAP_VERSION3 && ld->ld_rebindproc == NULL){
/* Nothing to do */
Debug(LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 1280, "new_connection: bind no needed with ldapv3\n"), 0,0,0);
} else {
if ( ld->ld_rebindproc == NULL ) {
binddn = passwd = "";
authmethod = LDAP_AUTH_SIMPLE;
} else {
if (( err = (*ld->ld_rebindproc)( ld, &binddn, &passwd,
&authmethod, 0, ld->ld_rebind_extra_arg )) == LDAP_SUCCESS ) {
freepasswd = 1;
} else {
ld->ld_errno = err;
err = -1;
}
}
if ( err == 0 ) {
savedefconn = ld->ld_defconn;
ld->ld_defconn = lc;
++lc->lconn_refcnt; /* avoid premature free */
if ( ldap_bind_s( ld, binddn, passwd, authmethod ) !=
LDAP_SUCCESS ) {
err = -1;
}
--lc->lconn_refcnt;
ld->ld_defconn = savedefconn;
}
if ( freepasswd ) {
(*ld->ld_rebindproc)( ld, &binddn, &passwd,
&authmethod, 1, ld->ld_rebind_extra_arg );
}
if ( err != 0 ) {
free_connection( ld, lc, 1, 0 );
lc = NULL;
}
}
}
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( lc );
}
static LDAPConn *
find_connection( LDAP *ld, LDAPServer *srv, int any )
/*
* return an existing connection (if any) to the server srv
* if "any" is non-zero, check for any server in the "srv" chain
*/
{
LDAPConn *lc;
LDAPServer *ls;
#ifdef _REENTRANT
LOCK_LDAP(ld);
#endif
for ( lc = ld->ld_conns; lc != NULL; lc = lc->lconn_next ) {
for ( ls = srv; ls != NULL; ls = ls->lsrv_next ) {
if ( lc->lconn_server->lsrv_host != NULL &&
ls->lsrv_host != NULL && strcasecmp(
ls->lsrv_host, lc->lconn_server->lsrv_host ) == 0
&& ls->lsrv_port == lc->lconn_server->lsrv_port ) {
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( lc );
}
if ( !any ) {
break;
}
}
}
#ifdef _REENTRANT
UNLOCK_LDAP(ld);
#endif
return( NULL );
}
static void
use_connection( LDAP *ld, LDAPConn *lc )
{
++lc->lconn_refcnt;
lc->lconn_lastused = time( 0 );
}
void
free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind )
{
LDAPConn *tmplc, *prevlc;
Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 211, "free_connection\n"), 0, 0, 0 );
if ( force || --lc->lconn_refcnt <= 0 ) {
if ( lc->lconn_status == LDAP_CONNST_CONNECTED ) {
mark_select_clear( ld, lc->lconn_sb );
if ( unbind ) {
send_unbind( ld, lc->lconn_sb );
}
close_ldap_connection( lc->lconn_sb );
if ( lc->lconn_sb->sb_ber.ber_buf != NULL ) {
free( lc->lconn_sb->sb_ber.ber_buf );
lc->lconn_sb->sb_ber.ber_buf = NULL;
}
}
prevlc = NULL;
for ( tmplc = ld->ld_conns; tmplc != NULL;
tmplc = tmplc->lconn_next ) {
if ( tmplc == lc ) {
if ( prevlc == NULL ) {
ld->ld_conns = tmplc->lconn_next;
} else {
prevlc->lconn_next = tmplc->lconn_next;
}
break;
}
}
free_servers( lc->lconn_server );
if ( lc->lconn_krbinstance != NULL ) {
free( lc->lconn_krbinstance );
}
if ( lc->lconn_sb != &ld->ld_sb ) {
free( (char *)lc->lconn_sb );
}
free( lc );
Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 212, "free_connection: actually freed\n"),
0, 0, 0 );
} else {
lc->lconn_lastused = time( 0 );
Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 213, "free_connection: refcnt %d\n"),
lc->lconn_refcnt, 0, 0 );
}
}
#ifdef LDAP_DEBUG
void
dump_connection( LDAP *ld, LDAPConn *lconns, int all )
{
LDAPConn *lc;
fprintf( stderr, "** Connection%s:\n", all ? "s" : "" );
for ( lc = lconns; lc != NULL; lc = lc->lconn_next ) {
if ( lc->lconn_server != NULL ) {
fprintf( stderr, "* host: %s port: %d%s\n",
( lc->lconn_server->lsrv_host == NULL ) ? "(null)"
: lc->lconn_server->lsrv_host,
lc->lconn_server->lsrv_port, ( lc->lconn_sb ==
&ld->ld_sb ) ? " (default)" : "" );
}
fprintf( stderr, " refcnt: %d status: %s\n", lc->lconn_refcnt,
( lc->lconn_status == LDAP_CONNST_NEEDSOCKET ) ?
"NeedSocket" : ( lc->lconn_status ==
LDAP_CONNST_CONNECTING ) ? "Connecting" : "Connected" );
fprintf( stderr, " last used: %s\n",
ctime( &lc->lconn_lastused ));
if ( !all ) {
break;
}
}
}
void
dump_requests_and_responses( LDAP *ld )
{
LDAPRequest *lr;
LDAPMessage *lm, *l;
fprintf( stderr, "** Outstanding Requests:\n" );
if (( lr = ld->ld_requests ) == NULL ) {
fprintf( stderr, " Empty\n" );
}
for ( ; lr != NULL; lr = lr->lr_next ) {
fprintf( stderr, " * msgid %d, origid %d, status %s\n",
lr->lr_msgid, lr->lr_origid, ( lr->lr_status ==
LDAP_REQST_INPROGRESS ) ? "InProgress" :
( lr->lr_status == LDAP_REQST_CHASINGREFS ) ? "ChasingRefs" :
( lr->lr_status == LDAP_REQST_NOTCONNECTED ) ? "NotConnected" :
"Writing" );
fprintf( stderr, " outstanding referrals %d, parent count %d\n",
lr->lr_outrefcnt, lr->lr_parentcnt );
}
fprintf( stderr, "** Response Queue:\n" );
#ifdef _REENTRANT
LOCK_RESPONSE(ld);
#endif
if (( lm = ld->ld_responses ) == NULLMSG ) {
fprintf( stderr, " Empty\n" );
}
for ( ; lm != NULLMSG; lm = lm->lm_next ) {
fprintf( stderr, " * msgid %d, type %d\n",
lm->lm_msgid, lm->lm_msgtype );
if (( l = lm->lm_chain ) != NULL ) {
fprintf( stderr, " chained responses:\n" );
for ( ; l != NULLMSG; l = l->lm_chain ) {
fprintf( stderr,
" * msgid %d, type %d\n",
l->lm_msgid, l->lm_msgtype );
}
}
}
#ifdef _REENTRANT
UNLOCK_RESPONSE(ld);
#endif
}
#endif /* LDAP_DEBUG */
void
free_request( LDAP *ld, LDAPRequest *lr )
{
LDAPRequest *tmplr, *nextlr;
int i;
Debug( LDAP_DEBUG_TRACE, catgets(slapdcat, 1, 214, "free_request (origid %1$d, msgid %2$d)\n"),
lr->lr_origid, lr->lr_msgid, 0 );
if ( lr->lr_parent != NULL ) {
--lr->lr_parent->lr_outrefcnt;
} else {
/* free all referrals (child requests) */
for ( tmplr = lr->lr_refnext; tmplr != NULL; tmplr = nextlr ) {
nextlr = tmplr->lr_refnext;
free_request( ld, tmplr );
}
}
if ( lr->lr_prev == NULL ) {
ld->ld_requests = lr->lr_next;
} else {
lr->lr_prev->lr_next = lr->lr_next;
}
if ( lr->lr_next != NULL ) {
lr->lr_next->lr_prev = lr->lr_prev;
}
if ( lr->lr_ber != NULL ) {
ber_free( lr->lr_ber, 1 );
}
if ( lr->lr_res_error != NULL ) {
free( lr->lr_res_error );
}
if ( lr->lr_res_matched != NULL ) {
free( lr->lr_res_matched );
}
if ( lr->lr_ref_tofollow != NULL ) {
for (i= 0; lr->lr_ref_tofollow[i] != NULL; i++)
free(lr->lr_ref_tofollow[i]);
free(lr->lr_ref_tofollow);
}
if ( lr->lr_ref_unfollowed != NULL ) {
for (i= 0; lr->lr_ref_unfollowed[i] != NULL; i++)
free(lr->lr_ref_unfollowed[i]);
free(lr->lr_ref_unfollowed);
}
if ( lr->lr_ref_followed != NULL ) {
for (i= 0; lr->lr_ref_followed[i] != NULL; i++)
free(lr->lr_ref_followed[i]);
free(lr->lr_ref_followed);
}
free( lr );
}
static void
free_servers( LDAPServer *srvlist )
{
LDAPServer *nextsrv;
while ( srvlist != NULL ) {
nextsrv = srvlist->lsrv_next;
if ( srvlist->lsrv_dn != NULL ) {
free( srvlist->lsrv_dn );
}
if ( srvlist->lsrv_host != NULL ) {
free( srvlist->lsrv_host );
}
free( srvlist );
srvlist = nextsrv;
}
}
/*
* nsldapi_connection_lost_nolock() resets "ld" to a non-connected, known
* state. It should be called whenever a fatal error occurs on the
* Sockbuf "sb." sb == NULL means we don't know specifically where
* the problem was so we assume all connections are bad.
*/
void
nsldapi_connection_lost_nolock( LDAP *ld, Sockbuf *sb )
{
LDAPRequest *lr;
/*
* change status of all pending requests that are associated with "sb
* to "connection dead."
* also change the connection status to "dead" and remove it from
* the list of sockets we are interested in.
*/
for ( lr = ld->ld_requests; lr != NULL; lr = lr->lr_next ) {
if ( sb == NULL ||
( lr->lr_conn != NULL && lr->lr_conn->lconn_sb == sb )) {
lr->lr_status = LDAP_REQST_CONNDEAD;
if ( lr->lr_conn != NULL ) {
lr->lr_conn->lconn_status = LDAP_CONNST_DEAD;
}
}
}
}
#ifdef LDAP_DNS
static LDAPServer *
dn2servers( LDAP *ld, char *dn ) /* dn can also be a domain.... */
{
char *p, *domain, *host, *server_dn, **dxs;
int i, port;
LDAPServer *srvlist, *prevsrv, *srv;
if (( domain = strrchr( dn, '@' )) != NULL ) {
++domain;
} else {
domain = dn;
}
if (( dxs = getdxbyname( domain )) == NULL ) {
ld->ld_errno = LDAP_NO_MEMORY;
return( NULL );
}
srvlist = NULL;
for ( i = 0; dxs[ i ] != NULL; ++i ) {
port = LDAP_PORT;
server_dn = NULL;
if ( strchr( dxs[ i ], ':' ) == NULL ) {
host = dxs[ i ];
} else if ( strlen( dxs[ i ] ) >= 7 &&
strncmp( dxs[ i ], "ldap://", 7 ) == 0 ) {
host = dxs[ i ] + 7;
if (( p = strchr( host, ':' )) == NULL ) {
p = host;
} else {
*p++ = '\0';
port = atoi( p );
}
if (( p = strchr( p, '/' )) != NULL ) {
server_dn = ++p;
if ( *server_dn == '\0' ) {
server_dn = NULL;
}
}
} else {
host = NULL;
}
if ( host != NULL ) { /* found a server we can use */
if (( srv = (LDAPServer *)calloc( 1,
sizeof( LDAPServer ))) == NULL ) {
free_servers( srvlist );
srvlist = NULL;
break; /* exit loop & return */
}
/* add to end of list of servers */
if ( srvlist == NULL ) {
srvlist = srv;
} else {
prevsrv->lsrv_next = srv;
}
prevsrv = srv;
/* copy in info. */
if (( srv->lsrv_host = strdup( host )) == NULL ||
( server_dn != NULL && ( srv->lsrv_dn =
strdup( server_dn )) == NULL )) {
free_servers( srvlist );
srvlist = NULL;
break; /* exit loop & return */
}
srv->lsrv_port = port;
}
}
ldap_value_free( dxs );
if ( srvlist == NULL ) {
ld->ld_errno = LDAP_SERVER_DOWN;
}
return( srvlist );
}
#endif /* LDAP_DNS */