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