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

   1 /* retcode.c - customizable response for client testing purposes */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2005 The OpenLDAP Foundation.
   6  * Portions Copyright 2005 Pierangelo Masarati <ando@sys-net.it>
   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 Pierangelo Masarati for inclusion
  19  * in OpenLDAP Software.
  20  */
  21
  22 #include "portable.h"
  23
  24 #ifdef SLAPD_OVER_RETCODE
  25
  26 #include <stdio.h>
  27
  28 #include <ac/unistd.h>
  29 #include <ac/string.h>
  30 #include <ac/ctype.h>
  31 #include <ac/socket.h>
  32
  33 #include "slap.h"
  34 #include "lutil.h"
  35
  36 static slap_overinst            retcode;
  37
  38 static AttributeDescription     *ad_errCode;
  39 static AttributeDescription     *ad_errText;
  40 static AttributeDescription     *ad_errOp;
  41 static AttributeDescription     *ad_errSleepTime;
  42 static AttributeDescription     *ad_errMatchedDN;
  43 static ObjectClass              *oc_errAbsObject;
  44 static ObjectClass              *oc_errObject;
  45 static ObjectClass              *oc_errAuxObject;
  46
  47 typedef enum retcode_op_e {
  48         SN_DG_OP_NONE           = 0x0000,
  49         SN_DG_OP_ADD            = 0x0001,
  50         SN_DG_OP_BIND           = 0x0002,
  51         SN_DG_OP_COMPARE        = 0x0004,
  52         SN_DG_OP_DELETE         = 0x0008,
  53         SN_DG_OP_MODIFY         = 0x0010,
  54         SN_DG_OP_RENAME         = 0x0020,
  55         SN_DG_OP_SEARCH         = 0x0040,
  56         SN_DG_EXTENDED          = 0x0080,
  57         SN_DG_OP_AUTH           = SN_DG_OP_BIND,
  58         SN_DG_OP_READ           = (SN_DG_OP_COMPARE|SN_DG_OP_SEARCH),
  59         SN_DG_OP_WRITE          = (SN_DG_OP_ADD|SN_DG_OP_DELETE|SN_DG_OP_MODIFY|SN_DG_OP_RENAME),
  60         SN_DG_OP_ALL            = (SN_DG_OP_AUTH|SN_DG_OP_READ|SN_DG_OP_WRITE|SN_DG_EXTENDED)
  61 } retcode_op_e;
  62
  63 typedef struct retcode_item_t {
  64         struct berval           rdi_dn;
  65         struct berval           rdi_ndn;
  66         struct berval           rdi_text;
  67         struct berval           rdi_matched;
  68         int                     rdi_err;
  69         BerVarray               rdi_ref;
  70         int                     rdi_sleeptime;
  71         Entry                   rdi_e;
  72         slap_mask_t             rdi_mask;
  73         struct retcode_item_t   *rdi_next;
  74 } retcode_item_t;
  75
  76 typedef struct retcode_t {
  77         struct berval           rd_pdn;
  78         struct berval           rd_npdn;
  79
  80         retcode_item_t          *rd_item;
  81
  82         unsigned                rd_flags;
  83 #define RETCODE_FNONE           0x00
  84 #define RETCODE_FINDIR          0x01
  85 #define RETCODE_INDIR( rd )     ( (rd)->rd_flags & RETCODE_FINDIR )
  86 } retcode_t;
  87
  88 static int
  89 retcode_entry_response( Operation *op, SlapReply *rs, Entry *e );
  90
  91 static int
  92 retcode_cleanup_cb( Operation *op, SlapReply *rs )
  93 {
  94         rs->sr_matched = NULL;
  95         rs->sr_text = NULL;
  96
  97         if ( rs->sr_ref != NULL ) {
  98                 ber_bvarray_free( rs->sr_ref );
  99                 rs->sr_ref = NULL;
 100         }
 101
 102         ch_free( op->o_callback );
 103         op->o_callback = NULL;
 104
 105         return SLAP_CB_CONTINUE;
 106 }
 107
 108 static int
 109 retcode_send_onelevel( Operation *op, SlapReply *rs )
 110 {
 111         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 112         retcode_t       *rd = (retcode_t *)on->on_bi.bi_private;
 113
 114         retcode_item_t  *rdi;
 115
 116         for ( rdi = rd->rd_item; rdi != NULL; rdi = rdi->rdi_next ) {
 117                 int     rc;
 118
 119                 if ( op->o_abandon ) {
 120                         return rs->sr_err = SLAPD_ABANDON;
 121                 }
 122
 123                 rs->sr_err = test_filter( op, &rdi->rdi_e, op->ors_filter );
 124                 if ( rs->sr_err == LDAP_COMPARE_TRUE ) {
 125                         if ( op->ors_slimit == rs->sr_nentries ) {
 126                                 rs->sr_err = LDAP_SIZELIMIT_EXCEEDED;
 127                                 goto done;
 128                         }
 129
 130                         /* safe default */
 131                         rs->sr_attrs = op->ors_attrs;
 132                         rs->sr_operational_attrs = NULL;
 133                         rs->sr_ctrls = NULL;
 134                         rs->sr_flags = 0;
 135                         rs->sr_err = LDAP_SUCCESS;
 136                         rs->sr_entry = &rdi->rdi_e;
 137
 138                         rc = send_search_entry( op, rs );
 139
 140                         switch ( rc ) {
 141                         case 0:         /* entry sent ok */
 142                                 break;
 143                         case 1:         /* entry not sent */
 144                                 break;
 145                         case -1:        /* connection closed */
 146                                 rs->sr_entry = NULL;
 147                                 rs->sr_err = LDAP_OTHER;
 148                                 goto done;
 149                         }
 150                 }
 151                 rs->sr_err = LDAP_SUCCESS;
 152         }
 153
 154 done:;
 155
 156         send_ldap_result( op, rs );
 157
 158         return rs->sr_err;
 159 }
 160
 161 static int
 162 retcode_op_add( Operation *op, SlapReply *rs )
 163 {
 164         return retcode_entry_response( op, rs, op->ora_e );
 165 }
 166
 167 typedef struct retcode_cb_t {
 168         unsigned        rdc_flags;
 169         ber_tag_t       rdc_tag;
 170         AttributeName   *rdc_attrs;
 171 } retcode_cb_t;
 172
 173 static int
 174 retcode_cb_response( Operation *op, SlapReply *rs )
 175 {
 176         retcode_cb_t    *rdc = (retcode_cb_t *)op->o_callback->sc_private;
 177
 178         if ( rs->sr_type == REP_SEARCH ) {
 179                 ber_tag_t       o_tag = op->o_tag;
 180                 int             rc;
 181
 182                 op->o_tag = rdc->rdc_tag;
 183                 if ( op->o_tag == LDAP_REQ_SEARCH ) {
 184                         rs->sr_attrs = rdc->rdc_attrs;
 185                 }
 186                 rc = retcode_entry_response( op, rs, rs->sr_entry );
 187                 op->o_tag = o_tag;
 188
 189                 return rc;
 190         }
 191
 192         if ( rs->sr_err == LDAP_SUCCESS ) {
 193                 if ( !op->o_abandon ) {
 194                         rdc->rdc_flags = SLAP_CB_CONTINUE;
 195                 }
 196                 return 0;
 197         }
 198
 199         return SLAP_CB_CONTINUE;
 200 }
 201
 202 static int
 203 retcode_op_internal( Operation *op, SlapReply *rs )
 204 {
 205         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 206
 207         Operation       op2 = *op;
 208         SlapReply       rs2 = { 0 };
 209         BackendDB       db = *op->o_bd;
 210         slap_callback   sc = { 0 };
 211         retcode_cb_t    rdc;
 212
 213         int             rc;
 214
 215         op2.o_tag = LDAP_REQ_SEARCH;
 216         op2.ors_scope = LDAP_SCOPE_BASE;
 217         op2.ors_deref = LDAP_DEREF_NEVER;
 218         op2.ors_tlimit = SLAP_NO_LIMIT;
 219         op2.ors_slimit = SLAP_NO_LIMIT;
 220         op2.ors_limit = NULL;
 221         op2.ors_attrsonly = 0;
 222         op2.ors_attrs = slap_anlist_all_attributes;
 223
 224         ber_str2bv_x( "(objectClass=errAbsObject)",
 225                 STRLENOF( "(objectClass=errAbsObject)" ),
 226                 1, &op2.ors_filterstr, op2.o_tmpmemctx );
 227         op2.ors_filter = str2filter_x( &op2, op2.ors_filterstr.bv_val );
 228
 229         db.bd_info = on->on_info->oi_orig;
 230         op2.o_bd = &db;
 231
 232         rdc.rdc_flags = RETCODE_FINDIR;
 233         if ( op->o_tag == LDAP_REQ_SEARCH ) {
 234                 rdc.rdc_attrs = op->ors_attrs;
 235         }
 236         rdc.rdc_tag = op->o_tag;
 237         sc.sc_response = retcode_cb_response;
 238         sc.sc_private = &rdc;
 239         op2.o_callback = &sc;
 240
 241         rc = op2.o_bd->be_search( &op2, &rs2 );
 242
 243         filter_free_x( &op2, op2.ors_filter );
 244         ber_memfree_x( op2.ors_filterstr.bv_val, op2.o_tmpmemctx );
 245
 246         if ( rdc.rdc_flags == SLAP_CB_CONTINUE ) {
 247                 return SLAP_CB_CONTINUE;
 248         }
 249
 250         return rc;
 251 }
 252
 253 static int
 254 retcode_op_func( Operation *op, SlapReply *rs )
 255 {
 256         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 257         retcode_t       *rd = (retcode_t *)on->on_bi.bi_private;
 258
 259         retcode_item_t  *rdi;
 260         struct berval           nrdn, npdn;
 261
 262         slap_callback           *cb = NULL;
 263
 264         if ( !dnIsSuffix( &op->o_req_ndn, &rd->rd_npdn ) ) {
 265                 if ( RETCODE_INDIR( rd ) ) {
 266                         switch ( op->o_tag ) {
 267                         case LDAP_REQ_ADD:
 268                                 return retcode_op_add( op, rs );
 269
 270                         case LDAP_REQ_BIND:
 271                                 /* skip if rootdn */
 272                                 if ( be_isroot_pw( op ) ) {
 273                                         return SLAP_CB_CONTINUE;
 274                                 }
 275                                 return retcode_op_internal( op, rs );
 276
 277                         case LDAP_REQ_SEARCH:
 278                                 if ( op->ors_scope == LDAP_SCOPE_BASE ) {
 279                                         rs->sr_err = retcode_op_internal( op, rs );
 280                                         if ( rs->sr_err == SLAP_CB_CONTINUE ) {
 281                                                 rs->sr_err = LDAP_SUCCESS;
 282                                         }
 283                                         send_ldap_result( op, rs );
 284                                         return rs->sr_err;
 285                                 }
 286                                 break;
 287
 288                         case LDAP_REQ_MODIFY:
 289                         case LDAP_REQ_DELETE:
 290                         case LDAP_REQ_MODRDN:
 291                         case LDAP_REQ_COMPARE:
 292                                 return retcode_op_internal( op, rs );
 293                         }
 294                 }
 295
 296                 return SLAP_CB_CONTINUE;
 297         }
 298
 299         if ( op->o_tag == LDAP_REQ_SEARCH
 300                         && op->ors_scope != LDAP_SCOPE_BASE
 301                         && op->o_req_ndn.bv_len == rd->rd_npdn.bv_len )
 302         {
 303                 return retcode_send_onelevel( op, rs );
 304         }
 305
 306         dnParent( &op->o_req_ndn, &npdn );
 307         if ( npdn.bv_len != rd->rd_npdn.bv_len ) {
 308                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 309                 rs->sr_matched = rd->rd_pdn.bv_val;
 310                 send_ldap_result( op, rs );
 311                 rs->sr_matched = NULL;
 312                 return rs->sr_err;
 313         }
 314
 315         dnRdn( &op->o_req_ndn, &nrdn );
 316
 317         for ( rdi = rd->rd_item; rdi != NULL; rdi = rdi->rdi_next ) {
 318                 struct berval   rdi_nrdn;
 319
 320                 dnRdn( &rdi->rdi_ndn, &rdi_nrdn );
 321                 if ( dn_match( &nrdn, &rdi_nrdn ) ) {
 322                         break;
 323                 }
 324         }
 325
 326         if ( rdi != NULL && rdi->rdi_mask != SN_DG_OP_ALL ) {
 327                 retcode_op_e    o_tag = SN_DG_OP_NONE;
 328
 329                 switch ( op->o_tag ) {
 330                 case LDAP_REQ_ADD:
 331                         o_tag = SN_DG_OP_ADD;
 332                         break;
 333
 334                 case LDAP_REQ_BIND:
 335                         o_tag = SN_DG_OP_BIND;
 336                         break;
 337
 338                 case LDAP_REQ_COMPARE:
 339                         o_tag = SN_DG_OP_COMPARE;
 340                         break;
 341
 342                 case LDAP_REQ_DELETE:
 343                         o_tag = SN_DG_OP_DELETE;
 344                         break;
 345
 346                 case LDAP_REQ_MODIFY:
 347                         o_tag = SN_DG_OP_MODIFY;
 348                         break;
 349
 350                 case LDAP_REQ_MODRDN:
 351                         o_tag = SN_DG_OP_RENAME;
 352                         break;
 353
 354                 case LDAP_REQ_SEARCH:
 355                         o_tag = SN_DG_OP_SEARCH;
 356                         break;
 357
 358                 case LDAP_REQ_EXTENDED:
 359                         o_tag = SN_DG_EXTENDED;
 360                         break;
 361
 362                 default:
 363                         /* Should not happen */
 364                         break;
 365                 }
 366
 367                 if ( !( o_tag & rdi->rdi_mask ) ) {
 368                         return SLAP_CB_CONTINUE;
 369                 }
 370         }
 371
 372         if ( rdi == NULL ) {
 373                 rs->sr_matched = rd->rd_pdn.bv_val;
 374                 rs->sr_err = LDAP_NO_SUCH_OBJECT;
 375                 rs->sr_text = "retcode not found";
 376
 377         } else {
 378                 rs->sr_err = rdi->rdi_err;
 379                 rs->sr_text = rdi->rdi_text.bv_val;
 380                 rs->sr_matched = rdi->rdi_matched.bv_val;
 381
 382                 /* FIXME: we only honor the rdi_ref field in case rdi_err
 383                  * is LDAP_REFERRAL otherwise send_ldap_result() bails out */
 384                 if ( rs->sr_err == LDAP_REFERRAL ) {
 385                         BerVarray       ref;
 386
 387                         if ( rdi->rdi_ref != NULL ) {
 388                                 ref = rdi->rdi_ref;
 389                         } else {
 390                                 ref = default_referral;
 391                         }
 392
 393                         if ( ref != NULL ) {
 394                                 rs->sr_ref = referral_rewrite( ref,
 395                                         NULL, &op->o_req_dn, LDAP_SCOPE_DEFAULT );
 396
 397                         } else {
 398                                 rs->sr_err = LDAP_OTHER;
 399                                 rs->sr_text = "bad referral object";
 400                         }
 401                 }
 402
 403                 if ( rdi->rdi_sleeptime > 0 ) {
 404                         sleep( rdi->rdi_sleeptime );
 405                 }
 406         }
 407
 408         switch ( op->o_tag ) {
 409         case LDAP_REQ_EXTENDED:
 410                 if ( rdi == NULL ) {
 411                         break;
 412                 }
 413                 cb = ( slap_callback * )ch_malloc( sizeof( slap_callback ) );
 414                 memset( cb, 0, sizeof( slap_callback ) );
 415                 cb->sc_cleanup = retcode_cleanup_cb;
 416                 op->o_callback = cb;
 417                 break;
 418
 419         default:
 420                 send_ldap_result( op, rs );
 421                 if ( rs->sr_ref != NULL ) {
 422                         ber_bvarray_free( rs->sr_ref );
 423                         rs->sr_ref = NULL;
 424                 }
 425                 rs->sr_matched = NULL;
 426                 rs->sr_text = NULL;
 427                 break;
 428         }
 429
 430         return rs->sr_err;
 431 }
 432
 433 static int
 434 retcode_op2str( ber_tag_t op, struct berval *bv )
 435 {
 436         switch ( op ) {
 437         case LDAP_REQ_BIND:
 438                 BER_BVSTR( bv, "bind" );
 439                 return 0;
 440         case LDAP_REQ_ADD:
 441                 BER_BVSTR( bv, "add" );
 442                 return 0;
 443         case LDAP_REQ_DELETE:
 444                 BER_BVSTR( bv, "delete" );
 445                 return 0;
 446         case LDAP_REQ_MODRDN:
 447                 BER_BVSTR( bv, "modrdn" );
 448                 return 0;
 449         case LDAP_REQ_MODIFY:
 450                 BER_BVSTR( bv, "modify" );
 451                 return 0;
 452         case LDAP_REQ_COMPARE:
 453                 BER_BVSTR( bv, "compare" );
 454                 return 0;
 455         case LDAP_REQ_SEARCH:
 456                 BER_BVSTR( bv, "search" );
 457                 return 0;
 458         case LDAP_REQ_EXTENDED:
 459                 BER_BVSTR( bv, "extended" );
 460                 return 0;
 461         }
 462         return -1;
 463 }
 464
 465 static int
 466 retcode_entry_response( Operation *op, SlapReply *rs, Entry *e )
 467 {
 468         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 469
 470         Attribute       *a;
 471         int             err;
 472         char            *next;
 473
 474         if ( get_manageDSAit( op ) ) {
 475                 return SLAP_CB_CONTINUE;
 476         }
 477
 478         if ( !is_entry_objectclass_or_sub( e, oc_errAbsObject ) ) {
 479                 return SLAP_CB_CONTINUE;
 480         }
 481
 482         /* operation */
 483         a = attr_find( e->e_attrs, ad_errOp );
 484         if ( a != NULL ) {
 485                 int             i,
 486                                 gotit = 0;
 487                 struct berval   bv = BER_BVNULL;
 488
 489                 (void)retcode_op2str( op->o_tag, &bv );
 490
 491                 if ( BER_BVISNULL( &bv ) ) {
 492                         return SLAP_CB_CONTINUE;
 493                 }
 494
 495                 for ( i = 0; !BER_BVISNULL( &a->a_nvals[ i ] ); i++ ) {
 496                         if ( bvmatch( &a->a_nvals[ i ], &bv ) ) {
 497                                 gotit = 1;
 498                                 break;
 499                         }
 500                 }
 501
 502                 if ( !gotit ) {
 503                         return SLAP_CB_CONTINUE;
 504                 }
 505         }
 506
 507         /* error code */
 508         a = attr_find( e->e_attrs, ad_errCode );
 509         if ( a == NULL ) {
 510                 return SLAP_CB_CONTINUE;
 511         }
 512         err = strtol( a->a_nvals[ 0 ].bv_val, &next, 0 );
 513         if ( next == a->a_nvals[ 0 ].bv_val || next[ 0 ] != '\0' ) {
 514                 return SLAP_CB_CONTINUE;
 515         }
 516         rs->sr_err = err;
 517
 518         /* sleep time */
 519         a = attr_find( e->e_attrs, ad_errSleepTime );
 520         if ( a != NULL ) {
 521                 int     sleepTime;
 522
 523                 sleepTime = strtoul( a->a_nvals[ 0 ].bv_val, &next, 0 );
 524                 if ( next != a->a_nvals[ 0 ].bv_val && next[ 0 ] == '\0' ) {
 525                         sleep( sleepTime );
 526                 }
 527         }
 528
 529         if ( rs->sr_err != LDAP_SUCCESS ) {
 530                 BackendDB       db = *op->o_bd;
 531                 void            *o_callback = op->o_callback;
 532
 533                 /* message text */
 534                 a = attr_find( e->e_attrs, ad_errText );
 535                 if ( a != NULL ) {
 536                         rs->sr_text = a->a_vals[ 0 ].bv_val;
 537                 }
 538
 539                 /* matched DN */
 540                 a = attr_find( e->e_attrs, ad_errMatchedDN );
 541                 if ( a != NULL ) {
 542                         rs->sr_matched = a->a_vals[ 0 ].bv_val;
 543                 }
 544
 545                 db.bd_info = on->on_info->oi_orig;
 546                 op->o_bd = &db;
 547                 op->o_callback = NULL;
 548
 549                 /* referral */
 550                 if ( rs->sr_err == LDAP_REFERRAL ) {
 551                         BerVarray       refs = default_referral;
 552
 553                         a = attr_find( e->e_attrs, slap_schema.si_ad_ref );
 554                         if ( a != NULL ) {
 555                                 refs = a->a_vals;
 556                         }
 557                         rs->sr_ref = referral_rewrite( refs,
 558                                 NULL, &op->o_req_dn, op->oq_search.rs_scope );
 559
 560                         send_search_reference( op, rs );
 561                         ber_bvarray_free( rs->sr_ref );
 562                         rs->sr_ref = NULL;
 563
 564                 } else {
 565                         send_ldap_result( op, rs );
 566                 }
 567
 568                 rs->sr_text = NULL;
 569                 rs->sr_matched = NULL;
 570                 op->o_callback = o_callback;
 571         }
 572
 573         if ( rs->sr_err != LDAP_SUCCESS ) {
 574                 op->o_abandon = 1;
 575                 return rs->sr_err;
 576         }
 577
 578         return SLAP_CB_CONTINUE;
 579 }
 580
 581 static int
 582 retcode_response( Operation *op, SlapReply *rs )
 583 {
 584         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
 585         retcode_t       *rd = (retcode_t *)on->on_bi.bi_private;
 586
 587         if ( rs->sr_type != REP_SEARCH || !RETCODE_INDIR( rd ) ) {
 588                 return SLAP_CB_CONTINUE;
 589         }
 590
 591         return retcode_entry_response( op, rs, rs->sr_entry );
 592 }
 593
 594 static int
 595 retcode_db_init( BackendDB *be )
 596 {
 597         slap_overinst   *on = (slap_overinst *)be->bd_info;
 598         retcode_t       *rd;
 599
 600         rd = (retcode_t *)ch_malloc( sizeof( retcode_t ) );
 601         memset( rd, 0, sizeof( retcode_t ) );
 602
 603         on->on_bi.bi_private = (void *)rd;
 604
 605         return 0;
 606 }
 607
 608 static int
 609 retcode_db_config(
 610         BackendDB       *be,
 611         const char      *fname,
 612         int             lineno,
 613         int             argc,
 614         char            **argv )
 615 {
 616         slap_overinst   *on = (slap_overinst *)be->bd_info;
 617         retcode_t       *rd = (retcode_t *)on->on_bi.bi_private;
 618
 619         char                    *argv0 = argv[ 0 ] + STRLENOF( "retcode-" );
 620
 621         if ( strncasecmp( argv[ 0 ], "retcode-", STRLENOF( "retcode-" ) ) != 0 ) {
 622                 return SLAP_CONF_UNKNOWN;
 623         }
 624
 625         if ( strcasecmp( argv0, "parent" ) == 0 ) {
 626                 struct berval   dn;
 627                 int             rc;
 628
 629                 if ( argc != 2 ) {
 630                         fprintf( stderr, "%s: line %d: retcode: "
 631                                 "\"retcode-parent <DN>\": missing <DN>\n",
 632                                 fname, lineno );
 633                         return 1;
 634                 }
 635
 636                 if ( !BER_BVISNULL( &rd->rd_pdn ) ) {
 637                         fprintf( stderr, "%s: line %d: retcode: "
 638                                 "parent already defined.\n", fname, lineno );
 639                         return 1;
 640                 }
 641
 642                 ber_str2bv( argv[ 1 ], 0, 0, &dn );
 643
 644                 rc = dnPrettyNormal( NULL, &dn, &rd->rd_pdn, &rd->rd_npdn, NULL );
 645                 if ( rc != LDAP_SUCCESS ) {
 646                         fprintf( stderr, "%s: line %d: retcode: "
 647                                 "unable to normalize parent DN \"%s\": %d\n",
 648                                 fname, lineno, argv[ 1 ], rc );
 649                         return 1;
 650                 }
 651
 652         } else if ( strcasecmp( argv0, "item" ) == 0 ) {
 653                 retcode_item_t  rdi = { BER_BVNULL }, **rdip;
 654                 struct berval           bv, rdn, nrdn;
 655                 int                     rc;
 656                 char                    *next = NULL;
 657
 658                 if ( argc < 3 ) {
 659                         fprintf( stderr, "%s: line %d: retcode: "
 660                                 "\"retcode-item <RDN> <retcode> [<text>]\": "
 661                                 "missing args\n",
 662                                 fname, lineno );
 663                         return 1;
 664                 }
 665
 666                 ber_str2bv( argv[ 1 ], 0, 0, &bv );
 667
 668                 rc = dnPrettyNormal( NULL, &bv, &rdn, &nrdn, NULL );
 669                 if ( rc != LDAP_SUCCESS ) {
 670                         fprintf( stderr, "%s: line %d: retcode: "
 671                                 "unable to normalize RDN \"%s\": %d\n",
 672                                 fname, lineno, argv[ 1 ], rc );
 673                         return 1;
 674                 }
 675
 676                 if ( !dnIsOneLevelRDN( &nrdn ) ) {
 677                         fprintf( stderr, "%s: line %d: retcode: "
 678                                 "value \"%s\" is not a RDN\n",
 679                                 fname, lineno, argv[ 1 ] );
 680                         return 1;
 681                 }
 682
 683                 if ( BER_BVISNULL( &rd->rd_npdn ) ) {
 684                         /* FIXME: we use the database suffix */
 685                         if ( be->be_nsuffix == NULL ) {
 686                                 fprintf( stderr, "%s: line %d: retcode: "
 687                                         "either \"retcode-parent\" "
 688                                         "or \"suffix\" must be defined.\n",
 689                                         fname, lineno );
 690                                 return 1;
 691                         }
 692
 693                         ber_dupbv( &rd->rd_pdn, &be->be_suffix[ 0 ] );
 694                         ber_dupbv( &rd->rd_npdn, &be->be_nsuffix[ 0 ] );
 695                 }
 696
 697                 build_new_dn( &rdi.rdi_dn, &rd->rd_pdn, &rdn, NULL );
 698                 build_new_dn( &rdi.rdi_ndn, &rd->rd_npdn, &nrdn, NULL );
 699
 700                 ch_free( rdn.bv_val );
 701                 ch_free( nrdn.bv_val );
 702
 703                 rdi.rdi_err = strtol( argv[ 2 ], &next, 0 );
 704                 if ( next == argv[ 2 ] || next[ 0 ] != '\0' ) {
 705                         fprintf( stderr, "%s: line %d: retcode: "
 706                                 "unable to parse return code \"%s\"\n",
 707                                 fname, lineno, argv[ 2 ] );
 708                         return 1;
 709                 }
 710
 711                 rdi.rdi_mask = SN_DG_OP_ALL;
 712
 713                 if ( argc > 3 ) {
 714                         int     i;
 715
 716                         for ( i = 3; i < argc; i++ ) {
 717                                 if ( strncasecmp( argv[ i ], "op=", STRLENOF( "op=" ) ) == 0 )
 718                                 {
 719                                         char            **ops;
 720                                         int             j;
 721
 722                                         ops = ldap_str2charray( &argv[ i ][ STRLENOF( "op=" ) ], "," );
 723                                         assert( ops != NULL );
 724
 725                                         rdi.rdi_mask = SN_DG_OP_NONE;
 726
 727                                         for ( j = 0; ops[ j ] != NULL; j++ ) {
 728                                                 if ( strcasecmp( ops[ j ], "add" ) == 0 ) {
 729                                                         rdi.rdi_mask |= SN_DG_OP_ADD;
 730
 731                                                 } else if ( strcasecmp( ops[ j ], "bind" ) == 0 ) {
 732                                                         rdi.rdi_mask |= SN_DG_OP_BIND;
 733
 734                                                 } else if ( strcasecmp( ops[ j ], "compare" ) == 0 ) {
 735                                                         rdi.rdi_mask |= SN_DG_OP_COMPARE;
 736
 737                                                 } else if ( strcasecmp( ops[ j ], "delete" ) == 0 ) {
 738                                                         rdi.rdi_mask |= SN_DG_OP_DELETE;
 739
 740                                                 } else if ( strcasecmp( ops[ j ], "modify" ) == 0 ) {
 741                                                         rdi.rdi_mask |= SN_DG_OP_MODIFY;
 742
 743                                                 } else if ( strcasecmp( ops[ j ], "rename" ) == 0
 744                                                         || strcasecmp( ops[ j ], "modrdn" ) == 0 )
 745                                                 {
 746                                                         rdi.rdi_mask |= SN_DG_OP_RENAME;
 747
 748                                                 } else if ( strcasecmp( ops[ j ], "search" ) == 0 ) {
 749                                                         rdi.rdi_mask |= SN_DG_OP_SEARCH;
 750
 751                                                 } else if ( strcasecmp( ops[ j ], "extended" ) == 0 ) {
 752                                                         rdi.rdi_mask |= SN_DG_EXTENDED;
 753
 754                                                 } else if ( strcasecmp( ops[ j ], "auth" ) == 0 ) {
 755                                                         rdi.rdi_mask |= SN_DG_OP_AUTH;
 756
 757                                                 } else if ( strcasecmp( ops[ j ], "read" ) == 0 ) {
 758                                                         rdi.rdi_mask |= SN_DG_OP_READ;
 759
 760                                                 } else if ( strcasecmp( ops[ j ], "write" ) == 0 ) {
 761                                                         rdi.rdi_mask |= SN_DG_OP_WRITE;
 762
 763                                                 } else if ( strcasecmp( ops[ j ], "all" ) == 0 ) {
 764                                                         rdi.rdi_mask |= SN_DG_OP_ALL;
 765
 766                                                 } else {
 767                                                         fprintf( stderr, "retcode: unknown op \"%s\"\n",
 768                                                                 ops[ j ] );
 769                                                         return 1;
 770                                                 }
 771                                         }
 772
 773                                         ldap_charray_free( ops );
 774
 775                                 } else if ( strncasecmp( argv[ i ], "text=", STRLENOF( "text=" ) ) == 0 )
 776                                 {
 777                                         if ( !BER_BVISNULL( &rdi.rdi_text ) ) {
 778                                                 fprintf( stderr, "%s: line %d: retcode: "
 779                                                         "\"text\" already provided.\n",
 780                                                         fname, lineno );
 781                                                 return 1;
 782                                         }
 783                                         ber_str2bv( &argv[ i ][ STRLENOF( "text=" ) ], 0, 1, &rdi.rdi_text );
 784
 785                                 } else if ( strncasecmp( argv[ i ], "matched=", STRLENOF( "matched=" ) ) == 0 )
 786                                 {
 787                                         struct berval   dn;
 788
 789                                         if ( !BER_BVISNULL( &rdi.rdi_matched ) ) {
 790                                                 fprintf( stderr, "%s: line %d: retcode: "
 791                                                         "\"matched\" already provided.\n",
 792                                                         fname, lineno );
 793                                                 return 1;
 794                                         }
 795                                         ber_str2bv( &argv[ i ][ STRLENOF( "matched=" ) ], 0, 0, &dn );
 796                                         if ( dnPretty( NULL, &dn, &rdi.rdi_matched, NULL ) != LDAP_SUCCESS ) {
 797                                                 fprintf( stderr, "%s: line %d: retcode: "
 798                                                         "unable to prettify matched DN \"%s\".\n",
 799                                                         fname, lineno, &argv[ i ][ STRLENOF( "matched=" ) ] );
 800                                                 return 1;
 801                                         }
 802
 803                                 } else if ( strncasecmp( argv[ i ], "ref=", STRLENOF( "ref=" ) ) == 0 )
 804                                 {
 805                                         char            **refs;
 806                                         int             j;
 807
 808                                         if ( rdi.rdi_ref != NULL ) {
 809                                                 fprintf( stderr, "%s: line %d: retcode: "
 810                                                         "\"ref\" already provided.\n",
 811                                                         fname, lineno );
 812                                                 return 1;
 813                                         }
 814
 815                                         if ( rdi.rdi_err != LDAP_REFERRAL ) {
 816                                                 fprintf( stderr, "%s: line %d: retcode: "
 817                                                         "providing \"ref\"\n"
 818                                                         "\talong with a non-referral "
 819                                                         "resultCode may cause slapd failures\n"
 820                                                         "\trelated to internal checks.\n",
 821                                                         fname, lineno );
 822                                         }
 823
 824                                         refs = ldap_str2charray( &argv[ i ][ STRLENOF( "ref=" ) ], " " );
 825                                         assert( refs != NULL );
 826
 827                                         for ( j = 0; refs[ j ] != NULL; j++ ) {
 828                                                 struct berval   bv;
 829
 830                                                 ber_str2bv( refs[ j ], 0, 1, &bv );
 831                                                 ber_bvarray_add( &rdi.rdi_ref, &bv );
 832                                         }
 833
 834                                         ldap_charray_free( refs );
 835
 836                                 } else if ( strncasecmp( argv[ i ], "sleeptime=", STRLENOF( "sleeptime=" ) ) == 0 )
 837                                 {
 838                                         char            *next;
 839                                         if ( rdi.rdi_sleeptime != 0 ) {
 840                                                 fprintf( stderr, "%s: line %d: retcode: "
 841                                                         "\"sleeptime\" already provided.\n",
 842                                                         fname, lineno );
 843                                                 return 1;
 844                                         }
 845
 846                                         rdi.rdi_sleeptime = strtol( &argv[ i ][ STRLENOF( "sleeptime=" ) ], &next, 10 );
 847                                         if ( next == argv[ i ] || next[ 0 ] != '\0' ) {
 848                                                 fprintf( stderr, "%s: line %d: retcode: "
 849                                                         "unable to parse \"sleeptime=%s\".\n",
 850                                                         fname, lineno, &argv[ i ][ STRLENOF( "sleeptime=" ) ] );
 851                                                 return 1;
 852                                         }
 853
 854                                 } else {
 855                                         fprintf( stderr, "%s: line %d: retcode: "
 856                                                 "unknown option \"%s\".\n",
 857                                                         fname, lineno, argv[ i ] );
 858                                         return 1;
 859                                 }
 860                         }
 861                 }
 862
 863                 for ( rdip = &rd->rd_item; *rdip; rdip = &(*rdip)->rdi_next )
 864                         /* go to last */ ;
 865
 866
 867                 *rdip = ( retcode_item_t * )ch_malloc( sizeof( retcode_item_t ) );
 868                 *(*rdip) = rdi;
 869
 870         } else if ( strcasecmp( argv0, "indir" ) == 0 ) {
 871                 rd->rd_flags |= RETCODE_FINDIR;
 872
 873         } else {
 874                 return SLAP_CONF_UNKNOWN;
 875         }
 876
 877         return 0;
 878 }
 879
 880 static int
 881 retcode_db_open( BackendDB *be )
 882 {
 883         slap_overinst   *on = (slap_overinst *)be->bd_info;
 884         retcode_t       *rd = (retcode_t *)on->on_bi.bi_private;
 885
 886         retcode_item_t  *rdi;
 887
 888         for ( rdi = rd->rd_item; rdi; rdi = rdi->rdi_next ) {
 889                 LDAPRDN                 rdn = NULL;
 890                 int                     rc, j;
 891                 char*                   p;
 892                 struct berval           val[ 3 ];
 893                 char                    buf[ SLAP_TEXT_BUFLEN ];
 894
 895                 /* DN */
 896                 rdi->rdi_e.e_name = rdi->rdi_dn;
 897                 rdi->rdi_e.e_nname = rdi->rdi_ndn;
 898
 899                 /* objectClass */
 900                 val[ 0 ] = oc_errObject->soc_cname;
 901                 val[ 1 ] = slap_schema.si_oc_extensibleObject->soc_cname;
 902                 BER_BVZERO( &val[ 2 ] );
 903
 904                 attr_merge( &rdi->rdi_e, slap_schema.si_ad_objectClass, val, NULL );
 905
 906                 /* RDN avas */
 907                 rc = ldap_bv2rdn( &rdi->rdi_dn, &rdn, (char **) &p,
 908                                 LDAP_DN_FORMAT_LDAP );
 909
 910                 assert( rc == LDAP_SUCCESS );
 911
 912                 for ( j = 0; rdn[ j ]; j++ ) {
 913                         LDAPAVA                 *ava = rdn[ j ];
 914                         AttributeDescription    *ad = NULL;
 915                         const char              *text;
 916
 917                         rc = slap_bv2ad( &ava->la_attr, &ad, &text );
 918                         assert( rc == LDAP_SUCCESS );
 919
 920                         attr_merge_normalize_one( &rdi->rdi_e, ad,
 921                                         &ava->la_value, NULL );
 922                 }
 923
 924                 ldap_rdnfree( rdn );
 925
 926                 /* error code */
 927                 snprintf( buf, sizeof( buf ), "%d", rdi->rdi_err );
 928                 ber_str2bv( buf, 0, 0, &val[ 0 ] );
 929
 930                 attr_merge_one( &rdi->rdi_e, ad_errCode, &val[ 0 ], NULL );
 931
 932                 if ( rdi->rdi_ref != NULL ) {
 933                         attr_merge_normalize( &rdi->rdi_e, slap_schema.si_ad_ref,
 934                                 rdi->rdi_ref, NULL );
 935                 }
 936
 937                 /* text */
 938                 if ( !BER_BVISNULL( &rdi->rdi_text ) ) {
 939                         val[ 0 ] = rdi->rdi_text;
 940
 941                         attr_merge_normalize_one( &rdi->rdi_e, ad_errText, &val[ 0 ], NULL );
 942                 }
 943
 944                 /* matched */
 945                 if ( !BER_BVISNULL( &rdi->rdi_matched ) ) {
 946                         val[ 0 ] = rdi->rdi_matched;
 947
 948                         attr_merge_normalize_one( &rdi->rdi_e, ad_errMatchedDN, &val[ 0 ], NULL );
 949                 }
 950
 951                 /* sleep time */
 952                 if ( rdi->rdi_sleeptime > 0 ) {
 953                         snprintf( buf, sizeof( buf ), "%d", rdi->rdi_sleeptime );
 954                         ber_str2bv( buf, 0, 0, &val[ 0 ] );
 955
 956                         attr_merge_one( &rdi->rdi_e, ad_errSleepTime, &val[ 0 ], NULL );
 957                 }
 958
 959                 /* operations */
 960                 if ( rdi->rdi_mask & SN_DG_OP_ADD ) {
 961                         BER_BVSTR( &val[ 0 ], "add" );
 962                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 963                 }
 964
 965                 if ( rdi->rdi_mask & SN_DG_OP_BIND ) {
 966                         BER_BVSTR( &val[ 0 ], "bind" );
 967                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 968                 }
 969
 970                 if ( rdi->rdi_mask & SN_DG_OP_COMPARE ) {
 971                         BER_BVSTR( &val[ 0 ], "compare" );
 972                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 973                 }
 974
 975                 if ( rdi->rdi_mask & SN_DG_OP_DELETE ) {
 976                         BER_BVSTR( &val[ 0 ], "delete" );
 977                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 978                 }
 979
 980                 if ( rdi->rdi_mask & SN_DG_EXTENDED ) {
 981                         BER_BVSTR( &val[ 0 ], "extended" );
 982                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 983                 }
 984
 985                 if ( rdi->rdi_mask & SN_DG_OP_MODIFY ) {
 986                         BER_BVSTR( &val[ 0 ], "modify" );
 987                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 988                 }
 989
 990                 if ( rdi->rdi_mask & SN_DG_OP_RENAME ) {
 991                         BER_BVSTR( &val[ 0 ], "rename" );
 992                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 993                 }
 994
 995                 if ( rdi->rdi_mask & SN_DG_OP_SEARCH ) {
 996                         BER_BVSTR( &val[ 0 ], "search" );
 997                         attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL );
 998                 }
 999         }
