1 /* $NetBSD: retcode.c,v 1.4 2025/09/05 21:16:32 christos Exp $ */ 2 3 /* retcode.c - customizable response for client testing purposes */ 4 /* $OpenLDAP$ */ 5 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 6 * 7 * Copyright 2005-2024 The OpenLDAP Foundation. 8 * Portions Copyright 2005 Pierangelo Masarati <ando (at) sys-net.it> 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted only as authorized by the OpenLDAP 13 * Public License. 14 * 15 * A copy of this license is available in the file LICENSE in the 16 * top-level directory of the distribution or, alternatively, at 17 * <http://www.OpenLDAP.org/license.html>. 18 */ 19 /* ACKNOWLEDGEMENTS: 20 * This work was initially developed by Pierangelo Masarati for inclusion 21 * in OpenLDAP Software. 22 */ 23 24 #include <sys/cdefs.h> 25 __RCSID("$NetBSD: retcode.c,v 1.4 2025/09/05 21:16:32 christos Exp $"); 26 27 #include "portable.h" 28 29 #ifdef SLAPD_OVER_RETCODE 30 31 #include <stdio.h> 32 33 #include <ac/unistd.h> 34 #include <ac/string.h> 35 #include <ac/ctype.h> 36 #include <ac/socket.h> 37 38 #include "slap.h" 39 #include "slap-config.h" 40 #include "lutil.h" 41 #include "ldif.h" 42 43 static slap_overinst retcode; 44 45 static AttributeDescription *ad_errCode; 46 static AttributeDescription *ad_errText; 47 static AttributeDescription *ad_errOp; 48 static AttributeDescription *ad_errSleepTime; 49 static AttributeDescription *ad_errMatchedDN; 50 static AttributeDescription *ad_errUnsolicitedOID; 51 static AttributeDescription *ad_errUnsolicitedData; 52 static AttributeDescription *ad_errDisconnect; 53 54 static ObjectClass *oc_errAbsObject; 55 static ObjectClass *oc_errObject; 56 static ObjectClass *oc_errAuxObject; 57 58 typedef enum retcode_op_e { 59 SN_DG_OP_NONE = 0x0000, 60 SN_DG_OP_ADD = 0x0001, 61 SN_DG_OP_BIND = 0x0002, 62 SN_DG_OP_COMPARE = 0x0004, 63 SN_DG_OP_DELETE = 0x0008, 64 SN_DG_OP_MODIFY = 0x0010, 65 SN_DG_OP_RENAME = 0x0020, 66 SN_DG_OP_SEARCH = 0x0040, 67 SN_DG_EXTENDED = 0x0080, 68 SN_DG_OP_AUTH = SN_DG_OP_BIND, 69 SN_DG_OP_READ = (SN_DG_OP_COMPARE|SN_DG_OP_SEARCH), 70 SN_DG_OP_WRITE = (SN_DG_OP_ADD|SN_DG_OP_DELETE|SN_DG_OP_MODIFY|SN_DG_OP_RENAME), 71 SN_DG_OP_ALL = (SN_DG_OP_AUTH|SN_DG_OP_READ|SN_DG_OP_WRITE|SN_DG_EXTENDED) 72 } retcode_op_e; 73 74 typedef struct retcode_item_t { 75 struct berval rdi_line; 76 struct berval rdi_dn; 77 struct berval rdi_ndn; 78 struct berval rdi_text; 79 struct berval rdi_matched; 80 int rdi_err; 81 BerVarray rdi_ref; 82 int rdi_sleeptime; 83 Entry rdi_e; 84 slap_mask_t rdi_mask; 85 struct berval rdi_unsolicited_oid; 86 struct berval rdi_unsolicited_data; 87 88 unsigned rdi_flags; 89 #define RDI_PRE_DISCONNECT (0x1U) 90 #define RDI_POST_DISCONNECT (0x2U) 91 92 struct retcode_item_t *rdi_next; 93 } retcode_item_t; 94 95 typedef struct retcode_t { 96 struct berval rd_pdn; 97 struct berval rd_npdn; 98 99 int rd_sleep; 100 101 retcode_item_t *rd_item; 102 103 int rd_indir; 104 #define RETCODE_FINDIR 0x01 105 #define RETCODE_INDIR( rd ) ( (rd)->rd_indir ) 106 } retcode_t; 107 108 static int 109 retcode_entry_response( Operation *op, SlapReply *rs, BackendInfo *bi, Entry *e ); 110 111 static unsigned int 112 retcode_sleep( int s ) 113 { 114 unsigned int r = 0; 115 116 /* sleep as required */ 117 if ( s < 0 ) { 118 #if 0 /* use high-order bits for better randomness (Numerical Recipes in "C") */ 119 r = rand() % (-s); 120 #endif 121 r = ((double)(-s))*rand()/(RAND_MAX + 1.0); 122 } else if ( s > 0 ) { 123 r = (unsigned int)s; 124 } 125 if ( r ) { 126 sleep( r ); 127 } 128 129 return r; 130 } 131 132 static int 133 retcode_cleanup_cb( Operation *op, SlapReply *rs ) 134 { 135 rs->sr_matched = NULL; 136 rs->sr_text = NULL; 137 138 if ( rs->sr_ref != NULL ) { 139 ber_bvarray_free( rs->sr_ref ); 140 rs->sr_ref = NULL; 141 } 142 143 ch_free( op->o_callback ); 144 op->o_callback = NULL; 145 146 return SLAP_CB_CONTINUE; 147 } 148 149 static int 150 retcode_send_onelevel( Operation *op, SlapReply *rs ) 151 { 152 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; 153 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 154 155 retcode_item_t *rdi; 156 157 for ( rdi = rd->rd_item; rdi != NULL; rdi = rdi->rdi_next ) { 158 if ( op->o_abandon ) { 159 return rs->sr_err = SLAPD_ABANDON; 160 } 161 162 rs->sr_err = test_filter( op, &rdi->rdi_e, op->ors_filter ); 163 if ( rs->sr_err == LDAP_COMPARE_TRUE ) { 164 /* safe default */ 165 rs->sr_attrs = op->ors_attrs; 166 rs->sr_operational_attrs = NULL; 167 rs->sr_ctrls = NULL; 168 rs->sr_flags = 0; 169 rs->sr_err = LDAP_SUCCESS; 170 rs->sr_entry = &rdi->rdi_e; 171 172 rs->sr_err = send_search_entry( op, rs ); 173 rs->sr_flags = 0; 174 rs->sr_entry = NULL; 175 rs->sr_attrs = NULL; 176 177 switch ( rs->sr_err ) { 178 case LDAP_UNAVAILABLE: /* connection closed */ 179 rs->sr_err = LDAP_OTHER; 180 /* fallthru */ 181 case LDAP_SIZELIMIT_EXCEEDED: 182 goto done; 183 } 184 } 185 rs->sr_err = LDAP_SUCCESS; 186 } 187 188 done:; 189 190 send_ldap_result( op, rs ); 191 192 return rs->sr_err; 193 } 194 195 static int 196 retcode_op_add( Operation *op, SlapReply *rs ) 197 { 198 return retcode_entry_response( op, rs, NULL, op->ora_e ); 199 } 200 201 typedef struct retcode_cb_t { 202 BackendInfo *rdc_info; 203 unsigned rdc_flags; 204 ber_tag_t rdc_tag; 205 AttributeName *rdc_attrs; 206 } retcode_cb_t; 207 208 static int 209 retcode_cb_response( Operation *op, SlapReply *rs ) 210 { 211 retcode_cb_t *rdc = (retcode_cb_t *)op->o_callback->sc_private; 212 213 op->o_tag = rdc->rdc_tag; 214 if ( rs->sr_type == REP_SEARCH ) { 215 ber_tag_t o_tag = op->o_tag; 216 int rc; 217 218 if ( op->o_tag == LDAP_REQ_SEARCH ) { 219 rs->sr_attrs = rdc->rdc_attrs; 220 } 221 rc = retcode_entry_response( op, rs, rdc->rdc_info, rs->sr_entry ); 222 op->o_tag = o_tag; 223 224 return rc; 225 } 226 227 switch ( rs->sr_err ) { 228 case LDAP_SUCCESS: 229 case LDAP_NO_SUCH_OBJECT: 230 /* in case of noSuchObject, stop the internal search 231 * for in-directory error stuff */ 232 if ( !op->o_abandon ) { 233 rdc->rdc_flags = SLAP_CB_CONTINUE; 234 } 235 return 0; 236 } 237 238 return SLAP_CB_CONTINUE; 239 } 240 241 static int 242 retcode_op_internal( Operation *op, SlapReply *rs ) 243 { 244 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; 245 246 Operation op2 = *op; 247 BackendDB db = *op->o_bd; 248 slap_callback sc = { 0 }; 249 retcode_cb_t rdc; 250 251 int rc; 252 253 op2.o_tag = LDAP_REQ_SEARCH; 254 op2.ors_scope = LDAP_SCOPE_BASE; 255 op2.ors_deref = LDAP_DEREF_NEVER; 256 op2.ors_tlimit = SLAP_NO_LIMIT; 257 op2.ors_slimit = SLAP_NO_LIMIT; 258 op2.ors_limit = NULL; 259 op2.ors_attrsonly = 0; 260 op2.ors_attrs = slap_anlist_all_attributes; 261 262 ber_str2bv_x( "(objectClass=errAbsObject)", 263 STRLENOF( "(objectClass=errAbsObject)" ), 264 1, &op2.ors_filterstr, op2.o_tmpmemctx ); 265 op2.ors_filter = str2filter_x( &op2, op2.ors_filterstr.bv_val ); 266 267 /* errAbsObject is defined by this overlay! */ 268 assert( op2.ors_filter != NULL ); 269 270 db.bd_info = on->on_info->oi_orig; 271 op2.o_bd = &db; 272 273 rdc.rdc_info = on->on_info->oi_orig; 274 rdc.rdc_flags = RETCODE_FINDIR; 275 if ( op->o_tag == LDAP_REQ_SEARCH ) { 276 rdc.rdc_attrs = op->ors_attrs; 277 } 278 rdc.rdc_tag = op->o_tag; 279 sc.sc_response = retcode_cb_response; 280 sc.sc_private = &rdc; 281 op2.o_callback = ≻ 282 283 rc = op2.o_bd->be_search( &op2, rs ); 284 op->o_abandon = op2.o_abandon; 285 286 filter_free_x( &op2, op2.ors_filter, 1 ); 287 ber_memfree_x( op2.ors_filterstr.bv_val, op2.o_tmpmemctx ); 288 289 if ( rdc.rdc_flags == SLAP_CB_CONTINUE ) { 290 return SLAP_CB_CONTINUE; 291 } 292 293 return rc; 294 } 295 296 static int 297 retcode_op_func( Operation *op, SlapReply *rs ) 298 { 299 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; 300 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 301 302 retcode_item_t *rdi; 303 struct berval nrdn, npdn; 304 305 slap_callback *cb = NULL; 306 307 /* sleep as required */ 308 retcode_sleep( rd->rd_sleep ); 309 310 if ( !dnIsSuffix( &op->o_req_ndn, &rd->rd_npdn ) ) { 311 if ( RETCODE_INDIR( rd ) ) { 312 switch ( op->o_tag ) { 313 case LDAP_REQ_ADD: 314 return retcode_op_add( op, rs ); 315 316 case LDAP_REQ_BIND: 317 /* skip if rootdn */ 318 /* FIXME: better give the db a chance? */ 319 if ( be_isroot_pw( op ) ) { 320 return LDAP_SUCCESS; 321 } 322 return retcode_op_internal( op, rs ); 323 324 case LDAP_REQ_SEARCH: 325 if ( op->ors_scope == LDAP_SCOPE_BASE ) { 326 rs->sr_err = retcode_op_internal( op, rs ); 327 switch ( rs->sr_err ) { 328 case SLAP_CB_CONTINUE: 329 if ( rs->sr_nentries == 0 ) { 330 break; 331 } 332 rs->sr_err = LDAP_SUCCESS; 333 /* fallthru */ 334 335 default: 336 send_ldap_result( op, rs ); 337 break; 338 } 339 return rs->sr_err; 340 } 341 break; 342 343 case LDAP_REQ_MODIFY: 344 case LDAP_REQ_DELETE: 345 case LDAP_REQ_MODRDN: 346 case LDAP_REQ_COMPARE: 347 return retcode_op_internal( op, rs ); 348 } 349 } 350 351 return SLAP_CB_CONTINUE; 352 } 353 354 if ( op->o_tag == LDAP_REQ_SEARCH 355 && op->ors_scope != LDAP_SCOPE_BASE 356 && op->o_req_ndn.bv_len == rd->rd_npdn.bv_len ) 357 { 358 return retcode_send_onelevel( op, rs ); 359 } 360 361 dnParent( &op->o_req_ndn, &npdn ); 362 if ( npdn.bv_len != rd->rd_npdn.bv_len ) { 363 rs->sr_err = LDAP_NO_SUCH_OBJECT; 364 rs->sr_matched = rd->rd_pdn.bv_val; 365 send_ldap_result( op, rs ); 366 rs->sr_matched = NULL; 367 return rs->sr_err; 368 } 369 370 dnRdn( &op->o_req_ndn, &nrdn ); 371 372 for ( rdi = rd->rd_item; rdi != NULL; rdi = rdi->rdi_next ) { 373 struct berval rdi_nrdn; 374 375 dnRdn( &rdi->rdi_ndn, &rdi_nrdn ); 376 if ( dn_match( &nrdn, &rdi_nrdn ) ) { 377 break; 378 } 379 } 380 381 if ( rdi != NULL && rdi->rdi_mask != SN_DG_OP_ALL ) { 382 retcode_op_e o_tag = SN_DG_OP_NONE; 383 384 switch ( op->o_tag ) { 385 case LDAP_REQ_ADD: 386 o_tag = SN_DG_OP_ADD; 387 break; 388 389 case LDAP_REQ_BIND: 390 o_tag = SN_DG_OP_BIND; 391 break; 392 393 case LDAP_REQ_COMPARE: 394 o_tag = SN_DG_OP_COMPARE; 395 break; 396 397 case LDAP_REQ_DELETE: 398 o_tag = SN_DG_OP_DELETE; 399 break; 400 401 case LDAP_REQ_MODIFY: 402 o_tag = SN_DG_OP_MODIFY; 403 break; 404 405 case LDAP_REQ_MODRDN: 406 o_tag = SN_DG_OP_RENAME; 407 break; 408 409 case LDAP_REQ_SEARCH: 410 o_tag = SN_DG_OP_SEARCH; 411 break; 412 413 case LDAP_REQ_EXTENDED: 414 o_tag = SN_DG_EXTENDED; 415 break; 416 417 default: 418 /* Should not happen */ 419 break; 420 } 421 422 if ( !( o_tag & rdi->rdi_mask ) ) { 423 return SLAP_CB_CONTINUE; 424 } 425 } 426 427 if ( rdi == NULL ) { 428 rs->sr_matched = rd->rd_pdn.bv_val; 429 rs->sr_err = LDAP_NO_SUCH_OBJECT; 430 rs->sr_text = "retcode not found"; 431 432 } else { 433 if ( rdi->rdi_flags & RDI_PRE_DISCONNECT ) { 434 return rs->sr_err = SLAPD_DISCONNECT; 435 } 436 437 rs->sr_err = rdi->rdi_err; 438 rs->sr_text = rdi->rdi_text.bv_val; 439 rs->sr_matched = rdi->rdi_matched.bv_val; 440 441 /* FIXME: we only honor the rdi_ref field in case rdi_err 442 * is LDAP_REFERRAL otherwise send_ldap_result() bails out */ 443 if ( rs->sr_err == LDAP_REFERRAL ) { 444 BerVarray ref; 445 446 if ( rdi->rdi_ref != NULL ) { 447 ref = rdi->rdi_ref; 448 } else { 449 ref = default_referral; 450 } 451 452 if ( ref != NULL ) { 453 rs->sr_ref = referral_rewrite( ref, 454 NULL, &op->o_req_dn, LDAP_SCOPE_DEFAULT ); 455 456 } else { 457 rs->sr_err = LDAP_OTHER; 458 rs->sr_text = "bad referral object"; 459 } 460 } 461 462 retcode_sleep( rdi->rdi_sleeptime ); 463 } 464 465 switch ( op->o_tag ) { 466 case LDAP_REQ_EXTENDED: 467 if ( rdi == NULL ) { 468 break; 469 } 470 cb = ( slap_callback * )ch_malloc( sizeof( slap_callback ) ); 471 memset( cb, 0, sizeof( slap_callback ) ); 472 cb->sc_cleanup = retcode_cleanup_cb; 473 op->o_callback = cb; 474 break; 475 476 default: 477 if ( rdi && !BER_BVISNULL( &rdi->rdi_unsolicited_oid ) ) { 478 ber_int_t msgid = op->o_msgid; 479 480 /* RFC 4511 unsolicited response */ 481 482 op->o_msgid = 0; 483 if ( strcmp( rdi->rdi_unsolicited_oid.bv_val, "0" ) == 0 ) { 484 send_ldap_result( op, rs ); 485 486 } else { 487 ber_tag_t tag = op->o_tag; 488 489 op->o_tag = LDAP_REQ_EXTENDED; 490 rs->sr_rspoid = rdi->rdi_unsolicited_oid.bv_val; 491 if ( !BER_BVISNULL( &rdi->rdi_unsolicited_data ) ) { 492 rs->sr_rspdata = &rdi->rdi_unsolicited_data; 493 } 494 send_ldap_extended( op, rs ); 495 rs->sr_rspoid = NULL; 496 rs->sr_rspdata = NULL; 497 op->o_tag = tag; 498 499 } 500 op->o_msgid = msgid; 501 502 } else { 503 send_ldap_result( op, rs ); 504 } 505 506 if ( rs->sr_ref != NULL ) { 507 ber_bvarray_free( rs->sr_ref ); 508 rs->sr_ref = NULL; 509 } 510 rs->sr_matched = NULL; 511 rs->sr_text = NULL; 512 513 if ( rdi && rdi->rdi_flags & RDI_POST_DISCONNECT ) { 514 return rs->sr_err = SLAPD_DISCONNECT; 515 } 516 break; 517 } 518 519 return rs->sr_err; 520 } 521 522 static int 523 retcode_op2str( ber_tag_t op, struct berval *bv ) 524 { 525 switch ( op ) { 526 case LDAP_REQ_BIND: 527 BER_BVSTR( bv, "bind" ); 528 return 0; 529 case LDAP_REQ_ADD: 530 BER_BVSTR( bv, "add" ); 531 return 0; 532 case LDAP_REQ_DELETE: 533 BER_BVSTR( bv, "delete" ); 534 return 0; 535 case LDAP_REQ_MODRDN: 536 BER_BVSTR( bv, "modrdn" ); 537 return 0; 538 case LDAP_REQ_MODIFY: 539 BER_BVSTR( bv, "modify" ); 540 return 0; 541 case LDAP_REQ_COMPARE: 542 BER_BVSTR( bv, "compare" ); 543 return 0; 544 case LDAP_REQ_SEARCH: 545 BER_BVSTR( bv, "search" ); 546 return 0; 547 case LDAP_REQ_EXTENDED: 548 BER_BVSTR( bv, "extended" ); 549 return 0; 550 } 551 return -1; 552 } 553 554 static int 555 retcode_entry_response( Operation *op, SlapReply *rs, BackendInfo *bi, Entry *e ) 556 { 557 Attribute *a; 558 int err; 559 char *next; 560 int disconnect = 0; 561 562 if ( get_manageDSAit( op ) ) { 563 return SLAP_CB_CONTINUE; 564 } 565 566 if ( !is_entry_objectclass_or_sub( e, oc_errAbsObject ) ) { 567 return SLAP_CB_CONTINUE; 568 } 569 570 /* operation */ 571 a = attr_find( e->e_attrs, ad_errOp ); 572 if ( a != NULL ) { 573 int i, 574 gotit = 0; 575 struct berval bv = BER_BVNULL; 576 577 (void)retcode_op2str( op->o_tag, &bv ); 578 579 if ( BER_BVISNULL( &bv ) ) { 580 return SLAP_CB_CONTINUE; 581 } 582 583 for ( i = 0; !BER_BVISNULL( &a->a_nvals[ i ] ); i++ ) { 584 if ( bvmatch( &a->a_nvals[ i ], &bv ) ) { 585 gotit = 1; 586 break; 587 } 588 } 589 590 if ( !gotit ) { 591 return SLAP_CB_CONTINUE; 592 } 593 } 594 595 /* disconnect */ 596 a = attr_find( e->e_attrs, ad_errDisconnect ); 597 if ( a != NULL ) { 598 if ( bvmatch( &a->a_nvals[ 0 ], &slap_true_bv ) ) { 599 return rs->sr_err = SLAPD_DISCONNECT; 600 } 601 disconnect = 1; 602 } 603 604 /* error code */ 605 a = attr_find( e->e_attrs, ad_errCode ); 606 if ( a == NULL ) { 607 return SLAP_CB_CONTINUE; 608 } 609 err = strtol( a->a_nvals[ 0 ].bv_val, &next, 0 ); 610 if ( next == a->a_nvals[ 0 ].bv_val || next[ 0 ] != '\0' ) { 611 return SLAP_CB_CONTINUE; 612 } 613 rs->sr_err = err; 614 615 /* sleep time */ 616 a = attr_find( e->e_attrs, ad_errSleepTime ); 617 if ( a != NULL && a->a_nvals[ 0 ].bv_val[ 0 ] != '-' ) { 618 int sleepTime; 619 620 if ( lutil_atoi( &sleepTime, a->a_nvals[ 0 ].bv_val ) == 0 ) { 621 retcode_sleep( sleepTime ); 622 } 623 } 624 625 if ( rs->sr_err != LDAP_SUCCESS && !LDAP_API_ERROR( rs->sr_err )) { 626 BackendDB db = *op->o_bd, 627 *o_bd = op->o_bd; 628 void *o_callback = op->o_callback; 629 630 /* message text */ 631 a = attr_find( e->e_attrs, ad_errText ); 632 if ( a != NULL ) { 633 rs->sr_text = a->a_vals[ 0 ].bv_val; 634 } 635 636 /* matched DN */ 637 a = attr_find( e->e_attrs, ad_errMatchedDN ); 638 if ( a != NULL ) { 639 rs->sr_matched = a->a_vals[ 0 ].bv_val; 640 } 641 642 if ( bi == NULL ) { 643 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; 644 645 bi = on->on_info->oi_orig; 646 } 647 648 db.bd_info = bi; 649 op->o_bd = &db; 650 op->o_callback = NULL; 651 652 /* referral */ 653 if ( rs->sr_err == LDAP_REFERRAL ) { 654 BerVarray refs = default_referral; 655 656 a = attr_find( e->e_attrs, slap_schema.si_ad_ref ); 657 if ( a != NULL ) { 658 refs = a->a_vals; 659 } 660 rs->sr_ref = referral_rewrite( refs, 661 NULL, &op->o_req_dn, op->oq_search.rs_scope ); 662 663 send_search_reference( op, rs ); 664 ber_bvarray_free( rs->sr_ref ); 665 rs->sr_ref = NULL; 666 667 } else { 668 a = attr_find( e->e_attrs, ad_errUnsolicitedOID ); 669 if ( a != NULL ) { 670 struct berval oid = BER_BVNULL, 671 data = BER_BVNULL; 672 ber_int_t msgid = op->o_msgid; 673 674 /* RFC 4511 unsolicited response */ 675 676 op->o_msgid = 0; 677 678 oid = a->a_nvals[ 0 ]; 679 680 a = attr_find( e->e_attrs, ad_errUnsolicitedData ); 681 if ( a != NULL ) { 682 data = a->a_nvals[ 0 ]; 683 } 684 685 if ( strcmp( oid.bv_val, "0" ) == 0 ) { 686 send_ldap_result( op, rs ); 687 688 } else { 689 ber_tag_t tag = op->o_tag; 690 691 op->o_tag = LDAP_REQ_EXTENDED; 692 rs->sr_rspoid = oid.bv_val; 693 if ( !BER_BVISNULL( &data ) ) { 694 rs->sr_rspdata = &data; 695 } 696 send_ldap_extended( op, rs ); 697 rs->sr_rspoid = NULL; 698 rs->sr_rspdata = NULL; 699 op->o_tag = tag; 700 } 701 op->o_msgid = msgid; 702 703 } else { 704 send_ldap_result( op, rs ); 705 } 706 } 707 708 rs->sr_text = NULL; 709 rs->sr_matched = NULL; 710 op->o_bd = o_bd; 711 op->o_callback = o_callback; 712 } 713 714 if ( rs->sr_err != LDAP_SUCCESS ) { 715 if ( disconnect ) { 716 return rs->sr_err = SLAPD_DISCONNECT; 717 } 718 719 return rs->sr_err; 720 } 721 722 return SLAP_CB_CONTINUE; 723 } 724 725 static int 726 retcode_response( Operation *op, SlapReply *rs ) 727 { 728 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; 729 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 730 731 if ( rs->sr_type != REP_SEARCH || !RETCODE_INDIR( rd ) ) { 732 return SLAP_CB_CONTINUE; 733 } 734 735 return retcode_entry_response( op, rs, NULL, rs->sr_entry ); 736 } 737 738 static int 739 retcode_db_init( BackendDB *be, ConfigReply *cr ) 740 { 741 slap_overinst *on = (slap_overinst *)be->bd_info; 742 retcode_t *rd; 743 744 srand( getpid() ); 745 746 rd = (retcode_t *)ch_malloc( sizeof( retcode_t ) ); 747 memset( rd, 0, sizeof( retcode_t ) ); 748 749 on->on_bi.bi_private = (void *)rd; 750 751 return 0; 752 } 753 754 static void 755 retcode_item_destroy( retcode_item_t *rdi ) 756 { 757 ber_memfree( rdi->rdi_line.bv_val ); 758 759 ber_memfree( rdi->rdi_dn.bv_val ); 760 ber_memfree( rdi->rdi_ndn.bv_val ); 761 762 if ( !BER_BVISNULL( &rdi->rdi_text ) ) { 763 ber_memfree( rdi->rdi_text.bv_val ); 764 } 765 766 if ( !BER_BVISNULL( &rdi->rdi_matched ) ) { 767 ber_memfree( rdi->rdi_matched.bv_val ); 768 } 769 770 if ( rdi->rdi_ref ) { 771 ber_bvarray_free( rdi->rdi_ref ); 772 } 773 774 BER_BVZERO( &rdi->rdi_e.e_name ); 775 BER_BVZERO( &rdi->rdi_e.e_nname ); 776 777 entry_clean( &rdi->rdi_e ); 778 779 if ( !BER_BVISNULL( &rdi->rdi_unsolicited_oid ) ) { 780 ber_memfree( rdi->rdi_unsolicited_oid.bv_val ); 781 if ( !BER_BVISNULL( &rdi->rdi_unsolicited_data ) ) 782 ber_memfree( rdi->rdi_unsolicited_data.bv_val ); 783 } 784 785 ch_free( rdi ); 786 } 787 788 enum { 789 RC_PARENT = 1, 790 RC_ITEM 791 }; 792 793 static ConfigDriver rc_cf_gen; 794 795 static ConfigTable rccfg[] = { 796 { "retcode-parent", "dn", 797 2, 2, 0, ARG_MAGIC|ARG_DN|ARG_QUOTE|RC_PARENT, rc_cf_gen, 798 "( OLcfgOvAt:20.1 NAME 'olcRetcodeParent' " 799 "DESC '' " 800 "EQUALITY distinguishedNameMatch " 801 "SYNTAX OMsDN SINGLE-VALUE )", NULL, NULL }, 802 { "retcode-item", "rdn> <retcode> <...", 803 3, 0, 0, ARG_MAGIC|RC_ITEM, rc_cf_gen, 804 "( OLcfgOvAt:20.2 NAME 'olcRetcodeItem' " 805 "DESC '' " 806 "EQUALITY caseIgnoreMatch " 807 "SYNTAX OMsDirectoryString " 808 "X-ORDERED 'VALUES' )", NULL, NULL }, 809 { "retcode-indir", "on|off", 810 1, 2, 0, ARG_OFFSET|ARG_ON_OFF, 811 (void *)offsetof(retcode_t, rd_indir), 812 "( OLcfgOvAt:20.3 NAME 'olcRetcodeInDir' " 813 "DESC '' " 814 "EQUALITY booleanMatch " 815 "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL }, 816 817 { "retcode-sleep", "sleeptime", 818 2, 2, 0, ARG_OFFSET|ARG_INT, 819 (void *)offsetof(retcode_t, rd_sleep), 820 "( OLcfgOvAt:20.4 NAME 'olcRetcodeSleep' " 821 "DESC '' " 822 "EQUALITY integerMatch " 823 "SYNTAX OMsInteger SINGLE-VALUE )", NULL, NULL }, 824 825 { NULL, NULL, 0, 0, 0, ARG_IGNORED } 826 }; 827 828 static ConfigOCs rcocs[] = { 829 { "( OLcfgOvOc:20.1 " 830 "NAME 'olcRetcodeConfig' " 831 "DESC 'Retcode configuration' " 832 "SUP olcOverlayConfig " 833 "MAY ( olcRetcodeParent " 834 "$ olcRetcodeItem " 835 "$ olcRetcodeInDir " 836 "$ olcRetcodeSleep " 837 ") )", 838 Cft_Overlay, rccfg, NULL, NULL }, 839 { NULL, 0, NULL } 840 }; 841 842 static int 843 rc_cf_gen( ConfigArgs *c ) 844 { 845 slap_overinst *on = (slap_overinst *)c->bi; 846 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 847 int rc = ARG_BAD_CONF; 848 849 if ( c->op == SLAP_CONFIG_EMIT ) { 850 switch( c->type ) { 851 case RC_PARENT: 852 if ( !BER_BVISEMPTY( &rd->rd_pdn )) { 853 rc = value_add_one( &c->rvalue_vals, 854 &rd->rd_pdn ); 855 if ( rc == 0 ) { 856 rc = value_add_one( &c->rvalue_nvals, 857 &rd->rd_npdn ); 858 } 859 return rc; 860 } 861 rc = 0; 862 break; 863 864 case RC_ITEM: { 865 retcode_item_t *rdi; 866 int i; 867 868 for ( rdi = rd->rd_item, i = 0; rdi; rdi = rdi->rdi_next, i++ ) { 869 char buf[4096]; 870 struct berval bv; 871 char *ptr; 872 873 bv.bv_len = snprintf( buf, sizeof( buf ), SLAP_X_ORDERED_FMT, i ); 874 bv.bv_len += rdi->rdi_line.bv_len; 875 ptr = bv.bv_val = ch_malloc( bv.bv_len + 1 ); 876 ptr = lutil_strcopy( ptr, buf ); 877 ptr = lutil_strncopy( ptr, rdi->rdi_line.bv_val, rdi->rdi_line.bv_len ); 878 ber_bvarray_add( &c->rvalue_vals, &bv ); 879 } 880 rc = 0; 881 } break; 882 883 default: 884 assert( 0 ); 885 break; 886 } 887 888 return rc; 889 890 } else if ( c->op == LDAP_MOD_DELETE ) { 891 switch( c->type ) { 892 case RC_PARENT: 893 if ( rd->rd_pdn.bv_val ) { 894 ber_memfree ( rd->rd_pdn.bv_val ); 895 rc = 0; 896 } 897 if ( rd->rd_npdn.bv_val ) { 898 ber_memfree ( rd->rd_npdn.bv_val ); 899 } 900 break; 901 902 case RC_ITEM: 903 if ( c->valx == -1 ) { 904 retcode_item_t *rdi, *next; 905 906 for ( rdi = rd->rd_item; rdi != NULL; rdi = next ) { 907 next = rdi->rdi_next; 908 retcode_item_destroy( rdi ); 909 } 910 911 } else { 912 retcode_item_t **rdip, *rdi; 913 int i; 914 915 for ( rdip = &rd->rd_item, i = 0; i <= c->valx && *rdip; i++, rdip = &(*rdip)->rdi_next ) 916 ; 917 if ( *rdip == NULL ) { 918 return 1; 919 } 920 rdi = *rdip; 921 *rdip = rdi->rdi_next; 922 923 retcode_item_destroy( rdi ); 924 } 925 rc = 0; 926 break; 927 928 default: 929 assert( 0 ); 930 break; 931 } 932 return rc; /* FIXME */ 933 } 934 935 switch( c->type ) { 936 case RC_PARENT: 937 if ( rd->rd_pdn.bv_val ) { 938 ber_memfree ( rd->rd_pdn.bv_val ); 939 } 940 if ( rd->rd_npdn.bv_val ) { 941 ber_memfree ( rd->rd_npdn.bv_val ); 942 } 943 rd->rd_pdn = c->value_dn; 944 rd->rd_npdn = c->value_ndn; 945 rc = 0; 946 break; 947 948 case RC_ITEM: { 949 retcode_item_t rdi = { BER_BVNULL }, **rdip; 950 struct berval bv, rdn, nrdn; 951 char *next = NULL; 952 int i; 953 954 if ( c->argc < 3 ) { 955 snprintf( c->cr_msg, sizeof(c->cr_msg), 956 "\"retcode-item <RDN> <retcode> [<text>]\": " 957 "missing args" ); 958 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 959 c->log, c->cr_msg ); 960 return ARG_BAD_CONF; 961 } 962 963 ber_str2bv( c->argv[ 1 ], 0, 0, &bv ); 964 965 rc = dnPrettyNormal( NULL, &bv, &rdn, &nrdn, NULL ); 966 if ( rc != LDAP_SUCCESS ) { 967 snprintf( c->cr_msg, sizeof(c->cr_msg), 968 "unable to normalize RDN \"%s\": %d", 969 c->argv[ 1 ], rc ); 970 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 971 c->log, c->cr_msg ); 972 return ARG_BAD_CONF; 973 } 974 975 if ( !dnIsOneLevelRDN( &nrdn ) ) { 976 snprintf( c->cr_msg, sizeof(c->cr_msg), 977 "value \"%s\" is not a RDN", 978 c->argv[ 1 ] ); 979 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 980 c->log, c->cr_msg ); 981 return ARG_BAD_CONF; 982 } 983 984 if ( BER_BVISNULL( &rd->rd_npdn ) ) { 985 /* FIXME: we use the database suffix */ 986 if ( c->be->be_nsuffix == NULL ) { 987 snprintf( c->cr_msg, sizeof(c->cr_msg), 988 "either \"retcode-parent\" " 989 "or \"suffix\" must be defined" ); 990 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 991 c->log, c->cr_msg ); 992 return ARG_BAD_CONF; 993 } 994 995 ber_dupbv( &rd->rd_pdn, &c->be->be_suffix[ 0 ] ); 996 ber_dupbv( &rd->rd_npdn, &c->be->be_nsuffix[ 0 ] ); 997 } 998 999 build_new_dn( &rdi.rdi_dn, &rd->rd_pdn, &rdn, NULL ); 1000 build_new_dn( &rdi.rdi_ndn, &rd->rd_npdn, &nrdn, NULL ); 1001 1002 ch_free( rdn.bv_val ); 1003 ch_free( nrdn.bv_val ); 1004 1005 rdi.rdi_err = strtol( c->argv[ 2 ], &next, 0 ); 1006 if ( next == c->argv[ 2 ] || next[ 0 ] != '\0' ) { 1007 snprintf( c->cr_msg, sizeof(c->cr_msg), 1008 "unable to parse return code \"%s\"", 1009 c->argv[ 2 ] ); 1010 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1011 c->log, c->cr_msg ); 1012 return ARG_BAD_CONF; 1013 } 1014 1015 rdi.rdi_mask = SN_DG_OP_ALL; 1016 1017 if ( c->argc > 3 ) { 1018 for ( i = 3; i < c->argc; i++ ) { 1019 if ( strncasecmp( c->argv[ i ], "op=", STRLENOF( "op=" ) ) == 0 ) 1020 { 1021 char **ops; 1022 int j; 1023 1024 ops = ldap_str2charray( &c->argv[ i ][ STRLENOF( "op=" ) ], "," ); 1025 assert( ops != NULL ); 1026 1027 rdi.rdi_mask = SN_DG_OP_NONE; 1028 1029 for ( j = 0; ops[ j ] != NULL; j++ ) { 1030 if ( strcasecmp( ops[ j ], "add" ) == 0 ) { 1031 rdi.rdi_mask |= SN_DG_OP_ADD; 1032 1033 } else if ( strcasecmp( ops[ j ], "bind" ) == 0 ) { 1034 rdi.rdi_mask |= SN_DG_OP_BIND; 1035 1036 } else if ( strcasecmp( ops[ j ], "compare" ) == 0 ) { 1037 rdi.rdi_mask |= SN_DG_OP_COMPARE; 1038 1039 } else if ( strcasecmp( ops[ j ], "delete" ) == 0 ) { 1040 rdi.rdi_mask |= SN_DG_OP_DELETE; 1041 1042 } else if ( strcasecmp( ops[ j ], "modify" ) == 0 ) { 1043 rdi.rdi_mask |= SN_DG_OP_MODIFY; 1044 1045 } else if ( strcasecmp( ops[ j ], "rename" ) == 0 1046 || strcasecmp( ops[ j ], "modrdn" ) == 0 ) 1047 { 1048 rdi.rdi_mask |= SN_DG_OP_RENAME; 1049 1050 } else if ( strcasecmp( ops[ j ], "search" ) == 0 ) { 1051 rdi.rdi_mask |= SN_DG_OP_SEARCH; 1052 1053 } else if ( strcasecmp( ops[ j ], "extended" ) == 0 ) { 1054 rdi.rdi_mask |= SN_DG_EXTENDED; 1055 1056 } else if ( strcasecmp( ops[ j ], "auth" ) == 0 ) { 1057 rdi.rdi_mask |= SN_DG_OP_AUTH; 1058 1059 } else if ( strcasecmp( ops[ j ], "read" ) == 0 ) { 1060 rdi.rdi_mask |= SN_DG_OP_READ; 1061 1062 } else if ( strcasecmp( ops[ j ], "write" ) == 0 ) { 1063 rdi.rdi_mask |= SN_DG_OP_WRITE; 1064 1065 } else if ( strcasecmp( ops[ j ], "all" ) == 0 ) { 1066 rdi.rdi_mask |= SN_DG_OP_ALL; 1067 1068 } else { 1069 snprintf( c->cr_msg, sizeof(c->cr_msg), 1070 "unknown op \"%s\"", 1071 ops[ j ] ); 1072 ldap_charray_free( ops ); 1073 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1074 c->log, c->cr_msg ); 1075 return ARG_BAD_CONF; 1076 } 1077 } 1078 1079 ldap_charray_free( ops ); 1080 1081 } else if ( strncasecmp( c->argv[ i ], "text=", STRLENOF( "text=" ) ) == 0 ) 1082 { 1083 if ( !BER_BVISNULL( &rdi.rdi_text ) ) { 1084 snprintf( c->cr_msg, sizeof(c->cr_msg), 1085 "\"text\" already provided" ); 1086 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1087 c->log, c->cr_msg ); 1088 return ARG_BAD_CONF; 1089 } 1090 ber_str2bv( &c->argv[ i ][ STRLENOF( "text=" ) ], 0, 1, &rdi.rdi_text ); 1091 1092 } else if ( strncasecmp( c->argv[ i ], "matched=", STRLENOF( "matched=" ) ) == 0 ) 1093 { 1094 struct berval dn; 1095 1096 if ( !BER_BVISNULL( &rdi.rdi_matched ) ) { 1097 snprintf( c->cr_msg, sizeof(c->cr_msg), 1098 "\"matched\" already provided" ); 1099 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1100 c->log, c->cr_msg ); 1101 return ARG_BAD_CONF; 1102 } 1103 ber_str2bv( &c->argv[ i ][ STRLENOF( "matched=" ) ], 0, 0, &dn ); 1104 if ( dnPretty( NULL, &dn, &rdi.rdi_matched, NULL ) != LDAP_SUCCESS ) { 1105 snprintf( c->cr_msg, sizeof(c->cr_msg), 1106 "unable to prettify matched DN \"%s\"", 1107 &c->argv[ i ][ STRLENOF( "matched=" ) ] ); 1108 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1109 c->log, c->cr_msg ); 1110 return ARG_BAD_CONF; 1111 } 1112 1113 } else if ( strncasecmp( c->argv[ i ], "ref=", STRLENOF( "ref=" ) ) == 0 ) 1114 { 1115 char **refs; 1116 int j; 1117 1118 if ( rdi.rdi_ref != NULL ) { 1119 snprintf( c->cr_msg, sizeof(c->cr_msg), 1120 "\"ref\" already provided" ); 1121 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1122 c->log, c->cr_msg ); 1123 return ARG_BAD_CONF; 1124 } 1125 1126 if ( rdi.rdi_err != LDAP_REFERRAL ) { 1127 snprintf( c->cr_msg, sizeof(c->cr_msg), 1128 "providing \"ref\" " 1129 "along with a non-referral " 1130 "resultCode may cause slapd failures " 1131 "related to internal checks" ); 1132 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1133 c->log, c->cr_msg ); 1134 } 1135 1136 refs = ldap_str2charray( &c->argv[ i ][ STRLENOF( "ref=" ) ], " " ); 1137 assert( refs != NULL ); 1138 1139 for ( j = 0; refs[ j ] != NULL; j++ ) { 1140 struct berval bv; 1141 1142 ber_str2bv( refs[ j ], 0, 1, &bv ); 1143 ber_bvarray_add( &rdi.rdi_ref, &bv ); 1144 } 1145 1146 ldap_charray_free( refs ); 1147 1148 } else if ( strncasecmp( c->argv[ i ], "sleeptime=", STRLENOF( "sleeptime=" ) ) == 0 ) 1149 { 1150 if ( rdi.rdi_sleeptime != 0 ) { 1151 snprintf( c->cr_msg, sizeof(c->cr_msg), 1152 "\"sleeptime\" already provided" ); 1153 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1154 c->log, c->cr_msg ); 1155 return ARG_BAD_CONF; 1156 } 1157 1158 if ( lutil_atoi( &rdi.rdi_sleeptime, &c->argv[ i ][ STRLENOF( "sleeptime=" ) ] ) ) { 1159 snprintf( c->cr_msg, sizeof(c->cr_msg), 1160 "unable to parse \"sleeptime=%s\"", 1161 &c->argv[ i ][ STRLENOF( "sleeptime=" ) ] ); 1162 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1163 c->log, c->cr_msg ); 1164 return ARG_BAD_CONF; 1165 } 1166 1167 } else if ( strncasecmp( c->argv[ i ], "unsolicited=", STRLENOF( "unsolicited=" ) ) == 0 ) 1168 { 1169 char *data; 1170 1171 if ( !BER_BVISNULL( &rdi.rdi_unsolicited_oid ) ) { 1172 snprintf( c->cr_msg, sizeof(c->cr_msg), 1173 "\"unsolicited\" already provided" ); 1174 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1175 c->log, c->cr_msg ); 1176 return ARG_BAD_CONF; 1177 } 1178 1179 data = strchr( &c->argv[ i ][ STRLENOF( "unsolicited=" ) ], ':' ); 1180 if ( data != NULL ) { 1181 struct berval oid; 1182 1183 if ( ldif_parse_line2( &c->argv[ i ][ STRLENOF( "unsolicited=" ) ], 1184 &oid, &rdi.rdi_unsolicited_data, NULL ) ) 1185 { 1186 snprintf( c->cr_msg, sizeof(c->cr_msg), 1187 "unable to parse \"unsolicited\"" ); 1188 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1189 c->log, c->cr_msg ); 1190 return ARG_BAD_CONF; 1191 } 1192 1193 ber_dupbv( &rdi.rdi_unsolicited_oid, &oid ); 1194 1195 } else { 1196 ber_str2bv( &c->argv[ i ][ STRLENOF( "unsolicited=" ) ], 0, 1, 1197 &rdi.rdi_unsolicited_oid ); 1198 } 1199 1200 } else if ( strncasecmp( c->argv[ i ], "flags=", STRLENOF( "flags=" ) ) == 0 ) 1201 { 1202 char *arg = &c->argv[ i ][ STRLENOF( "flags=" ) ]; 1203 if ( strcasecmp( arg, "disconnect" ) == 0 ) { 1204 rdi.rdi_flags |= RDI_PRE_DISCONNECT; 1205 1206 } else if ( strcasecmp( arg, "pre-disconnect" ) == 0 ) { 1207 rdi.rdi_flags |= RDI_PRE_DISCONNECT; 1208 1209 } else if ( strcasecmp( arg, "post-disconnect" ) == 0 ) { 1210 rdi.rdi_flags |= RDI_POST_DISCONNECT; 1211 1212 } else { 1213 snprintf( c->cr_msg, sizeof(c->cr_msg), 1214 "unknown flag \"%s\"", arg ); 1215 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1216 c->log, c->cr_msg ); 1217 return ARG_BAD_CONF; 1218 } 1219 1220 } else { 1221 snprintf( c->cr_msg, sizeof(c->cr_msg), 1222 "unknown option \"%s\"", 1223 c->argv[ i ] ); 1224 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1225 c->log, c->cr_msg ); 1226 return ARG_BAD_CONF; 1227 } 1228 } 1229 } 1230 1231 rdi.rdi_line.bv_len = 2*(c->argc - 1) + c->argc - 2; 1232 for ( i = 1; i < c->argc; i++ ) { 1233 rdi.rdi_line.bv_len += strlen( c->argv[ i ] ); 1234 } 1235 next = rdi.rdi_line.bv_val = ch_malloc( rdi.rdi_line.bv_len + 1 ); 1236 1237 for ( i = 1; i < c->argc; i++ ) { 1238 *next++ = '"'; 1239 next = lutil_strcopy( next, c->argv[ i ] ); 1240 *next++ = '"'; 1241 *next++ = ' '; 1242 } 1243 *--next = '\0'; 1244 1245 /* We're marked X-ORDERED 'VALUES', valx might be valid */ 1246 for ( i = 0, rdip = &rd->rd_item; 1247 *rdip && (c->valx < 0 || i < c->valx); 1248 rdip = &(*rdip)->rdi_next, i++ ) 1249 /* go to position */ ; 1250 1251 1252 rdi.rdi_next = *rdip; 1253 *rdip = ( retcode_item_t * )ch_malloc( sizeof( retcode_item_t ) ); 1254 *(*rdip) = rdi; 1255 1256 rc = 0; 1257 } break; 1258 1259 default: 1260 rc = SLAP_CONF_UNKNOWN; 1261 break; 1262 } 1263 1264 return rc; 1265 } 1266 1267 static int 1268 retcode_db_open( BackendDB *be, ConfigReply *cr) 1269 { 1270 slap_overinst *on = (slap_overinst *)be->bd_info; 1271 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 1272 1273 retcode_item_t *rdi; 1274 1275 for ( rdi = rd->rd_item; rdi; rdi = rdi->rdi_next ) { 1276 LDAPRDN rdn = NULL; 1277 int rc, j; 1278 char* p; 1279 struct berval val[ 3 ]; 1280 char buf[ SLAP_TEXT_BUFLEN ]; 1281 1282 /* DN */ 1283 rdi->rdi_e.e_name = rdi->rdi_dn; 1284 rdi->rdi_e.e_nname = rdi->rdi_ndn; 1285 1286 /* objectClass */ 1287 val[ 0 ] = oc_errObject->soc_cname; 1288 val[ 1 ] = slap_schema.si_oc_extensibleObject->soc_cname; 1289 BER_BVZERO( &val[ 2 ] ); 1290 1291 attr_merge( &rdi->rdi_e, slap_schema.si_ad_objectClass, val, NULL ); 1292 1293 /* RDN avas */ 1294 rc = ldap_bv2rdn( &rdi->rdi_dn, &rdn, (char **) &p, 1295 LDAP_DN_FORMAT_LDAP ); 1296 1297 assert( rc == LDAP_SUCCESS ); 1298 1299 for ( j = 0; rdn[ j ]; j++ ) { 1300 LDAPAVA *ava = rdn[ j ]; 1301 AttributeDescription *ad = NULL; 1302 const char *text; 1303 1304 rc = slap_bv2ad( &ava->la_attr, &ad, &text ); 1305 assert( rc == LDAP_SUCCESS ); 1306 1307 attr_merge_normalize_one( &rdi->rdi_e, ad, 1308 &ava->la_value, NULL ); 1309 } 1310 1311 ldap_rdnfree( rdn ); 1312 1313 /* error code */ 1314 snprintf( buf, sizeof( buf ), "%d", rdi->rdi_err ); 1315 ber_str2bv( buf, 0, 0, &val[ 0 ] ); 1316 1317 attr_merge_one( &rdi->rdi_e, ad_errCode, &val[ 0 ], NULL ); 1318 1319 if ( rdi->rdi_ref != NULL ) { 1320 attr_merge_normalize( &rdi->rdi_e, slap_schema.si_ad_ref, 1321 rdi->rdi_ref, NULL ); 1322 } 1323 1324 /* text */ 1325 if ( !BER_BVISNULL( &rdi->rdi_text ) ) { 1326 val[ 0 ] = rdi->rdi_text; 1327 1328 attr_merge_normalize_one( &rdi->rdi_e, ad_errText, &val[ 0 ], NULL ); 1329 } 1330 1331 /* matched */ 1332 if ( !BER_BVISNULL( &rdi->rdi_matched ) ) { 1333 val[ 0 ] = rdi->rdi_matched; 1334 1335 attr_merge_normalize_one( &rdi->rdi_e, ad_errMatchedDN, &val[ 0 ], NULL ); 1336 } 1337 1338 /* sleep time */ 1339 if ( rdi->rdi_sleeptime ) { 1340 snprintf( buf, sizeof( buf ), "%d", rdi->rdi_sleeptime ); 1341 ber_str2bv( buf, 0, 0, &val[ 0 ] ); 1342 1343 attr_merge_one( &rdi->rdi_e, ad_errSleepTime, &val[ 0 ], NULL ); 1344 } 1345 1346 /* operations */ 1347 if ( rdi->rdi_mask & SN_DG_OP_ADD ) { 1348 BER_BVSTR( &val[ 0 ], "add" ); 1349 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1350 } 1351 1352 if ( rdi->rdi_mask & SN_DG_OP_BIND ) { 1353 BER_BVSTR( &val[ 0 ], "bind" ); 1354 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1355 } 1356 1357 if ( rdi->rdi_mask & SN_DG_OP_COMPARE ) { 1358 BER_BVSTR( &val[ 0 ], "compare" ); 1359 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1360 } 1361 1362 if ( rdi->rdi_mask & SN_DG_OP_DELETE ) { 1363 BER_BVSTR( &val[ 0 ], "delete" ); 1364 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1365 } 1366 1367 if ( rdi->rdi_mask & SN_DG_EXTENDED ) { 1368 BER_BVSTR( &val[ 0 ], "extended" ); 1369 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1370 } 1371 1372 if ( rdi->rdi_mask & SN_DG_OP_MODIFY ) { 1373 BER_BVSTR( &val[ 0 ], "modify" ); 1374 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1375 } 1376 1377 if ( rdi->rdi_mask & SN_DG_OP_RENAME ) { 1378 BER_BVSTR( &val[ 0 ], "rename" ); 1379 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1380 } 1381 1382 if ( rdi->rdi_mask & SN_DG_OP_SEARCH ) { 1383 BER_BVSTR( &val[ 0 ], "search" ); 1384 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1385 } 1386 } 1387 1388 return 0; 1389 } 1390 1391 static int 1392 retcode_db_destroy( BackendDB *be, ConfigReply *cr ) 1393 { 1394 slap_overinst *on = (slap_overinst *)be->bd_info; 1395 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 1396 1397 if ( rd ) { 1398 retcode_item_t *rdi, *next; 1399 1400 for ( rdi = rd->rd_item; rdi != NULL; rdi = next ) { 1401 next = rdi->rdi_next; 1402 retcode_item_destroy( rdi ); 1403 } 1404 1405 if ( !BER_BVISNULL( &rd->rd_pdn ) ) { 1406 ber_memfree( rd->rd_pdn.bv_val ); 1407 } 1408 1409 if ( !BER_BVISNULL( &rd->rd_npdn ) ) { 1410 ber_memfree( rd->rd_npdn.bv_val ); 1411 } 1412 1413 ber_memfree( rd ); 1414 } 1415 1416 return 0; 1417 } 1418 1419 #if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC 1420 static 1421 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */ 1422 int 1423 retcode_initialize( void ) 1424 { 1425 int i, code; 1426 1427 static struct { 1428 char *desc; 1429 AttributeDescription **ad; 1430 } retcode_at[] = { 1431 { "( 1.3.6.1.4.1.4203.666.11.4.1.1 " 1432 "NAME ( 'errCode' ) " 1433 "DESC 'LDAP error code' " 1434 "EQUALITY integerMatch " 1435 "ORDERING integerOrderingMatch " 1436 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 " 1437 "SINGLE-VALUE )", 1438 &ad_errCode }, 1439 { "( 1.3.6.1.4.1.4203.666.11.4.1.2 " 1440 "NAME ( 'errOp' ) " 1441 "DESC 'Operations the errObject applies to' " 1442 "EQUALITY caseIgnoreMatch " 1443 "SUBSTR caseIgnoreSubstringsMatch " 1444 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )", 1445 &ad_errOp}, 1446 { "( 1.3.6.1.4.1.4203.666.11.4.1.3 " 1447 "NAME ( 'errText' ) " 1448 "DESC 'LDAP error textual description' " 1449 "EQUALITY caseIgnoreMatch " 1450 "SUBSTR caseIgnoreSubstringsMatch " 1451 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 " 1452 "SINGLE-VALUE )", 1453 &ad_errText }, 1454 { "( 1.3.6.1.4.1.4203.666.11.4.1.4 " 1455 "NAME ( 'errSleepTime' ) " 1456 "DESC 'Time to wait before returning the error' " 1457 "EQUALITY integerMatch " 1458 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 " 1459 "SINGLE-VALUE )", 1460 &ad_errSleepTime }, 1461 { "( 1.3.6.1.4.1.4203.666.11.4.1.5 " 1462 "NAME ( 'errMatchedDN' ) " 1463 "DESC 'Value to be returned as matched DN' " 1464 "EQUALITY distinguishedNameMatch " 1465 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 " 1466 "SINGLE-VALUE )", 1467 &ad_errMatchedDN }, 1468 { "( 1.3.6.1.4.1.4203.666.11.4.1.6 " 1469 "NAME ( 'errUnsolicitedOID' ) " 1470 "DESC 'OID to be returned within unsolicited response' " 1471 "EQUALITY objectIdentifierMatch " 1472 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 " 1473 "SINGLE-VALUE )", 1474 &ad_errUnsolicitedOID }, 1475 { "( 1.3.6.1.4.1.4203.666.11.4.1.7 " 1476 "NAME ( 'errUnsolicitedData' ) " 1477 "DESC 'Data to be returned within unsolicited response' " 1478 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 " 1479 "SINGLE-VALUE )", 1480 &ad_errUnsolicitedData }, 1481 { "( 1.3.6.1.4.1.4203.666.11.4.1.8 " 1482 "NAME ( 'errDisconnect' ) " 1483 "DESC 'Disconnect without notice' " 1484 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 " 1485 "SINGLE-VALUE )", 1486 &ad_errDisconnect }, 1487 { NULL } 1488 }; 1489 1490 static struct { 1491 char *desc; 1492 ObjectClass **oc; 1493 } retcode_oc[] = { 1494 { "( 1.3.6.1.4.1.4203.666.11.4.3.0 " 1495 "NAME ( 'errAbsObject' ) " 1496 "SUP top ABSTRACT " 1497 "MUST ( errCode ) " 1498 "MAY ( " 1499 "cn " 1500 "$ description " 1501 "$ errOp " 1502 "$ errText " 1503 "$ errSleepTime " 1504 "$ errMatchedDN " 1505 "$ errUnsolicitedOID " 1506 "$ errUnsolicitedData " 1507 "$ errDisconnect " 1508 ") )", 1509 &oc_errAbsObject }, 1510 { "( 1.3.6.1.4.1.4203.666.11.4.3.1 " 1511 "NAME ( 'errObject' ) " 1512 "SUP errAbsObject STRUCTURAL " 1513 ")", 1514 &oc_errObject }, 1515 { "( 1.3.6.1.4.1.4203.666.11.4.3.2 " 1516 "NAME ( 'errAuxObject' ) " 1517 "SUP errAbsObject AUXILIARY " 1518 ")", 1519 &oc_errAuxObject }, 1520 { NULL } 1521 }; 1522 1523 1524 for ( i = 0; retcode_at[ i ].desc != NULL; i++ ) { 1525 code = register_at( retcode_at[ i ].desc, retcode_at[ i ].ad, 0 ); 1526 if ( code ) { 1527 Debug( LDAP_DEBUG_ANY, 1528 "retcode: register_at failed\n" ); 1529 return code; 1530 } 1531 1532 (*retcode_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE; 1533 } 1534 1535 for ( i = 0; retcode_oc[ i ].desc != NULL; i++ ) { 1536 code = register_oc( retcode_oc[ i ].desc, retcode_oc[ i ].oc, 0 ); 1537 if ( code ) { 1538 Debug( LDAP_DEBUG_ANY, 1539 "retcode: register_oc failed\n" ); 1540 return code; 1541 } 1542 1543 (*retcode_oc[ i ].oc)->soc_flags |= SLAP_OC_HIDE; 1544 } 1545 1546 retcode.on_bi.bi_type = "retcode"; 1547 1548 retcode.on_bi.bi_db_init = retcode_db_init; 1549 retcode.on_bi.bi_db_open = retcode_db_open; 1550 retcode.on_bi.bi_db_destroy = retcode_db_destroy; 1551 1552 retcode.on_bi.bi_op_add = retcode_op_func; 1553 retcode.on_bi.bi_op_bind = retcode_op_func; 1554 retcode.on_bi.bi_op_compare = retcode_op_func; 1555 retcode.on_bi.bi_op_delete = retcode_op_func; 1556 retcode.on_bi.bi_op_modify = retcode_op_func; 1557 retcode.on_bi.bi_op_modrdn = retcode_op_func; 1558 retcode.on_bi.bi_op_search = retcode_op_func; 1559 1560 retcode.on_bi.bi_extended = retcode_op_func; 1561 1562 retcode.on_response = retcode_response; 1563 1564 retcode.on_bi.bi_cf_ocs = rcocs; 1565 1566 code = config_register_schema( rccfg, rcocs ); 1567 if ( code ) { 1568 return code; 1569 } 1570 1571 return overlay_register( &retcode ); 1572 } 1573 1574 #if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC 1575 int 1576 init_module( int argc, char *argv[] ) 1577 { 1578 return retcode_initialize(); 1579 } 1580 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */ 1581 1582 #endif /* SLAPD_OVER_RETCODE */ 1583
Indexes created Tue Jul 07 00:25:39 UTC 2026