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

   1 /* rwm.c - rewrite/remap operations */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 2003-2004 The OpenLDAP Foundation.
   6  * Portions Copyright 2003 Pierangelo Masarati.
   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
  18 #include "portable.h"
  19
  20 #ifdef SLAPD_OVER_RWM
  21
  22 #include <stdio.h>
  23
  24 #include "slap.h"
  25 #include "rwm.h"
  26
  27 static int
  28 rwm_op_dn_massage( Operation *op, SlapReply *rs, void *cookie )
  29 {
  30         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
  31         struct ldaprwmap        *rwmap =
  32                         (struct ldaprwmap *)on->on_bi.bi_private;
  33
  34         struct berval           dn, ndn, mdn = BER_BVNULL;
  35         int                     rc = 0;
  36         dncookie                dc;
  37
  38         /*
  39          * Rewrite the bind dn if needed
  40          */
  41         dc.rwmap = rwmap;
  42 #ifdef ENABLE_REWRITE
  43         dc.conn = op->o_conn;
  44         dc.rs = rs;
  45         dc.ctx = (char *)cookie;
  46 #else
  47         dc.tofrom = ((int *)cookie)[0];
  48         dc.normalized = 0;
  49 #endif
  50
  51         rc = rwm_dn_massage( &dc, &op->o_req_dn, &mdn );
  52         if ( rc != LDAP_SUCCESS ) {
  53                 return rc;
  54         }
  55
  56         if ( mdn.bv_val == op->o_req_dn.bv_val ) {
  57                 return LDAP_SUCCESS;
  58         }
  59
  60         rc = dnPrettyNormal( NULL, &mdn, &dn, &ndn, op->o_tmpmemctx );
  61         if ( rc != LDAP_SUCCESS ) {
  62                 return rc;
  63         }
  64
  65         if ( mdn.bv_val != dn.bv_val ) {
  66                 ch_free( mdn.bv_val );
  67         }
  68
  69         op->o_tmpfree( op->o_req_dn.bv_val, op->o_tmpmemctx );
  70         op->o_tmpfree( op->o_req_ndn.bv_val, op->o_tmpmemctx );
  71
  72         op->o_req_dn = dn;
  73         op->o_req_ndn = ndn;
  74
  75         return LDAP_SUCCESS;
  76 }
  77
  78 static int
  79 rwm_add( Operation *op, SlapReply *rs )
  80 {
  81         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
  82         struct ldaprwmap        *rwmap =
  83                         (struct ldaprwmap *)on->on_bi.bi_private;
  84
  85         int                     rc,
  86                                 i,
  87                                 isupdate;
  88         Attribute               **ap = NULL;
  89
  90 #ifdef ENABLE_REWRITE
  91         rc = rwm_op_dn_massage( op, rs, "addDn" );
  92 #else
  93         rc = 1;
  94         rc = rwm_op_dn_massage( op, rs, &rc );
  95 #endif
  96         if ( rc != LDAP_SUCCESS ) {
  97                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
  98                 send_ldap_error( op, rs, rc, "addDn massage error" );
  99                 return -1;
 100         }
 101
 102         /* Count number of attributes in entry */
 103         isupdate = be_shadow_update( op );
 104         for ( i = 0, ap = &op->oq_add.rs_e->e_attrs; *ap; ) {
 105                 struct berval   mapped;
 106                 Attribute       *a;
 107
 108                 if ( !isupdate && (*ap)->a_desc->ad_type->sat_no_user_mod ) {
 109                         goto cleanup_attr;
 110                 }
 111
 112                 rwm_map( &rwmap->rwm_at, &(*ap)->a_desc->ad_cname,
 113                                 &mapped, RWM_MAP );
 114                 if ( mapped.bv_val == NULL || mapped.bv_val[0] == '\0' ) {
 115                         goto cleanup_attr;
 116                 }
 117
 118                 if ( (*ap)->a_desc->ad_type->sat_syntax
 119                                 == slap_schema.si_syn_distinguishedName )
 120                 {
 121                         /*
 122                          * FIXME: rewrite could fail; in this case
 123                          * the operation should give up, right?
 124                          */
 125 #ifdef ENABLE_REWRITE
 126                         rc = rwm_dnattr_rewrite( op, rs, "addDn",
 127                                         (*ap)->a_vals );
 128 #else
 129                         rc = 1;
 130                         rc = rwm_dnattr_rewrite( op, rs, &rc,
 131                                         (*ap)->a_vals );
 132 #endif
 133                         if ( rc ) {
 134                                 goto cleanup_attr;
 135                         }
 136                 }
 137
 138                 ap = &(*ap)->a_next;
 139                 continue;
 140
 141 cleanup_attr:;
 142                 /* FIXME: leaking attribute/values? */
 143                 a = *ap;
 144
 145                 *ap = (*ap)->a_next;
 146                 ber_bvarray_free( a->a_vals );
 147                 ber_bvarray_free( a->a_nvals );
 148                 ch_free( a );
 149         }
 150
 151
 152         /* TODO: map attribute types, values of DN-valued attributes ... */
 153         return SLAP_CB_CONTINUE;
 154 }
 155
 156 static int
 157 rwm_bind( Operation *op, SlapReply *rs )
 158 {
 159         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 160         struct ldaprwmap        *rwmap =
 161                         (struct ldaprwmap *)on->on_bi.bi_private;
 162         int                     rc;
 163
 164 #ifdef ENABLE_REWRITE
 165         ( void )rewrite_session_init( rwmap->rwm_rw, op->o_conn );
 166
 167         rc = rwm_op_dn_massage( op, rs, "bindDn" );
 168 #else
 169         rc = 1;
 170         rc = rwm_op_dn_massage( op, rs, &rc );
 171 #endif
 172         if ( rc != LDAP_SUCCESS ) {
 173                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 174                 send_ldap_error( op, rs, rc, "bindDn massage error" );
 175                 return -1;
 176         }
 177
 178         return SLAP_CB_CONTINUE;
 179 }
 180
 181 static int
 182 rwm_unbind( Operation *op, SlapReply *rs )
 183 {
 184         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 185         struct ldaprwmap        *rwmap =
 186                         (struct ldaprwmap *)on->on_bi.bi_private;
 187
 188 #ifdef ENABLE_REWRITE
 189         rewrite_session_delete( rwmap->rwm_rw, op->o_conn );
 190 #endif
 191
 192         return SLAP_CB_CONTINUE;
 193 }
 194
 195 static int
 196 rwm_compare( Operation *op, SlapReply *rs )
 197 {
 198         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 199         struct ldaprwmap        *rwmap =
 200                         (struct ldaprwmap *)on->on_bi.bi_private;
 201
 202         int                     rc;
 203         struct berval           mapped_at = BER_BVNULL,
 204                                 mapped_vals[2] = { BER_BVNULL, BER_BVNULL };
 205
 206 #ifdef ENABLE_REWRITE
 207         rc = rwm_op_dn_massage( op, rs, "compareDn" );
 208 #else
 209         rc = 1;
 210         rc = rwm_op_dn_massage( op, rs, &rc );
 211 #endif
 212         if ( rc != LDAP_SUCCESS ) {
 213                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 214                 send_ldap_error( op, rs, rc, "compareDn massage error" );
 215                 return -1;
 216         }
 217
 218         /* if the attribute is an objectClass, try to remap its value */
 219         if ( op->orc_ava->aa_desc == slap_schema.si_ad_objectClass
 220                         || op->orc_ava->aa_desc == slap_schema.si_ad_structuralObjectClass )
 221         {
 222                 rwm_map( &rwmap->rwm_oc, &op->orc_ava->aa_value,
 223                                 &mapped_vals[0], RWM_MAP );
 224                 if ( mapped_vals[0].bv_val == NULL
 225                                 || mapped_vals[0].bv_val[0] == '\0')
 226                 {
 227                         op->o_bd->bd_info = (BackendInfo *)on->on_info;
 228                         send_ldap_error( op, rs, LDAP_OTHER, "compare objectClass map error" );
 229                         return -1;
 230
 231                 } else if ( mapped_vals[0].bv_val != op->orc_ava->aa_value.bv_val ) {
 232                         free( op->orc_ava->aa_value.bv_val );
 233                         op->orc_ava->aa_value = mapped_vals[0];
 234                 }
 235                 mapped_at = op->orc_ava->aa_desc->ad_cname;
 236
 237         } else {
 238                 rwm_map( &rwmap->rwm_at,
 239                                 &op->orc_ava->aa_desc->ad_cname,
 240                                 &mapped_at,
 241                                 RWM_MAP );
 242                 if ( mapped_at.bv_val == NULL
 243                                 || mapped_at.bv_val[0] == '\0')
 244                 {
 245                         op->o_bd->bd_info = (BackendInfo *)on->on_info;
 246                         send_ldap_error( op, rs, LDAP_OTHER, "compare attributeType map error" );
 247                         return -1;
 248                 }
 249                 if ( op->orc_ava->aa_desc->ad_type->sat_syntax == slap_schema.si_syn_distinguishedName )
 250                 {
 251                         mapped_vals[0] = op->orc_ava->aa_value;
 252                         rc = rwm_dnattr_rewrite( op, rs, "compareAttrDN", mapped_vals );
 253                         if ( rc != LDAP_SUCCESS ) {
 254                                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 255                                 send_ldap_error( op, rs, rc, "compareAttrDN massage error" );
 256                                 return -1;
 257                         }
 258
 259                         if ( mapped_vals[0].bv_val != op->orc_ava->aa_value.bv_val ) {
 260                                 free( op->orc_ava->aa_value.bv_val );
 261                                 op->orc_ava->aa_value = mapped_vals[0];
 262                         }
 263                 }
 264         }
 265
 266         /* TODO: rewrite attribute types, values of DN-valued attributes ... */
 267         return SLAP_CB_CONTINUE;
 268 }
 269
 270 static int
 271 rwm_delete( Operation *op, SlapReply *rs )
 272 {
 273         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 274         int                     rc;
 275
 276 #ifdef ENABLE_REWRITE
 277         rc = rwm_op_dn_massage( op, rs, "deleteDn" );
 278 #else
 279         rc = 1;
 280         rc = rwm_op_dn_massage( op, rs, &rc );
 281 #endif
 282         if ( rc != LDAP_SUCCESS ) {
 283                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 284                 send_ldap_error( op, rs, rc, "deleteDn massage error" );
 285                 return rc;
 286         }
 287
 288         return SLAP_CB_CONTINUE;
 289 }
 290
 291 static int
 292 rwm_modify( Operation *op, SlapReply *rs )
 293 {
 294         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 295         int                     rc;
 296
 297 #ifdef ENABLE_REWRITE
 298         rc = rwm_op_dn_massage( op, rs, "modifyDn" );
 299 #else
 300         rc = 1;
 301         rc = rwm_op_dn_massage( op, rs, &rc );
 302 #endif
 303         if ( rc != LDAP_SUCCESS ) {
 304                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 305                 send_ldap_error( op, rs, rc, "modifyDn massage error" );
 306                 return rc;
 307         }
 308
 309         /* TODO: rewrite attribute types, values of DN-valued attributes ... */
 310         return SLAP_CB_CONTINUE;
 311 }
 312
 313 static int
 314 rwm_modrdn( Operation *op, SlapReply *rs )
 315 {
 316         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 317         int                     rc;
 318
 319 #ifdef ENABLE_REWRITE
 320         rc = rwm_op_dn_massage( op, rs, "renameDn" );
 321 #else
 322         rc = 1;
 323         rc = rwm_op_dn_massage( op, rs, &rc );
 324 #endif
 325         if ( rc != LDAP_SUCCESS ) {
 326                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 327                 send_ldap_error( op, rs, rc, "renameDn massage error" );
 328                 return rc;
 329         }
 330
 331         /* TODO: rewrite attribute types, values of DN-valued attributes ... */
 332         return SLAP_CB_CONTINUE;
 333 }
 334
 335 static int
 336 rwm_search( Operation *op, SlapReply *rs )
 337 {
 338         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 339         int                     rc;
 340
 341 #ifdef ENABLE_REWRITE
 342         rc = rwm_op_dn_massage( op, rs, "searchDn" );
 343 #else
 344         rc = 1;
 345         rc = rwm_op_dn_massage( op, rs, &rc );
 346 #endif
 347         if ( rc != LDAP_SUCCESS ) {
 348                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 349                 send_ldap_error( op, rs, rc, "searchDn massage error" );
 350                 return rc;
 351         }
 352
 353         /* TODO: rewrite/map filter & attrs */
 354         return SLAP_CB_CONTINUE;
 355 }
 356
 357 static int
 358 rwm_extended( Operation *op, SlapReply *rs )
 359 {
 360         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 361         int                     rc;
 362
 363 #ifdef ENABLE_REWRITE
 364         rc = rwm_op_dn_massage( op, rs, "extendedDn" );
 365 #else
 366         rc = 1;
 367         rc = rwm_op_dn_massage( op, rs, &rc );
 368 #endif
 369         if ( rc != LDAP_SUCCESS ) {
 370                 op->o_bd->bd_info = (BackendInfo *)on->on_info;
 371                 send_ldap_error( op, rs, rc, "extendedDn massage error" );
 372                 return rc;
 373         }
 374
 375         /* TODO: rewrite/map extended data ? ... */
 376         return 0;
 377 }
 378
 379 static int
 380 rwm_matched( Operation *op, SlapReply *rs )
 381 {
 382         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 383         struct ldaprwmap        *rwmap =
 384                         (struct ldaprwmap *)on->on_bi.bi_private;
 385
 386         struct berval           dn, mdn;
 387         dncookie                dc;
 388
 389         if ( rs->sr_matched == NULL ) {
 390                 return SLAP_CB_CONTINUE;
 391         }
 392
 393         dc.rwmap = rwmap;
 394 #ifdef ENABLE_REWRITE
 395         dc.conn = op->o_conn;
 396         dc.rs = rs;
 397         dc.ctx = "matchedDN";
 398 #else
 399         dc.tofrom = 0;
 400         dc.normalized = 0;
 401 #endif
 402         ber_str2bv( rs->sr_matched, 0, 0, &dn );
 403         rwm_dn_massage( &dc, &dn, &mdn );
 404
 405         if ( mdn.bv_val != dn.bv_val ) {
 406                 if ( rs->sr_flags & REP_MATCHED_MUSTBEFREED ) {
 407                         ch_free( (void *)rs->sr_matched );
 408                 } else {
 409                         rs->sr_flags |= REP_MATCHED_MUSTBEFREED;
 410                 }
 411                 rs->sr_matched = mdn.bv_val;
 412         }
 413
 414         return SLAP_CB_CONTINUE;
 415 }
 416
 417 static int
 418 rwm_send_entry( Operation *op, SlapReply *rs )
 419 {
 420         slap_overinst           *on = (slap_overinst *) op->o_bd->bd_info;
 421         struct ldaprwmap        *rwmap =
 422                         (struct ldaprwmap *)on->on_bi.bi_private;
 423
 424         Entry           *e = NULL;
 425         struct berval   dn = BER_BVNULL, ndn = BER_BVNULL;
 426         dncookie        dc;
 427         int             rc = SLAP_CB_CONTINUE;
 428
 429         assert( rs->sr_entry );
 430
 431         e = rs->sr_entry;
 432
 433         /*
 434          * Rewrite the dn of the result, if needed
 435          */
 436         dc.rwmap = rwmap;
 437 #ifdef ENABLE_REWRITE
 438         dc.conn = op->o_conn;
 439         dc.rs = NULL;
 440         dc.ctx = "searchResult";
 441 #else
 442         dc.tofrom = 0;
 443         dc.normalized = 0;
 444 #endif
 445         if ( rwm_dn_massage( &dc, &e->e_name, &dn ) ) {
 446                 return LDAP_OTHER;
 447         }
 448
 449         if ( e->e_name.bv_val == dn.bv_val ) {
 450                 return SLAP_CB_CONTINUE;
 451         }
 452
 453         /*
 454          * Note: this may fail if the target host(s) schema differs
 455          * from the one known to the meta, and a DN with unknown
 456          * attributes is returned.
 457          */
 458         if ( dnNormalize( 0, NULL, NULL, &dn, &ndn, NULL ) != LDAP_SUCCESS ) {
 459                 if ( dn.bv_val != e->e_name.bv_val ) {
 460                         ch_free( dn.bv_val );
 461                 }
 462                 rc = LDAP_INVALID_DN_SYNTAX;
 463                 goto fail;
 464         }
 465
 466         if ( !( rs->sr_flags & REP_ENTRY_MODIFIABLE ) ) {
 467                 e = entry_dup( e );
 468                 if ( e == NULL ) {
 469                         goto fail;
 470                 }
 471                 rs->sr_flags |= ( REP_ENTRY_MODIFIABLE | REP_ENTRY_MUSTBEFREED );
 472         }
 473
 474         free( e->e_name.bv_val );
 475         free( e->e_nname.bv_val );
 476
 477         e->e_name = dn;
 478         e->e_nname = ndn;
 479
 480         rs->sr_entry = e;
 481
 482         /* TODO: map entry attribute types, objectclasses
 483          * and dn-valued attribute values */
 484
 485         return SLAP_CB_CONTINUE;
 486
 487 fail:;
 488         if ( dn.bv_val && ( dn.bv_val != e->e_name.bv_val ) ) {
 489                 ch_free( dn.bv_val );
 490         }
 491
 492         if ( ndn.bv_val ) {
 493                 ch_free( ndn.bv_val );
 494         }
 495
 496         return rc;
 497 }
 498
 499 static int
 500 rwm_rw_config(
 501     BackendDB   *be,
 502     const char  *fname,
 503     int         lineno,
 504     int         argc,
 505     char        **argv
 506 )
 507 {
 508 #ifdef ENABLE_REWRITE
 509         slap_overinst           *on = (slap_overinst *) be->bd_info;
 510         struct ldaprwmap        *rwmap =
 511                         (struct ldaprwmap *)on->on_bi.bi_private;
 512
 513         return rewrite_parse( rwmap->rwm_rw,
 514                                 fname, lineno, argc, argv );
 515
 516 #else /* !ENABLE_REWRITE */
 517         fprintf( stderr, "%s: line %d: rewrite capabilities "
 518                         "are not enabled\n", fname, lineno );
 519 #endif /* !ENABLE_REWRITE */
 520
 521         return 0;
 522 }
 523
 524 static int
 525 rwm_suffixmassage_config(
 526     BackendDB   *be,
 527     const char  *fname,
 528     int         lineno,
 529     int         argc,
 530     char        **argv
 531 )
 532 {
 533         slap_overinst           *on = (slap_overinst *) be->bd_info;
 534         struct ldaprwmap        *rwmap =
 535                         (struct ldaprwmap *)on->on_bi.bi_private;
 536
 537         struct berval   bvnc, nvnc, pvnc, brnc, nrnc, prnc;
 538 #ifdef ENABLE_REWRITE
 539         int             rc;
 540 #endif /* ENABLE_REWRITE */
 541
 542         /*
 543          * syntax:
 544          *
 545          *      suffixmassage <suffix> <massaged suffix>
 546          *
 547          * the <suffix> field must be defined as a valid suffix
 548          * (or suffixAlias?) for the current database;
 549          * the <massaged suffix> shouldn't have already been
 550          * defined as a valid suffix or suffixAlias for the
 551          * current server
 552          */
 553         if ( argc != 3 ) {
 554                 fprintf( stderr, "%s: line %d: syntax is"
 555                                " \"suffixMassage <suffix>"
 556                                " <massaged suffix>\"\n",
 557                         fname, lineno );
 558                 return 1;
 559         }
 560
 561         ber_str2bv( argv[1], 0, 0, &bvnc );
 562         if ( dnPrettyNormal( NULL, &bvnc, &pvnc, &nvnc, NULL ) != LDAP_SUCCESS ) {
 563                 fprintf( stderr, "%s: line %d: suffix DN %s is invalid\n",
 564                         fname, lineno, bvnc.bv_val );
 565                 return 1;
 566         }
 567
 568         ber_str2bv( argv[2], 0, 0, &brnc );
 569         if ( dnPrettyNormal( NULL, &brnc, &prnc, &nrnc, NULL ) != LDAP_SUCCESS ) {
 570                 fprintf( stderr, "%s: line %d: suffix DN %s is invalid\n",
 571                                 fname, lineno, brnc.bv_val );
 572                 free( nvnc.bv_val );
 573                 free( pvnc.bv_val );
 574                 return 1;
 575         }
 576
 577 #ifdef ENABLE_REWRITE
 578         /*
 579          * The suffix massaging is emulated
 580          * by means of the rewrite capabilities
 581          */
 582         rc = rwm_suffix_massage_config( rwmap->rwm_rw,
 583                         &pvnc, &nvnc, &prnc, &nrnc );
 584         free( nvnc.bv_val );
 585         free( pvnc.bv_val );
 586         free( nrnc.bv_val );
 587         free( prnc.bv_val );
 588
 589         return( rc );
 590
 591 #else /* !ENABLE_REWRITE */
 592         ber_bvarray_add( &rwmap->rwm_suffix_massage, &pvnc );
 593         ber_bvarray_add( &rwmap->rwm_suffix_massage, &nvnc );
 594
 595         ber_bvarray_add( &rwmap->rwm_suffix_massage, &prnc );
 596         ber_bvarray_add( &rwmap->rwm_suffix_massage, &nrnc );
 597 #endif /* !ENABLE_REWRITE */
 598
 599         return 0;
 600 }
 601
 602 static int
 603 rwm_m_config(
 604     BackendDB   *be,
 605     const char  *fname,
 606     int         lineno,
 607     int         argc,
 608     char        **argv
 609 )
 610 {
 611         slap_overinst           *on = (slap_overinst *) be->bd_info;
 612         struct ldaprwmap        *rwmap =
 613                         (struct ldaprwmap *)on->on_bi.bi_private;
 614
 615         /* objectclass/attribute mapping */
 616         return rwm_map_config( &rwmap->rwm_oc,
 617                         &rwmap->rwm_at,
 618                         fname, lineno, argc, argv );
 619 }
 620
 621 static int
 622 rwm_response( Operation *op, SlapReply *rs )
 623 {
 624         int     rc;
 625
 626         if ( op->o_tag == LDAP_REQ_SEARCH && rs->sr_type == REP_SEARCH ) {
 627                 return rwm_send_entry( op, rs );
 628         }
 629
 630         switch( op->o_tag ) {
 631         case LDAP_REQ_BIND:
 632         case LDAP_REQ_ADD:
 633         case LDAP_REQ_DELETE:
 634         case LDAP_REQ_MODRDN:
 635         case LDAP_REQ_MODIFY:
 636         case LDAP_REQ_COMPARE:
 637         case LDAP_REQ_SEARCH:
 638         case LDAP_REQ_EXTENDED:
 639                 rc = rwm_matched( op, rs );
 640                 break;
 641         default:
 642                 rc = SLAP_CB_CONTINUE;
 643                 break;
 644         }
 645
 646         return rc;
 647 }
 648
 649 static int
 650 rwm_config(
 651     BackendDB   *be,
 652     const char  *fname,
 653     int         lineno,
 654     int         argc,
 655     char        **argv
 656 )
 657 {
 658         int             rc = 0;
 659         char            *argv0 = NULL;
 660
 661         if ( strncasecmp( argv[ 0 ], "rwm-", sizeof( "rwm-" ) - 1 ) == 0 ) {
 662                 argv0 = argv[ 0 ];
 663                 argv[ 0 ] = &argv0[ sizeof( "rwm-" ) - 1 ];
 664         }
 665
 666         if ( strncasecmp( argv[0], "rewrite", sizeof("rewrite") - 1 ) == 0 ) {
 667                 rc = rwm_rw_config( be, fname, lineno, argc, argv );
 668
 669         } else if (strcasecmp( argv[0], "map" ) == 0 ) {
 670                 rc = rwm_m_config( be, fname, lineno, argc, argv );
 671
 672         } else if (strcasecmp( argv[0], "suffixmassage" ) == 0 ) {
 673                 rc = rwm_suffixmassage_config( be, fname, lineno, argc, argv );
 674
 675         } else {
 676                 rc = SLAP_CONF_UNKNOWN;
 677         }
 678
 679         if ( argv0 ) {
 680                 argv[ 0 ] = argv0;
 681         }
 682
 683         return rc;
 684 }
 685
 686 static int
 687 rwm_over_init(
 688         BackendDB *be
 689 )
 690 {
 691         slap_overinst           *on = (slap_overinst *) be->bd_info;
 692         struct ldapmapping      *mapping = NULL;
 693         struct ldaprwmap        *rwmap;
 694
 695         rwmap = (struct ldaprwmap *)ch_malloc(sizeof(struct ldaprwmap));
 696         memset(rwmap, 0, sizeof(struct ldaprwmap));
 697
 698 #ifdef ENABLE_REWRITE
 699         rwmap->rwm_rw = rewrite_info_init( REWRITE_MODE_USE_DEFAULT );
 700         if ( rwmap->rwm_rw == NULL ) {
 701                 ch_free( rwmap );
 702                 return -1;
 703         }
 704
 705         {
 706                 char    *rargv[3];
 707
 708                 /* this rewriteContext by default must be null;
 709                  * rules can be added if required */
 710                 rargv[ 0 ] = "rewriteContext";
 711                 rargv[ 1 ] = "searchFilter";
 712                 rargv[ 2 ] = NULL;
 713                 rewrite_parse( rwmap->rwm_rw, "<suffix massage>", 1, 2, rargv );
 714
 715                 rargv[ 0 ] = "rewriteContext";
 716                 rargv[ 1 ] = "default";
 717                 rargv[ 2 ] = NULL;
 718                 rewrite_parse( rwmap->rwm_rw, "<suffix massage>", 2, 2, rargv );
 719         }
 720
 721 #endif /* ENABLE_REWRITE */
 722
 723         rwm_map_init( &rwmap->rwm_oc, &mapping );
 724         rwm_map_init( &rwmap->rwm_at, &mapping );
 725
 726         on->on_bi.bi_private = (void *)rwmap;
 727
 728         return 0;
 729 }
 730
 731 static int
 732 rwm_destroy(
 733         BackendDB *be
 734 )
 735 {
 736         slap_overinst   *on = (slap_overinst *) be->bd_info;
 737         int             rc = 0;
 738
 739         if ( on->on_bi.bi_private ) {
 740                 struct ldaprwmap        *rwmap =
 741                         (struct ldaprwmap *)on->on_bi.bi_private;
 742
 743 #ifdef ENABLE_REWRITE
 744                 if (rwmap->rwm_rw) {
 745                         rewrite_info_delete( &rwmap->rwm_rw );
 746                 }
 747 #else /* !ENABLE_REWRITE */
 748                 if ( rwmap->rwm_suffix_massage ) {
 749                         ber_bvarray_free( rwmap->rwm_suffix_massage );
 750                 }
 751 #endif /* !ENABLE_REWRITE */
 752
 753                 avl_free( rwmap->rwm_oc.remap, NULL );
 754                 avl_free( rwmap->rwm_oc.map, rwm_mapping_free );
 755                 avl_free( rwmap->rwm_at.remap, NULL );
 756                 avl_free( rwmap->rwm_at.map, rwm_mapping_free );
 757         }
 758
 759         return rc;
 760 }
 761
 762 static slap_overinst rwm = { { NULL } };
 763
 764 int
 765 rwm_init(void)
 766 {
 767         memset( &rwm, 0, sizeof(slap_overinst) );
 768
 769         rwm.on_bi.bi_type = "rwm";
 770         rwm.on_bi.bi_db_init = rwm_over_init;
 771         rwm.on_bi.bi_db_config = rwm_config;
 772         rwm.on_bi.bi_db_destroy = rwm_destroy;
 773
 774         rwm.on_bi.bi_op_bind = rwm_bind;
 775         rwm.on_bi.bi_op_search = rwm_search;
 776         rwm.on_bi.bi_op_compare = rwm_compare;
 777         rwm.on_bi.bi_op_modify = rwm_modify;
 778         rwm.on_bi.bi_op_modrdn = rwm_modrdn;
 779         rwm.on_bi.bi_op_add = rwm_add;
 780         rwm.on_bi.bi_op_delete = rwm_delete;
 781         rwm.on_bi.bi_op_unbind = rwm_unbind;
 782         rwm.on_bi.bi_extended = rwm_extended;
 783
 784         rwm.on_response = rwm_response;
 785
 786         return overlay_register( &rwm );
 787 }
 788
 789 #if SLAPD_OVER_RWM == SLAPD_MOD_DYNAMIC
 790 int init_module(int argc, char *argv[]) {
 791         return rwm_init();
 792 }
 793 #endif
 794
 795 #endif /* SLAPD_OVER_RWM */