Diff for /servers/slapd/dn.c between versions 1.20 and 1.20.2.4

version 1.20, 1999/07/22 17:06:56 version 1.20.2.4, 2000/06/17 16:16:58
Line 1 Line 1
 /* dn.c - routines for dealing with distinguished names */  /* 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"  #include "portable.h"
   
Line 9 Line 14
 #include <ac/string.h>  #include <ac/string.h>
 #include <ac/time.h>  #include <ac/time.h>
   
   #include "ldap_pvt.h"
   
 #include "slap.h"  #include "slap.h"
   
 #define B4LEADTYPE              0  #define B4LEADTYPE              0
Line 22 Line 29
 #define B4SEPARATOR             8  #define B4SEPARATOR             8
   
 /*  /*
  * dn_normalize - put dn into a canonical format.  the dn is   * dn_validate - validate and compress dn.  the dn is
  * normalized in place, as well as returned if valid.   * compressed in place are returned if valid.
  */   */
   
 char *  char *
 dn_normalize( char *dn )  dn_validate( char *dn )
 {  {
         char    *d, *s;          char    *d, *s;
         int     state, gotesc;          int     state, gotesc;
Line 38  dn_normalize( char *dn ) Line 45  dn_normalize( char *dn )
                 switch ( state ) {                  switch ( state ) {
                 case B4LEADTYPE:                  case B4LEADTYPE:
                 case B4TYPE:                  case B4TYPE:
                         if ( LEADOIDCHAR(*s) ) {                          if ( OID_LEADCHAR(*s) ) {
                                 state = INOIDTYPE;                                  state = INOIDTYPE;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( LEADKEYCHAR(*s) ) {                          } else if ( ATTR_LEADCHAR(*s) ) {
                                 state = INKEYTYPE;                                  state = INKEYTYPE;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( ! SPACE( *s ) ) {                          } else if ( ! ASCII_SPACE( *s ) ) {
                                 dn = NULL;                                  dn = NULL;
                                 state = INKEYTYPE;                                  state = INKEYTYPE;
                                 *d++ = *s;                                  *d++ = *s;
Line 52  dn_normalize( char *dn ) Line 59  dn_normalize( char *dn )
                         break;                          break;
   
                 case INOIDTYPE:                  case INOIDTYPE:
                         if ( OIDCHAR(*s) ) {                          if ( OID_CHAR(*s) ) {
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( *s == '=' ) {                          } else if ( *s == '=' ) {
                                 state = B4VALUE;                                  state = B4VALUE;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( SPACE( *s ) ) {                          } else if ( ASCII_SPACE( *s ) ) {
                                 state = B4EQUAL;                                  state = B4EQUAL;
                         } else {                          } else {
                                 dn = NULL;                                  dn = NULL;
Line 66  dn_normalize( char *dn ) Line 73  dn_normalize( char *dn )
                         break;                          break;
   
                 case INKEYTYPE:                  case INKEYTYPE:
                         if ( KEYCHAR(*s) ) {                          if ( ATTR_CHAR(*s) ) {
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( *s == '=' ) {                          } else if ( *s == '=' ) {
                                 state = B4VALUE;                                  state = B4VALUE;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( SPACE( *s ) ) {                          } else if ( ASCII_SPACE( *s ) ) {
                                 state = B4EQUAL;                                  state = B4EQUAL;
                         } else {                          } else {
                                 dn = NULL;                                  dn = NULL;
Line 83  dn_normalize( char *dn ) Line 90  dn_normalize( char *dn )
                         if ( *s == '=' ) {                          if ( *s == '=' ) {
                                 state = B4VALUE;                                  state = B4VALUE;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( ! SPACE( *s ) ) {                          } else if ( ! ASCII_SPACE( *s ) ) {
                                 /* not a valid dn - but what can we do here? */                                  /* not a valid dn - but what can we do here? */
                                 *d++ = *s;                                  *d++ = *s;
                                 dn = NULL;                                  dn = NULL;
Line 94  dn_normalize( char *dn ) Line 101  dn_normalize( char *dn )
                         if ( *s == '"' ) {                          if ( *s == '"' ) {
                                 state = INQUOTEDVALUE;                                  state = INQUOTEDVALUE;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( ! SPACE( *s ) ) {                           } else if ( ! ASCII_SPACE( *s ) ) { 
                                 state = INVALUE;                                  state = INVALUE;
                                 *d++ = *s;                                  *d++ = *s;
                         }                          }
                         break;                          break;
   
                 case INVALUE:                  case INVALUE:
                         if ( !gotesc && SEPARATOR( *s ) ) {                          if ( !gotesc && RDN_SEPARATOR( *s ) ) {
                                 while ( SPACE( *(d - 1) ) )                                  while ( ASCII_SPACE( *(d - 1) ) )
                                         d--;                                          d--;
                                 state = B4TYPE;                                  state = B4TYPE;
                                 if ( *s == '+' ) {                                  if ( *s == '+' ) {
Line 110  dn_normalize( char *dn ) Line 117  dn_normalize( char *dn )
                                 } else {                                  } else {
                                         *d++ = ',';                                          *d++ = ',';
                                 }                                  }
                         } else if ( gotesc && !NEEDSESCAPE( *s ) &&                          } else if ( gotesc && !RDN_NEEDSESCAPE( *s ) &&
                             !SEPARATOR( *s ) ) {                              !RDN_SEPARATOR( *s ) ) {
                                 *--d = *s;                                  *--d = *s;
                                 d++;                                  d++;
                         } else {                          } else {
Line 123  dn_normalize( char *dn ) Line 130  dn_normalize( char *dn )
                         if ( !gotesc && *s == '"' ) {                          if ( !gotesc && *s == '"' ) {
                                 state = B4SEPARATOR;                                  state = B4SEPARATOR;
                                 *d++ = *s;                                  *d++ = *s;
                         } else if ( gotesc && !NEEDSESCAPE( *s ) ) {                          } else if ( gotesc && !RDN_NEEDSESCAPE( *s ) ) {
                                 *--d = *s;                                  *--d = *s;
                                 d++;                                  d++;
                         } else {                          } else {
                                 *d++ = *s;                                  *d++ = *s;
                         }                          }
                         break;                          break;
   
                 case B4SEPARATOR:                  case B4SEPARATOR:
                         if ( SEPARATOR( *s ) ) {                          if ( RDN_SEPARATOR( *s ) ) {
                                 state = B4TYPE;                                  state = B4TYPE;
                                 *d++ = *s;                                  *d++ = *s;
                         }                          }
                         break;                          break;
   
                 default:                  default:
                         dn = NULL;                          dn = NULL;
                         Debug( LDAP_DEBUG_ANY,                          Debug( LDAP_DEBUG_ANY,
                             "dn_normalize - unknown state %d\n", state, 0, 0 );                              "dn_validate - unknown state %d\n", state, 0, 0 );
                         break;                          break;
                 }                  }
   
                 if ( *s == '\\' ) {                  if ( *s == '\\' ) {
                         gotesc = 1;                          gotesc = 1;
                 } else {                  } else {
Line 169  dn_normalize( char *dn ) Line 179  dn_normalize( char *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   * in a hash database.  this involves normalizing the case as well as
  * the format.  the dn is normalized in place as well as returned if valid.   * the format.  the dn is normalized in place as well as returned if valid.
  */   */
   
 char *  char *
 dn_normalize_case( char *dn )  dn_normalize( char *dn )
 {  {
         str2upper( dn );          /* upper case it */
           ldap_pvt_str2upper( dn );
   
         /* normalize format */          /* validate and compress dn */
         dn = dn_normalize( dn );          dn = dn_validate( dn );
   
         /* and upper case it */  
         return( dn );          return( dn );
 }  }
   
Line 193  dn_normalize_case( char *dn ) Line 203  dn_normalize_case( char *dn )
 char *  char *
 dn_parent(  dn_parent(
     Backend     *be,      Backend     *be,
     char        *dn      const char  *dn
 )  )
 {  {
         char    *s;          const char      *s;
         int     inquote;          int     inquote;
   
         if( dn == NULL ) {          if( dn == NULL ) {
                 return NULL;                  return NULL;
         }          }
   
         while(*dn && SPACE(*dn)) {          while(*dn != '\0' && ASCII_SPACE(*dn)) {
                 dn++;                  dn++;
         }          }
   
Line 216  dn_parent( Line 226  dn_parent(
         }          }
   
         /*          /*
          * no =, assume it is a dns name, like blah@some.domain.name           * assume it is an X.500-style name, which looks like
          * 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  
          * foo=bar,sha=baz,...           * foo=bar,sha=baz,...
          */           */
   
Line 253  dn_parent( Line 245  dn_parent(
                 } else {                  } else {
                         if ( *s == '"' ) {                          if ( *s == '"' ) {
                                 inquote = 1;                                  inquote = 1;
                         } else if ( DNSEPARATOR( *s ) ) {                          } else if ( DN_SEPARATOR( *s ) ) {
                                 return( ch_strdup( &s[1] ) );                                  return( ch_strdup( &s[1] ) );
                         }                          }
                 }                  }
Line 264  dn_parent( Line 256  dn_parent(
   
 char * dn_rdn(   char * dn_rdn( 
     Backend     *be,      Backend     *be,
     char        *dn )      const char  *dn_in )
 {  {
         char    *s;          char    *dn, *s;
         int     inquote;          int     inquote;
   
         if( dn == NULL ) {          if( dn_in == NULL ) {
                 return NULL;                  return NULL;
         }          }
   
         while(*dn && SPACE(*dn)) {          while(*dn_in && ASCII_SPACE(*dn_in)) {
                 dn++;                  dn_in++;
         }          }
   
         if( *dn == '\0' ) {          if( *dn_in == '\0' ) {
                 return( NULL );                  return( NULL );
         }          }
   
         if ( be != NULL && be_issuffix( be, dn ) ) {          if ( be != NULL && be_issuffix( be, dn_in ) ) {
                 return( NULL );                  return( NULL );
         }          }
   
         dn = ch_strdup( dn );          dn = ch_strdup( dn_in );
   
 #ifdef DNS_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 );  
         }  
 #endif  
   
         /*  
          * else assume it is an X.500-style name, which looks like  
          * foo=bar,sha=baz,...  
          */  
   
         inquote = 0;          inquote = 0;
   
Line 325  char * dn_rdn( Line 295  char * dn_rdn(
                 } else {                  } else {
                         if ( *s == '"' ) {                          if ( *s == '"' ) {
                                 inquote = 1;                                  inquote = 1;
                         } else if ( DNSEPARATOR( *s ) ) {                          } else if ( DN_SEPARATOR( *s ) ) {
                                 *s = '\0';                                  *s = '\0';
                                 return( dn );                                  return( dn );
                         }                          }
Line 335  char * dn_rdn( Line 305  char * dn_rdn(
         return( dn );          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   * dn_issuffix - tells whether suffix is a suffix of dn.  both dn
  * and suffix must be normalized.   * and suffix must be normalized.
Line 342  char * dn_rdn( Line 339  char * dn_rdn(
   
 int  int
 dn_issuffix(  dn_issuffix(
     char        *dn,      const char  *dn,
     char        *suffix      const char  *suffix
 )  )
 {  {
         int     dnlen, suffixlen;          int     dnlen, suffixlen;
Line 362  dn_issuffix( Line 359  dn_issuffix(
         return( strcmp( dn + dnlen - suffixlen, suffix ) == 0 );          return( strcmp( dn + dnlen - suffixlen, suffix ) == 0 );
 }  }
   
 #ifdef DNS_DN  
 /*  
  * 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 );  
 }  
 #endif  
   
 char *  
 str2upper( char *str )  
 {  
         char    *s;  
   
         /* normalize case */  
         for ( s = str; *s; s++ ) {  
                 *s = TOUPPER( (unsigned char) *s );  
         }  
   
         return( str );  
 }  
   
 char *  
 str2lower( char *str )  
 {  
         char    *s;  
   
         /* normalize case */  
         for ( s = str; *s; s++ ) {  
                 *s = TOLOWER( (unsigned char) *s );  
         }  
   
         return( str );  
 }  
   
   
 /*  /*
  * get_next_substring(), rdn_attr_type(), rdn_attr_value(), and   * get_next_substring(), rdn_attr_type(), rdn_attr_value(), and
  * build_new_dn().   * build_new_dn().
Line 425  str2lower( char *str ) Line 381  str2lower( char *str )
  */    */ 
   
 static char *   static char * 
 get_next_substring( char * s, char d )  get_next_substring( const char * s, char d )
 {  {
   
         char    *str, *r;          char    *str, *r;
Line 434  get_next_substring( char * s, char d ) Line 390  get_next_substring( char * s, char d )
   
         /* Skip leading spaces */          /* Skip leading spaces */
                   
         while ( *s && SPACE(*s) ) {          while ( *s && ASCII_SPACE(*s) ) {
               
                 s++;                  s++;
               
         }          }
                   
         /* Copy word */          /* Copy word */
Line 468  get_next_substring( char * s, char d ) Line 422  get_next_substring( char * s, char d )
  * memory. The returned string will be null-terminated.   * 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, '=' );          return get_next_substring( s, '=' );
   
 }  }
   
   
Line 486  char * rdn_attr_type( char * s ) Line 438  char * rdn_attr_type( char * s )
  */   */
   
 char *   char * 
 rdn_attr_value( char * rdn )  rdn_attr_value( const char * rdn )
 {  {
   
         char    *str;          const char      *str;
   
         if ( (str = strchr( rdn, '=' )) != NULL ) {          if ( (str = strchr( rdn, '=' )) != NULL ) {
   
                 return get_next_substring(++str, '\0');                  return get_next_substring(++str, '\0');
   
         }          }
   
         return NULL;          return NULL;
Line 518  int rdn_validate( const char * rdn ) Line 468  int rdn_validate( const char * rdn )
  */   */
   
 void  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 ) {      if ( p_dn == NULL ) {
   
         *new_dn = ch_strdup( newrdn );          *new_dn = ch_strdup( newrdn );
         return;          return;
   
     }      }
           
     *new_dn = (char *) ch_malloc( strlen( p_dn ) + strlen( newrdn ) + 3 );      *new_dn = (char *) ch_malloc( strlen( p_dn ) + strlen( newrdn ) + 3 );
   
 #ifdef DNS_DN  
     if ( dn_type( e_dn ) == DN_X500 ) {  
 #endif  
   
         strcpy( *new_dn, newrdn );          strcpy( *new_dn, newrdn );
         strcat( *new_dn, "," );          strcat( *new_dn, "," );
         strcat( *new_dn, p_dn );          strcat( *new_dn, p_dn );
   
 #ifdef DNS_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 );  
   
             }  
   
         }  
   
         strcat( *new_dn, p_dn );  
   
     }  
 #endif  
       
 }  }

Removed from v.1.20  
changed lines
  Added in v.1.20.2.4


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org