X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fdn.c;h=a20d5a2cb5c845aff9bf52cb8487299ccc42ed61;hb=ae63be3894c799771d0ccabec1e376c7478cd263;hp=4f28d164b8989490de6b653ce3aa95a3328986c9;hpb=9b8a5036dd0d52242e05e3348088ea3365e10149;p=openldap diff --git a/servers/slapd/dn.c b/servers/slapd/dn.c index 4f28d164b8..a20d5a2cb5 100644 --- a/servers/slapd/dn.c +++ b/servers/slapd/dn.c @@ -1,4 +1,9 @@ /* dn.c - routines for dealing with distinguished names */ +/* $OpenLDAP$ */ +/* + * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved. + * COPYING RESTRICTIONS APPLY, see COPYRIGHT file + */ #include "portable.h" @@ -9,70 +14,102 @@ #include #include +#include "ldap_pvt.h" + #include "slap.h" -#define B4TYPE 0 -#define INTYPE 1 -#define B4EQUAL 2 -#define B4VALUE 3 -#define INVALUE 4 -#define INQUOTEDVALUE 5 -#define B4SEPARATOR 6 +#define B4LEADTYPE 0 +#define B4TYPE 1 +#define INOIDTYPE 2 +#define INKEYTYPE 3 +#define B4EQUAL 4 +#define B4VALUE 5 +#define INVALUE 6 +#define INQUOTEDVALUE 7 +#define B4SEPARATOR 8 /* - * dn_normalize - put dn into a canonical format. the dn is - * normalized in place, as well as returned. + * dn_validate - validate and compress dn. the dn is + * compressed in place are returned if valid. */ char * -dn_normalize( char *dn ) +dn_validate( char *dn ) { char *d, *s; int state, gotesc; - /* Debug( LDAP_DEBUG_TRACE, "=> dn_normalize \"%s\"\n", dn, 0, 0 ); */ - gotesc = 0; - state = B4TYPE; + state = B4LEADTYPE; for ( d = s = dn; *s; s++ ) { switch ( state ) { + case B4LEADTYPE: case B4TYPE: - if ( ! SPACE( *s ) ) { - state = INTYPE; + if ( OID_LEADCHAR(*s) ) { + state = INOIDTYPE; + *d++ = *s; + } else if ( ATTR_LEADCHAR(*s) ) { + state = INKEYTYPE; + *d++ = *s; + } else if ( ! ASCII_SPACE( *s ) ) { + dn = NULL; + state = INKEYTYPE; *d++ = *s; } break; - case INTYPE: - if ( *s == '=' ) { + + case INOIDTYPE: + if ( OID_CHAR(*s) ) { + *d++ = *s; + } else if ( *s == '=' ) { + state = B4VALUE; + *d++ = *s; + } else if ( ASCII_SPACE( *s ) ) { + state = B4EQUAL; + } else { + dn = NULL; + *d++ = *s; + } + break; + + case INKEYTYPE: + if ( ATTR_CHAR(*s) ) { + *d++ = *s; + } else if ( *s == '=' ) { state = B4VALUE; *d++ = *s; - } else if ( SPACE( *s ) ) { + } else if ( ASCII_SPACE( *s ) ) { state = B4EQUAL; } else { + dn = NULL; *d++ = *s; } break; + case B4EQUAL: if ( *s == '=' ) { state = B4VALUE; *d++ = *s; - } else if ( ! SPACE( *s ) ) { + } else if ( ! ASCII_SPACE( *s ) ) { /* not a valid dn - but what can we do here? */ *d++ = *s; + dn = NULL; } break; + case B4VALUE: if ( *s == '"' ) { state = INQUOTEDVALUE; *d++ = *s; - } else if ( ! SPACE( *s ) ) { + } else if ( ! ASCII_SPACE( *s ) ) { state = INVALUE; *d++ = *s; } break; + case INVALUE: - if ( !gotesc && SEPARATOR( *s ) ) { - while ( SPACE( *(d - 1) ) ) + if ( !gotesc && RDN_SEPARATOR( *s ) ) { + while ( ASCII_SPACE( *(d - 1) ) ) d--; state = B4TYPE; if ( *s == '+' ) { @@ -80,36 +117,41 @@ dn_normalize( char *dn ) } else { *d++ = ','; } - } else if ( gotesc && !NEEDSESCAPE( *s ) && - !SEPARATOR( *s ) ) { + } else if ( gotesc && !RDN_NEEDSESCAPE( *s ) && + !RDN_SEPARATOR( *s ) ) { *--d = *s; d++; } else { *d++ = *s; } break; + case INQUOTEDVALUE: if ( !gotesc && *s == '"' ) { state = B4SEPARATOR; *d++ = *s; - } else if ( gotesc && !NEEDSESCAPE( *s ) ) { + } else if ( gotesc && !RDN_NEEDSESCAPE( *s ) ) { *--d = *s; d++; } else { *d++ = *s; } break; + case B4SEPARATOR: - if ( SEPARATOR( *s ) ) { + if ( RDN_SEPARATOR( *s ) ) { state = B4TYPE; *d++ = *s; } break; + default: + dn = NULL; Debug( LDAP_DEBUG_ANY, - "dn_normalize - unknown state %d\n", state, 0, 0 ); + "dn_validate - unknown state %d\n", state, 0, 0 ); break; } + if ( *s == '\\' ) { gotesc = 1; } else { @@ -118,28 +160,38 @@ dn_normalize( char *dn ) } *d = '\0'; - /* Debug( LDAP_DEBUG_TRACE, "<= dn_normalize \"%s\"\n", dn, 0, 0 ); */ + if( gotesc ) { + /* shouldn't be left in escape */ + dn = NULL; + } + + /* check end state */ + switch( state ) { + case B4LEADTYPE: /* looking for first type */ + case B4SEPARATOR: /* looking for separator */ + case INVALUE: /* inside value */ + break; + default: + dn = NULL; + } + return( dn ); } /* - * dn_normalize_case - put dn into a canonical form suitable for storing + * dn_normalize - put dn into a canonical form suitable for storing * in a hash database. this involves normalizing the case as well as - * the format. the dn is normalized in place as well as returned. + * the format. the dn is normalized in place as well as returned if valid. */ char * -dn_normalize_case( char *dn ) +dn_normalize( char *dn ) { - char *s; - - /* normalize format */ - dn_normalize( dn ); + /* upper case it */ + ldap_pvt_str2upper( dn ); - /* normalize case */ - for ( s = dn; *s; s++ ) { - *s = TOUPPER( (unsigned char) *s ); - } + /* validate and compress dn */ + dn = dn_validate( dn ); return( dn ); } @@ -151,17 +203,17 @@ dn_normalize_case( char *dn ) char * dn_parent( Backend *be, - char *dn + const char *dn ) { - char *s; + const char *s; int inquote; if( dn == NULL ) { return NULL; } - while(*dn && SPACE(*dn)) { + while(*dn != '\0' && ASCII_SPACE(*dn)) { dn++; } @@ -174,25 +226,7 @@ dn_parent( } /* - * no =, assume it is a dns name, like blah@some.domain.name - * if the blah@ part is there, return some.domain.name. if - * it's just some.domain.name, return domain.name. - */ - if ( strchr( dn, '=' ) == NULL ) { - if ( (s = strchr( dn, '@' )) == NULL ) { - if ( (s = strchr( dn, '.' )) == NULL ) { - return( NULL ); - } - } - if ( *(s + 1) == '\0' ) { - return( NULL ); - } else { - return( ch_strdup( &s[1] ) ); - } - } - - /* - * else assume it is an X.500-style name, which looks like + * assume it is an X.500-style name, which looks like * foo=bar,sha=baz,... */ @@ -211,7 +245,7 @@ dn_parent( } else { if ( *s == '"' ) { inquote = 1; - } else if ( DNSEPARATOR( *s ) ) { + } else if ( DN_SEPARATOR( *s ) ) { return( ch_strdup( &s[1] ) ); } } @@ -222,48 +256,28 @@ dn_parent( char * dn_rdn( Backend *be, - char *dn ) + const char *dn_in ) { - char *s; + char *dn, *s; int inquote; - if( dn == NULL ) { + if( dn_in == NULL ) { return NULL; } - while(*dn && SPACE(*dn)) { - dn++; + while(*dn_in && ASCII_SPACE(*dn_in)) { + dn_in++; } - if( *dn == '\0' ) { + if( *dn_in == '\0' ) { return( NULL ); } - if ( be != NULL && be_issuffix( be, dn ) ) { + if ( be != NULL && be_issuffix( be, dn_in ) ) { return( NULL ); } - dn = ch_strdup( dn ); - - /* - * no =, assume it is a dns name, like blah@some.domain.name - * if the blah@ part is there, return some.domain.name. if - * it's just some.domain.name, return domain.name. - */ - if ( strchr( dn, '=' ) == NULL ) { - if ( (s = strchr( dn, '@' )) == NULL ) { - if ( (s = strchr( dn, '.' )) == NULL ) { - return( dn ); - } - } - *s = '\0'; - return( dn ); - } - - /* - * else assume it is an X.500-style name, which looks like - * foo=bar,sha=baz,... - */ + dn = ch_strdup( dn_in ); inquote = 0; @@ -281,7 +295,7 @@ char * dn_rdn( } else { if ( *s == '"' ) { inquote = 1; - } else if ( DNSEPARATOR( *s ) ) { + } else if ( DN_SEPARATOR( *s ) ) { *s = '\0'; return( dn ); } @@ -291,6 +305,33 @@ char * dn_rdn( return( dn ); } + +/* + * return a charray of all subtrees to which the DN resides in + */ +char **dn_subtree( + Backend *be, + const char *dn ) +{ + char *child, *parent; + char **subtree = NULL; + + child = ch_strdup( dn ); + + do { + charray_add( &subtree, child ); + + parent = dn_parent( be, child ); + + free( child ); + + child = parent; + } while ( child != NULL ); + + return subtree; +} + + /* * dn_issuffix - tells whether suffix is a suffix of dn. both dn * and suffix must be normalized. @@ -298,8 +339,8 @@ char * dn_rdn( int dn_issuffix( - char *dn, - char *suffix + const char *dn, + const char *suffix ) { int dnlen, suffixlen; @@ -318,32 +359,6 @@ dn_issuffix( return( strcmp( dn + dnlen - suffixlen, suffix ) == 0 ); } -/* - * dn_type - tells whether the given dn is an X.500 thing or DNS thing - * returns (defined in slap.h): DN_DNS dns-style thing - * DN_X500 x500-style thing - */ - -int -dn_type( char *dn ) -{ - return( strchr( dn, '=' ) == NULL ? DN_DNS : DN_X500 ); -} - -char * -dn_upcase( char *dn ) -{ - char *s; - - /* normalize case */ - for ( s = dn; *s; s++ ) { - *s = TOUPPER( (unsigned char) *s ); - } - - return( dn ); -} - - /* * get_next_substring(), rdn_attr_type(), rdn_attr_value(), and * build_new_dn(). @@ -366,7 +381,7 @@ dn_upcase( char *dn ) */ static char * -get_next_substring( char * s, char d ) +get_next_substring( const char * s, char d ) { char *str, *r; @@ -375,11 +390,9 @@ get_next_substring( char * s, char d ) /* Skip leading spaces */ - while ( *s && SPACE(*s) ) { - + while ( *s && ASCII_SPACE(*s) ) { s++; - - }/* while ( *s && SPACE(*s) ) */ + } /* Copy word */ @@ -391,13 +404,13 @@ get_next_substring( char * s, char d ) *str++ = *s++; - }/* while ( *s && (*s != d) ) */ + } *str = '\0'; return r; -}/* char * get_word() */ +} /* rdn_attr_type: @@ -409,12 +422,10 @@ get_next_substring( char * s, char d ) * memory. The returned string will be null-terminated. */ -char * rdn_attr_type( char * s ) +char * rdn_attr_type( const char * s ) { - return get_next_substring( s, '=' ); - -}/* char * rdn_attr_type() */ +} /* rdn_attr_value: @@ -427,20 +438,25 @@ char * rdn_attr_type( char * s ) */ char * -rdn_attr_value( char * rdn ) +rdn_attr_value( const char * rdn ) { - char *str; + const char *str; if ( (str = strchr( rdn, '=' )) != NULL ) { - return get_next_substring(++str, '\0'); - - }/* if ( (str = strpbrk( rdn, "=" )) != NULL ) */ + } return NULL; -}/* char * rdn_attr_value() */ +} + + +int rdn_validate( const char * rdn ) +{ + /* just a simple check for now */ + return strchr( rdn, '=' ) != NULL; +} /* build_new_dn: @@ -452,47 +468,20 @@ rdn_attr_value( char * rdn ) */ void -build_new_dn( char ** new_dn, char *e_dn, char * p_dn, char * newrdn ) +build_new_dn( char ** new_dn, + const char *e_dn, + const char * p_dn, + const char * newrdn ) { if ( p_dn == NULL ) { - *new_dn = ch_strdup( newrdn ); return; - } *new_dn = (char *) ch_malloc( strlen( p_dn ) + strlen( newrdn ) + 3 ); - if ( dn_type( e_dn ) == DN_X500 ) { - strcpy( *new_dn, newrdn ); strcat( *new_dn, "," ); strcat( *new_dn, p_dn ); - - } else { - - char *s; - char sep[2]; - - strcpy( *new_dn, newrdn ); - s = strchr( newrdn, '\0' ); - s--; - - if ( (*s != '.') && (*s != '@') ) { - - if ( (s = strpbrk( e_dn, ".@" )) != NULL ) { - - sep[0] = *s; - sep[1] = '\0'; - strcat( *new_dn, sep ); - - }/* if ( (s = strpbrk( dn, ".@" )) != NULL ) */ - - }/* if ( *s != '.' && *s != '@' ) */ - - strcat( *new_dn, p_dn ); - - }/* if ( dn_type( e_dn ) == DN_X500 ) {}else */ - -}/* void build_new_dn() */ +}