fix previous commit: don't loop on undefined; return success with no data in case...

[openldap] / servers / slapd / back-ldap / search.c

diff --git a/servers/slapd/back-ldap/search.c b/servers/slapd/back-ldap/search.c
index a9fc57fb752cc312e0cad3065415c021f822c207..fd57590a139fd9e1e6011ee9ab12e4ae25bc9051 100644 (file)
--- a/servers/slapd/back-ldap/search.c
+++ b/servers/slapd/back-ldap/search.c
@@ -41,6 +41,96 @@ ldap_build_entry( Operation *op, LDAPMessage *e, Entry *ent,
         struct berval *bdn, int flags );
 #define LDAP_BUILD_ENTRY_PRIVATE       0x01
 
+/*
+ * Quick'n'dirty rewrite of filter in case of error, to deal with
+ * <draft-zeilenga-ldap-t-f>.
+ */
+static int
+munge_filter(
+       Operation       *op,
+       struct berval   *filter )
+{
+       struct ldapinfo *li = (struct ldapinfo *) op->o_bd->be_private;
+
+       char            *ptr;
+       int             gotit = 0;
+
+       Debug( LDAP_DEBUG_ARGS, "=> ldap_back_munge_filter \"%s\"\n",
+                       filter->bv_val, 0, 0 );
+
+       for ( ptr = strstr( filter->bv_val, "(?=" ); 
+                       ptr;
+                       ptr = strstr( ptr, "(?=" ) )
+       {
+               static struct berval
+                       bv_true = BER_BVC( "(?=true)" ),
+                       bv_false = BER_BVC( "(?=false)" ),
+                       bv_t = BER_BVC( "(&)" ),
+                       bv_f = BER_BVC( "(|)" ),
+                       bv_T = BER_BVC( "(objectClass=*)" ),
+                       bv_F = BER_BVC( "(!(objectClass=*))" );
+               struct berval   *oldbv = NULL,
+                               *newbv = NULL,
+                               oldfilter = BER_BVNULL;
+
+               if ( strncmp( ptr, bv_true.bv_val, bv_true.bv_len ) == 0 ) {
+                       oldbv = &bv_true;
+                       if ( li->flags & LDAP_BACK_F_SUPPORT_T_F ) {
+                               newbv = &bv_t;
+
+                       } else {
+                               newbv = &bv_T;
+                       }
+
+               } else if ( strncmp( ptr, bv_false.bv_val, bv_false.bv_len ) == 0 )
+               {
+                       oldbv = &bv_false;
+                       if ( li->flags & LDAP_BACK_F_SUPPORT_T_F ) {
+                               newbv = &bv_f;
+
+                       } else {
+                               newbv = &bv_F;
+                       }
+
+               } else {
+                       gotit = 0;
+                       goto done;
+               }
+
+               oldfilter = *filter;
+               if ( !( li->flags & LDAP_BACK_F_SUPPORT_T_F ) ) {
+                       filter->bv_len += newbv->bv_len - oldbv->bv_len;
+                       if ( filter->bv_val == op->ors_filterstr.bv_val ) {
+                               filter->bv_val = op->o_tmpalloc( filter->bv_len + 1,
+                                               op->o_tmpmemctx );
+
+                               AC_MEMCPY( filter->bv_val, op->ors_filterstr.bv_val,
+                                               op->ors_filterstr.bv_len + 1 );
+
+                       } else {
+                               filter->bv_val = op->o_tmprealloc( filter->bv_val,
+                                               filter->bv_len + 1, op->o_tmpmemctx );
+                       }
+
+                       ptr = filter->bv_val + ( ptr - oldfilter.bv_val );
+               }
+
+               AC_MEMCPY( &ptr[ newbv->bv_len ],
+                               &ptr[ oldbv->bv_len ], 
+                               oldfilter.bv_len - ( ptr - filter->bv_val ) - oldbv->bv_len + 1 );
+               AC_MEMCPY( ptr, newbv->bv_val, newbv->bv_len );
+
+               ptr += newbv->bv_len;
+               gotit = 1;
+       }
+
+done:;
+       Debug( LDAP_DEBUG_ARGS, "<= ldap_back_munge_filter \"%s\" (%d)\n",
+                       filter->bv_val, gotit, 0 );
+
+       return gotit;
+}
+
 int
 ldap_back_search(
                Operation       *op,
@@ -52,11 +142,11 @@ ldap_back_search(
                        *e;
        int             rc = 0,
                        msgid; 
-       struct berval   match = BER_BVNULL;
+       struct berval   match = BER_BVNULL,
+                       filter = BER_BVNULL;
        int             i;
        char            **attrs = NULL;
        int             dontfreetext = 0;
-       int             freeconn = 0;
        int             do_retry = 1;
        LDAPControl     **ctrls = NULL;
 
@@ -110,22 +200,46 @@ ldap_back_search(
                dontfreetext = 1;
                goto finish;
        }
-       
+
+       /* deal with <draft-zeilenga-ldap-t-f> filters */
+       filter = op->ors_filterstr;
 retry:
        rs->sr_err = ldap_search_ext( lc->lc_ld, op->o_req_ndn.bv_val,
-                       op->ors_scope, op->ors_filterstr.bv_val,
+                       op->ors_scope, filter.bv_val,
                        attrs, op->ors_attrsonly, ctrls, NULL,
                        tv.tv_sec ? &tv : NULL,
                        op->ors_slimit, &msgid );
 
        if ( rs->sr_err != LDAP_SUCCESS ) {
 fail:;
-               rc = ldap_back_op_result( lc, op, rs, msgid, LDAP_BACK_SENDERR );
-               if ( freeconn ) {
+               switch ( rs->sr_err ) {
+               case LDAP_SERVER_DOWN:
+                       if ( do_retry ) {
+                               do_retry = 0;
+                               if ( ldap_back_retry( lc, op, rs, LDAP_BACK_DONTSEND ) ) {
+                                       goto retry;
+                               }
+                       }
+                       rc = ldap_back_op_result( lc, op, rs, msgid, LDAP_BACK_DONTSEND );
                        ldap_back_freeconn( op, lc );
                        lc = NULL;
+                       goto finish;
+
+               case LDAP_FILTER_ERROR:
+                       if ( munge_filter( op, &filter ) ) {
+                               goto retry;
+                       }
+
+                       /* invalid filters return success with no data */
+                       rs->sr_err = LDAP_SUCCESS;
+                       rs->sr_text = NULL;
+                       goto finish;
+               
+               default:
+                       rs->sr_err = slap_map_api2result( rs );
+                       rs->sr_text = NULL;
+                       goto finish;
                }
-               goto finish;
        }
 
        /* We pull apart the ber result, stuff it into a slapd entry, and
@@ -165,18 +279,16 @@ fail:;
                                abort = send_search_entry( op, rs );
                                while ( ent.e_attrs ) {
                                        Attribute       *a;
-                                       BerVarray       v;
 
                                        a = ent.e_attrs;
                                        ent.e_attrs = a->a_next;
 
-                                       v = a->a_vals;
+                                       if ( a->a_nvals != a->a_vals ) {
+                                               ber_bvarray_free( a->a_nvals );
+                                       }
                                        if ( a->a_vals != &slap_dummy_bv ) {
                                                ber_bvarray_free( a->a_vals );
                                        }
-                                       if ( a->a_nvals != v ) {
-                                               ber_bvarray_free( a->a_nvals );
-                                       }
                                        ch_free( a );
                                }
                                
@@ -274,9 +386,7 @@ fail:;
                                goto retry;
                        }
                }
-               /* FIXME: invalidate the connection? */
                rs->sr_err = LDAP_SERVER_DOWN;
-               freeconn = 1;
                goto fail;
        }
 
@@ -307,6 +417,10 @@ finish:;
                LDAP_FREE( match.bv_val );
        }
 
+       if ( !BER_BVISNULL( &filter ) && filter.bv_val != op->ors_filterstr.bv_val ) {
+               op->o_tmpfree( filter.bv_val, op->o_tmpmemctx );
+       }
+
        if ( rs->sr_text ) {
                if ( !dontfreetext ) {
                        LDAP_FREE( (char *)rs->sr_text );