X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=libraries%2Flibldap%2Frequest.c;h=fd7c9b66134cf0d29b32d4bbdf73f1607c7da439;hb=f9eabe153b97050a878d83a041a9c6dd23133423;hp=4732c639f366bac854ac44e3eda5631b496e665a;hpb=702109706b76fea49bde29d6351b2aaa4ee0e7fa;p=openldap diff --git a/libraries/libldap/request.c b/libraries/libldap/request.c index 4732c639f3..fd7c9b6613 100644 --- a/libraries/libldap/request.c +++ b/libraries/libldap/request.c @@ -1,18 +1,48 @@ -/* - * Copyright (c) 1995 Regents of the University of Michigan. - * All rights reserved. +/* $OpenLDAP$ */ +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2004 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . + */ +/* Portions Copyright (c) 1995 Regents of the University of Michigan. + * All rights reserved. + */ +/* This notice applies to changes, created by or for Novell, Inc., + * to preexisting works for which notices appear elsewhere in this file. + * + * Copyright (C) 1999, 2000 Novell, Inc. All Rights Reserved. * + * THIS WORK IS SUBJECT TO U.S. AND INTERNATIONAL COPYRIGHT LAWS AND TREATIES. + * USE, MODIFICATION, AND REDISTRIBUTION OF THIS WORK IS SUBJECT TO VERSION + * 2.0.1 OF THE OPENLDAP PUBLIC LICENSE, A COPY OF WHICH IS AVAILABLE AT + * HTTP://WWW.OPENLDAP.ORG/LICENSE.HTML OR IN THE FILE "LICENSE" IN THE + * TOP-LEVEL DIRECTORY OF THE DISTRIBUTION. ANY USE OR EXPLOITATION OF THIS + * WORK OTHER THAN AS AUTHORIZED IN VERSION 2.0.1 OF THE OPENLDAP PUBLIC + * LICENSE, OR OTHER PRIOR WRITTEN CONSENT FROM NOVELL, COULD SUBJECT THE + * PERPETRATOR TO CRIMINAL AND CIVIL LIABILITY. + *--- + * Modification to OpenLDAP source by Novell, Inc. + * April 2000 sfs Added code to chase V3 referrals * request.c - sending of ldap requests; handling of referrals + *--- + * Note: A verbatim copy of version 2.0.1 of the OpenLDAP Public License + * can be found in the file "build/LICENSE-2.0.1" in this distribution + * of OpenLDAP Software. */ #include "portable.h" -#ifndef lint -static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of Michigan.\nAll rights reserved.\n"; -#endif - #include -#include + +#include #include #include @@ -21,35 +51,26 @@ static char copyright[] = "@(#) Copyright (c) 1995 Regents of the University of #include #include "ldap-int.h" +#include "lber.h" -#if defined( LDAP_REFERRALS ) || defined( LDAP_DNS ) -static LDAPConn *find_connection LDAP_P(( LDAP *ld, LDAPServer *srv, int any )); +static LDAPConn *find_connection LDAP_P(( LDAP *ld, LDAPURLDesc *srv, int any )); static void use_connection LDAP_P(( LDAP *ld, LDAPConn *lc )); -static void free_servers LDAP_P(( LDAPServer *srvlist )); -#endif /* LDAP_REFERRALS || LDAP_DNS */ - - -#ifdef LDAP_DNS -static LDAPServer *dn2servers LDAP_P(( LDAP *ld, char *dn )); -#endif /* LDAP_DNS */ - -#ifdef LDAP_REFERRALS -static BerElement *re_encode_request LDAP_P(( LDAP *ld, BerElement *origber, - int msgid, char **dnp )); -#endif /* LDAP_REFERRALS */ +static BerElement * +re_encode_request( LDAP *ld, + BerElement *origber, + ber_int_t msgid, + int sref, + LDAPURLDesc *srv, + int *type ); BerElement * ldap_alloc_ber_with_options( LDAP *ld ) { BerElement *ber; - if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULLBER ) { + if (( ber = ber_alloc_t( ld->ld_lberoptions )) == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; -#ifdef STR_TRANSLATION - } else { - ldap_set_ber_options( ld, ber ); -#endif /* STR_TRANSLATION */ } return( ber ); @@ -60,84 +81,132 @@ void ldap_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 -ldap_send_initial_request( LDAP *ld, unsigned long msgtype, char *dn, - BerElement *ber ) +ber_int_t +ldap_send_initial_request( + LDAP *ld, + ber_tag_t msgtype, + const char *dn, + BerElement *ber, + ber_int_t msgid) { -#if defined( LDAP_REFERRALS ) || defined( LDAP_DNS ) - LDAPServer *servers; -#endif /* LDAP_REFERRALS || LDAP_DNS */ + LDAPURLDesc *servers; + int rc; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "ldap_send_initial_request\n", 0, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ldap_send_initial_request\n", 0, 0, 0 ); +#endif -#if !defined( LDAP_REFERRALS ) && !defined( LDAP_DNS ) - if ( ber_flush( &ld->ld_sb, ber, 1 ) != 0 ) { - ld->ld_errno = LDAP_SERVER_DOWN; - return( -1 ); - } - - ld->ld_errno = LDAP_SUCCESS; - return( ld->ld_msgid ); -#else /* !LDAP_REFERRALS && !LDAP_DNS */ + if ( ber_sockbuf_ctrl( ld->ld_sb, LBER_SB_OPT_GET_FD, NULL ) == -1 ) { + /* not connected yet */ + int rc = ldap_open_defconn( ld ); -#ifdef LDAP_DNS - if (( ld->ld_options & LDAP_OPT_DNS ) != 0 && ldap_is_dns_dn( dn )) { - if (( servers = dn2servers( ld, dn )) == NULL ) { + if( rc < 0 ) { ber_free( ber, 1 ); return( -1 ); } -#ifdef LDAP_DEBUG - if ( ldap_debug & LDAP_DEBUG_TRACE ) { - LDAPServer *srv; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_send_initial_request: ldap_open_defconn: successful\n" , + 0, 0, 0); +#else + Debug( LDAP_DEBUG_TRACE, + "ldap_open_defconn: successful\n", + 0, 0, 0 ); +#endif + } - 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 */ - return( ldap_send_server_request( ld, ber, ld->ld_msgid, NULL, servers, - NULL, 0 )); -#endif /* !LDAP_REFERRALS && !LDAP_DNS */ +#ifdef LDAP_CONNECTIONLESS + if (LDAP_IS_UDP(ld)) { + if (msgtype == LDAP_REQ_BIND) { + if (ld->ld_options.ldo_cldapdn) + ldap_memfree(ld->ld_options.ldo_cldapdn); + ld->ld_options.ldo_cldapdn = ldap_strdup(dn); + return 0; + } + if (msgtype != LDAP_REQ_ABANDON && msgtype != LDAP_REQ_SEARCH) + return LDAP_PARAM_ERROR; + } +#endif +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif + rc = ldap_send_server_request( ld, ber, msgid, NULL, + servers, NULL, NULL ); +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); +#endif + if (servers) + ldap_free_urllist(servers); + return(rc); } +int +ldap_int_flush_request( + LDAP *ld, + LDAPRequest *lr +) +{ + LDAPConn *lc = lr->lr_conn; + + if ( ber_flush( lc->lconn_sb, lr->lr_ber, 0 ) != 0 ) { + if ( errno == EAGAIN ) { + /* need to continue write later */ + lr->lr_status = LDAP_REQST_WRITING; + ldap_mark_select_write( ld, lc->lconn_sb ); + ld->ld_errno = LDAP_BUSY; + return -2; + } else { + ld->ld_errno = LDAP_SERVER_DOWN; + ldap_free_request( ld, lr ); + ldap_free_connection( ld, lc, 0, 0 ); + return( -1 ); + } + } else { + if ( lr->lr_parent == NULL ) { + lr->lr_ber->ber_end = lr->lr_ber->ber_ptr; + lr->lr_ber->ber_ptr = lr->lr_ber->ber_buf; + } + lr->lr_status = LDAP_REQST_INPROGRESS; + + /* sent -- waiting for a response */ + ldap_mark_select_read( ld, lc->lconn_sb ); + } + return 0; +} -#if defined( LDAP_REFERRALS ) || defined( LDAP_DNS ) int -ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest - *parentreq, LDAPServer *srvlist, LDAPConn *lc, int bind ) +ldap_send_server_request( + LDAP *ld, + BerElement *ber, + ber_int_t msgid, + LDAPRequest *parentreq, + LDAPURLDesc *srvlist, + LDAPConn *lc, + LDAPreqinfo *bind ) { LDAPRequest *lr; - int incparent; + int incparent, rc; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "ldap_send_server_request\n", 0, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ldap_send_server_request\n", 0, 0, 0 ); +#endif incparent = 0; ld->ld_errno = LDAP_SUCCESS; /* optimistic */ @@ -148,14 +217,13 @@ ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest } else { if (( lc = find_connection( ld, srvlist, 1 )) == NULL ) { - if ( bind && (parentreq != NULL) ) { + if ( (bind != NULL) && (parentreq != NULL) ) { /* Remember the bind in the parent */ incparent = 1; ++parentreq->lr_outrefcnt; } - lc = ldap_new_connection( ld, &srvlist, 0, 1, bind ); + lc = ldap_new_connection( ld, srvlist, 0, 1, bind ); } - free_servers( srvlist ); } } @@ -172,7 +240,21 @@ ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest } use_connection( ld, lc ); - if (( lr = (LDAPRequest *)calloc( 1, sizeof( LDAPRequest ))) == + + /* If we still have an incomplete write, try to finish it before + * dealing with the new request. If we don't finish here, return + * LDAP_BUSY and let the caller retry later. We only allow a single + * request to be in WRITING state. + */ + rc = 0; + if ( ld->ld_requests && + ld->ld_requests->lr_status == LDAP_REQST_WRITING && + ldap_int_flush_request( ld, ld->ld_requests ) < 0 ) { + rc = -1; + } + if ( rc ) return rc; + + if (( lr = (LDAPRequest *)LDAP_CALLOC( 1, sizeof( LDAPRequest ))) == NULL ) { ld->ld_errno = LDAP_NO_MEMORY; ldap_free_connection( ld, lc, 0, 0 ); @@ -196,8 +278,8 @@ ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest 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; + lr->lr_refnext = parentreq->lr_child; + parentreq->lr_child = lr; } else { /* original request */ lr->lr_origid = lr->lr_msgid; } @@ -208,90 +290,59 @@ ldap_send_server_request( LDAP *ld, BerElement *ber, int msgid, LDAPRequest 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; - ldap_mark_select_write( ld, lc->lconn_sb ); - } else { -#else /* notyet */ - ld->ld_errno = LDAP_SERVER_DOWN; - ldap_free_request( ld, lr ); - ldap_free_connection( ld, lc, 0, 0 ); - 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 */ - ldap_mark_select_read( ld, lc->lconn_sb ); + ld->ld_errno = LDAP_SUCCESS; + if ( ldap_int_flush_request( ld, lr ) == -1 ) { + msgid = -1; } - ld->ld_errno = LDAP_SUCCESS; return( msgid ); } - LDAPConn * -ldap_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb, - int connect, int bind ) +ldap_new_connection( LDAP *ld, LDAPURLDesc *srvlist, int use_ldsb, + int connect, LDAPreqinfo *bind ) { LDAPConn *lc; - LDAPServer *prevsrv, *srv; - Sockbuf *sb; + LDAPURLDesc *srv; + Sockbuf *sb = NULL; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "ldap_new_connection\n", 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "ldap_new_connection\n", 0, 0, 0 ); +#endif /* * 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 = (LDAPConn *)LDAP_CALLOC( 1, sizeof( LDAPConn ))) == NULL || + ( !use_ldsb && ( (sb = ber_sockbuf_alloc()) == NULL ))) { if ( lc != NULL ) { - free( (char *)lc ); + LDAP_FREE( (char *)lc ); } ld->ld_errno = LDAP_NO_MEMORY; return( NULL ); } - lc->lconn_sb = ( use_ldsb ) ? &ld->ld_sb : sb; + 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 ) { + for ( srv = srvlist; srv != NULL; srv = srv->lud_next ) { + if ( ldap_int_open_connection( ld, lc, srv, 0 ) != -1 ) { break; } - prevsrv = srv; } if ( srv == NULL ) { - if ( !use_ldsb ) { - free( (char *)lc->lconn_sb ); - } - free( (char *)lc ); + if ( !use_ldsb ) { + ber_sockbuf_free( lc->lconn_sb ); + } + LDAP_FREE( (char *)lc ); ld->ld_errno = LDAP_SERVER_DOWN; return( NULL ); } - if ( prevsrv == NULL ) { - *srvlistp = srv->lsrv_next; - } else { - prevsrv->lsrv_next = srv->lsrv_next; - } - lc->lconn_server = srv; + lc->lconn_server = ldap_url_dup(srv); } lc->lconn_status = LDAP_CONNST_CONNECTED; @@ -302,72 +353,111 @@ ldap_new_connection( LDAP *ld, LDAPServer **srvlistp, int use_ldsb, * 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; + if ( bind != NULL) { + int err = 0; LDAPConn *savedefconn; - freepasswd = err = 0; - - if ( ld->ld_rebindproc == NULL ) { - binddn = passwd = ""; - authmethod = LDAP_AUTH_SIMPLE; - } else { - if (( err = (*ld->ld_rebindproc)( ld, &binddn, &passwd, - &authmethod, 0 )) == LDAP_SUCCESS ) { - freepasswd = 1; + /* Set flag to prevent additional referrals from being processed on this + * connection until the bind has completed + */ + lc->lconn_rebind_inprogress = 1; + /* V3 rebind function */ + if ( ld->ld_rebind_proc != NULL) { + LDAPURLDesc *srvfunc; + if( ( srvfunc = ldap_url_dup( srvlist)) == NULL) { + ld->ld_errno = LDAP_NO_MEMORY; + err = -1; } else { - ld->ld_errno = err; + savedefconn = ld->ld_defconn; + ++lc->lconn_refcnt; /* avoid premature free */ + ld->ld_defconn = lc; + +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_new_connection: Call application rebind_proc\n", + 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "Call application rebind_proc\n", 0, 0, 0); +#endif +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); + ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex ); +#endif + err = (*ld->ld_rebind_proc)( ld, + bind->ri_url, bind->ri_request, bind->ri_msgid, + ld->ld_rebind_params ); +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex ); + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif + + ld->ld_defconn = savedefconn; + --lc->lconn_refcnt; + + if( err != 0) { err = -1; + ldap_free_connection( ld, lc, 1, 0 ); + lc = NULL; } + ldap_free_urldesc( srvfunc); } - - - if ( err == 0 ) { + } else { savedefconn = ld->ld_defconn; - ld->ld_defconn = lc; ++lc->lconn_refcnt; /* avoid premature free */ + ld->ld_defconn = lc; - if ( ldap_bind_s( ld, binddn, passwd, authmethod ) != - LDAP_SUCCESS ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_new_connection: anonymous rebind via ldap_bind_s\n", + 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "anonymous rebind via ldap_bind_s\n", 0, 0, 0); +#endif +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); + ldap_pvt_thread_mutex_unlock( &ld->ld_res_mutex ); +#endif + if ( ldap_bind_s( ld, "", "", LDAP_AUTH_SIMPLE ) != LDAP_SUCCESS ) { err = -1; } - --lc->lconn_refcnt; +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_res_mutex ); + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif ld->ld_defconn = savedefconn; - } - - if ( freepasswd ) { - (*ld->ld_rebindproc)( ld, &binddn, &passwd, - &authmethod, 1 ); - } + --lc->lconn_refcnt; if ( err != 0 ) { ldap_free_connection( ld, lc, 1, 0 ); lc = NULL; } } + if( lc != NULL) + lc->lconn_rebind_inprogress = 0; + } return( lc ); } static LDAPConn * -find_connection( LDAP *ld, LDAPServer *srv, int any ) +find_connection( LDAP *ld, LDAPURLDesc *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; + LDAPURLDesc *ls; 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 ) { - return( lc ); + for ( ls = srv; ls != NULL; ls = ls->lud_next ) { + if ( lc->lconn_server->lud_host != NULL && + *lc->lconn_server->lud_host != '\0' && + ls->lud_host != NULL && *ls->lud_host != '\0' && + strcasecmp( ls->lud_host, lc->lconn_server->lud_host ) == 0 + && ls->lud_port == lc->lconn_server->lud_port ) { + return lc; } if ( !any ) { break; @@ -375,7 +465,7 @@ find_connection( LDAP *ld, LDAPServer *srv, int any ) } } - return( NULL ); + return NULL; } @@ -384,7 +474,7 @@ static void use_connection( LDAP *ld, LDAPConn *lc ) { ++lc->lconn_refcnt; - lc->lconn_lastused = time( 0 ); + lc->lconn_lastused = time( NULL ); } @@ -393,19 +483,26 @@ ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind ) { LDAPConn *tmplc, *prevlc; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "ldap_free_connection\n", 0, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ldap_free_connection\n", 0, 0, 0 ); +#endif if ( force || --lc->lconn_refcnt <= 0 ) { if ( lc->lconn_status == LDAP_CONNST_CONNECTED ) { ldap_mark_select_clear( ld, lc->lconn_sb ); if ( unbind ) { - ldap_send_unbind( ld, lc->lconn_sb ); - } - ldap_close_connection( lc->lconn_sb ); - if ( lc->lconn_sb->sb_ber.ber_buf != NULL ) { - free( lc->lconn_sb->sb_ber.ber_buf ); + ldap_send_unbind( ld, lc->lconn_sb, NULL, NULL ); } } + + if( lc->lconn_ber != NULL ) { + ber_free( lc->lconn_ber, 1 ); + } + + ldap_int_sasl_close( ld, lc ); + prevlc = NULL; for ( tmplc = ld->ld_conns; tmplc != NULL; tmplc = tmplc->lconn_next ) { @@ -419,20 +516,39 @@ ldap_free_connection( LDAP *ld, LDAPConn *lc, int force, int unbind ) } prevlc = tmplc; } - free_servers( lc->lconn_server ); + ldap_free_urllist( lc->lconn_server ); +#ifdef LDAP_API_FEATURE_X_OPENLDAP_V2_KBIND if ( lc->lconn_krbinstance != NULL ) { - free( lc->lconn_krbinstance ); + LDAP_FREE( lc->lconn_krbinstance ); } - if ( lc->lconn_sb != &ld->ld_sb ) { - free( (char *)lc->lconn_sb ); +#endif + if ( lc->lconn_sb != ld->ld_sb ) { + ber_sockbuf_free( lc->lconn_sb ); } - free( lc ); + if( lc->lconn_rebind_queue != NULL) { + int i; + for( i = 0; lc->lconn_rebind_queue[i] != NULL; i++) { + LDAP_VFREE(lc->lconn_rebind_queue[i]); + } + LDAP_FREE( lc->lconn_rebind_queue); + } + LDAP_FREE( lc ); +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, + "ldap_free_connection: actually freed\n", 0, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ldap_free_connection: actually freed\n", 0, 0, 0 ); +#endif } else { - lc->lconn_lastused = time( 0 ); + lc->lconn_lastused = time( NULL ); +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, RESULTS, "ldap_free_connection: refcnt %d\n", + lc->lconn_refcnt, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ldap_free_connection: refcnt %d\n", lc->lconn_refcnt, 0, 0 ); +#endif } } @@ -442,22 +558,39 @@ void ldap_dump_connection( LDAP *ld, LDAPConn *lconns, int all ) { LDAPConn *lc; + char timebuf[32]; 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)" : "" ); + ( lc->lconn_server->lud_host == NULL ) ? "(null)" + : lc->lconn_server->lud_host, + lc->lconn_server->lud_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 )); + fprintf( stderr, " last used: %s", + ldap_pvt_ctime( &lc->lconn_lastused, timebuf )); + if( lc->lconn_rebind_inprogress ) { + fprintf( stderr, " rebind in progress\n"); + if( lc->lconn_rebind_queue != NULL) { + int i = 0; + for( ;lc->lconn_rebind_queue[i] != NULL; i++) { + int j = 0; + for( ;lc->lconn_rebind_queue[i][j] != 0; j++) { + fprintf( stderr, " queue %d entry %d - %s\n", + i, j, lc->lconn_rebind_queue[i][j]); + } + } + } else { + fprintf( stderr, " queue is empty\n"); + } + } + fprintf(stderr, "\n"); if ( !all ) { break; } @@ -471,59 +604,50 @@ ldap_dump_requests_and_responses( LDAP *ld ) LDAPRequest *lr; LDAPMessage *lm, *l; +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif 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_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" ); + ( lr->lr_status == LDAP_REQST_WRITING) ? "Writing" : + ( lr->lr_status == LDAP_REQST_COMPLETED ? "Request Completed" : "Invalid Status")); fprintf( stderr, " outstanding referrals %d, parent count %d\n", lr->lr_outrefcnt, lr->lr_parentcnt ); } - +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); +#endif fprintf( stderr, "** Response Queue:\n" ); - if (( lm = ld->ld_responses ) == NULLMSG ) { + if (( lm = ld->ld_responses ) == NULL ) { fprintf( stderr, " Empty\n" ); } - for ( ; lm != NULLMSG; lm = lm->lm_next ) { - fprintf( stderr, " * msgid %d, type %d\n", - lm->lm_msgid, lm->lm_msgtype ); + for ( ; lm != NULL; lm = lm->lm_next ) { + fprintf( stderr, " * msgid %d, type %lu\n", + lm->lm_msgid, (unsigned long) lm->lm_msgtype ); if (( l = lm->lm_chain ) != NULL ) { fprintf( stderr, " chained responses:\n" ); - for ( ; l != NULLMSG; l = l->lm_chain ) { + for ( ; l != NULL; l = l->lm_chain ) { fprintf( stderr, - " * msgid %d, type %d\n", - l->lm_msgid, l->lm_msgtype ); + " * msgid %d, type %lu\n", + l->lm_msgid, + (unsigned long) l->lm_msgtype ); } } } } #endif /* LDAP_DEBUG */ - void -ldap_free_request( LDAP *ld, LDAPRequest *lr ) +ldap_free_request_int( LDAP *ld, LDAPRequest *lr ) { - LDAPRequest *tmplr, *nextlr; - - Debug( LDAP_DEBUG_TRACE, "ldap_free_request (origid %d, msgid %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; - ldap_free_request( ld, tmplr ); - } - } - if ( lr->lr_prev == NULL ) { ld->ld_requests = lr->lr_next; } else { @@ -539,54 +663,336 @@ ldap_free_request( LDAP *ld, LDAPRequest *lr ) } if ( lr->lr_res_error != NULL ) { - free( lr->lr_res_error ); + LDAP_FREE( lr->lr_res_error ); } if ( lr->lr_res_matched != NULL ) { - free( lr->lr_res_matched ); + LDAP_FREE( lr->lr_res_matched ); } - free( lr ); + LDAP_FREE( lr ); } +void +ldap_free_request( LDAP *ld, LDAPRequest *lr ) +{ + LDAPRequest **ttmplr; -static void -free_servers( LDAPServer *srvlist ) +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ARGS, "ldap_free_request (origid %d, msgid %d)\n", + lr->lr_origid, lr->lr_msgid, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "ldap_free_request (origid %d, msgid %d)\n", + lr->lr_origid, lr->lr_msgid, 0 ); +#endif + + /* free all referrals (child requests) */ + while ( lr->lr_child ) + ldap_free_request( ld, lr->lr_child ); + + if ( lr->lr_parent != NULL ) { + --lr->lr_parent->lr_outrefcnt; + for ( ttmplr = &lr->lr_parent->lr_child; *ttmplr && *ttmplr != lr; ttmplr = &(*ttmplr)->lr_refnext ); + if ( *ttmplr == lr ) + *ttmplr = lr->lr_refnext; + } + ldap_free_request_int( ld, lr ); +} + + +/* + * Chase v3 referrals + * + * Parameters: + * (IN) ld = LDAP connection handle + * (IN) lr = LDAP Request structure + * (IN) refs = array of pointers to referral strings that we will chase + * The array will be free'd by this function when no longer needed + * (IN) sref != 0 if following search reference + * (OUT) errstrp = Place to return a string of referrals which could not be followed + * (OUT) hadrefp = 1 if sucessfully followed referral + * + * Return value - number of referrals followed + */ +int +ldap_chase_v3referrals( LDAP *ld, LDAPRequest *lr, char **refs, int sref, char **errstrp, int *hadrefp ) { - LDAPServer *nextsrv; + char *unfollowed; + int unfollowedcnt = 0; + LDAPRequest *origreq; + LDAPURLDesc *srv = NULL; + BerElement *ber; + char **refarray = NULL; + LDAPConn *lc; + int rc, count, i, j, id; + int parent_was_reference; + LDAPreqinfo rinfo; + + ld->ld_errno = LDAP_SUCCESS; /* optimistic */ + *hadrefp = 0; + +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "ldap_chase_v3referrals\n", 0, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, "ldap_chase_v3referrals\n", 0, 0, 0 ); +#endif + + unfollowed = NULL; + rc = count = 0; + + /* If no referrals in array, return */ + if ( (refs == NULL) || ( (refs)[0] == NULL) ) { + rc = 0; + goto done; + } - while ( srvlist != NULL ) { - nextsrv = srvlist->lsrv_next; - if ( srvlist->lsrv_dn != NULL ) { - free( srvlist->lsrv_dn ); + /* Check for hop limit exceeded */ + if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_chase_v3referrals: more than %d referral hops (dropping)\n", + ld->ld_refhoplimit, 0, 0 ); +#else + Debug( LDAP_DEBUG_ANY, + "more than %d referral hops (dropping)\n", ld->ld_refhoplimit, 0, 0 ); +#endif + ld->ld_errno = LDAP_REFERRAL_LIMIT_EXCEEDED; + rc = -1; + goto done; } - if ( srvlist->lsrv_host != NULL ) { - free( srvlist->lsrv_host ); + + /* check if parent request was a search reference */ + parent_was_reference = ( lr->lr_parent && + lr->lr_parent->lr_res_msgtype == LDAP_RES_SEARCH_REFERENCE ) ? + 1 : 0; + + /* find original request */ + for ( origreq = lr; + origreq->lr_parent != NULL; + origreq = origreq->lr_parent ) + { + /* empty */ ; } - free( srvlist ); - srvlist = nextsrv; - } -} -#endif /* LDAP_REFERRALS || LDAP_DNS */ + refarray = refs; + refs = NULL; + /* parse out & follow referrals */ + for( i=0; refarray[i] != NULL; i++) { + /* Parse the referral URL */ + if (( rc = ldap_url_parse_ext( refarray[i], &srv)) != LDAP_SUCCESS) { + ld->ld_errno = rc; + rc = -1; + goto done; + } + + if( srv->lud_crit_exts ) { + /* we do not support any extensions */ + ld->ld_errno = LDAP_NOT_SUPPORTED; + rc = -1; + goto done; + } + + /* treat ldap://hostpart and ldap://hostpart/ the same */ + if ( srv->lud_dn && srv->lud_dn[0] == '\0' ) { + LDAP_FREE( srv->lud_dn ); + srv->lud_dn = NULL; + } + + /* check connection for re-bind in progress */ + if (( lc = find_connection( ld, srv, 1 )) != NULL ) { + if( lc->lconn_rebind_inprogress) { + /* We are already chasing a referral or search reference and a + * bind on that connection is in progress. We must queue + * referrals on that connection, so we don't get a request + * going out before the bind operation completes. This happens + * if two search references come in one behind the other + * for the same server with different contexts. + */ +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_chase_v3referrals: queue referral \"%s\"\n", + refarray[i], 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "ldap_chase_v3referrals: queue referral \"%s\"\n", + refarray[i], 0, 0); +#endif + if( lc->lconn_rebind_queue == NULL ) { + /* Create a referral list */ + lc->lconn_rebind_queue = + (char ***) LDAP_MALLOC( sizeof(void *) * 2); + + if( lc->lconn_rebind_queue == NULL) { + ld->ld_errno = LDAP_NO_MEMORY; + rc = -1; + goto done; + } + + lc->lconn_rebind_queue[0] = refarray; + lc->lconn_rebind_queue[1] = NULL; + refarray = NULL; + + } else { + /* Count how many referral arrays we already have */ + for( j = 0; lc->lconn_rebind_queue[j] != NULL; j++) { + /* empty */; + } + + /* Add the new referral to the list */ + lc->lconn_rebind_queue = (char ***) LDAP_REALLOC( + lc->lconn_rebind_queue, sizeof(void *) * (j + 2)); + + if( lc->lconn_rebind_queue == NULL ) { + ld->ld_errno = LDAP_NO_MEMORY; + rc = -1; + goto done; + } + lc->lconn_rebind_queue[j] = refarray; + lc->lconn_rebind_queue[j+1] = NULL; + refarray = NULL; + } + + /* We have queued the referral/reference, now just return */ + rc = 0; + *hadrefp = 1; + count = 1; /* Pretend we already followed referral */ + goto done; + } + } + /* Re-encode the request with the new starting point of the search. + * Note: In the future we also need to replace the filter if one + * was provided with the search reference + */ + + /* For references we don't want old dn if new dn empty */ + if ( sref && srv->lud_dn == NULL ) { + srv->lud_dn = LDAP_STRDUP( "" ); + } + + LDAP_NEXT_MSGID( ld, id ); + ber = re_encode_request( ld, origreq->lr_ber, id, + sref, srv, &rinfo.ri_request ); + + if( ber == NULL ) { + ld->ld_errno = LDAP_ENCODING_ERROR; + rc = -1; + goto done; + } + +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_chase_v3referrals: msgid %d, url \"%s\"\n", + lr->lr_msgid, refarray[i], 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "ldap_chase_v3referral: msgid %d, url \"%s\"\n", + lr->lr_msgid, refarray[i], 0); +#endif + + /* Send the new request to the server - may require a bind */ + rinfo.ri_msgid = origreq->lr_origid; + rinfo.ri_url = refarray[i]; +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif + rc = ldap_send_server_request( ld, ber, id, + (sref && !parent_was_reference) ? origreq : lr, + srv, NULL, &rinfo ); +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); +#endif + if ( rc < 0 ) { + /* Failure, try next referral in the list */ +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ERR, + "ldap_chase_v3referrals: Unable to chase referral \"%s\" (%s)\n", + refarray[i], ldap_err2string( ld->ld_errno ), 0 ); +#else + Debug( LDAP_DEBUG_ANY, "Unable to chase referral \"%s\" (%s)\n", + refarray[i], ldap_err2string( ld->ld_errno ), 0); +#endif + unfollowedcnt += ldap_append_referral( ld, &unfollowed, refarray[i]); + ldap_free_urllist(srv); + srv = NULL; + } else { + /* Success, no need to try this referral list further */ + rc = 0; + ++count; + *hadrefp = 1; + + /* check if there is a queue of referrals that came in during bind */ + if( lc == NULL) { + if (( lc = find_connection( ld, srv, 1 )) == NULL ) { + ld->ld_errno = LDAP_OPERATIONS_ERROR; + rc = -1; + goto done; + } + } + + if( lc->lconn_rebind_queue != NULL) { + /* Release resources of previous list */ + LDAP_VFREE(refarray); + refarray = NULL; + ldap_free_urllist(srv); + srv = NULL; + + /* Pull entries off end of queue so list always null terminated */ + for( j = 0; lc->lconn_rebind_queue[j] != NULL; j++) { + ; + } + refarray = lc->lconn_rebind_queue[j-1]; + lc->lconn_rebind_queue[j-1] = NULL; + /* we pulled off last entry from queue, free queue */ + if ( j == 1 ) { + LDAP_FREE( lc->lconn_rebind_queue); + lc->lconn_rebind_queue = NULL; + } + /* restart the loop the with new referral list */ + i = -1; + continue; + } + break; /* referral followed, break out of for loop */ + } + } /* end for loop */ +done: + LDAP_VFREE(refarray); + ldap_free_urllist(srv); + LDAP_FREE( *errstrp ); + + if( rc == 0) { + *errstrp = NULL; + LDAP_FREE( unfollowed ); + return count; + } else { + ld->ld_errno = LDAP_REFERRAL; + *errstrp = unfollowed; + return rc; + } +} -#ifdef LDAP_REFERRALS /* * XXX merging of errors in this routine needs to be improved */ int -ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp ) +ldap_chase_referrals( LDAP *ld, + LDAPRequest *lr, + char **errstrp, + int sref, + int *hadrefp ) { - int rc, count, len, newdn; -#ifdef LDAP_DNS - int ldapref; -#endif /* LDAP_DNS */ - char *p, *ports, *ref, *tmpref, *refdn, *unfollowed; + int rc, count, id; + unsigned len; + char *p, *ref, *unfollowed; LDAPRequest *origreq; - LDAPServer *srv; + LDAPURLDesc *srv; BerElement *ber; + LDAPreqinfo rinfo; +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, "ldap_chase_referrals\n", 0, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ldap_chase_referrals\n", 0, 0, 0 ); +#endif ld->ld_errno = LDAP_SUCCESS; /* optimistic */ *hadrefp = 0; @@ -597,8 +1003,7 @@ ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp ) len = strlen( *errstrp ); for ( p = *errstrp; len >= LDAP_REF_STR_LEN; ++p, --len ) { - if (( *p == 'R' || *p == 'r' ) && strncasecmp( p, - LDAP_REF_STR, LDAP_REF_STR_LEN ) == 0 ) { + if ( strncasecmp( p, LDAP_REF_STR, LDAP_REF_STR_LEN ) == 0 ) { *p = '\0'; p += LDAP_REF_STR_LEN; break; @@ -610,9 +1015,15 @@ ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp ) } if ( lr->lr_parentcnt >= ld->ld_refhoplimit ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ENTRY, + "ldap_chase_referrals: more than %d referral hops (dropping)\n", + ld->ld_refhoplimit, 0, 0 ); +#else Debug( LDAP_DEBUG_ANY, "more than %d referral hops (dropping)\n", ld->ld_refhoplimit, 0, 0 ); +#endif /* XXX report as error in ld->ld_errno? */ return( 0 ); } @@ -620,7 +1031,7 @@ ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp ) /* find original request */ for ( origreq = lr; origreq->lr_parent != NULL; origreq = origreq->lr_parent ) { - ; + /* empty */; } unfollowed = NULL; @@ -628,98 +1039,86 @@ ldap_chase_referrals( LDAP *ld, LDAPRequest *lr, char **errstrp, int *hadrefp ) /* parse out & follow referrals */ for ( ref = p; rc == 0 && ref != NULL; ref = p ) { -#ifdef LDAP_DNS - ldapref = 0; -#endif /* LDAP_DNS */ - if (( p = strchr( ref, '\n' )) != NULL ) { *p++ = '\0'; } else { p = NULL; } - len = strlen( ref ); - if ( len > LDAP_LDAP_REF_STR_LEN && strncasecmp( ref, - LDAP_LDAP_REF_STR, LDAP_LDAP_REF_STR_LEN ) == 0 ) { - Debug( LDAP_DEBUG_TRACE, - "chasing LDAP referral: <%s>\n", ref, 0, 0 ); -#ifdef LDAP_DNS - ldapref = 1; -#endif /* LDAP_DNS */ - tmpref = ref + LDAP_LDAP_REF_STR_LEN; -#ifdef LDAP_DNS - } else if ( len > LDAP_DX_REF_STR_LEN && strncasecmp( ref, - LDAP_DX_REF_STR, LDAP_DX_REF_STR_LEN ) == 0 ) { - Debug( LDAP_DEBUG_TRACE, - "chasing DX referral: <%s>\n", ref, 0, 0 ); - tmpref = ref + LDAP_DX_REF_STR_LEN; -#endif /* LDAP_DNS */ - } else { + rc = ldap_url_parse_ext( ref, &srv ); + + if ( rc != LDAP_URL_SUCCESS ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_chase_referrals: ignoring unknown referral <%s>\n", + ref, 0, 0 ); +#else Debug( LDAP_DEBUG_TRACE, "ignoring unknown referral <%s>\n", ref, 0, 0 ); +#endif rc = ldap_append_referral( ld, &unfollowed, ref ); *hadrefp = 1; continue; } - *hadrefp = 1; - if (( refdn = strchr( tmpref, '/' )) != NULL ) { - *refdn++ = '\0'; - newdn = 1; - } else { - newdn = 0; + if( srv->lud_dn != NULL && srv->lud_dn == '\0' ) { + LDAP_FREE( srv->lud_dn ); + srv->lud_dn = NULL; } - if (( ber = re_encode_request( ld, origreq->lr_ber, - ++ld->ld_msgid, &refdn )) == NULL ) { - return( -1 ); - } +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "ldap_chase_referrals: chasing LDAP referral <%s>\n", ref, 0, 0 ); +#else + Debug( LDAP_DEBUG_TRACE, + "chasing LDAP referral: <%s>\n", ref, 0, 0 ); +#endif -#ifdef LDAP_DNS - if ( ldapref ) { -#endif /* LDAP_DNS */ - if (( srv = (LDAPServer *)calloc( 1, - sizeof( LDAPServer ))) == NULL ) { - ber_free( ber, 1 ); - ld->ld_errno = LDAP_NO_MEMORY; - return( -1 ); - } + *hadrefp = 1; - if (( srv->lsrv_host = strdup( tmpref )) == NULL ) { - free( (char *)srv ); - ber_free( ber, 1 ); - ld->ld_errno = LDAP_NO_MEMORY; - return( -1 ); - } + LDAP_NEXT_MSGID( ld, id ); + ber = re_encode_request( ld, origreq->lr_ber, + id, sref, srv, &rinfo.ri_request ); - if (( ports = strchr( srv->lsrv_host, ':' )) != NULL ) { - *ports++ = '\0'; - srv->lsrv_port = atoi( ports ); - } else { - srv->lsrv_port = LDAP_PORT; - } -#ifdef LDAP_DNS - } else { - srv = dn2servers( ld, tmpref ); + if( ber == NULL ) { + return -1 ; } -#endif /* LDAP_DNS */ - if ( srv != NULL && ldap_send_server_request( ld, ber, ld->ld_msgid, - lr, srv, NULL, 1 ) >= 0 ) { + /* copy the complete referral for rebind process */ + rinfo.ri_url = LDAP_STRDUP( ref ); + + rinfo.ri_msgid = origreq->lr_origid; + +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif + rc = ldap_send_server_request( ld, ber, id, + lr, srv, NULL, &rinfo ); +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); +#endif + + LDAP_FREE( rinfo.ri_url ); + + if( rc >= 0 ) { ++count; } else { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ERR, + "ldap_chase_referrals: Unable to chase referral <%s>\n", + ldap_err2string( ld->ld_errno), 0, 0 ); +#else Debug( LDAP_DEBUG_ANY, "Unable to chase referral (%s)\n", ldap_err2string( ld->ld_errno ), 0, 0 ); +#endif rc = ldap_append_referral( ld, &unfollowed, ref ); } - if ( !newdn && refdn != NULL ) { - free( refdn ); - } + ldap_free_urllist(srv); } - free( *errstrp ); + LDAP_FREE( *errstrp ); *errstrp = unfollowed; return(( rc == 0 ) ? count : rc ); @@ -733,11 +1132,11 @@ ldap_append_referral( LDAP *ld, char **referralsp, char *s ) if ( *referralsp == NULL ) { first = 1; - *referralsp = (char *)malloc( strlen( s ) + LDAP_REF_STR_LEN + *referralsp = (char *)LDAP_MALLOC( strlen( s ) + LDAP_REF_STR_LEN + 1 ); } else { first = 0; - *referralsp = (char *)realloc( *referralsp, + *referralsp = (char *)LDAP_REALLOC( *referralsp, strlen( *referralsp ) + strlen( s ) + 2 ); } @@ -759,183 +1158,164 @@ ldap_append_referral( LDAP *ld, char **referralsp, char *s ) static BerElement * -re_encode_request( LDAP *ld, BerElement *origber, int msgid, char **dnp ) +re_encode_request( LDAP *ld, + BerElement *origber, + ber_int_t msgid, + int sref, + LDAPURLDesc *srv, + int *type ) { -/* - * XXX this routine knows way too much about how the lber library works! - */ - unsigned long along, tag; - long ver; + /* + * XXX this routine knows way too much about how the lber library works! + */ + ber_int_t along; + ber_tag_t tag; + ber_tag_t rtag; + ber_int_t ver; + ber_int_t scope; int rc; BerElement tmpber, *ber; char *orig_dn; - + char *dn; + +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, ARGS, + "re_encode_request: new msgid %ld, new dn <%s>\n", + (long) msgid, + ( srv == NULL || srv->lud_dn == NULL ) ? "NONE" : srv->lud_dn, 0 ); +#else Debug( LDAP_DEBUG_TRACE, - "re_encode_request: new msgid %d, new dn <%s>\n", - msgid, ( *dnp == NULL ) ? "NONE" : *dnp, 0 ); + "re_encode_request: new msgid %ld, new dn <%s>\n", + (long) msgid, + ( srv == NULL || srv->lud_dn == NULL) ? "NONE" : srv->lud_dn, 0 ); +#endif tmpber = *origber; /* - * all LDAP requests are sequences that start with a message id, - * followed by a sequence that is tagged with the operation code + * all LDAP requests are sequences that start with a message id. + * For all except delete, this is followed by a sequence that is + * tagged with the operation code. For delete, the provided DN + * is not wrapped by a sequence. */ - if ( ber_scanf( &tmpber, "{i", &along ) != LDAP_TAG_MSGID || - ( tag = ber_skip_tag( &tmpber, &along )) == LBER_DEFAULT ) { - ld->ld_errno = LDAP_DECODING_ERROR; + rtag = ber_scanf( &tmpber, "{it", /*}*/ &along, &tag ); + + if ( rtag == LBER_ERROR ) { + ld->ld_errno = LDAP_DECODING_ERROR; return( NULL ); } - if (( ber = ldap_alloc_ber_with_options( ld )) == NULLBER ) { - return( NULL ); - } + assert( tag != 0); + if ( tag == LDAP_REQ_BIND ) { + /* bind requests have a version number before the DN & other stuff */ + rtag = ber_scanf( &tmpber, "{ia" /*}*/, &ver, &orig_dn ); + + } else if ( tag == LDAP_REQ_DELETE ) { + /* delete requests don't have a DN wrapping sequence */ + rtag = ber_scanf( &tmpber, "a", &orig_dn ); + + } else if ( tag == LDAP_REQ_SEARCH ) { + /* search requests need to be re-scope-ed */ + rtag = ber_scanf( &tmpber, "{ae" /*"}"*/, &orig_dn, &scope ); + + if( srv->lud_scope != LDAP_SCOPE_DEFAULT ) { + /* use the scope provided in reference */ + scope = srv->lud_scope; + + } else if ( sref && scope != LDAP_SCOPE_SUBTREE ) { + /* use scope implied by previous operation */ + /* base -> base */ + /* one -> base */ + /* subtree -> subtree */ + scope = LDAP_SCOPE_BASE; + } - /* bind requests have a version number before the DN & other stuff */ - if ( tag == LDAP_REQ_BIND && ber_get_int( &tmpber, (long *)&ver ) == - LBER_DEFAULT ) { - ld->ld_errno = LDAP_DECODING_ERROR; - ber_free( ber, 1 ); - return( NULL ); + } else { + rtag = ber_scanf( &tmpber, "{a" /*}*/, &orig_dn ); } - /* the rest of the request is the DN followed by other stuff */ - if ( ber_get_stringa( &tmpber, &orig_dn ) == LBER_DEFAULT ) { - ber_free( ber, 1 ); - return( NULL ); + if( rtag == LBER_ERROR ) { + ld->ld_errno = LDAP_DECODING_ERROR; + return NULL; } - if ( *dnp == NULL ) { - *dnp = orig_dn; + if (( ber = ldap_alloc_ber_with_options( ld )) == NULL ) { + return NULL; + } + + if ( srv->lud_dn == NULL ) { + dn = orig_dn; } else { - free( orig_dn ); + dn = srv->lud_dn; } if ( tag == LDAP_REQ_BIND ) { - rc = ber_printf( ber, "{it{is", msgid, tag, ver, *dnp ); + rc = ber_printf( ber, "{it{is" /*}}*/, msgid, tag, ver, dn ); + } else if ( tag == LDAP_REQ_DELETE ) { + rc = ber_printf( ber, "{itsN}", msgid, tag, dn ); + } else if ( tag == LDAP_REQ_SEARCH ) { + rc = ber_printf( ber, "{it{se" /*}}*/, msgid, tag, dn, scope ); } else { - rc = ber_printf( ber, "{it{s", msgid, tag, *dnp ); + rc = ber_printf( ber, "{it{s" /*}}*/, msgid, tag, dn ); } + LDAP_FREE( orig_dn ); + if ( rc == -1 ) { + ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); - return( NULL ); + return NULL; } - if ( ber_write( ber, tmpber.ber_ptr, ( tmpber.ber_end - - tmpber.ber_ptr ), 0 ) != ( tmpber.ber_end - tmpber.ber_ptr ) || - ber_printf( ber, "}}" ) == -1 ) { + if ( tag != LDAP_REQ_DELETE && ( + ber_write(ber, tmpber.ber_ptr, ( tmpber.ber_end - tmpber.ber_ptr ), 0) + != ( tmpber.ber_end - tmpber.ber_ptr ) || + ber_printf( ber, /*{{*/ "N}N}" ) == -1 ) ) + { ld->ld_errno = LDAP_ENCODING_ERROR; ber_free( ber, 1 ); - return( NULL ); + return NULL; } #ifdef LDAP_DEBUG if ( ldap_debug & LDAP_DEBUG_PACKETS ) { +#ifdef NEW_LOGGING + LDAP_LOG ( OPERATION, DETAIL1, + "re_encode_request: new request is:\n", 0, 0, 0 ); +#else Debug( LDAP_DEBUG_ANY, "re_encode_request new request is:\n", 0, 0, 0 ); - ber_dump( ber, 0 ); +#endif + ber_log_dump( LDAP_DEBUG_BER, ldap_debug, ber, 0 ); } #endif /* LDAP_DEBUG */ - return( ber ); + *type = tag; /* return request type */ + return ber; } LDAPRequest * -ldap_find_request_by_msgid( LDAP *ld, int msgid ) +ldap_find_request_by_msgid( LDAP *ld, ber_int_t msgid ) { - LDAPRequest *lr; + LDAPRequest *lr; +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_lock( &ld->ld_req_mutex ); +#endif for ( lr = ld->ld_requests; lr != NULL; lr = lr->lr_next ) { + if( lr->lr_status == LDAP_REQST_COMPLETED ) { + continue; /* Skip completed requests */ + } if ( msgid == lr->lr_msgid ) { break; } } +#ifdef LDAP_R_COMPILE + ldap_pvt_thread_mutex_unlock( &ld->ld_req_mutex ); +#endif return( lr ); } -#endif /* LDAP_REFERRALS */ -#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 = ldap_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 */