Diff for /servers/slapd/overlays/unique.c between versions 1.8 and 1.8.2.8

version 1.8, 2004/12/05 02:06:01 version 1.8.2.8, 2005/11/26 23:54:52
Line 1 Line 1
 /* unique.c - attribute uniqueness module */  /* unique.c - attribute uniqueness module */
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/unique.c,v 1.7 2004/11/25 20:16:56 hyc Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/unique.c,v 1.8.2.7 2005/10/11 17:42:19 kurt Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2004 The OpenLDAP Foundation.   * Copyright 2004-2005 The OpenLDAP Foundation.
  * Portions Copyright 2004 Symas Corporation.   * Portions Copyright 2004 Symas Corporation.
  * All rights reserved.   * All rights reserved.
  *   *
Line 46  typedef struct unique_data_s { Line 46  typedef struct unique_data_s {
 } unique_data;  } unique_data;
   
 typedef struct unique_counter_s {  typedef struct unique_counter_s {
           struct berval *ndn;
         int count;          int count;
 } unique_counter;  } unique_counter;
   
Line 138  static int unique_config( Line 139  static int unique_config(
                                 up->next = ud->attrs;                                  up->next = ud->attrs;
                                 ud->attrs = up;                                  ud->attrs = up;
                         }                          }
                         Debug(LDAP_DEBUG_ANY, "%s: line %d: new attribute <%s>\n",                          Debug(LDAP_DEBUG_CONFIG, "%s: line %d: new attribute <%s>\n",
                                 fname, lineno, argv[i]);                                  fname, lineno, argv[i]);
                 }                  }
         } else if(!strcasecmp(*argv, "unique_strict")) {          } else if(!strcasecmp(*argv, "unique_strict")) {
Line 148  static int unique_config( Line 149  static int unique_config(
                 ber_str2bv( argv[1], 0, 0, &bv );                  ber_str2bv( argv[1], 0, 0, &bv );
                 ch_free(ud->dn.bv_val);                  ch_free(ud->dn.bv_val);
                 dnNormalize(0, NULL, NULL, &bv, &ud->dn, NULL);                  dnNormalize(0, NULL, NULL, &bv, &ud->dn, NULL);
                 Debug(LDAP_DEBUG_ANY, "%s: line %d: new base dn <%s>\n",                  Debug(LDAP_DEBUG_CONFIG, "%s: line %d: new base dn <%s>\n",
                         fname, lineno, argv[1]);                          fname, lineno, argv[1]);
         } else {          } else {
                 return(SLAP_CONF_UNKNOWN);                  return(SLAP_CONF_UNKNOWN);
Line 231  static int count_attr_cb( Line 232  static int count_attr_cb(
         SlapReply *rs          SlapReply *rs
 )  )
 {  {
           unique_counter *uc;
   
         /* because you never know */          /* because you never know */
         if(!op || !rs) return(0);          if(!op || !rs) return(0);
   
         /* Only search entries are interesting */          /* Only search entries are interesting */
         if(rs->sr_type != REP_SEARCH) return(0);          if(rs->sr_type != REP_SEARCH) return(0);
   
           uc = op->o_callback->sc_private;
   
           /* Ignore the current entry */
           if ( dn_match( uc->ndn, &rs->sr_entry->e_nname )) return(0);
   
         Debug(LDAP_DEBUG_TRACE, "==> count_attr_cb <%s>\n",          Debug(LDAP_DEBUG_TRACE, "==> count_attr_cb <%s>\n",
                 rs->sr_entry ? rs->sr_entry->e_name.bv_val : "UNKNOWN_DN", 0, 0);                  rs->sr_entry ? rs->sr_entry->e_name.bv_val : "UNKNOWN_DN", 0, 0);
   
         ((unique_counter*)op->o_callback->sc_private)->count++;          uc->count++;
   
         return(0);          return(0);
 }  }
Line 255  static int count_filter_len( Line 263  static int count_filter_len(
         unique_attrs *up;          unique_attrs *up;
         int i;          int i;
   
         while(!is_at_operational(ad->ad_type)) {          while ( !is_at_operational( ad->ad_type ) ) {
                 if(ud->ignore) {                  if ( ud->ignore ) {
                         for(up = ud->ignore; up; up = up->next)                          for ( up = ud->ignore; up; up = up->next ) {
                                 if(ad == up->attr) break;                                  if (ad == up->attr ) {
                         if(up) break;                                          break;
                                   }
                           }
                           if ( up ) {
                                   break;
                           }
                 }                  }
                 if(ud->attrs) {                  if ( ud->attrs ) {
                         for(up = ud->attrs; up; up = up->next)                          for ( up = ud->attrs; up; up = up->next ) {
                                 if(ad == up->attr) break;                                  if ( ad == up->attr ) {
                         if(!up) break;                                          break;
                                   }
                           }
                           if ( !up ) {
                                   break;
                           }
                 }                  }
                 if(b && b[0].bv_val) for(i = 0; b[i].bv_val; i++)                  if ( b && b[0].bv_val ) {
                         ks += b[i].bv_len + ad->ad_cname.bv_len + STRLENOF( "(=)" );                          for (i = 0; b[i].bv_val; i++ ) {
                 else if(ud->strict)                                  /* note: make room for filter escaping... */
                                   ks += ( 3 * b[i].bv_len ) + ad->ad_cname.bv_len + STRLENOF( "(=)" );
                           }
                   } else if ( ud->strict ) {
                         ks += ad->ad_cname.bv_len + STRLENOF( "(=*)" ); /* (attr=*) */                          ks += ad->ad_cname.bv_len + STRLENOF( "(=*)" ); /* (attr=*) */
                   }
                 break;                  break;
         }          }
         return ks;          return ks;
Line 279  static char *build_filter( Line 301  static char *build_filter(
         unique_data *ud,          unique_data *ud,
         AttributeDescription *ad,          AttributeDescription *ad,
         BerVarray b,          BerVarray b,
         char *kp          char *kp,
           void *ctx
 )  )
 {  {
         unique_attrs *up;          unique_attrs *up;
         int i;          int i;
   
         while(!is_at_operational(ad->ad_type)) {          while ( !is_at_operational( ad->ad_type ) ) {
                 if(ud->ignore) {                  if ( ud->ignore ) {
                         for(up = ud->ignore; up; up = up->next)                          for ( up = ud->ignore; up; up = up->next ) {
                                 if(ad == up->attr) break;                                  if ( ad == up->attr ) {
                         if(up) break;                                          break;
                                   }
                           }
                           if ( up ) {
                                   break;
                           }
                 }                  }
                 if(ud->attrs) {                  if ( ud->attrs ) {
                         for(up = ud->attrs; up; up = up->next)                          for ( up = ud->attrs; up; up = up->next ) {
                                 if(ad == up->attr) break;                                  if ( ad == up->attr ) {
                         if(!up) break;                                          break;
                                   }
                           }
                           if ( !up ) {
                                   break;
                           }
                   }
                   if ( b && b[0].bv_val ) {
                           for ( i = 0; b[i].bv_val; i++ ) {
                                   struct berval   bv;
   
                                   ldap_bv2escaped_filter_value_x( &b[i], &bv, 1, ctx );
                                   kp += sprintf( kp, "(%s=%s)", ad->ad_cname.bv_val, bv.bv_val );
                                   if ( bv.bv_val != b[i].bv_val ) {
                                           ber_memfree_x( bv.bv_val, ctx );
                                   }
                           }
                   } else if ( ud->strict ) {
                           kp += sprintf( kp, "(%s=*)", ad->ad_cname.bv_val );
                 }                  }
                 if(b && b[0].bv_val) for(i = 0; b[i].bv_val; i++)  
                         kp += sprintf(kp, "(%s=%s)", ad->ad_cname.bv_val, b[i].bv_val);  
                 else if(ud->strict)  
                         kp += sprintf(kp, "(%s=*)", ad->ad_cname.bv_val);  
                 break;                  break;
         }          }
         return kp;          return kp;
Line 316  static int unique_search( Line 358  static int unique_search(
         unique_data *ud = on->on_bi.bi_private;          unique_data *ud = on->on_bi.bi_private;
         SlapReply nrs = { REP_RESULT };          SlapReply nrs = { REP_RESULT };
         slap_callback cb = { NULL, NULL, NULL, NULL }; /* XXX */          slap_callback cb = { NULL, NULL, NULL, NULL }; /* XXX */
         unique_counter uq = { 0 };          unique_counter uq = { NULL, 0 };
         int rc;          int rc;
   
         nop->ors_filter = str2filter_x(nop, key);          nop->ors_filter = str2filter_x(nop, key);
Line 328  static int unique_search( Line 370  static int unique_search(
         nop->o_tag      = LDAP_REQ_SEARCH;          nop->o_tag      = LDAP_REQ_SEARCH;
         nop->ors_scope  = LDAP_SCOPE_SUBTREE;          nop->ors_scope  = LDAP_SCOPE_SUBTREE;
         nop->ors_deref  = LDAP_DEREF_NEVER;          nop->ors_deref  = LDAP_DEREF_NEVER;
           nop->ors_limit  = NULL;
         nop->ors_slimit = SLAP_NO_LIMIT;          nop->ors_slimit = SLAP_NO_LIMIT;
         nop->ors_tlimit = SLAP_NO_LIMIT;          nop->ors_tlimit = SLAP_NO_LIMIT;
         nop->ors_attrs  = slap_anlist_no_attrs;          nop->ors_attrs  = slap_anlist_no_attrs;
         nop->ors_attrsonly = 1;          nop->ors_attrsonly = 1;
   
           uq.ndn = &op->o_req_ndn;
   
         nop->o_req_ndn  = ud->dn;          nop->o_req_ndn  = ud->dn;
         nop->o_ndn = op->o_bd->be_rootndn;          nop->o_ndn = op->o_bd->be_rootndn;
   
           nop->o_bd = on->on_info->oi_origdb;
         rc = nop->o_bd->be_search(nop, &nrs);          rc = nop->o_bd->be_search(nop, &nrs);
         filter_free_x(nop, nop->ors_filter);          filter_free_x(nop, nop->ors_filter);
         ch_free( key );          ch_free( key );
Line 373  static int unique_add( Line 419  static int unique_add(
   
         Debug(LDAP_DEBUG_TRACE, "==> unique_add <%s>\n", op->o_req_dn.bv_val, 0, 0);          Debug(LDAP_DEBUG_TRACE, "==> unique_add <%s>\n", op->o_req_dn.bv_val, 0, 0);
   
         /* validate backend. Should have already been done, but whatever */          if ( !dnIsSuffix( &op->o_req_ndn, &ud->dn ))
         nop.o_bd = select_backend(&ud->dn, 0, 1);                  return SLAP_CB_CONTINUE;
         if(nop.o_bd) {  
                 if (!nop.o_bd->be_search) {  
                         op->o_bd->bd_info = (BackendInfo *) on->on_info;  
                         send_ldap_error(op, rs, LDAP_UNWILLING_TO_PERFORM,  
                         "backend missing search function");  
                         return(rs->sr_err);  
                 }  
         } else {  
                 op->o_bd->bd_info = (BackendInfo *) on->on_info;  
                 send_ldap_error(op, rs, LDAP_OTHER,  
                         "no known backend? this shouldn't be happening!");  
                 return(rs->sr_err);  
         }  
   
 /*  /*
 ** count everything first;  ** count everything first;
Line 410  static int unique_add( Line 443  static int unique_add(
         kp = key + sprintf(key, "(|");          kp = key + sprintf(key, "(|");
   
         for(a = op->ora_e->e_attrs; a; a = a->a_next) {          for(a = op->ora_e->e_attrs; a; a = a->a_next) {
                 kp = build_filter(ud, a->a_desc, a->a_vals, kp);                  kp = build_filter(ud, a->a_desc, a->a_vals, kp, op->o_tmpmemctx);
         }          }
   
         sprintf(kp, ")");          sprintf(kp, ")");
Line 436  static int unique_modify( Line 469  static int unique_modify(
   
         Debug(LDAP_DEBUG_TRACE, "==> unique_modify <%s>\n", op->o_req_dn.bv_val, 0, 0);          Debug(LDAP_DEBUG_TRACE, "==> unique_modify <%s>\n", op->o_req_dn.bv_val, 0, 0);
   
         nop.o_bd = select_backend(&ud->dn, 0, 1);          if ( !dnIsSuffix( &op->o_req_ndn, &ud->dn ))
         if(nop.o_bd) {                  return SLAP_CB_CONTINUE;
                 if (!nop.o_bd->be_search) {  
                         op->o_bd->bd_info = (BackendInfo *) on->on_info;  
                         send_ldap_error(op, rs, LDAP_UNWILLING_TO_PERFORM,  
                         "backend missing search function");  
                         return(rs->sr_err);  
                 }  
         } else {  
                 op->o_bd->bd_info = (BackendInfo *) on->on_info;  
                 send_ldap_error(op, rs, LDAP_OTHER,  
                         "no known backend? this shouldn't be happening!");  
                 return(rs->sr_err);  
         }  
   
 /*  /*
 ** count everything first;  ** count everything first;
Line 474  static int unique_modify( Line 495  static int unique_modify(
   
         for(m = op->orm_modlist; m; m = m->sml_next) {          for(m = op->orm_modlist; m; m = m->sml_next) {
                 if ((m->sml_op & LDAP_MOD_OP) == LDAP_MOD_DELETE) continue;                  if ((m->sml_op & LDAP_MOD_OP) == LDAP_MOD_DELETE) continue;
                 kp = build_filter(ud, m->sml_desc, m->sml_values, kp);                  kp = build_filter(ud, m->sml_desc, m->sml_values, kp, op->o_tmpmemctx);
         }          }
   
         sprintf(kp, ")");          sprintf(kp, ")");
Line 495  static int unique_modrdn( Line 516  static int unique_modrdn(
         Operation nop = *op;          Operation nop = *op;
   
         char *key, *kp;          char *key, *kp;
         int i, rc, ks = 16;             /* a handful of extra bytes */          int i, ks = 16;                 /* a handful of extra bytes */
         LDAPRDN newrdn;          LDAPRDN newrdn;
         struct berval bv[2];          struct berval bv[2];
   
         Debug(LDAP_DEBUG_TRACE, "==> unique_modrdn <%s> <%s>\n",          Debug(LDAP_DEBUG_TRACE, "==> unique_modrdn <%s> <%s>\n",
                 op->o_req_dn.bv_val, op->orr_newrdn.bv_val, 0);                  op->o_req_dn.bv_val, op->orr_newrdn.bv_val, 0);
   
         nop.o_bd = select_backend(&ud->dn, 0, 1);          if ( !dnIsSuffix( &op->o_req_ndn, &ud->dn ) && 
         if(nop.o_bd) {                  (!op->orr_nnewSup || !dnIsSuffix( op->orr_nnewSup, &ud->dn )))
                 if (!nop.o_bd->be_search) {                  return SLAP_CB_CONTINUE;
                         op->o_bd->bd_info = (BackendInfo *) on->on_info;  
                         send_ldap_error(op, rs, LDAP_UNWILLING_TO_PERFORM,  
                         "backend missing search function");  
                         return(rs->sr_err);  
                 }  
         } else {  
                 op->o_bd->bd_info = (BackendInfo *) on->on_info;  
                 send_ldap_error(op, rs, LDAP_OTHER,  
                         "no known backend? this shouldn't be happening!");  
                 return(rs->sr_err);  
         }  
   
         if(ldap_bv2rdn_x(&op->oq_modrdn.rs_newrdn, &newrdn,          if(ldap_bv2rdn_x(&op->oq_modrdn.rs_newrdn, &newrdn,
                 (char **)&rs->sr_text, LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx )) {                  (char **)&rs->sr_text, LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx )) {
Line 548  static int unique_modrdn( Line 558  static int unique_modrdn(
   
         for(i = 0; newrdn[i]; i++) {          for(i = 0; newrdn[i]; i++) {
                 bv[0] = newrdn[i]->la_value;                  bv[0] = newrdn[i]->la_value;
                 kp = build_filter(ud, newrdn[i]->la_private, bv, kp);                  kp = build_filter(ud, newrdn[i]->la_private, bv, kp, op->o_tmpmemctx);
         }          }
   
         sprintf(kp, ")");          sprintf(kp, ")");
Line 563  static int unique_modrdn( Line 573  static int unique_modrdn(
 ** it expects to be called automagically during dynamic module initialization  ** it expects to be called automagically during dynamic module initialization
 */  */
   
 int unique_init() {  int unique_initialize() {
   
         /* statically declared just after the #includes at top */          /* statically declared just after the #includes at top */
         unique.on_bi.bi_type = "unique";          unique.on_bi.bi_type = "unique";
Line 581  int unique_init() { Line 591  int unique_init() {
   
 #if SLAPD_OVER_UNIQUE == SLAPD_MOD_DYNAMIC && defined(PIC)  #if SLAPD_OVER_UNIQUE == SLAPD_MOD_DYNAMIC && defined(PIC)
 int init_module(int argc, char *argv[]) {  int init_module(int argc, char *argv[]) {
         return unique_init();          return unique_initialize();
 }  }
 #endif  #endif
   

Removed from v.1.8  
changed lines
  Added in v.1.8.2.8


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