retcode.c revision 1.1.1.4.6.1
1 /* $NetBSD: retcode.c,v 1.1.1.4.6.1 2017/03/20 06:56:18 pgoyette 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-2016 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.1.1.4.6.1 2017/03/20 06:56:18 pgoyette 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 "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 op->o_abandon = 1; 720 return rs->sr_err; 721 } 722 723 return SLAP_CB_CONTINUE; 724 } 725 726 static int 727 retcode_response( Operation *op, SlapReply *rs ) 728 { 729 slap_overinst *on = (slap_overinst *)op->o_bd->bd_info; 730 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 731 732 if ( rs->sr_type != REP_SEARCH || !RETCODE_INDIR( rd ) ) { 733 return SLAP_CB_CONTINUE; 734 } 735 736 return retcode_entry_response( op, rs, NULL, rs->sr_entry ); 737 } 738 739 static int 740 retcode_db_init( BackendDB *be, ConfigReply *cr ) 741 { 742 slap_overinst *on = (slap_overinst *)be->bd_info; 743 retcode_t *rd; 744 745 srand( getpid() ); 746 747 rd = (retcode_t *)ch_malloc( sizeof( retcode_t ) ); 748 memset( rd, 0, sizeof( retcode_t ) ); 749 750 on->on_bi.bi_private = (void *)rd; 751 752 return 0; 753 } 754 755 static void 756 retcode_item_destroy( retcode_item_t *rdi ) 757 { 758 ber_memfree( rdi->rdi_line.bv_val ); 759 760 ber_memfree( rdi->rdi_dn.bv_val ); 761 ber_memfree( rdi->rdi_ndn.bv_val ); 762 763 if ( !BER_BVISNULL( &rdi->rdi_text ) ) { 764 ber_memfree( rdi->rdi_text.bv_val ); 765 } 766 767 if ( !BER_BVISNULL( &rdi->rdi_matched ) ) { 768 ber_memfree( rdi->rdi_matched.bv_val ); 769 } 770 771 if ( rdi->rdi_ref ) { 772 ber_bvarray_free( rdi->rdi_ref ); 773 } 774 775 BER_BVZERO( &rdi->rdi_e.e_name ); 776 BER_BVZERO( &rdi->rdi_e.e_nname ); 777 778 entry_clean( &rdi->rdi_e ); 779 780 if ( !BER_BVISNULL( &rdi->rdi_unsolicited_oid ) ) { 781 ber_memfree( rdi->rdi_unsolicited_oid.bv_val ); 782 if ( !BER_BVISNULL( &rdi->rdi_unsolicited_data ) ) 783 ber_memfree( rdi->rdi_unsolicited_data.bv_val ); 784 } 785 786 ch_free( rdi ); 787 } 788 789 enum { 790 RC_PARENT = 1, 791 RC_ITEM 792 }; 793 794 static ConfigDriver rc_cf_gen; 795 796 static ConfigTable rccfg[] = { 797 { "retcode-parent", "dn", 798 2, 2, 0, ARG_MAGIC|ARG_DN|RC_PARENT, rc_cf_gen, 799 "( OLcfgOvAt:20.1 NAME 'olcRetcodeParent' " 800 "DESC '' " 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 "SYNTAX OMsBoolean SINGLE-VALUE )", NULL, NULL }, 815 816 { "retcode-sleep", "sleeptime", 817 2, 2, 0, ARG_OFFSET|ARG_INT, 818 (void *)offsetof(retcode_t, rd_sleep), 819 "( OLcfgOvAt:20.4 NAME 'olcRetcodeSleep' " 820 "DESC '' " 821 "SYNTAX OMsInteger SINGLE-VALUE )", NULL, NULL }, 822 823 { NULL, NULL, 0, 0, 0, ARG_IGNORED } 824 }; 825 826 static ConfigOCs rcocs[] = { 827 { "( OLcfgOvOc:20.1 " 828 "NAME 'olcRetcodeConfig' " 829 "DESC 'Retcode configuration' " 830 "SUP olcOverlayConfig " 831 "MAY ( olcRetcodeParent " 832 "$ olcRetcodeItem " 833 "$ olcRetcodeInDir " 834 "$ olcRetcodeSleep " 835 ") )", 836 Cft_Overlay, rccfg, NULL, NULL }, 837 { NULL, 0, NULL } 838 }; 839 840 static int 841 rc_cf_gen( ConfigArgs *c ) 842 { 843 slap_overinst *on = (slap_overinst *)c->bi; 844 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 845 int rc = ARG_BAD_CONF; 846 847 if ( c->op == SLAP_CONFIG_EMIT ) { 848 switch( c->type ) { 849 case RC_PARENT: 850 if ( !BER_BVISEMPTY( &rd->rd_pdn )) { 851 rc = value_add_one( &c->rvalue_vals, 852 &rd->rd_pdn ); 853 if ( rc == 0 ) { 854 rc = value_add_one( &c->rvalue_nvals, 855 &rd->rd_npdn ); 856 } 857 return rc; 858 } 859 rc = 0; 860 break; 861 862 case RC_ITEM: { 863 retcode_item_t *rdi; 864 int i; 865 866 for ( rdi = rd->rd_item, i = 0; rdi; rdi = rdi->rdi_next, i++ ) { 867 char buf[4096]; 868 struct berval bv; 869 char *ptr; 870 871 bv.bv_len = snprintf( buf, sizeof( buf ), SLAP_X_ORDERED_FMT, i ); 872 bv.bv_len += rdi->rdi_line.bv_len; 873 ptr = bv.bv_val = ch_malloc( bv.bv_len + 1 ); 874 ptr = lutil_strcopy( ptr, buf ); 875 ptr = lutil_strncopy( ptr, rdi->rdi_line.bv_val, rdi->rdi_line.bv_len ); 876 ber_bvarray_add( &c->rvalue_vals, &bv ); 877 } 878 rc = 0; 879 } break; 880 881 default: 882 assert( 0 ); 883 break; 884 } 885 886 return rc; 887 888 } else if ( c->op == LDAP_MOD_DELETE ) { 889 switch( c->type ) { 890 case RC_PARENT: 891 if ( rd->rd_pdn.bv_val ) { 892 ber_memfree ( rd->rd_pdn.bv_val ); 893 rc = 0; 894 } 895 if ( rd->rd_npdn.bv_val ) { 896 ber_memfree ( rd->rd_npdn.bv_val ); 897 } 898 break; 899 900 case RC_ITEM: 901 if ( c->valx == -1 ) { 902 retcode_item_t *rdi, *next; 903 904 for ( rdi = rd->rd_item; rdi != NULL; rdi = next ) { 905 next = rdi->rdi_next; 906 retcode_item_destroy( rdi ); 907 } 908 909 } else { 910 retcode_item_t **rdip, *rdi; 911 int i; 912 913 for ( rdip = &rd->rd_item, i = 0; i <= c->valx && *rdip; i++, rdip = &(*rdip)->rdi_next ) 914 ; 915 if ( *rdip == NULL ) { 916 return 1; 917 } 918 rdi = *rdip; 919 *rdip = rdi->rdi_next; 920 921 retcode_item_destroy( rdi ); 922 } 923 rc = 0; 924 break; 925 926 default: 927 assert( 0 ); 928 break; 929 } 930 return rc; /* FIXME */ 931 } 932 933 switch( c->type ) { 934 case RC_PARENT: 935 if ( rd->rd_pdn.bv_val ) { 936 ber_memfree ( rd->rd_pdn.bv_val ); 937 } 938 if ( rd->rd_npdn.bv_val ) { 939 ber_memfree ( rd->rd_npdn.bv_val ); 940 } 941 rd->rd_pdn = c->value_dn; 942 rd->rd_npdn = c->value_ndn; 943 rc = 0; 944 break; 945 946 case RC_ITEM: { 947 retcode_item_t rdi = { BER_BVNULL }, **rdip; 948 struct berval bv, rdn, nrdn; 949 char *next = NULL; 950 int i; 951 952 if ( c->argc < 3 ) { 953 snprintf( c->cr_msg, sizeof(c->cr_msg), 954 "\"retcode-item <RDN> <retcode> [<text>]\": " 955 "missing args" ); 956 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 957 c->log, c->cr_msg, 0 ); 958 return ARG_BAD_CONF; 959 } 960 961 ber_str2bv( c->argv[ 1 ], 0, 0, &bv ); 962 963 rc = dnPrettyNormal( NULL, &bv, &rdn, &nrdn, NULL ); 964 if ( rc != LDAP_SUCCESS ) { 965 snprintf( c->cr_msg, sizeof(c->cr_msg), 966 "unable to normalize RDN \"%s\": %d", 967 c->argv[ 1 ], rc ); 968 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 969 c->log, c->cr_msg, 0 ); 970 return ARG_BAD_CONF; 971 } 972 973 if ( !dnIsOneLevelRDN( &nrdn ) ) { 974 snprintf( c->cr_msg, sizeof(c->cr_msg), 975 "value \"%s\" is not a RDN", 976 c->argv[ 1 ] ); 977 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 978 c->log, c->cr_msg, 0 ); 979 return ARG_BAD_CONF; 980 } 981 982 if ( BER_BVISNULL( &rd->rd_npdn ) ) { 983 /* FIXME: we use the database suffix */ 984 if ( c->be->be_nsuffix == NULL ) { 985 snprintf( c->cr_msg, sizeof(c->cr_msg), 986 "either \"retcode-parent\" " 987 "or \"suffix\" must be defined" ); 988 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 989 c->log, c->cr_msg, 0 ); 990 return ARG_BAD_CONF; 991 } 992 993 ber_dupbv( &rd->rd_pdn, &c->be->be_suffix[ 0 ] ); 994 ber_dupbv( &rd->rd_npdn, &c->be->be_nsuffix[ 0 ] ); 995 } 996 997 build_new_dn( &rdi.rdi_dn, &rd->rd_pdn, &rdn, NULL ); 998 build_new_dn( &rdi.rdi_ndn, &rd->rd_npdn, &nrdn, NULL ); 999 1000 ch_free( rdn.bv_val ); 1001 ch_free( nrdn.bv_val ); 1002 1003 rdi.rdi_err = strtol( c->argv[ 2 ], &next, 0 ); 1004 if ( next == c->argv[ 2 ] || next[ 0 ] != '\0' ) { 1005 snprintf( c->cr_msg, sizeof(c->cr_msg), 1006 "unable to parse return code \"%s\"", 1007 c->argv[ 2 ] ); 1008 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1009 c->log, c->cr_msg, 0 ); 1010 return ARG_BAD_CONF; 1011 } 1012 1013 rdi.rdi_mask = SN_DG_OP_ALL; 1014 1015 if ( c->argc > 3 ) { 1016 for ( i = 3; i < c->argc; i++ ) { 1017 if ( strncasecmp( c->argv[ i ], "op=", STRLENOF( "op=" ) ) == 0 ) 1018 { 1019 char **ops; 1020 int j; 1021 1022 ops = ldap_str2charray( &c->argv[ i ][ STRLENOF( "op=" ) ], "," ); 1023 assert( ops != NULL ); 1024 1025 rdi.rdi_mask = SN_DG_OP_NONE; 1026 1027 for ( j = 0; ops[ j ] != NULL; j++ ) { 1028 if ( strcasecmp( ops[ j ], "add" ) == 0 ) { 1029 rdi.rdi_mask |= SN_DG_OP_ADD; 1030 1031 } else if ( strcasecmp( ops[ j ], "bind" ) == 0 ) { 1032 rdi.rdi_mask |= SN_DG_OP_BIND; 1033 1034 } else if ( strcasecmp( ops[ j ], "compare" ) == 0 ) { 1035 rdi.rdi_mask |= SN_DG_OP_COMPARE; 1036 1037 } else if ( strcasecmp( ops[ j ], "delete" ) == 0 ) { 1038 rdi.rdi_mask |= SN_DG_OP_DELETE; 1039 1040 } else if ( strcasecmp( ops[ j ], "modify" ) == 0 ) { 1041 rdi.rdi_mask |= SN_DG_OP_MODIFY; 1042 1043 } else if ( strcasecmp( ops[ j ], "rename" ) == 0 1044 || strcasecmp( ops[ j ], "modrdn" ) == 0 ) 1045 { 1046 rdi.rdi_mask |= SN_DG_OP_RENAME; 1047 1048 } else if ( strcasecmp( ops[ j ], "search" ) == 0 ) { 1049 rdi.rdi_mask |= SN_DG_OP_SEARCH; 1050 1051 } else if ( strcasecmp( ops[ j ], "extended" ) == 0 ) { 1052 rdi.rdi_mask |= SN_DG_EXTENDED; 1053 1054 } else if ( strcasecmp( ops[ j ], "auth" ) == 0 ) { 1055 rdi.rdi_mask |= SN_DG_OP_AUTH; 1056 1057 } else if ( strcasecmp( ops[ j ], "read" ) == 0 ) { 1058 rdi.rdi_mask |= SN_DG_OP_READ; 1059 1060 } else if ( strcasecmp( ops[ j ], "write" ) == 0 ) { 1061 rdi.rdi_mask |= SN_DG_OP_WRITE; 1062 1063 } else if ( strcasecmp( ops[ j ], "all" ) == 0 ) { 1064 rdi.rdi_mask |= SN_DG_OP_ALL; 1065 1066 } else { 1067 snprintf( c->cr_msg, sizeof(c->cr_msg), 1068 "unknown op \"%s\"", 1069 ops[ j ] ); 1070 ldap_charray_free( ops ); 1071 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1072 c->log, c->cr_msg, 0 ); 1073 return ARG_BAD_CONF; 1074 } 1075 } 1076 1077 ldap_charray_free( ops ); 1078 1079 } else if ( strncasecmp( c->argv[ i ], "text=", STRLENOF( "text=" ) ) == 0 ) 1080 { 1081 if ( !BER_BVISNULL( &rdi.rdi_text ) ) { 1082 snprintf( c->cr_msg, sizeof(c->cr_msg), 1083 "\"text\" already provided" ); 1084 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1085 c->log, c->cr_msg, 0 ); 1086 return ARG_BAD_CONF; 1087 } 1088 ber_str2bv( &c->argv[ i ][ STRLENOF( "text=" ) ], 0, 1, &rdi.rdi_text ); 1089 1090 } else if ( strncasecmp( c->argv[ i ], "matched=", STRLENOF( "matched=" ) ) == 0 ) 1091 { 1092 struct berval dn; 1093 1094 if ( !BER_BVISNULL( &rdi.rdi_matched ) ) { 1095 snprintf( c->cr_msg, sizeof(c->cr_msg), 1096 "\"matched\" already provided" ); 1097 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1098 c->log, c->cr_msg, 0 ); 1099 return ARG_BAD_CONF; 1100 } 1101 ber_str2bv( &c->argv[ i ][ STRLENOF( "matched=" ) ], 0, 0, &dn ); 1102 if ( dnPretty( NULL, &dn, &rdi.rdi_matched, NULL ) != LDAP_SUCCESS ) { 1103 snprintf( c->cr_msg, sizeof(c->cr_msg), 1104 "unable to prettify matched DN \"%s\"", 1105 &c->argv[ i ][ STRLENOF( "matched=" ) ] ); 1106 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1107 c->log, c->cr_msg, 0 ); 1108 return ARG_BAD_CONF; 1109 } 1110 1111 } else if ( strncasecmp( c->argv[ i ], "ref=", STRLENOF( "ref=" ) ) == 0 ) 1112 { 1113 char **refs; 1114 int j; 1115 1116 if ( rdi.rdi_ref != NULL ) { 1117 snprintf( c->cr_msg, sizeof(c->cr_msg), 1118 "\"ref\" already provided" ); 1119 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1120 c->log, c->cr_msg, 0 ); 1121 return ARG_BAD_CONF; 1122 } 1123 1124 if ( rdi.rdi_err != LDAP_REFERRAL ) { 1125 snprintf( c->cr_msg, sizeof(c->cr_msg), 1126 "providing \"ref\" " 1127 "along with a non-referral " 1128 "resultCode may cause slapd failures " 1129 "related to internal checks" ); 1130 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1131 c->log, c->cr_msg, 0 ); 1132 } 1133 1134 refs = ldap_str2charray( &c->argv[ i ][ STRLENOF( "ref=" ) ], " " ); 1135 assert( refs != NULL ); 1136 1137 for ( j = 0; refs[ j ] != NULL; j++ ) { 1138 struct berval bv; 1139 1140 ber_str2bv( refs[ j ], 0, 1, &bv ); 1141 ber_bvarray_add( &rdi.rdi_ref, &bv ); 1142 } 1143 1144 ldap_charray_free( refs ); 1145 1146 } else if ( strncasecmp( c->argv[ i ], "sleeptime=", STRLENOF( "sleeptime=" ) ) == 0 ) 1147 { 1148 if ( rdi.rdi_sleeptime != 0 ) { 1149 snprintf( c->cr_msg, sizeof(c->cr_msg), 1150 "\"sleeptime\" already provided" ); 1151 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1152 c->log, c->cr_msg, 0 ); 1153 return ARG_BAD_CONF; 1154 } 1155 1156 if ( lutil_atoi( &rdi.rdi_sleeptime, &c->argv[ i ][ STRLENOF( "sleeptime=" ) ] ) ) { 1157 snprintf( c->cr_msg, sizeof(c->cr_msg), 1158 "unable to parse \"sleeptime=%s\"", 1159 &c->argv[ i ][ STRLENOF( "sleeptime=" ) ] ); 1160 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1161 c->log, c->cr_msg, 0 ); 1162 return ARG_BAD_CONF; 1163 } 1164 1165 } else if ( strncasecmp( c->argv[ i ], "unsolicited=", STRLENOF( "unsolicited=" ) ) == 0 ) 1166 { 1167 char *data; 1168 1169 if ( !BER_BVISNULL( &rdi.rdi_unsolicited_oid ) ) { 1170 snprintf( c->cr_msg, sizeof(c->cr_msg), 1171 "\"unsolicited\" already provided" ); 1172 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1173 c->log, c->cr_msg, 0 ); 1174 return ARG_BAD_CONF; 1175 } 1176 1177 data = strchr( &c->argv[ i ][ STRLENOF( "unsolicited=" ) ], ':' ); 1178 if ( data != NULL ) { 1179 struct berval oid; 1180 1181 if ( ldif_parse_line2( &c->argv[ i ][ STRLENOF( "unsolicited=" ) ], 1182 &oid, &rdi.rdi_unsolicited_data, NULL ) ) 1183 { 1184 snprintf( c->cr_msg, sizeof(c->cr_msg), 1185 "unable to parse \"unsolicited\"" ); 1186 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1187 c->log, c->cr_msg, 0 ); 1188 return ARG_BAD_CONF; 1189 } 1190 1191 ber_dupbv( &rdi.rdi_unsolicited_oid, &oid ); 1192 1193 } else { 1194 ber_str2bv( &c->argv[ i ][ STRLENOF( "unsolicited=" ) ], 0, 1, 1195 &rdi.rdi_unsolicited_oid ); 1196 } 1197 1198 } else if ( strncasecmp( c->argv[ i ], "flags=", STRLENOF( "flags=" ) ) == 0 ) 1199 { 1200 char *arg = &c->argv[ i ][ STRLENOF( "flags=" ) ]; 1201 if ( strcasecmp( arg, "disconnect" ) == 0 ) { 1202 rdi.rdi_flags |= RDI_PRE_DISCONNECT; 1203 1204 } else if ( strcasecmp( arg, "pre-disconnect" ) == 0 ) { 1205 rdi.rdi_flags |= RDI_PRE_DISCONNECT; 1206 1207 } else if ( strcasecmp( arg, "post-disconnect" ) == 0 ) { 1208 rdi.rdi_flags |= RDI_POST_DISCONNECT; 1209 1210 } else { 1211 snprintf( c->cr_msg, sizeof(c->cr_msg), 1212 "unknown flag \"%s\"", arg ); 1213 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1214 c->log, c->cr_msg, 0 ); 1215 return ARG_BAD_CONF; 1216 } 1217 1218 } else { 1219 snprintf( c->cr_msg, sizeof(c->cr_msg), 1220 "unknown option \"%s\"", 1221 c->argv[ i ] ); 1222 Debug( LDAP_DEBUG_CONFIG, "%s: retcode: %s\n", 1223 c->log, c->cr_msg, 0 ); 1224 return ARG_BAD_CONF; 1225 } 1226 } 1227 } 1228 1229 rdi.rdi_line.bv_len = 2*(c->argc - 1) + c->argc - 2; 1230 for ( i = 1; i < c->argc; i++ ) { 1231 rdi.rdi_line.bv_len += strlen( c->argv[ i ] ); 1232 } 1233 next = rdi.rdi_line.bv_val = ch_malloc( rdi.rdi_line.bv_len + 1 ); 1234 1235 for ( i = 1; i < c->argc; i++ ) { 1236 *next++ = '"'; 1237 next = lutil_strcopy( next, c->argv[ i ] ); 1238 *next++ = '"'; 1239 *next++ = ' '; 1240 } 1241 *--next = '\0'; 1242 1243 for ( rdip = &rd->rd_item; *rdip; rdip = &(*rdip)->rdi_next ) 1244 /* go to last */ ; 1245 1246 1247 *rdip = ( retcode_item_t * )ch_malloc( sizeof( retcode_item_t ) ); 1248 *(*rdip) = rdi; 1249 1250 rc = 0; 1251 } break; 1252 1253 default: 1254 rc = SLAP_CONF_UNKNOWN; 1255 break; 1256 } 1257 1258 return rc; 1259 } 1260 1261 static int 1262 retcode_db_open( BackendDB *be, ConfigReply *cr) 1263 { 1264 slap_overinst *on = (slap_overinst *)be->bd_info; 1265 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 1266 1267 retcode_item_t *rdi; 1268 1269 for ( rdi = rd->rd_item; rdi; rdi = rdi->rdi_next ) { 1270 LDAPRDN rdn = NULL; 1271 int rc, j; 1272 char* p; 1273 struct berval val[ 3 ]; 1274 char buf[ SLAP_TEXT_BUFLEN ]; 1275 1276 /* DN */ 1277 rdi->rdi_e.e_name = rdi->rdi_dn; 1278 rdi->rdi_e.e_nname = rdi->rdi_ndn; 1279 1280 /* objectClass */ 1281 val[ 0 ] = oc_errObject->soc_cname; 1282 val[ 1 ] = slap_schema.si_oc_extensibleObject->soc_cname; 1283 BER_BVZERO( &val[ 2 ] ); 1284 1285 attr_merge( &rdi->rdi_e, slap_schema.si_ad_objectClass, val, NULL ); 1286 1287 /* RDN avas */ 1288 rc = ldap_bv2rdn( &rdi->rdi_dn, &rdn, (char **) &p, 1289 LDAP_DN_FORMAT_LDAP ); 1290 1291 assert( rc == LDAP_SUCCESS ); 1292 1293 for ( j = 0; rdn[ j ]; j++ ) { 1294 LDAPAVA *ava = rdn[ j ]; 1295 AttributeDescription *ad = NULL; 1296 const char *text; 1297 1298 rc = slap_bv2ad( &ava->la_attr, &ad, &text ); 1299 assert( rc == LDAP_SUCCESS ); 1300 1301 attr_merge_normalize_one( &rdi->rdi_e, ad, 1302 &ava->la_value, NULL ); 1303 } 1304 1305 ldap_rdnfree( rdn ); 1306 1307 /* error code */ 1308 snprintf( buf, sizeof( buf ), "%d", rdi->rdi_err ); 1309 ber_str2bv( buf, 0, 0, &val[ 0 ] ); 1310 1311 attr_merge_one( &rdi->rdi_e, ad_errCode, &val[ 0 ], NULL ); 1312 1313 if ( rdi->rdi_ref != NULL ) { 1314 attr_merge_normalize( &rdi->rdi_e, slap_schema.si_ad_ref, 1315 rdi->rdi_ref, NULL ); 1316 } 1317 1318 /* text */ 1319 if ( !BER_BVISNULL( &rdi->rdi_text ) ) { 1320 val[ 0 ] = rdi->rdi_text; 1321 1322 attr_merge_normalize_one( &rdi->rdi_e, ad_errText, &val[ 0 ], NULL ); 1323 } 1324 1325 /* matched */ 1326 if ( !BER_BVISNULL( &rdi->rdi_matched ) ) { 1327 val[ 0 ] = rdi->rdi_matched; 1328 1329 attr_merge_normalize_one( &rdi->rdi_e, ad_errMatchedDN, &val[ 0 ], NULL ); 1330 } 1331 1332 /* sleep time */ 1333 if ( rdi->rdi_sleeptime ) { 1334 snprintf( buf, sizeof( buf ), "%d", rdi->rdi_sleeptime ); 1335 ber_str2bv( buf, 0, 0, &val[ 0 ] ); 1336 1337 attr_merge_one( &rdi->rdi_e, ad_errSleepTime, &val[ 0 ], NULL ); 1338 } 1339 1340 /* operations */ 1341 if ( rdi->rdi_mask & SN_DG_OP_ADD ) { 1342 BER_BVSTR( &val[ 0 ], "add" ); 1343 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1344 } 1345 1346 if ( rdi->rdi_mask & SN_DG_OP_BIND ) { 1347 BER_BVSTR( &val[ 0 ], "bind" ); 1348 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1349 } 1350 1351 if ( rdi->rdi_mask & SN_DG_OP_COMPARE ) { 1352 BER_BVSTR( &val[ 0 ], "compare" ); 1353 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1354 } 1355 1356 if ( rdi->rdi_mask & SN_DG_OP_DELETE ) { 1357 BER_BVSTR( &val[ 0 ], "delete" ); 1358 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1359 } 1360 1361 if ( rdi->rdi_mask & SN_DG_EXTENDED ) { 1362 BER_BVSTR( &val[ 0 ], "extended" ); 1363 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1364 } 1365 1366 if ( rdi->rdi_mask & SN_DG_OP_MODIFY ) { 1367 BER_BVSTR( &val[ 0 ], "modify" ); 1368 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1369 } 1370 1371 if ( rdi->rdi_mask & SN_DG_OP_RENAME ) { 1372 BER_BVSTR( &val[ 0 ], "rename" ); 1373 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1374 } 1375 1376 if ( rdi->rdi_mask & SN_DG_OP_SEARCH ) { 1377 BER_BVSTR( &val[ 0 ], "search" ); 1378 attr_merge_normalize_one( &rdi->rdi_e, ad_errOp, &val[ 0 ], NULL ); 1379 } 1380 } 1381 1382 return 0; 1383 } 1384 1385 static int 1386 retcode_db_destroy( BackendDB *be, ConfigReply *cr ) 1387 { 1388 slap_overinst *on = (slap_overinst *)be->bd_info; 1389 retcode_t *rd = (retcode_t *)on->on_bi.bi_private; 1390 1391 if ( rd ) { 1392 retcode_item_t *rdi, *next; 1393 1394 for ( rdi = rd->rd_item; rdi != NULL; rdi = next ) { 1395 next = rdi->rdi_next; 1396 retcode_item_destroy( rdi ); 1397 } 1398 1399 if ( !BER_BVISNULL( &rd->rd_pdn ) ) { 1400 ber_memfree( rd->rd_pdn.bv_val ); 1401 } 1402 1403 if ( !BER_BVISNULL( &rd->rd_npdn ) ) { 1404 ber_memfree( rd->rd_npdn.bv_val ); 1405 } 1406 1407 ber_memfree( rd ); 1408 } 1409 1410 return 0; 1411 } 1412 1413 #if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC 1414 static 1415 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */ 1416 int 1417 retcode_initialize( void ) 1418 { 1419 int i, code; 1420 1421 static struct { 1422 char *desc; 1423 AttributeDescription **ad; 1424 } retcode_at[] = { 1425 { "( 1.3.6.1.4.1.4203.666.11.4.1.1 " 1426 "NAME ( 'errCode' ) " 1427 "DESC 'LDAP error code' " 1428 "EQUALITY integerMatch " 1429 "ORDERING integerOrderingMatch " 1430 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 " 1431 "SINGLE-VALUE )", 1432 &ad_errCode }, 1433 { "( 1.3.6.1.4.1.4203.666.11.4.1.2 " 1434 "NAME ( 'errOp' ) " 1435 "DESC 'Operations the errObject applies to' " 1436 "EQUALITY caseIgnoreMatch " 1437 "SUBSTR caseIgnoreSubstringsMatch " 1438 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )", 1439 &ad_errOp}, 1440 { "( 1.3.6.1.4.1.4203.666.11.4.1.3 " 1441 "NAME ( 'errText' ) " 1442 "DESC 'LDAP error textual description' " 1443 "EQUALITY caseIgnoreMatch " 1444 "SUBSTR caseIgnoreSubstringsMatch " 1445 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 " 1446 "SINGLE-VALUE )", 1447 &ad_errText }, 1448 { "( 1.3.6.1.4.1.4203.666.11.4.1.4 " 1449 "NAME ( 'errSleepTime' ) " 1450 "DESC 'Time to wait before returning the error' " 1451 "EQUALITY integerMatch " 1452 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 " 1453 "SINGLE-VALUE )", 1454 &ad_errSleepTime }, 1455 { "( 1.3.6.1.4.1.4203.666.11.4.1.5 " 1456 "NAME ( 'errMatchedDN' ) " 1457 "DESC 'Value to be returned as matched DN' " 1458 "EQUALITY distinguishedNameMatch " 1459 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 " 1460 "SINGLE-VALUE )", 1461 &ad_errMatchedDN }, 1462 { "( 1.3.6.1.4.1.4203.666.11.4.1.6 " 1463 "NAME ( 'errUnsolicitedOID' ) " 1464 "DESC 'OID to be returned within unsolicited response' " 1465 "EQUALITY objectIdentifierMatch " 1466 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 " 1467 "SINGLE-VALUE )", 1468 &ad_errUnsolicitedOID }, 1469 { "( 1.3.6.1.4.1.4203.666.11.4.1.7 " 1470 "NAME ( 'errUnsolicitedData' ) " 1471 "DESC 'Data to be returned within unsolicited response' " 1472 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 " 1473 "SINGLE-VALUE )", 1474 &ad_errUnsolicitedData }, 1475 { "( 1.3.6.1.4.1.4203.666.11.4.1.8 " 1476 "NAME ( 'errDisconnect' ) " 1477 "DESC 'Disconnect without notice' " 1478 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 " 1479 "SINGLE-VALUE )", 1480 &ad_errDisconnect }, 1481 { NULL } 1482 }; 1483 1484 static struct { 1485 char *desc; 1486 ObjectClass **oc; 1487 } retcode_oc[] = { 1488 { "( 1.3.6.1.4.1.4203.666.11.4.3.0 " 1489 "NAME ( 'errAbsObject' ) " 1490 "SUP top ABSTRACT " 1491 "MUST ( errCode ) " 1492 "MAY ( " 1493 "cn " 1494 "$ description " 1495 "$ errOp " 1496 "$ errText " 1497 "$ errSleepTime " 1498 "$ errMatchedDN " 1499 "$ errUnsolicitedOID " 1500 "$ errUnsolicitedData " 1501 "$ errDisconnect " 1502 ") )", 1503 &oc_errAbsObject }, 1504 { "( 1.3.6.1.4.1.4203.666.11.4.3.1 " 1505 "NAME ( 'errObject' ) " 1506 "SUP errAbsObject STRUCTURAL " 1507 ")", 1508 &oc_errObject }, 1509 { "( 1.3.6.1.4.1.4203.666.11.4.3.2 " 1510 "NAME ( 'errAuxObject' ) " 1511 "SUP errAbsObject AUXILIARY " 1512 ")", 1513 &oc_errAuxObject }, 1514 { NULL } 1515 }; 1516 1517 1518 for ( i = 0; retcode_at[ i ].desc != NULL; i++ ) { 1519 code = register_at( retcode_at[ i ].desc, retcode_at[ i ].ad, 0 ); 1520 if ( code ) { 1521 Debug( LDAP_DEBUG_ANY, 1522 "retcode: register_at failed\n", 0, 0, 0 ); 1523 return code; 1524 } 1525 1526 (*retcode_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE; 1527 } 1528 1529 for ( i = 0; retcode_oc[ i ].desc != NULL; i++ ) { 1530 code = register_oc( retcode_oc[ i ].desc, retcode_oc[ i ].oc, 0 ); 1531 if ( code ) { 1532 Debug( LDAP_DEBUG_ANY, 1533 "retcode: register_oc failed\n", 0, 0, 0 ); 1534 return code; 1535 } 1536 1537 (*retcode_oc[ i ].oc)->soc_flags |= SLAP_OC_HIDE; 1538 } 1539 1540 retcode.on_bi.bi_type = "retcode"; 1541 1542 retcode.on_bi.bi_db_init = retcode_db_init; 1543 retcode.on_bi.bi_db_open = retcode_db_open; 1544 retcode.on_bi.bi_db_destroy = retcode_db_destroy; 1545 1546 retcode.on_bi.bi_op_add = retcode_op_func; 1547 retcode.on_bi.bi_op_bind = retcode_op_func; 1548 retcode.on_bi.bi_op_compare = retcode_op_func; 1549 retcode.on_bi.bi_op_delete = retcode_op_func; 1550 retcode.on_bi.bi_op_modify = retcode_op_func; 1551 retcode.on_bi.bi_op_modrdn = retcode_op_func; 1552 retcode.on_bi.bi_op_search = retcode_op_func; 1553 1554 retcode.on_bi.bi_extended = retcode_op_func; 1555 1556 retcode.on_response = retcode_response; 1557 1558 retcode.on_bi.bi_cf_ocs = rcocs; 1559 1560 code = config_register_schema( rccfg, rcocs ); 1561 if ( code ) { 1562 return code; 1563 } 1564 1565 return overlay_register( &retcode ); 1566 } 1567 1568 #if SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC 1569 int 1570 init_module( int argc, char *argv[] ) 1571 { 1572 return retcode_initialize(); 1573 } 1574 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */ 1575 1576 #endif /* SLAPD_OVER_RETCODE */ 1577
Indexes created Wed Jul 08 00:27:11 UTC 2026