Diff for /servers/slapd/ad.c between versions 1.95 and 1.95.2.4

version 1.95, 2006/03/19 22:26:12 version 1.95.2.4, 2008/02/11 23:26:43
Line 1 Line 1
 /* ad.c - routines for dealing with attribute descriptions */  /* ad.c - routines for dealing with attribute descriptions */
 /* $OpenLDAP: pkg/ldap/servers/slapd/ad.c,v 1.94 2006/01/13 15:42:34 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/ad.c,v 1.95.2.3 2007/08/31 23:13:57 quanah Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 1998-2006 The OpenLDAP Foundation.   * Copyright 1998-2008 The OpenLDAP Foundation.
  * All rights reserved.   * All rights reserved.
  *   *
  * Redistribution and use in source and binary forms, with or without   * Redistribution and use in source and binary forms, with or without
Line 58  typedef struct Attr_option { Line 58  typedef struct Attr_option {
         int           prefix;   /* NAME is a tag and range prefix */          int           prefix;   /* NAME is a tag and range prefix */
 } Attr_option;  } Attr_option;
   
 static Attr_option lang_option = { { sizeof("lang-")-1, "lang-" }, 1 };  static Attr_option lang_option = { BER_BVC("lang-"), 1 };
   
 /* Options sorted by name, and number of options */  /* Options sorted by name, and number of options */
 static Attr_option *options = &lang_option;  static Attr_option *options = &lang_option;
Line 124  int slap_str2ad( Line 124  int slap_str2ad(
 }  }
   
 static char *strchrlen(  static char *strchrlen(
         const char *p,           const char *beg, 
           const char *end,
         const char ch,           const char ch, 
         int *len )          int *len )
 {  {
         int i;          const char *p;
   
         for( i=0; p[i]; i++ ) {          for( p=beg; *p && p < end; p++ ) {
                 if( p[i] == ch ) {                  if( *p == ch ) {
                         *len = i;                          *len = p - beg;
                         return (char *) &p[i];                          return (char *) p;
                 }                  }
         }          }
   
         *len = i;          *len = p - beg;
         return NULL;          return NULL;
 }  }
   
