Fix extensible filters

[openldap] / libraries / libldap / getdn.c

diff --git a/libraries/libldap/getdn.c b/libraries/libldap/getdn.c
index 5f3ce02d8e057fd45df7be7486d17e24d68c8309..76bc499463702d1adf5de93f0be0842b549c8024 100644 (file)
--- a/libraries/libldap/getdn.c
+++ b/libraries/libldap/getdn.c
@@ -20,6 +20,7 @@
 #include <ac/time.h>
 
 #include "ldap-int.h"
+#include "ldap_schema.h"
 
 /* extension to UFN that turns trailing "dc=value" rdns in DNS style,
  * e.g. "ou=People,dc=openldap,dc=org" => "People, openldap.org" */
@@ -353,25 +354,21 @@ ldap_dn_normalize( const char *dnin, unsigned fin, char **dnout, unsigned fout )
  */
 #define LDAP_DN_ASCII_SPACE(c) \
        ( (c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r' )
-#define LDAP_DN_ASCII_LOWER(c)         ( (c) >= 'a' && (c) <= 'z' )
-#define LDAP_DN_ASCII_UPPER(c)         ( (c) >= 'A' && (c) <= 'Z' )
-#define LDAP_DN_ASCII_ALPHA(c) \
-       ( LDAP_DN_ASCII_LOWER(c) || LDAP_DN_ASCII_UPPER(c) )
-#define LDAP_DN_ASCII_DIGIT(c)         ( (c) >= '0' && (c) <= '9' )
-#define LDAP_DN_ASCII_LCASE_HEXALPHA(c)        ( (c) >= 'a' && (c) <= 'f' )
-#define LDAP_DN_ASCII_UCASE_HEXALPHA(c)        ( (c) >= 'A' && (c) <= 'F' )
-#define LDAP_DN_ASCII_HEXDIGIT(c) \
-       ( LDAP_DN_ASCII_DIGIT(c) \
-         || LDAP_DN_ASCII_LCASE_HEXALPHA(c) \
-         || LDAP_DN_ASCII_UCASE_HEXALPHA(c) )
-#define LDAP_DN_ASCII_ALNUM(c) \
-       ( LDAP_DN_ASCII_ALPHA(c) || LDAP_DN_ASCII_DIGIT(c) )
+#define LDAP_DN_ASCII_LOWER(c)         LDAP_LOWER(c)
+#define LDAP_DN_ASCII_UPPER(c)         LDAP_UPPER(c)
+#define LDAP_DN_ASCII_ALPHA(c)         LDAP_ALPHA(c)
+
+#define LDAP_DN_ASCII_DIGIT(c)         LDAP_DIGIT(c)
+#define LDAP_DN_ASCII_LCASE_HEXALPHA(c)        LDAP_HEXLOWER(c)
+#define LDAP_DN_ASCII_UCASE_HEXALPHA(c)        LDAP_HEXUPPER(c)
+#define LDAP_DN_ASCII_HEXDIGIT(c)      LDAP_HEX(c)
+#define LDAP_DN_ASCII_ALNUM(c)         LDAP_ALNUM(c)
 #define LDAP_DN_ASCII_PRINTABLE(c)     ( (c) >= ' ' && (c) <= '~' )
 
 /* attribute type */
-#define LDAP_DN_OID_LEADCHAR(c)                ( LDAP_DN_ASCII_DIGIT(c) )
-#define LDAP_DN_DESC_LEADCHAR(c)       ( LDAP_DN_ASCII_ALPHA(c) )
-#define LDAP_DN_DESC_CHAR(c)           ( LDAP_DN_ASCII_ALNUM(c) || (c) == '-' )
+#define LDAP_DN_OID_LEADCHAR(c)                LDAP_DIGIT(c)
+#define LDAP_DN_DESC_LEADCHAR(c)       LDAP_ALPHA(c)
+#define LDAP_DN_DESC_CHAR(c)           LDAP_LDH(c)
 #define LDAP_DN_LANG_SEP(c)            ( (c) == ';' )
 #define LDAP_DN_ATTRDESC_CHAR(c) \
        ( LDAP_DN_DESC_CHAR(c) || LDAP_DN_LANG_SEP(c) )
@@ -463,7 +460,7 @@ ldap_dn_normalize( const char *dnin, unsigned fin, char **dnout, unsigned fout )
 #define        LDAP_DC_ATTR    "dc"
 #define        LDAP_DC_ATTRU   "DC"
 #define LDAP_DN_IS_RDN_DC( r ) \
-       ( (r) && (r)[0][0] && !(r)[1] \
+       ( (r) && (r)[0][0] && !(r)[0][1] \
          && ((r)[0][0]->la_flags == LDAP_AVA_STRING) \
          && ((r)[0][0]->la_attr.bv_len == 2) \
          && (((r)[0][0]->la_attr.bv_val[0] == LDAP_DC_ATTR[0]) \
@@ -505,14 +502,18 @@ ldapava_new( const struct berval *attr, const struct berval *val,
        assert( attr );
        assert( val );
 
-       ava = LDAP_MALLOC( sizeof( LDAPAVA ) );
+       ava = LDAP_MALLOC( sizeof( LDAPAVA ) + attr->bv_len + 1 );
        
        /* should we test it? */
        if ( ava == NULL ) {
                return( NULL );
        }
 
-       ava->la_attr = *attr;
+       ava->la_attr.bv_len = attr->bv_len;
+       ava->la_attr.bv_val = (char *)(ava+1);
+       AC_MEMCPY( ava->la_attr.bv_val, attr->bv_val, attr->bv_len );
+       ava->la_attr.bv_val[attr->bv_len] = '\0';
+
        ava->la_value = *val;
        ava->la_flags = flags;
 
@@ -533,7 +534,10 @@ ldap_avafree( LDAPAVA *ava )
        assert( ava->la_private == NULL );
 #endif
 
+#if 0
+       /* la_attr is now contiguous with ava, not freed separately */
        free( ava->la_attr.bv_val );
+#endif
        free( ava->la_value.bv_val );
 
        LDAP_FREE( ava );
@@ -647,7 +651,6 @@ ldap_str2dn( const char *str, LDAPDN **dn, unsigned flags )
        }
 
        for ( ; p[ 0 ]; p++ ) {
-               LDAPDN          *dn;
                int             err;
                
                err = ldap_str2rdn( p, &newRDN, &p, flags );
@@ -702,7 +705,7 @@ ldap_str2dn( const char *str, LDAPDN **dn, unsigned flags )
                        } else {
                                int i;
 
-                               newDN[0] = (LDAPRDN **)newDN+1;
+                               newDN[0] = (LDAPRDN **)(newDN+1);
 
                                if ( LDAP_DN_DCE( flags ) ) {
                                        /* add in reversed order */
@@ -878,23 +881,14 @@ ldap_str2rdn( const char *str, LDAPRDN **rdn, const char **n, unsigned flags )
                
                case B4OIDATTRTYPE: {
                        int             err = LDAP_SUCCESS;
-                       char            *type;
                        
-                       type = parse_numericoid( &p, &err, 0 );
-                       if ( type == NULL ) {
-                               goto parsing_error;
-                       }
+                       attrType.bv_val = parse_numericoid( &p, &err,
+                               LDAP_SCHEMA_SKIP);
 
-                       if ( flags & LDAP_DN_SKIP ) {
-                               /*
-                                * FIXME: hack for skipping a rdn; 
-                                * need a cleaner solution
-                                */
-                               LDAP_FREE( type );
-
-                       } else {
-                               ber_str2bv( type, 0, 0, &attrType );
+                       if ( err != LDAP_SUCCESS ) {
+                               goto parsing_error;
                        }
+                       attrType.bv_len = p - attrType.bv_val;
 
                        attrTypeEncoding = LDAP_AVA_BINARY;
 
@@ -961,11 +955,7 @@ ldap_str2rdn( const char *str, LDAPRDN **rdn, const char **n, unsigned flags )
                                break;
                        }
 
-                       attrType.bv_val = LDAP_STRNDUP( startPos, len );
-                       if ( attrType.bv_val == NULL ) {
-                               rc = LDAP_NO_MEMORY;
-                               goto parsing_error;
-                       }
+                       attrType.bv_val = (char *)startPos;
                        attrType.bv_len = len;
 
                        break;
@@ -1157,7 +1147,7 @@ ldap_str2rdn( const char *str, LDAPRDN **rdn, const char **n, unsigned flags )
                                        } else {
                                                int i;
 
-                                               newRDN[0] = (LDAPAVA**) newRDN+1;
+                                               newRDN[0] = (LDAPAVA**)(newRDN+1);
 
                                                for (i=0; i<navas; i++)
                                                        newRDN[0][i] = tmpRDN[i];
@@ -1183,12 +1173,10 @@ ldap_str2rdn( const char *str, LDAPRDN **rdn, const char **n, unsigned flags )
                        goto parsing_error;
                }
        }
+       *n = p;
        
 parsing_error:;
        /* They are set to NULL after they're used in an AVA */
-       if ( attrType.bv_val ) {
-               free( attrType.bv_val );
-       }
 
        if ( attrValue.bv_val ) {
                free( attrValue.bv_val );
@@ -1200,7 +1188,7 @@ parsing_error:;
 return_result:;
 
        Debug( LDAP_DEBUG_TRACE, "<= ldap_str2rdn(%*s)=%d\n", 
-                       *n - p, str, rc );
+                       p - str, str, rc );
        if ( rdn ) {
                *rdn = newRDN;
        }
@@ -3067,7 +3055,8 @@ got_funcs:
 
        }
 
-       Debug( LDAP_DEBUG_TRACE, "<= ldap_dn2bv(%s,%u)=%d\n", bv->bv_val, flags, rc );
+       Debug( LDAP_DEBUG_TRACE, "<= ldap_dn2bv(%s,%u)=%d\n",
+               bv->bv_val, flags, rc );
 return_results:;
        return( rc );
 }