add support for VERSION, TIMEOUT and NETWORK_TIMEOUT in ldap.conf

[openldap] / libraries / libldap / search.c

diff --git a/libraries/libldap/search.c b/libraries/libldap/search.c
index 83202ace806b531c6bec2adb09022ee2c83ba726..762bfd2fe7abd4999fd9365d75f72dcea8d9c7a2 100644 (file)
--- a/libraries/libldap/search.c
+++ b/libraries/libldap/search.c
@@ -1,7 +1,7 @@
 /* $OpenLDAP$ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *
- * Copyright 1998-2005 The OpenLDAP Foundation.
+ * Copyright 1998-2006 The OpenLDAP Foundation.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -138,7 +138,7 @@ ldap_search_ext_s(
                return( rc );
        }
 
-       rc = ldap_result( ld, msgid, 1, timeout, res );
+       rc = ldap_result( ld, msgid, LDAP_MSG_ALL, timeout, res );
 
        if( rc <= 0 ) {
                /* error(-1) or timeout(0) */
@@ -298,6 +298,32 @@ ldap_build_search_req(
                return( NULL );
        }
 
+#ifdef LDAP_DEBUG
+       if ( ldap_debug & LDAP_DEBUG_ARGS ) {
+               char    buf[ BUFSIZ ] = { ' ', '*', '\0' };
+
+               if ( attrs != NULL ) {
+                       char    *ptr;
+                       int     i;
+
+                       for ( ptr = buf, i = 0;
+                               attrs[ i ] != NULL && ptr < &buf[ sizeof( buf ) ];
+                               i++ )
+                       {
+                               ptr += snprintf( ptr, sizeof( buf ) - ( ptr - buf ),
+                                       " %s", attrs[ i ] );
+                       }
+
+                       if ( ptr >= &buf[ sizeof( buf ) ] ) {
+                               AC_MEMCPY( &buf[ sizeof( buf ) - STRLENOF( "...(truncated)" ) - 1 ],
+                                       "...(truncated)", STRLENOF( "...(truncated)" ) + 1 );
+                       } 
+               }
+
+               Debug( LDAP_DEBUG_ARGS, "ldap_build_search_req ATTRS:%s\n", buf, 0, 0 );
+       }
+#endif /* LDAP_DEBUG */
+
        if ( ber_printf( ber, /*{*/ "{v}N}", attrs ) == -1 ) {
                ld->ld_errno = LDAP_ENCODING_ERROR;
                ber_free( ber, 1 );
@@ -331,7 +357,7 @@ ldap_search_st(
            == -1 )
                return( ld->ld_errno );
 
-       if ( ldap_result( ld, msgid, 1, timeout, res ) == -1 )
+       if ( ldap_result( ld, msgid, LDAP_MSG_ALL, timeout, res ) == -1 )
                return( ld->ld_errno );
 
        if ( ld->ld_errno == LDAP_TIMEOUT ) {
@@ -359,59 +385,110 @@ ldap_search_s(
            == -1 )
                return( ld->ld_errno );
 
-       if ( ldap_result( ld, msgid, 1, (struct timeval *) NULL, res ) == -1 )
+       if ( ldap_result( ld, msgid, LDAP_MSG_ALL, (struct timeval *) NULL, res ) == -1 )
                return( ld->ld_errno );
 
        return( ldap_result2error( ld, *res, 0 ) );
 }
 
+static char escape[128] = {
+       1, 1, 1, 1, 1, 1, 1, 1,
+       1, 1, 1, 1, 1, 1, 1, 1,
+       1, 1, 1, 1, 1, 1, 1, 1,
+       1, 1, 1, 1, 1, 1, 1, 1,
+
+       0, 0, 0, 0, 0, 0, 0, 0,
+       1, 1, 1, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0,
+
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 1, 0, 0, 0,
+
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 0,
+       0, 0, 0, 0, 0, 0, 0, 1
+};
+#define        NEEDFLTESCAPE(c)        ((c) & 0x80 || escape[ (unsigned)(c) ])
+
+/*
+ * compute the length of the escaped value
+ */
+ber_len_t
+ldap_bv2escaped_filter_value_len( struct berval *in )
+{
+       ber_len_t       i, l;
+
+       assert( in != NULL );
+
+       if ( in->bv_len == 0 ) {
+               return 0;
+       }
+
+       for( l = 0, i = 0; i < in->bv_len; l++, i++ ) {
+               char c = in->bv_val[ i ];
+               if ( NEEDFLTESCAPE( c ) ) {
+                       l += 2;
+               }
+       }
+
+       return l;
+}
+
 int
 ldap_bv2escaped_filter_value( struct berval *in, struct berval *out )
 {
-       char c;
-       ber_len_t i;
-       static char escape[128] = {
-               1, 1, 1, 1, 1, 1, 1, 1,
-               1, 1, 1, 1, 1, 1, 1, 1,
-               1, 1, 1, 1, 1, 1, 1, 1,
-               1, 1, 1, 1, 1, 1, 1, 1,
-
-               1, 1, 1, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 0,
-               0, 0, 0, 0, 0, 0, 0, 1
-       };
-
-       out->bv_len = 0;
-       out->bv_val = NULL;
-
-       if( in->bv_len == 0 ) return 0;
+       return ldap_bv2escaped_filter_value_x( in, out, 0, NULL );
+}
+
+int
+ldap_bv2escaped_filter_value_x( struct berval *in, struct berval *out, int inplace, void *ctx )
+{
+       ber_len_t       i, l;
+
+       assert( in != NULL );
+       assert( out != NULL );
+
+       BER_BVZERO( out );
+
+       if ( in->bv_len == 0 ) {
+               return 0;
+       }
 
        /* assume we'll escape everything */
-       out->bv_val = LDAP_MALLOC( 3 * in->bv_len + 1 );
-       if( out->bv_val == NULL ) return -1;
+       l = ldap_bv2escaped_filter_value_len( in );
+       if ( l == in->bv_len ) {
+               if ( inplace ) {
+                       *out = *in;
+               } else {
+                       ber_dupbv( out, in );
+               }
+               return 0;
+       }
+       out->bv_val = LDAP_MALLOCX( l + 1, ctx );
+       if ( out->bv_val == NULL ) {
+               return -1;
+       }
 
-       for( i=0; i<in->bv_len; i++ ) {
-               if (c & 0x80 || escape[in->bv_val[i]]) {
+       for ( i = 0; i < in->bv_len; i++ ) {
+               char c = in->bv_val[ i ];
+               if ( NEEDFLTESCAPE( c ) ) {
+                       assert( out->bv_len < l - 2 );
                        out->bv_val[out->bv_len++] = '\\';
                        out->bv_val[out->bv_len++] = "0123456789ABCDEF"[0x0f & (c>>4)];
                        out->bv_val[out->bv_len++] = "0123456789ABCDEF"[0x0f & c];
+
                } else {
+                       assert( out->bv_len < l );
                        out->bv_val[out->bv_len++] = c;
                }
        }
 
        out->bv_val[out->bv_len] = '\0';
+
        return 0;
 }