Line 148  int slap_bv2ad( Line 149  int slap_bv2ad(
 {  {
         int rtn = LDAP_UNDEFINED_TYPE;          int rtn = LDAP_UNDEFINED_TYPE;
         AttributeDescription desc, *d2;          AttributeDescription desc, *d2;
         char *name, *options;          char *name, *options, *optn;
         char *opt, *next;          char *opt, *next;
         int ntags;          int ntags;
         int tagslen;          int tagslen;
Line 174  int slap_bv2ad( Line 175  int slap_bv2ad(
         }          }
   
         /* find valid base attribute type; parse in place */          /* find valid base attribute type; parse in place */
         memset( &desc, 0, sizeof( desc ) );  
         desc.ad_cname = *bv;          desc.ad_cname = *bv;
           desc.ad_flags = 0;
           BER_BVZERO( &desc.ad_tags );
         name = bv->bv_val;          name = bv->bv_val;
         options = ber_bvchr( bv, ';' );          options = ber_bvchr( bv, ';' );
         if ( options != NULL && (unsigned) ( options - name ) < bv->bv_len ) {          if ( options != NULL && (unsigned) ( options - name ) < bv->bv_len ) {
Line 199  int slap_bv2ad( Line 201  int slap_bv2ad(
          * parse options in place           * parse options in place
          */           */
         ntags = 0;          ntags = 0;
         memset( tags, 0, sizeof( tags ));  
         tagslen = 0;          tagslen = 0;
           optn = bv->bv_val + bv->bv_len;
   
         for( opt=options; opt != NULL; opt=next ) {          for( opt=options; opt != NULL; opt=next ) {
                 int optlen;                  int optlen;
                 opt++;                   opt++; 
                 next = strchrlen( opt, ';', &optlen );                  next = strchrlen( opt, optn, ';', &optlen );
   
                 if( optlen == 0 ) {                  if( optlen == 0 ) {
                         *text = "zero length option is invalid";                          *text = "zero length option is invalid";
                         return rtn;                          return rtn;
                                   
                 } else if ( optlen == sizeof("binary")-1 &&                  } else if ( optlen == STRLENOF("binary") &&
                         strncasecmp( opt, "binary", sizeof("binary")-1 ) == 0 )                          strncasecmp( opt, "binary", STRLENOF("binary") ) == 0 )
                 {                  {
                         /* binary option */                          /* binary option */
                         if( slap_ad_is_binary( &desc ) ) {                          if( slap_ad_is_binary( &desc ) ) {
Line 354  done:; Line 356  done:;
                 if (desc.ad_tags.bv_len || desc.ad_flags != SLAP_DESC_NONE) {                  if (desc.ad_tags.bv_len || desc.ad_flags != SLAP_DESC_NONE) {
                         dlen = desc.ad_type->sat_cname.bv_len + 1;                          dlen = desc.ad_type->sat_cname.bv_len + 1;
                         if (desc.ad_tags.bv_len) {                          if (desc.ad_tags.bv_len) {
                                 dlen += 1+desc.ad_tags.bv_len;                                  dlen += 1 + desc.ad_tags.bv_len;
                         }                          }
                         if( slap_ad_is_binary( &desc ) ) {                          if ( slap_ad_is_binary( &desc ) ) {
                                 dlen += sizeof(";binary")+desc.ad_tags.bv_len;                                  dlen += 1 + STRLENOF(";binary") + desc.ad_tags.bv_len;
                         }                          }
                 }                  }
   
Line 382  done:; Line 384  done:;
                                 lp = NULL;                                  lp = NULL;
                                 if( desc.ad_tags.bv_len ) {                                  if( desc.ad_tags.bv_len ) {
                                         lp = desc.ad_tags.bv_val;                                          lp = desc.ad_tags.bv_val;
                                         while( strncasecmp(lp, "binary", sizeof("binary")-1) < 0                                          while( strncasecmp(lp, "binary", STRLENOF("binary")) < 0
                                                && (lp = strchr( lp, ';' )) != NULL )                                                 && (lp = strchr( lp, ';' )) != NULL )
                                                 ++lp;                                                  ++lp;
                                         if( lp != desc.ad_tags.bv_val ) {                                          if( lp != desc.ad_tags.bv_val ) {
Line 443  static int is_ad_subtags( Line 445  static int is_ad_subtags(
         struct berval *subtagsbv,           struct berval *subtagsbv, 
         struct berval *suptagsbv )          struct berval *suptagsbv )
 {  {
         const char *suptags, *supp, *supdelimp;          const char *suptags, *supp, *supdelimp, *supn;
         const char *subtags, *subp, *subdelimp;          const char *subtags, *subp, *subdelimp, *subn;
         int  suplen, sublen;          int  suplen, sublen;
   
         subtags =subtagsbv->bv_val;          subtags =subtagsbv->bv_val;
         suptags =suptagsbv->bv_val;          suptags =suptagsbv->bv_val;
           subn = subtags + subtagsbv->bv_len;
           supn = suptags + suptagsbv->bv_len;
   
         for( supp=suptags ; supp; supp=supdelimp ) {          for( supp=suptags ; supp; supp=supdelimp ) {
                 supdelimp = strchrlen( supp, ';', &suplen );                  supdelimp = strchrlen( supp, supn, ';', &suplen );
                 if( supdelimp ) supdelimp++;                  if( supdelimp ) supdelimp++;
   
                 for( subp=subtags ; subp; subp=subdelimp ) {                  for( subp=subtags ; subp; subp=subdelimp ) {
                         subdelimp = strchrlen( subp, ';', &sublen );                          subdelimp = strchrlen( subp, subn, ';', &sublen );
                         if( subdelimp ) subdelimp++;                          if( subdelimp ) subdelimp++;
   
                         if ( suplen > sublen                          if ( suplen > sublen
Line 769  int slap_bv2undef_ad( Line 773  int slap_bv2undef_ad(
         return LDAP_SUCCESS;          return LDAP_SUCCESS;
 }  }
   
   AttributeDescription *
   slap_bv2tmp_ad(
           struct berval *bv,
           void *memctx )
   {
           AttributeDescription *ad =
                    slap_sl_mfuncs.bmf_malloc( sizeof(AttributeDescription) +
                           bv->bv_len + 1, memctx );
   
           ad->ad_cname.bv_val = (char *)(ad+1);
           strncpy( ad->ad_cname.bv_val, bv->bv_val, bv->bv_len+1 );
           ad->ad_cname.bv_len = bv->bv_len;
           ad->ad_flags = SLAP_DESC_TEMPORARY;
           ad->ad_type = slap_schema.si_at_undefined;
   
           return ad;
   }
   
 static int  static int
 undef_promote(  undef_promote(
         AttributeType   *at,          AttributeType   *at,
Line 884  str2anlist( AttributeName *an, char *in, Line 906  str2anlist( AttributeName *an, char *in,
         }          }
   
         an = ch_realloc( an, ( i + j + 1 ) * sizeof( AttributeName ) );          an = ch_realloc( an, ( i + j + 1 ) * sizeof( AttributeName ) );
         BER_BVZERO( &an[i + j].an_name );  
         anew = an + i;          anew = an + i;
         for ( s = ldap_pvt_strtok( str, brkstr, &lasts );          for ( s = ldap_pvt_strtok( str, brkstr, &lasts );
                 s != NULL;                  s != NULL;
                 s = ldap_pvt_strtok( NULL, brkstr, &lasts ) )                  s = ldap_pvt_strtok( NULL, brkstr, &lasts ) )
         {          {
                   /* put a stop mark */
                   BER_BVZERO( &anew[1].an_name );
   
                 anew->an_desc = NULL;                  anew->an_desc = NULL;
                 anew->an_oc = NULL;                  anew->an_oc = NULL;
                 anew->an_oc_exclude = 0;                  anew->an_oc_exclude = 0;
Line 939  str2anlist( AttributeName *an, char *in, Line 963  str2anlist( AttributeName *an, char *in,
         return( an );          return( an );
   
 reterr:  reterr:
         for ( i = 0; an[i].an_name.bv_val; i++ ) {          anlist_free( an, 1, NULL );
                 free( an[i].an_name.bv_val );  
         }  
         free( an );  
         /*          /*
          * overwrites input string           * overwrites input string
          * on error!           * on error!
Line 952  reterr: Line 974  reterr:
         return NULL;          return NULL;
 }  }
   
   void
   anlist_free( AttributeName *an, int freename, void *ctx )
   {
           if ( an == NULL ) {
                   return;
           }
   
           if ( freename ) {
                   int     i;
   
                   for ( i = 0; an[i].an_name.bv_val; i++ ) {
                           ber_memfree_x( an[i].an_name.bv_val, ctx );
                   }
           }
   
           ber_memfree_x( an, ctx );
   }
   
 char **anlist2charray_x( AttributeName *an, int dup, void *ctx )  char **anlist2charray_x( AttributeName *an, int dup, void *ctx )
 {  {
     char **attrs;      char **attrs;
Line 1109  file2anlist( AttributeName *an, const ch Line 1149  file2anlist( AttributeName *an, const ch
                 }                  }
                 an = str2anlist( an, line, brkstr );                  an = str2anlist( an, line, brkstr );
                 if ( an == NULL )                  if ( an == NULL )
                         return NULL;                          break;
                 lcur = line;                  lcur = line;
         }          }
         ch_free( line );          ch_free( line );

Removed from v.1.95  
changed lines
  Added in v.1.95.2.4


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