1000
1001         return 0;
1002 }
1003
1004 static int
1005 retcode_db_destroy( BackendDB *be )
1006 {
1007         slap_overinst   *on = (slap_overinst *)be->bd_info;
1008         retcode_t       *rd = (retcode_t *)on->on_bi.bi_private;
1009
1010         if ( rd ) {
1011                 retcode_item_t  *rdi, *next;
1012
1013                 for ( rdi = rd->rd_item; rdi != NULL; rdi = next ) {
1014                         ber_memfree( rdi->rdi_dn.bv_val );
1015                         ber_memfree( rdi->rdi_ndn.bv_val );
1016
1017                         if ( !BER_BVISNULL( &rdi->rdi_text ) ) {
1018                                 ber_memfree( rdi->rdi_text.bv_val );
1019                         }
1020
1021                         if ( !BER_BVISNULL( &rdi->rdi_matched ) ) {
1022                                 ber_memfree( rdi->rdi_matched.bv_val );
1023                         }
1024
1025                         BER_BVZERO( &rdi->rdi_e.e_name );
1026                         BER_BVZERO( &rdi->rdi_e.e_nname );
1027
1028                         entry_clean( &rdi->rdi_e );
1029
1030                         next = rdi->rdi_next;
1031
1032                         ch_free( rdi );
1033                 }
1034
1035                 ber_memfree( rd );
1036         }
1037
1038         return 0;
1039 }
1040
1041 #if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC
1042 static
1043 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */
1044 int
1045 retcode_init( void )
1046 {
1047         int             i, code;
1048         const char      *err;
1049
1050         static struct {
1051                 char                    *name;
1052                 char                    *desc;
1053                 AttributeDescription    **ad;
1054         } retcode_at[] = {
1055                 { "errCode", "( 1.3.6.1.4.1.4203.666.11.4.1.1 "
1056                         "NAME ( 'errCode' ) "
1057                         "DESC 'LDAP error code' "
1058                         "EQUALITY integerMatch "
1059                         "ORDERING integerOrderingMatch "
1060                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
1061                         "SINGLE-VALUE )",
1062                         &ad_errCode },
1063                 { "errOp", "( 1.3.6.1.4.1.4203.666.11.4.1.2 "
1064                         "NAME ( 'errOp' ) "
1065                         "DESC 'Operations the errObject applies to' "
1066                         "EQUALITY caseIgnoreMatch "
1067                         "SUBSTR caseIgnoreSubstringsMatch "
1068                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
1069                         &ad_errOp},
1070                 { "errText", "( 1.3.6.1.4.1.4203.666.11.4.1.3 "
1071                         "NAME ( 'errText' ) "
1072                         "DESC 'LDAP error textual description' "
1073                         "EQUALITY caseIgnoreMatch "
1074                         "SUBSTR caseIgnoreSubstringsMatch "
1075                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 "
1076                         "SINGLE-VALUE )",
1077                         &ad_errText },
1078                 { "errSleepTime", "( 1.3.6.1.4.1.4203.666.11.4.1.4 "
1079                         "NAME ( 'errSleepTime' ) "
1080                         "DESC 'Time to wait before returning the error' "
1081                         "EQUALITY integerMatch "
1082                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
1083                         "SINGLE-VALUE )",
1084                         &ad_errSleepTime },
1085                 { "errMatchedDN", "( 1.3.6.1.4.1.4203.666.11.4.1.5 "
1086                         "NAME ( 'errMatchedDN' ) "
1087                         "DESC 'Value to be returned as matched DN' "
1088                         "EQUALITY distinguishedNameMatch "
1089                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 "
1090                         "SINGLE-VALUE )",
1091                         &ad_errMatchedDN },
1092                 { NULL }
1093         };
1094
1095         static struct {
1096                 char            *name;
1097                 char            *desc;
1098                 ObjectClass     **oc;
1099         } retcode_oc[] = {
1100                 { "errAbsObject", "( 1.3.6.1.4.1.4203.666.11.4.3.0 "
1101                         "NAME ( 'errAbsObject' ) "
1102                         "SUP top ABSTRACT "
1103                         "MUST ( errCode ) "
1104                         "MAY ( "
1105                                 "cn "
1106                                 "$ description "
1107                                 "$ errOp "
1108                                 "$ errText "
1109                                 "$ errSleepTime "
1110                                 "$ errMatchedDN "
1111                         ") )",
1112                         &oc_errAbsObject },
1113                 { "errObject", "( 1.3.6.1.4.1.4203.666.11.4.3.1 "
1114                         "NAME ( 'errObject' ) "
1115                         "SUP errAbsObject STRUCTURAL "
1116                         ")",
1117                         &oc_errObject },
1118                 { "errAuxObject", "( 1.3.6.1.4.1.4203.666.11.4.3.2 "
1119                         "NAME ( 'errAuxObject' ) "
1120                         "SUP errAbsObject AUXILIARY "
1121                         ")",
1122                         &oc_errAuxObject },
1123                 { NULL }
1124         };
1125
1126
1127         for ( i = 0; retcode_at[ i ].name != NULL; i++ ) {
1128                 LDAPAttributeType       *at;
1129
1130                 at = ldap_str2attributetype( retcode_at[ i ].desc,
1131                         &code, &err, LDAP_SCHEMA_ALLOW_ALL );
1132                 if ( !at ) {
1133                         fprintf( stderr, "retcode: "
1134                                 "AttributeType load failed: %s %s\n",
1135                                 ldap_scherr2str( code ), err );
1136                         return code;
1137                 }
1138
1139 #if LDAP_VENDOR_VERSION_MINOR == X || LDAP_VENDOR_VERSION_MINOR > 2
1140                 code = at_add( at, 0, NULL, &err );
1141 #else
1142                 code = at_add( at, &err );
1143 #endif
1144                 ldap_memfree( at );
1145                 if ( code != LDAP_SUCCESS ) {
1146                         fprintf( stderr, "retcode: "
1147                                 "AttributeType load failed: %s %s\n",
1148                                 scherr2str( code ), err );
1149                         return code;
1150                 }
1151
1152                 code = slap_str2ad( retcode_at[ i ].name,
1153                                 retcode_at[ i ].ad, &err );
1154                 if ( code != LDAP_SUCCESS ) {
1155                         fprintf( stderr, "retcode: unable to find "
1156                                 "AttributeDescription \"%s\": %d (%s)\n",
1157                                 retcode_at[ i ].name, code, err );
1158                         return 1;
1159                 }
1160         }
1161
1162         for ( i = 0; retcode_oc[ i ].name != NULL; i++ ) {
1163                 LDAPObjectClass *oc;
1164
1165                 oc = ldap_str2objectclass( retcode_oc[ i ].desc,
1166                                 &code, &err, LDAP_SCHEMA_ALLOW_ALL );
1167                 if ( !oc ) {
1168                         fprintf( stderr, "retcode: "
1169                                 "ObjectClass load failed: %s %s\n",
1170                                 ldap_scherr2str( code ), err );
1171                         return code;
1172                 }
1173
1174 #if LDAP_VENDOR_VERSION_MINOR == X || LDAP_VENDOR_VERSION_MINOR > 2
1175                 code = oc_add( oc, 0, NULL, &err );
1176 #else
1177                 code = oc_add( oc, &err );
1178 #endif
1179                 ldap_memfree(oc);
1180                 if ( code != LDAP_SUCCESS ) {
1181                         fprintf( stderr, "retcode: "
1182                                 "ObjectClass load failed: %s %s\n",
1183                                 scherr2str( code ), err );
1184                         return code;
1185                 }
1186
1187                 *retcode_oc[ i ].oc = oc_find( retcode_oc[ i ].name );
1188                 if ( *retcode_oc[ i ].oc == NULL ) {
1189                         fprintf( stderr, "retcode: unable to find "
1190                                 "objectClass \"%s\"\n",
1191                                 retcode_oc[ i ].name );
1192                         return 1;
1193                 }
1194         }
1195
1196         retcode.on_bi.bi_type = "retcode";
1197
1198         retcode.on_bi.bi_db_init = retcode_db_init;
1199         retcode.on_bi.bi_db_config = retcode_db_config;
1200         retcode.on_bi.bi_db_open = retcode_db_open;
1201         retcode.on_bi.bi_db_destroy = retcode_db_destroy;
1202
1203         retcode.on_bi.bi_op_add = retcode_op_func;
1204         retcode.on_bi.bi_op_bind = retcode_op_func;
1205         retcode.on_bi.bi_op_compare = retcode_op_func;
1206         retcode.on_bi.bi_op_delete = retcode_op_func;
1207         retcode.on_bi.bi_op_modify = retcode_op_func;
1208         retcode.on_bi.bi_op_modrdn = retcode_op_func;
1209         retcode.on_bi.bi_op_search = retcode_op_func;
1210
1211         retcode.on_bi.bi_extended = retcode_op_func;
1212
1213         retcode.on_response = retcode_response;
1214
1215         return overlay_register( &retcode );
1216 }
1217
1218 #if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC
1219 int
1220 init_module( int argc, char *argv[] )
1221 {
1222         return retcode_init();
1223 }
1224 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */
1225
1226 #endif /* SLAPD_OVER_RETCODE */