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