git.sur5r.net Git - openldap/blob - servers/slapd/overlays/unique.c

   1 /* unique.c - attribute uniqueness module */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2004-2007 The OpenLDAP Foundation.
   6  * Portions Copyright 2004 Symas Corporation.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted only as authorized by the OpenLDAP
  11  * Public License.
  12  *
  13  * A copy of this license is available in the file LICENSE in the
  14  * top-level directory of the distribution or, alternatively, at
  15  * <http://www.OpenLDAP.org/license.html>.
  16  */
  17 /* ACKNOWLEDGEMENTS:
  18  * This work was initially developed by Symas Corp. for inclusion in
  19  * OpenLDAP Software.  This work was sponsored by Hewlett-Packard.
  20  */
  21
  22 #include "portable.h"
  23
  24 #ifdef SLAPD_OVER_UNIQUE
  25
  26 #include <stdio.h>
  27
  28 #include <ac/string.h>
  29 #include <ac/socket.h>
  30
  31 #include "slap.h"
  32
  33 static slap_overinst unique;
  34
  35 typedef struct unique_attrs_s {
  36         struct unique_attrs_s *next;            /* list of attrs */
  37         AttributeDescription *attr;
  38 } unique_attrs;
  39
  40 typedef struct unique_data_s {
  41         const char *message;                    /* breadcrumbs */
  42         struct unique_attrs_s *attrs;           /* list of known attrs */
  43         struct unique_attrs_s *ignore;          /* list of ignored attrs */
  44         BerValue dn;                            /* base of "unique tree" */
  45         char strict;                            /* null considered unique too */
  46 } unique_data;
  47
  48 typedef struct unique_counter_s {
  49         struct berval *ndn;
  50         int count;
  51 } unique_counter;
  52
  53 /*
  54 ** allocate new unique_data;
  55 ** initialize, copy basedn;
  56 ** store in on_bi.bi_private;
  57 **
  58 */
  59
  60 static int unique_db_init(
  61         BackendDB       *be
  62 )
  63 {
  64         slap_overinst *on = (slap_overinst *)be->bd_info;
  65         unique_data *ud   = ch_malloc(sizeof(unique_data));
  66
  67         /* Debug(LDAP_DEBUG_TRACE, "==> unique_init\n", 0, 0, 0); */
  68
  69         ud->message     = "_init";
  70         ud->attrs       = NULL;
  71         ud->ignore      = NULL;
  72         ud->strict      = 0;
  73
  74         /* default to the base of our configured database */
  75         ber_dupbv(&ud->dn, &be->be_nsuffix[0]);
  76         on->on_bi.bi_private = ud;
  77
  78         return 0;
  79 }
  80
  81
  82 /*
  83 ** if command = attributes:
  84 **      foreach argument:
  85 **              convert to attribute;
  86 **              add to configured attribute list;
  87 ** elseif command = base:
  88 **      set our basedn to argument;
  89 ** else complain about invalid directive;
  90 **
  91 */
  92
  93 static int unique_config(
  94         BackendDB       *be,
  95         const char      *fname,
  96         int             lineno,
  97         int             argc,
  98         char            **argv
  99 )
 100 {
 101         slap_overinst *on = (slap_overinst *) be->bd_info;
 102         unique_data *ud   = on->on_bi.bi_private;
 103         unique_attrs *up;
 104         const char *text;
 105         AttributeDescription *ad;
 106         int i;
 107
 108         ud->message = "_config";
 109         Debug(LDAP_DEBUG_TRACE, "==> unique_config\n", 0, 0, 0);
 110
 111         if(!strcasecmp(*argv, "unique_attributes") ||
 112            !strcasecmp(*argv, "unique_ignore")) {
 113                 for(i = 1; i < argc; i++) {
 114                         for(up = ud->attrs; up; up = up->next)
 115                             if(!strcmp(argv[i], up->attr->ad_cname.bv_val)) {
 116                                 Debug(LDAP_DEBUG_ANY,
 117                                         "%s: line %d: duplicate attribute <%s>, ignored\n",
 118                                         fname, lineno, argv[i]);
 119                                 continue;
 120                         }
 121                         ad = NULL;
 122                         if(slap_str2ad(argv[i], &ad, &text) != LDAP_SUCCESS) {
 123                                 Debug(LDAP_DEBUG_ANY,
 124                                         "%s: line %d: bad attribute <%s>, ignored\n",
 125                                         fname, lineno, text);
 126                                 continue;               /* XXX */
 127                         } else if(ad->ad_next) {
 128                                 Debug(LDAP_DEBUG_ANY,
 129                                         "%s: line %d: multiple attributes match <%s>, ignored\n",
 130                                         fname, lineno, argv[i]);
 131                                 continue;
 132                         }
 133                         up = ch_malloc(sizeof(unique_attrs));
 134                         up->attr = ad;
 135                         if(!strcasecmp(*argv, "unique_ignore")) {
 136                                 up->next = ud->ignore;
 137                                 ud->ignore = up;
 138                         } else {
 139                                 up->next = ud->attrs;
 140                                 ud->attrs = up;
 141                         }
 142                         Debug(LDAP_DEBUG_CONFIG, "%s: line %d: new attribute <%s>\n",
 143                                 fname, lineno, argv[i]);
 144                 }
 145         } else if(!strcasecmp(*argv, "unique_strict")) {
 146                 ud->strict = 1;
 147         } else if(!strcasecmp(*argv, "unique_base")) {
 148                 struct berval bv;
 149                 ber_str2bv( argv[1], 0, 0, &bv );
 150                 ch_free(ud->dn.bv_val);
 151                 dnNormalize(0, NULL, NULL, &bv, &ud->dn, NULL);
 152                 Debug(LDAP_DEBUG_CONFIG, "%s: line %d: new base dn <%s>\n",
 153                         fname, lineno, argv[1]);
 154         } else {
 155                 return(SLAP_CONF_UNKNOWN);
 156         }
 157
 158         return(0);
 159 }
 160
 161
 162 /*
 163 ** mostly, just print the init message;
 164 **
 165 */
 166
 167 static int
 168 unique_open(
 169         BackendDB *be
 170 )
 171 {
 172         slap_overinst *on       = (slap_overinst *)be->bd_info;
 173         unique_data *ud         = on->on_bi.bi_private;
 174         ud->message             = "_open";
 175
 176         Debug(LDAP_DEBUG_TRACE, "unique_open: overlay initialized\n", 0, 0, 0);
 177
 178         return(0);
 179 }
 180
 181
 182 /*
 183 ** foreach configured attribute:
 184 **      free it;
 185 ** free our basedn;
 186 ** (do not) free ud->message;
 187 ** reset on_bi.bi_private;
 188 ** free our config data;
 189 **
 190 */
 191
 192 static int
 193 unique_close(
 194         BackendDB *be
 195 )
 196 {
 197         slap_overinst *on       = (slap_overinst *) be->bd_info;
 198         unique_data *ud         = on->on_bi.bi_private;
 199         unique_attrs *ii, *ij;
 200         ud->message             = "_close";
 201
 202         Debug(LDAP_DEBUG_TRACE, "==> unique_close\n", 0, 0, 0);
 203
 204         for(ii = ud->attrs; ii; ii = ij) {
 205                 ij = ii->next;
 206                 ch_free(ii);
 207         }
 208
 209         for(ii = ud->ignore; ii; ii = ij) {
 210                 ij = ii->next;
 211                 ch_free(ii);
 212         }
 213
 214         ch_free(ud->dn.bv_val);
 215
 216         on->on_bi.bi_private = NULL;    /* XXX */
 217
 218         ch_free(ud);
 219
 220         return(0);
 221 }
 222
 223
 224 /*
 225 ** search callback
 226 **      if this is a REP_SEARCH, count++;
 227 **
 228 */
 229
 230 static int count_attr_cb(
 231         Operation *op,
 232         SlapReply *rs
 233 )
 234 {
 235         unique_counter *uc;
 236
 237         /* because you never know */
 238         if(!op || !rs) return(0);
 239
 240         /* Only search entries are interesting */
 241         if(rs->sr_type != REP_SEARCH) return(0);
 242
 243         uc = op->o_callback->sc_private;
 244
 245         /* Ignore the current entry */
 246         if ( dn_match( uc->ndn, &rs->sr_entry->e_nname )) return(0);
 247
 248         Debug(LDAP_DEBUG_TRACE, "==> count_attr_cb <%s>\n",
 249                 rs->sr_entry ? rs->sr_entry->e_name.bv_val : "UNKNOWN_DN", 0, 0);
 250
 251         uc->count++;
 252
 253         return(0);
 254 }
 255
 256 static int count_filter_len(
 257         unique_data *ud,
 258         AttributeDescription *ad,
 259         BerVarray b,
 260         int ks
 261 )
 262 {
 263         unique_attrs *up;
 264         int i;
 265
 266         while ( !is_at_operational( ad->ad_type ) ) {
 267                 if ( ud->ignore ) {
 268                         for ( up = ud->ignore; up; up = up->next ) {
 269                                 if (ad == up->attr ) {
 270                                         break;
 271                                 }
 272                         }
 273                         if ( up ) {
 274                                 break;
 275                         }
 276                 }
 277                 if ( ud->attrs ) {
 278                         for ( up = ud->attrs; up; up = up->next ) {
 279                                 if ( ad == up->attr ) {
 280                                         break;
 281                                 }
 282                         }
 283                         if ( !up ) {
 284                                 break;
 285                         }
 286                 }
 287                 if ( b && b[0].bv_val ) {
 288                         for (i = 0; b[i].bv_val; i++ ) {
 289                                 /* note: make room for filter escaping... */
 290                                 ks += ( 3 * b[i].bv_len ) + ad->ad_cname.bv_len + STRLENOF( "(=)" );
 291                         }
 292                 } else if ( ud->strict ) {
 293                         ks += ad->ad_cname.bv_len + STRLENOF( "(=*)" ); /* (attr=*) */
 294                 }
 295                 break;
 296         }
 297         return ks;
 298 }
 299
 300 static char *build_filter(
 301         unique_data *ud,
 302         AttributeDescription *ad,
 303         BerVarray b,
 304         char *kp,
 305         void *ctx
 306 )
 307 {
 308         unique_attrs *up;
 309         int i;
 310
 311         while ( !is_at_operational( ad->ad_type ) ) {
 312                 if ( ud->ignore ) {
 313                         for ( up = ud->ignore; up; up = up->next ) {
 314                                 if ( ad == up->attr ) {
 315                                         break;
 316                                 }
 317                         }
 318                         if ( up ) {
 319                                 break;
 320                         }
 321                 }
 322                 if ( ud->attrs ) {
 323                         for ( up = ud->attrs; up; up = up->next ) {
 324                                 if ( ad == up->attr ) {
 325                                         break;
 326                                 }
 327                         }
 328                         if ( !up ) {
 329                                 break;
 330                         }
 331                 }
 332                 if ( b && b[0].bv_val ) {
 333                         for ( i = 0; b[i].bv_val; i++ ) {
 334                                 struct berval   bv;
 335
 336                                 ldap_bv2escaped_filter_value_x( &b[i], &bv, 1, ctx );
 337                                 kp += sprintf( kp, "(%s=%s)", ad->ad_cname.bv_val, bv.bv_val );
 338                                 if ( bv.bv_val != b[i].bv_val ) {
 339                                         ber_memfree_x( bv.bv_val, ctx );
 340                                 }
 341                         }
 342                 } else if ( ud->strict ) {
 343                         kp += sprintf( kp, "(%s=*)", ad->ad_cname.bv_val );
 344                 }
 345                 break;
 346         }
 347         return kp;
 348 }
 349
 350 static int unique_search(
 351         Operation *op,
 352         Operation *nop,
 353         SlapReply *rs,
 354         char *key
 355 )
 356 {
 357         slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
 358         unique_data *ud = on->on_bi.bi_private;
 359         SlapReply nrs = { REP_RESULT };
 360         slap_callback cb = { NULL, NULL, NULL, NULL }; /* XXX */
 361         unique_counter uq = { NULL, 0 };
 362         int rc;
 363
 364         nop->ors_filter = str2filter_x(nop, key);
 365         ber_str2bv(key, 0, 0, &nop->ors_filterstr);
 366
 367         cb.sc_response  = (slap_response*)count_attr_cb;
 368         cb.sc_private   = &uq;
 369         nop->o_callback = &cb;
 370         nop->o_tag      = LDAP_REQ_SEARCH;
 371         nop->ors_scope  = LDAP_SCOPE_SUBTREE;
 372         nop->ors_deref  = LDAP_DEREF_NEVER;
 373         nop->ors_limit  = NULL;
 374         nop->ors_slimit = SLAP_NO_LIMIT;
 375         nop->ors_tlimit = SLAP_NO_LIMIT;
 376         nop->ors_attrs  = slap_anlist_no_attrs;
 377         nop->ors_attrsonly = 1;
 378
 379         uq.ndn = &op->o_req_ndn;
 380
 381         nop->o_req_ndn  = ud->dn;
 382         nop->o_ndn = op->o_bd->be_rootndn;
 383
 384         nop->o_bd = on->on_info->oi_origdb;
 385         rc = nop->o_bd->be_search(nop, &nrs);
 386         filter_free_x(nop, nop->ors_filter);
 387         op->o_tmpfree( key, op->o_tmpmemctx );
 388
 389         if(rc != LDAP_SUCCESS && rc != LDAP_NO_SUCH_OBJECT) {
 390                 op->o_bd->bd_info = (BackendInfo *) on->on_info;
 391                 send_ldap_error(op, rs, rc, "unique_search failed");
 392                 return(rs->sr_err);
 393         }
 394
 395         Debug(LDAP_DEBUG_TRACE, "=> unique_search found %d records\n", uq.count, 0, 0);
 396
 397         if(uq.count) {
 398                 op->o_bd->bd_info = (BackendInfo *) on->on_info;
 399                 send_ldap_error(op, rs, LDAP_CONSTRAINT_VIOLATION,
 400                         "some attributes not unique");
 401                 return(rs->sr_err);
 402         }
 403
 404         return(SLAP_CB_CONTINUE);
 405 }
 406
 407 #define ALLOC_EXTRA     16      /* extra slop */
 408
 409 static int unique_add(
 410         Operation *op,
 411         SlapReply *rs
 412 )
 413 {
 414         slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
 415         unique_data *ud = on->on_bi.bi_private;
 416         Operation nop = *op;
 417
 418         Attribute *a;
 419         char *key, *kp;
 420         int ks = 0;
 421
 422         Debug(LDAP_DEBUG_TRACE, "==> unique_add <%s>\n", op->o_req_dn.bv_val, 0, 0);
 423
 424         if ( !dnIsSuffix( &op->o_req_ndn, &ud->dn ))
 425                 return SLAP_CB_CONTINUE;
 426
 427 /*
 428 ** count everything first;
 429 ** allocate some memory;
 430 ** write the search key;
 431 **
 432 */
 433
 434         if(!(a = op->ora_e->e_attrs)) {
 435                 op->o_bd->bd_info = (BackendInfo *) on->on_info;
 436                 send_ldap_error(op, rs, LDAP_INVALID_SYNTAX,
 437                         "unique_add() got null op.ora_e.e_attrs");
 438                 return(rs->sr_err);
 439         } else for(; a; a = a->a_next) {
 440                 ks = count_filter_len(ud, a->a_desc, a->a_vals, ks);
 441         }
 442
 443         if ( !ks )
 444                 return SLAP_CB_CONTINUE;
 445
 446         ks += ALLOC_EXTRA;
 447         key = op->o_tmpalloc(ks, op->o_tmpmemctx);
 448
 449         kp = key + sprintf(key, "(|");
 450
 451         for(a = op->ora_e->e_attrs; a; a = a->a_next) {
 452                 kp = build_filter(ud, a->a_desc, a->a_vals, kp, op->o_tmpmemctx);
 453         }
 454
 455         sprintf(kp, ")");
 456
 457         Debug(LDAP_DEBUG_TRACE, "=> unique_add %s\n", key, 0, 0);
 458
 459         return unique_search(op, &nop, rs, key);
 460 }
 461
 462
 463 static int unique_modify(
 464         Operation *op,
 465         SlapReply *rs
 466 )
 467 {
 468         slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
 469         unique_data *ud = on->on_bi.bi_private;
 470         Operation nop = *op;
 471
 472         Modifications *m;
 473         char *key, *kp;
 474         int ks = 0;
 475
 476         Debug(LDAP_DEBUG_TRACE, "==> unique_modify <%s>\n", op->o_req_dn.bv_val, 0, 0);
 477
 478         if ( !dnIsSuffix( &op->o_req_ndn, &ud->dn ))
 479                 return SLAP_CB_CONTINUE;
 480
 481 /*
 482 ** count everything first;
 483 ** allocate some memory;
 484 ** write the search key;
 485 **
 486 */
 487
 488         if(!(m = op->orm_modlist)) {
 489                 op->o_bd->bd_info = (BackendInfo *) on->on_info;
 490                 send_ldap_error(op, rs, LDAP_INVALID_SYNTAX,
 491                         "unique_modify() got null op.orm_modlist");
 492                 return(rs->sr_err);
 493         } else for(; m; m = m->sml_next) {
 494                 if ((m->sml_op & LDAP_MOD_OP) == LDAP_MOD_DELETE) continue;
 495                 ks = count_filter_len(ud, m->sml_desc, m->sml_values, ks);
 496         }
 497
 498         if ( !ks )
 499                 return SLAP_CB_CONTINUE;
 500
 501         ks += ALLOC_EXTRA;
 502         key = op->o_tmpalloc(ks, op->o_tmpmemctx);
 503
 504         kp = key + sprintf(key, "(|");
 505
 506         for(m = op->orm_modlist; m; m = m->sml_next) {
 507                 if ((m->sml_op & LDAP_MOD_OP) == LDAP_MOD_DELETE) continue;
 508                 kp = build_filter(ud, m->sml_desc, m->sml_values, kp, op->o_tmpmemctx);
 509         }
 510
 511         sprintf(kp, ")");
 512
 513         Debug(LDAP_DEBUG_TRACE, "=> unique_modify %s\n", key, 0, 0);
 514
 515         return unique_search(op, &nop, rs, key);
 516 }
 517
 518
 519 static int unique_modrdn(
 520         Operation *op,
 521         SlapReply *rs
 522 )
 523 {
 524         slap_overinst *on = (slap_overinst *) op->o_bd->bd_info;
 525         unique_data *ud = on->on_bi.bi_private;
 526         Operation nop = *op;
 527
 528         char *key, *kp;
 529         int i, ks = 0;
 530         LDAPRDN newrdn;
 531         struct berval bv[2];
 532
 533         Debug(LDAP_DEBUG_TRACE, "==> unique_modrdn <%s> <%s>\n",
 534                 op->o_req_dn.bv_val, op->orr_newrdn.bv_val, 0);
 535
 536         if ( !dnIsSuffix( &op->o_req_ndn, &ud->dn ) &&
 537                 (!op->orr_nnewSup || !dnIsSuffix( op->orr_nnewSup, &ud->dn )))
 538                 return SLAP_CB_CONTINUE;
 539
 540         if(ldap_bv2rdn_x(&op->oq_modrdn.rs_newrdn, &newrdn,
 541                 (char **)&rs->sr_text, LDAP_DN_FORMAT_LDAP, op->o_tmpmemctx )) {
 542                 op->o_bd->bd_info = (BackendInfo *) on->on_info;
 543                 send_ldap_error(op, rs, LDAP_INVALID_SYNTAX,
 544                         "unknown type(s) used in RDN");
 545                 return(rs->sr_err);
 546         }
 547         for(i = 0; newrdn[i]; i++) {
 548                 AttributeDescription *ad = NULL;
 549                 if ( slap_bv2ad( &newrdn[i]->la_attr, &ad, &rs->sr_text )) {
 550                         ldap_rdnfree_x( newrdn, op->o_tmpmemctx );
 551                         rs->sr_err = LDAP_INVALID_SYNTAX;
 552                         send_ldap_result( op, rs );
 553                         return(rs->sr_err);
 554                 }
 555                 newrdn[i]->la_private = ad;
 556         }
 557
 558         bv[1].bv_val = NULL;
 559         bv[1].bv_len = 0;
 560
 561         for(i = 0; newrdn[i]; i++) {
 562                 bv[0] = newrdn[i]->la_value;
 563                 ks = count_filter_len(ud, newrdn[i]->la_private, bv, ks);
 564         }
 565
 566         if ( !ks )
 567                 return SLAP_CB_CONTINUE;
 568
 569         ks += ALLOC_EXTRA;
 570         key = op->o_tmpalloc(ks, op->o_tmpmemctx);
 571         kp = key + sprintf(key, "(|");
 572
 573         for(i = 0; newrdn[i]; i++) {
 574                 bv[0] = newrdn[i]->la_value;
 575                 kp = build_filter(ud, newrdn[i]->la_private, bv, kp, op->o_tmpmemctx);
 576         }
 577
 578         sprintf(kp, ")");
 579
 580         Debug(LDAP_DEBUG_TRACE, "=> unique_modrdn %s\n", key, 0, 0);
 581
 582         return unique_search(op, &nop, rs, key);
 583 }
 584
 585 /*
 586 ** init_module is last so the symbols resolve "for free" --
 587 ** it expects to be called automagically during dynamic module initialization
 588 */
 589
 590 int unique_initialize() {
 591
 592         /* statically declared just after the #includes at top */
 593         unique.on_bi.bi_type = "unique";
 594         unique.on_bi.bi_db_init = unique_db_init;
 595         unique.on_bi.bi_db_config = unique_config;
 596         unique.on_bi.bi_db_open = unique_open;
 597         unique.on_bi.bi_db_close = unique_close;
 598         unique.on_bi.bi_op_add = unique_add;
 599         unique.on_bi.bi_op_modify = unique_modify;
 600         unique.on_bi.bi_op_modrdn = unique_modrdn;
 601         unique.on_bi.bi_op_delete = NULL;
 602
 603         return(overlay_register(&unique));
 604 }
 605
 606 #if SLAPD_OVER_UNIQUE == SLAPD_MOD_DYNAMIC && defined(PIC)
 607 int init_module(int argc, char *argv[]) {
 608         return unique_initialize();
 609 }
 610 #endif
 611
 612 #endif /* SLAPD_OVER_UNIQUE */