git.sur5r.net Git - openldap/blob - servers/slapd/back-meta/config.c

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 1999-2005 The OpenLDAP Foundation.
   5  * Portions Copyright 2001-2003 Pierangelo Masarati.
   6  * Portions Copyright 1999-2003 Howard Chu.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted only as authorized by the OpenLDAP
  11  * Public License.
  12  *
  13  * A copy of this license is available in the file LICENSE in the
  14  * top-level directory of the distribution or, alternatively, at
  15  * <http://www.OpenLDAP.org/license.html>.
  16  */
  17 /* ACKNOWLEDGEMENTS:
  18  * This work was initially developed by the Howard Chu for inclusion
  19  * in OpenLDAP Software and subsequently enhanced by Pierangelo
  20  * Masarati.
  21  */
  22
  23 #include "portable.h"
  24
  25 #include <stdio.h>
  26
  27 #include <ac/string.h>
  28 #include <ac/socket.h>
  29
  30 #include "slap.h"
  31 #include "lutil.h"
  32 #include "../back-ldap/back-ldap.h"
  33 #undef ldap_debug       /* silence a warning in ldap-int.h */
  34 #include "../../../libraries/libldap/ldap-int.h"
  35 #include "back-meta.h"
  36
  37 static int
  38 new_target(
  39         metatarget_t    *mt )
  40 {
  41         struct ldapmapping      *mapping;
  42         char                    *rargv[ 3 ];
  43
  44         memset( mt, 0, sizeof( metatarget_t ) );
  45
  46         mt->mt_rwmap.rwm_rw = rewrite_info_init( REWRITE_MODE_USE_DEFAULT );
  47         if ( mt->mt_rwmap.rwm_rw == NULL ) {
  48                 return -1;
  49         }
  50
  51
  52         /*
  53          * the filter rewrite as a string must be disabled
  54          * by default; it can be re-enabled by adding rules;
  55          * this creates an empty rewriteContext
  56          */
  57         rargv[ 0 ] = "rewriteContext";
  58         rargv[ 1 ] = "searchFilter";
  59         rargv[ 2 ] = NULL;
  60         rewrite_parse( mt->mt_rwmap.rwm_rw, "<suffix massage>", 1, 2, rargv );
  61
  62         rargv[ 0 ] = "rewriteContext";
  63         rargv[ 1 ] = "default";
  64         rargv[ 2 ] = NULL;
  65         rewrite_parse( mt->mt_rwmap.rwm_rw, "<suffix massage>", 1, 2, rargv );
  66
  67         ldap_back_map_init( &mt->mt_rwmap.rwm_at, &mapping );
  68
  69         return 0;
  70 }
  71
  72 static int
  73 check_true_false( char *str )
  74 {
  75         if ( strcasecmp( str, "true" ) == 0 || strcasecmp( str, "yes" ) == 0 ) {
  76                 return 1;
  77         }
  78
  79         if ( strcasecmp( str, "false" ) == 0 || strcasecmp( str, "no" ) == 0 ) {
  80                 return 0;
  81         }
  82
  83         return -1;
  84 }
  85
  86
  87 int
  88 meta_back_db_config(
  89                 BackendDB       *be,
  90                 const char      *fname,
  91                 int             lineno,
  92                 int             argc,
  93                 char            **argv
  94 )
  95 {
  96         metainfo_t      *mi = ( metainfo_t * )be->be_private;
  97
  98         if ( mi == NULL ) {
  99                 fprintf( stderr,
 100         "%s: line %d: meta backend info is null!\n",
 101                     fname, lineno );
 102                 return 1;
 103         }
 104
 105         /* URI of server to query */
 106         if ( strcasecmp( argv[ 0 ], "uri" ) == 0 ) {
 107                 int             i = mi->mi_ntargets;
 108 #if 0
 109                 int             j;
 110 #endif /* uncomment if uri MUST be a branch of suffix */
 111                 LDAPURLDesc     *ludp, *tmpludp;
 112                 struct berval   dn;
 113                 int             rc;
 114                 int             c;
 115
 116                 switch ( argc ) {
 117                 case 1:
 118                         fprintf( stderr,
 119         "%s: line %d: missing URI "
 120         "in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 121                                 fname, lineno );
 122                         return 1;
 123
 124                 case 2:
 125                         break;
 126
 127                 default:
 128                         fprintf( stderr,
 129         "%s: line %d: too many args "
 130         "in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 131                                 fname, lineno );
 132                         return 1;
 133                 }
 134
 135                 if ( be->be_nsuffix == NULL ) {
 136                         fprintf( stderr,
 137         "%s: line %d: the suffix must be defined before any target.\n",
 138                                 fname, lineno );
 139                         return 1;
 140                 }
 141
 142                 ++mi->mi_ntargets;
 143
 144                 mi->mi_targets = ( metatarget_t * )ch_realloc( mi->mi_targets,
 145                         sizeof( metatarget_t ) * mi->mi_ntargets );
 146                 if ( mi->mi_targets == NULL ) {
 147                         fprintf( stderr,
 148         "%s: line %d: out of memory while storing server name"
 149         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 150                                 fname, lineno );
 151                         return 1;
 152                 }
 153
 154                 if ( new_target( &mi->mi_targets[ i ] ) != 0 ) {
 155                         fprintf( stderr,
 156         "%s: line %d: unable to init server"
 157         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 158                                 fname, lineno );
 159                         return 1;
 160                 }
 161
 162                 mi->mi_targets[ i ].mt_nretries = mi->mi_nretries;
 163                 mi->mi_targets[ i ].mt_flags = mi->mi_flags;
 164                 mi->mi_targets[ i ].mt_version = mi->mi_version;
 165
 166                 for ( c = 0; c < LDAP_BACK_OP_LAST; c++ ) {
 167                         mi->mi_targets[ i ].mt_timeout[ c ] = mi->mi_timeout[ c ];
 168                 }
 169
 170                 /*
 171                  * uri MUST be legal!
 172                  */
 173                 if ( ldap_url_parselist_ext( &ludp, argv[ 1 ], "\t" ) != LDAP_SUCCESS ) {
 174                         fprintf( stderr,
 175         "%s: line %d: unable to parse URI"
 176         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 177                                 fname, lineno );
 178                         return 1;
 179                 }
 180
 181                 /*
 182                  * uri MUST have the <dn> part!
 183                  */
 184                 if ( ludp->lud_dn == NULL ) {
 185                         fprintf( stderr,
 186         "%s: line %d: missing <naming context> "
 187         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 188                                 fname, lineno );
 189                         return 1;
 190
 191                 } else if ( ludp->lud_dn[ 0 ] == '\0' ) {
 192                         int     j = -1;
 193
 194                         for ( j = 0; !BER_BVISNULL( &be->be_nsuffix[ j ] ); j++ ) {
 195                                 if ( BER_BVISEMPTY( &be->be_nsuffix[ j ] ) ) {
 196                                         break;
 197                                 }
 198                         }
 199
 200                         if ( BER_BVISNULL( &be->be_nsuffix[ j ] ) ) {
 201                                 fprintf( stderr,
 202                 "%s: line %d: missing <naming context> "
 203                 " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 204                                         fname, lineno );
 205                                 return 1;
 206                         }
 207                 }
 208
 209                 /*
 210                  * copies and stores uri and suffix
 211                  */
 212                 ber_str2bv( ludp->lud_dn, 0, 0, &dn );
 213                 rc = dnPrettyNormal( NULL, &dn, &mi->mi_targets[ i ].mt_psuffix,
 214                         &mi->mi_targets[ i ].mt_nsuffix, NULL );
 215                 if( rc != LDAP_SUCCESS ) {
 216                         fprintf( stderr, "%s: line %d: "
 217                                         "target '%s' DN is invalid\n",
 218                                         fname, lineno, argv[ 1 ] );
 219                         return( 1 );
 220                 }
 221
 222                 ludp->lud_dn[ 0 ] = '\0';
 223
 224                 switch ( ludp->lud_scope ) {
 225                 case LDAP_SCOPE_DEFAULT:
 226                         mi->mi_targets[ i ].mt_scope = LDAP_SCOPE_SUBTREE;
 227                         break;
 228
 229                 case LDAP_SCOPE_SUBTREE:
 230 #ifdef LDAP_SCOPE_SUBORDINATE
 231                 case LDAP_SCOPE_SUBORDINATE:
 232 #endif /* LDAP_SCOPE_SUBORDINATE */
 233                         mi->mi_targets[ i ].mt_scope = ludp->lud_scope;
 234                         break;
 235
 236                 default:
 237                         fprintf( stderr, "%s: line %d: "
 238                                         "invalid scope for target '%s'\n",
 239                                         fname, lineno, argv[ 1 ] );
 240                         return( 1 );
 241                 }
 242
 243                 /* check all, to apply the scope check on the first one */
 244                 for ( tmpludp = ludp; tmpludp; tmpludp = tmpludp->lud_next ) {
 245                         if ( tmpludp->lud_dn != NULL && tmpludp->lud_dn[ 0 ] != '\0' ) {
 246                                 fprintf( stderr, "%s: line %d: "
 247                                                 "multiple URIs must have "
 248                                                 "no DN part\n",
 249                                         fname, lineno );
 250                                 return( 1 );
 251
 252                         }
 253                 }
 254
 255                 mi->mi_targets[ i ].mt_uri = ldap_url_list2urls( ludp );
 256                 ldap_free_urllist( ludp );
 257                 if ( mi->mi_targets[ i ].mt_uri == NULL) {
 258                         fprintf( stderr, "%s: line %d: no memory?\n",
 259                                         fname, lineno );
 260                         return( 1 );
 261                 }
 262
 263                 /*
 264                  * uri MUST be a branch of suffix!
 265                  */
 266 #if 0 /* too strict a constraint */
 267                 if ( select_backend( &mi->mi_targets[ i ].suffix, 0, 0 ) != be ) {
 268                         fprintf( stderr,
 269         "%s: line %d: <naming context> of URI does not refer to current backend"
 270         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 271                                 fname, lineno );
 272                         return 1;
 273                 }
 274 #else
 275                 /*
 276                  * uri MUST be a branch of a suffix!
 277                  */
 278                 if ( select_backend( &mi->mi_targets[ i ].mt_nsuffix, 0, 0 ) == NULL ) {
 279                         fprintf( stderr,
 280         "%s: line %d: <naming context> of URI does not resolve to a backend"
 281         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 282                                 fname, lineno );
 283                         return 1;
 284                 }
 285 #endif
 286
 287         /* default target directive */
 288         } else if ( strcasecmp( argv[ 0 ], "default-target" ) == 0 ) {
 289                 int             i = mi->mi_ntargets - 1;
 290
 291                 if ( argc == 1 ) {
 292                         if ( i < 0 ) {
 293                                 fprintf( stderr,
 294         "%s: line %d: \"default-target\" alone need be"
 295         " inside a \"uri\" directive\n",
 296                                         fname, lineno );
 297                                 return 1;
 298                         }
 299                         mi->mi_defaulttarget = i;
 300                 } else {
 301                         if ( strcasecmp( argv[ 1 ], "none" ) == 0 ) {
 302                                 if ( i >= 0 ) {
 303                                         fprintf( stderr,
 304         "%s: line %d: \"default-target none\""
 305         " should go before uri definitions\n",
 306                                                 fname, lineno );
 307                                 }
 308                                 mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
 309
 310                         } else {
 311                                 char    *next;
 312                                 int     n = strtol( argv[ 1 ], &next, 10 );
 313                                 if ( n < 0 || n >= i - 1 ) {
 314                                         fprintf( stderr,
 315         "%s: line %d: illegal target number %d\n",
 316                                                 fname, lineno, n );
 317                                         return 1;
 318                                 }
 319                                 mi->mi_defaulttarget = n;
 320                         }
 321                 }
 322
 323         /* ttl of dn cache */
 324         } else if ( strcasecmp( argv[ 0 ], "dncache-ttl" ) == 0 ) {
 325                 if ( argc != 2 ) {
 326                         fprintf( stderr,
 327         "%s: line %d: missing ttl in \"dncache-ttl <ttl>\" line\n",
 328                                 fname, lineno );
 329                         return 1;
 330                 }
 331
 332                 if ( strcasecmp( argv[ 1 ], "forever" ) == 0 ) {
 333                         mi->mi_cache.ttl = META_DNCACHE_FOREVER;
 334                 } else if ( strcasecmp( argv[ 1 ], "disabled" ) == 0 ) {
 335                         mi->mi_cache.ttl = META_DNCACHE_DISABLED;
 336                 } else {
 337                         char            *next;
 338
 339                         mi->mi_cache.ttl = strtol( argv[ 1 ], &next, 10 );
 340                         if ( next == argv[ 1 ] || next[ 0 ] != '\0' ) {
 341                                 fprintf( stderr,
 342         "%s: line %d: unable to parse ttl \"%s\" in \"dncache-ttl <ttl>\" line\n",
 343                                         fname, lineno, argv[ 1 ] );
 344                                 return 1;
 345                         }
 346                 }
 347
 348         /* network timeout when connecting to ldap servers */
 349         } else if ( strcasecmp( argv[ 0 ], "network-timeout" ) == 0 ) {
 350                 if ( argc != 2 ) {
 351                         fprintf( stderr,
 352         "%s: line %d: missing network timeout in \"network-timeout <seconds>\" line\n",
 353                                 fname, lineno );
 354                         return 1;
 355                 }
 356                 mi->mi_network_timeout = atol(argv[ 1 ]);
 357
 358         /* name to use for meta_back_group */
 359         } else if ( strcasecmp( argv[ 0 ], "acl-authcDN" ) == 0
 360                         || strcasecmp( argv[ 0 ], "binddn" ) == 0 )
 361         {
 362                 int             i = mi->mi_ntargets - 1;
 363                 struct berval   dn;
 364
 365                 if ( i < 0 ) {
 366                         fprintf( stderr,
 367         "%s: line %d: need \"uri\" directive first\n",
 368                                 fname, lineno );
 369                         return 1;
 370                 }
 371
 372                 if ( argc != 2 ) {
 373                         fprintf( stderr,
 374         "%s: line %d: missing name in \"binddn <name>\" line\n",
 375                                 fname, lineno );
 376                         return 1;
 377                 }
 378
 379                 if ( strcasecmp( argv[ 0 ], "binddn" ) == 0 ) {
 380                         fprintf( stderr, "%s: line %d: "
 381                                 "\"binddn\" statement is deprecated; "
 382                                 "use \"acl-authcDN\" instead\n",
 383                                 fname, lineno );
 384                         /* FIXME: some day we'll need to throw an error */
 385                 }
 386
 387                 dn.bv_val = argv[ 1 ];
 388                 dn.bv_len = strlen( argv[ 1 ] );
 389                 if ( dnNormalize( 0, NULL, NULL, &dn, &mi->mi_targets[ i ].mt_binddn,
 390                         NULL ) != LDAP_SUCCESS )
 391                 {
 392                         fprintf( stderr, "%s: line %d: "
 393                                         "bind DN '%s' is invalid\n",
 394                                         fname, lineno, argv[ 1 ] );
 395                         return( 1 );
 396                 }
 397
 398         /* password to use for meta_back_group */
 399         } else if ( strcasecmp( argv[ 0 ], "acl-passwd" ) == 0
 400                         || strcasecmp( argv[ 0 ], "bindpw" ) == 0 )
 401         {
 402                 int             i = mi->mi_ntargets - 1;
 403
 404                 if ( i < 0 ) {
 405                         fprintf( stderr,
 406         "%s: line %d: need \"uri\" directive first\n",
 407                                 fname, lineno );
 408                         return 1;
 409                 }
 410
 411                 if ( argc != 2 ) {
 412                         fprintf( stderr,
 413         "%s: line %d: missing password in \"bindpw <password>\" line\n",
 414                             fname, lineno );
 415                         return 1;
 416                 }
 417
 418                 if ( strcasecmp( argv[ 0 ], "bindpw" ) == 0 ) {
 419                         fprintf( stderr, "%s: line %d: "
 420                                 "\"bindpw\" statement is deprecated; "
 421                                 "use \"acl-passwd\" instead\n",
 422                                 fname, lineno );
 423                         /* FIXME: some day we'll need to throw an error */
 424                 }
 425
 426                 ber_str2bv( argv[ 1 ], 0L, 1, &mi->mi_targets[ i ].mt_bindpw );
 427
 428         /* save bind creds for referral rebinds? */
 429         } else if ( strcasecmp( argv[ 0 ], "rebind-as-user" ) == 0 ) {
 430                 if ( argc > 2 ) {
 431                         fprintf( stderr,
 432         "%s: line %d: \"rebind-as-user {NO|yes}\" takes 1 argument.\n",
 433                             fname, lineno );
 434                         return( 1 );
 435                 }
 436
 437                 if ( argc == 1 ) {
 438                         fprintf( stderr,
 439         "%s: line %d: deprecated use of \"rebind-as-user {FALSE|true}\" with no arguments.\n",
 440                             fname, lineno );
 441                         mi->mi_flags |= LDAP_BACK_F_SAVECRED;
 442
 443                 } else {
 444                         switch ( check_true_false( argv[ 1 ] ) ) {
 445                         case 0:
 446                                 mi->mi_flags &= ~LDAP_BACK_F_SAVECRED;
 447                                 break;
 448
 449                         case 1:
 450                                 mi->mi_flags |= LDAP_BACK_F_SAVECRED;
 451                                 break;
 452
 453                         default:
 454                                 fprintf( stderr,
 455         "%s: line %d: \"rebind-as-user {FALSE|true}\" unknown argument \"%s\".\n",
 456                                     fname, lineno, argv[ 1 ] );
 457                                 return 1;
 458                         }
 459                 }
 460
 461         } else if ( strcasecmp( argv[ 0 ], "chase-referrals" ) == 0 ) {
 462                 unsigned        *flagsp = mi->mi_ntargets ?
 463                                 &mi->mi_targets[ mi->mi_ntargets - 1 ].mt_flags
 464                                 : &mi->mi_flags;
 465
 466                 if ( argc != 2 ) {
 467                         fprintf( stderr,
 468         "%s: line %d: \"chase-referrals {TRUE|false}\" needs 1 argument.\n",
 469                                         fname, lineno );
 470                         return( 1 );
 471                 }
 472
 473                 /* this is the default; we add it because the default might change... */
 474                 switch ( check_true_false( argv[ 1 ] ) ) {
 475                 case 1:
 476                         *flagsp |= LDAP_BACK_F_CHASE_REFERRALS;
 477                         break;
 478
 479                 case 0:
 480                         *flagsp &= ~LDAP_BACK_F_CHASE_REFERRALS;
 481                         break;
 482
 483                 default:
 484                         fprintf( stderr,
 485                 "%s: line %d: \"chase-referrals {TRUE|false}\": unknown argument \"%s\".\n",
 486                                         fname, lineno, argv[ 1 ] );
 487                         return( 1 );
 488                 }
 489
 490         } else if ( strcasecmp( argv[ 0 ], "tls" ) == 0 ) {
 491                 unsigned        *flagsp = mi->mi_ntargets ?
 492                                 &mi->mi_targets[ mi->mi_ntargets - 1 ].mt_flags
 493                                 : &mi->mi_flags;
 494
 495                 if ( argc != 2 ) {
 496                         fprintf( stderr,
 497                 "%s: line %d: \"tls <what>\" needs 1 argument.\n",
 498                                         fname, lineno );
 499                         return( 1 );
 500                 }
 501
 502                 /* start */
 503                 if ( strcasecmp( argv[ 1 ], "start" ) == 0 ) {
 504                         *flagsp |= ( LDAP_BACK_F_USE_TLS | LDAP_BACK_F_TLS_CRITICAL );
 505
 506                 /* try start tls */
 507                 } else if ( strcasecmp( argv[ 1 ], "try-start" ) == 0 ) {
 508                         *flagsp &= ~LDAP_BACK_F_TLS_CRITICAL;
 509                         *flagsp |= LDAP_BACK_F_USE_TLS;
 510
 511                 /* propagate start tls */
 512                 } else if ( strcasecmp( argv[ 1 ], "propagate" ) == 0 ) {
 513                         *flagsp |= ( LDAP_BACK_F_PROPAGATE_TLS | LDAP_BACK_F_TLS_CRITICAL );
 514
 515                 /* try start tls */
 516                 } else if ( strcasecmp( argv[ 1 ], "try-propagate" ) == 0 ) {
 517                         *flagsp &= ~LDAP_BACK_F_TLS_CRITICAL;
 518                         *flagsp |= LDAP_BACK_F_PROPAGATE_TLS;
 519
 520                 } else {
 521                         fprintf( stderr,
 522                 "%s: line %d: \"tls <what>\": unknown argument \"%s\".\n",
 523                                         fname, lineno, argv[ 1 ] );
 524                         return( 1 );
 525                 }
 526
 527         } else if ( strcasecmp( argv[ 0 ], "t-f-support" ) == 0 ) {
 528                 unsigned        *flagsp = mi->mi_ntargets ?
 529                                 &mi->mi_targets[ mi->mi_ntargets - 1 ].mt_flags
 530                                 : &mi->mi_flags;
 531
 532                 if ( argc != 2 ) {
 533                         fprintf( stderr,
 534                 "%s: line %d: \"t-f-support {FALSE|true|discover}\" needs 1 argument.\n",
 535                                         fname, lineno );
 536                         return( 1 );
 537                 }
 538
 539                 switch ( check_true_false( argv[ 1 ] ) ) {
 540                 case 0:
 541                         *flagsp &= ~(LDAP_BACK_F_SUPPORT_T_F|LDAP_BACK_F_SUPPORT_T_F_DISCOVER);
 542                         break;
 543
 544                 case 1:
 545                         *flagsp |= LDAP_BACK_F_SUPPORT_T_F;
 546                         break;
 547
 548                 default:
 549                         if ( strcasecmp( argv[ 1 ], "discover" ) == 0 ) {
 550                                 *flagsp |= LDAP_BACK_F_SUPPORT_T_F_DISCOVER;
 551
 552                         } else {
 553                                 fprintf( stderr,
 554         "%s: line %d: unknown value \"%s\" for \"t-f-support {no|yes|discover}\".\n",
 555                                         fname, lineno, argv[ 1 ] );
 556                                 return 1;
 557                         }
 558                         break;
 559                 }
 560
 561         /* onerr? */
 562         } else if ( strcasecmp( argv[ 0 ], "onerr" ) == 0 ) {
 563                 if ( argc != 2 ) {
 564                         fprintf( stderr,
 565         "%s: line %d: \"onerr {CONTINUE|stop}\" takes 1 argument\n",
 566                             fname, lineno );
 567                         return( 1 );
 568                 }
 569
 570                 if ( strcasecmp( argv[ 1 ], "continue" ) == 0 ) {
 571                         mi->mi_flags &= ~META_BACK_F_ONERR_STOP;
 572
 573                 } else if ( strcasecmp( argv[ 1 ], "stop" ) == 0 ) {
 574                         mi->mi_flags |= META_BACK_F_ONERR_STOP;
 575
 576                 } else {
 577                         fprintf( stderr,
 578         "%s: line %d: \"onerr {CONTINUE|stop}\": invalid arg \"%s\".\n",
 579                                 fname, lineno, argv[ 1 ] );
 580                         return 1;
 581                 }
 582
 583         /* bind-defer? */
 584         } else if ( strcasecmp( argv[ 0 ], "pseudoroot-bind-defer" ) == 0 ) {
 585                 if ( argc != 2 ) {
 586                         fprintf( stderr,
 587         "%s: line %d: \"pseudoroot-bind-defer {FALSE|true}\" takes 1 argument\n",
 588                             fname, lineno );
 589                         return( 1 );
 590                 }
 591
 592                 switch ( check_true_false( argv[ 1 ] ) ) {
 593                 case 0:
 594                         mi->mi_flags &= ~META_BACK_F_DEFER_ROOTDN_BIND;
 595                         break;
 596
 597                 case 1:
 598                         mi->mi_flags |= META_BACK_F_DEFER_ROOTDN_BIND;
 599                         break;
 600
 601                 default:
 602                         fprintf( stderr,
 603         "%s: line %d: \"pseudoroot-bind-defer {FALSE|true}\": invalid arg \"%s\".\n",
 604                                 fname, lineno, argv[ 1 ] );
 605                         return 1;
 606                 }
 607
 608         } else if ( strcasecmp( argv[ 0 ], "timeout" ) == 0 ) {
 609                 char    *sep, *next;
 610                 time_t  *tv = mi->mi_ntargets ?
 611                                 mi->mi_targets[ mi->mi_ntargets - 1 ].mt_timeout
 612                                 : mi->mi_timeout;
 613                 int     c;
 614
 615                 if ( argc < 2 ) {
 616                         fprintf( stderr,
 617         "%s: line %d: \"timeout [{add|delete|modify|modrdn}=]<val> [...]\" takes at least 1 argument\n",
 618                             fname, lineno );
 619                         return( 1 );
 620                 }
 621
 622                 for ( c = 1; c < argc; c++ ) {
 623                         time_t  *t = NULL, val;
 624
 625                         sep = strchr( argv[ c ], '=' );
 626                         if ( sep != NULL ) {
 627                                 size_t  len = sep - argv[ c ];
 628
 629                                 if ( strncasecmp( argv[ c ], "add", len ) == 0 ) {
 630                                         t = &tv[ LDAP_BACK_OP_ADD ];
 631                                 } else if ( strncasecmp( argv[ c ], "delete", len ) == 0 ) {
 632                                         t = &tv[ LDAP_BACK_OP_DELETE ];
 633                                 } else if ( strncasecmp( argv[ c ], "modify", len ) == 0 ) {
 634                                         t = &tv[ LDAP_BACK_OP_MODIFY ];
 635                                 } else if ( strncasecmp( argv[ c ], "modrdn", len ) == 0 ) {
 636                                         t = &tv[ LDAP_BACK_OP_MODRDN ];
 637                                 } else {
 638                                         fprintf( stderr,
 639                 "%s: line %d: unknown operation \"%s\" for timeout #%d.\n",
 640                                                 fname, lineno, argv[ c ], c );
 641                                         return 1;
 642                                 }
 643                                 sep++;
 644
 645                         } else {
 646                                 sep = argv[ c ];
 647                         }
 648
 649                         val = strtoul( sep, &next, 10 );
 650                         if ( next == sep || next[ 0 ] != '\0' ) {
 651                                 fprintf( stderr,
 652                 "%s: line %d: unable to parse value \"%s\" for timeout.\n",
 653                                         fname, lineno, sep );
 654                                 return 1;
 655                         }
 656
 657                         if ( t ) {
 658                                 *t = val;
 659
 660                         } else {
 661                                 int     i;
 662
 663                                 for ( i = 0; i < LDAP_BACK_OP_LAST; i++ ) {
 664                                         tv[ i ] = val;
 665                                 }
 666                         }
 667                 }
 668
 669         /* name to use as pseudo-root dn */
 670         } else if ( strcasecmp( argv[ 0 ], "pseudorootdn" ) == 0 ) {
 671                 int             i = mi->mi_ntargets - 1;
 672                 struct berval   dn;
 673
 674                 if ( i < 0 ) {
 675                         fprintf( stderr,
 676         "%s: line %d: need \"uri\" directive first\n",
 677                                 fname, lineno );
 678                         return 1;
 679                 }
 680
 681                 if ( argc != 2 ) {
 682                         fprintf( stderr,
 683         "%s: line %d: missing name in \"pseudorootdn <name>\" line\n",
 684                                 fname, lineno );
 685                         return 1;
 686                 }
 687
 688                 dn.bv_val = argv[ 1 ];
 689                 dn.bv_len = strlen( argv[ 1 ] );
 690                 if ( dnNormalize( 0, NULL, NULL, &dn,
 691                         &mi->mi_targets[ i ].mt_pseudorootdn, NULL ) != LDAP_SUCCESS )
 692                 {
 693                         fprintf( stderr, "%s: line %d: "
 694                                         "pseudoroot DN '%s' is invalid\n",
 695                                         fname, lineno, argv[ 1 ] );
 696                         return( 1 );
 697                 }
 698
 699         /* password to use as pseudo-root */
 700         } else if ( strcasecmp( argv[ 0 ], "pseudorootpw" ) == 0 ) {
 701                 int             i = mi->mi_ntargets - 1;
 702
 703                 if ( i < 0 ) {
 704                         fprintf( stderr,
 705         "%s: line %d: need \"uri\" directive first\n",
 706                                 fname, lineno );
 707                         return 1;
 708                 }
 709
 710                 if ( argc != 2 ) {
 711                         fprintf( stderr,
 712         "%s: line %d: missing password in \"pseudorootpw <password>\" line\n",
 713                             fname, lineno );
 714                         return 1;
 715                 }
 716                 ber_str2bv( argv[ 1 ], 0L, 1, &mi->mi_targets[ i ].mt_pseudorootpw );
 717
 718         /* dn massaging */
 719         } else if ( strcasecmp( argv[ 0 ], "suffixmassage" ) == 0 ) {
 720                 BackendDB       *tmp_be;
 721                 int             i = mi->mi_ntargets - 1, rc;
 722                 struct berval   dn, nvnc, pvnc, nrnc, prnc;
 723
 724                 if ( i < 0 ) {
 725                         fprintf( stderr,
 726         "%s: line %d: need \"uri\" directive first\n",
 727                                 fname, lineno );
 728                         return 1;
 729                 }
 730
 731                 /*
 732                  * syntax:
 733                  *
 734                  *      suffixmassage <suffix> <massaged suffix>
 735                  *
 736                  * the <suffix> field must be defined as a valid suffix
 737                  * (or suffixAlias?) for the current database;
 738                  * the <massaged suffix> shouldn't have already been
 739                  * defined as a valid suffix or suffixAlias for the
 740                  * current server
 741                  */
 742                 if ( argc != 3 ) {
 743                         fprintf( stderr,
 744         "%s: line %d: syntax is \"suffixMassage <suffix> <massaged suffix>\"\n",
 745                                 fname, lineno );
 746                         return 1;
 747                 }
 748
 749                 ber_str2bv( argv[ 1 ], 0, 0, &dn );
 750                 if ( dnPrettyNormal( NULL, &dn, &pvnc, &nvnc, NULL ) != LDAP_SUCCESS ) {
 751                         fprintf( stderr, "%s: line %d: "
 752                                         "suffix '%s' is invalid\n",
 753                                         fname, lineno, argv[ 1 ] );
 754                         return 1;
 755                 }
 756
 757                 tmp_be = select_backend( &nvnc, 0, 0 );
 758                 if ( tmp_be != NULL && tmp_be != be ) {
 759                         fprintf( stderr,
 760         "%s: line %d: suffix already in use by another backend in"
 761         " \"suffixMassage <suffix> <massaged suffix>\"\n",
 762                                 fname, lineno );
 763                         free( pvnc.bv_val );
 764                         free( nvnc.bv_val );
 765                         return 1;
 766                 }
 767
 768                 ber_str2bv( argv[ 2 ], 0, 0, &dn );
 769                 if ( dnPrettyNormal( NULL, &dn, &prnc, &nrnc, NULL ) != LDAP_SUCCESS ) {
 770                         fprintf( stderr, "%s: line %d: "
 771                                         "massaged suffix '%s' is invalid\n",
 772                                         fname, lineno, argv[ 2 ] );
 773                         free( pvnc.bv_val );
 774                         free( nvnc.bv_val );
 775                         return 1;
 776                 }
 777
 778 #if 0
 779                 tmp_be = select_backend( &nrnc, 0, 0 );
 780                 if ( tmp_be != NULL ) {
 781                         fprintf( stderr,
 782         "%s: line %d: massaged suffix already in use by another backend in"
 783         " \"suffixMassage <suffix> <massaged suffix>\"\n",
 784                                 fname, lineno );
 785                         free( pvnc.bv_val );
 786                         free( nvnc.bv_val );
 787                         free( prnc.bv_val );
 788                         free( nrnc.bv_val );
 789                         return 1;
 790                 }
 791 #endif
 792
 793                 /*
 794                  * The suffix massaging is emulated by means of the
 795                  * rewrite capabilities
 796                  * FIXME: no extra rewrite capabilities should be added
 797                  * to the database
 798                  */
 799                 rc = suffix_massage_config( mi->mi_targets[ i ].mt_rwmap.rwm_rw,
 800                                 &pvnc, &nvnc, &prnc, &nrnc );
 801
 802                 free( pvnc.bv_val );
 803                 free( nvnc.bv_val );
 804                 free( prnc.bv_val );
 805                 free( nrnc.bv_val );
 806
 807                 return rc;
 808
 809         /* rewrite stuff ... */
 810         } else if ( strncasecmp( argv[ 0 ], "rewrite", 7 ) == 0 ) {
 811                 int             i = mi->mi_ntargets - 1;
 812
 813                 if ( i < 0 ) {
 814                         fprintf( stderr, "%s: line %d: \"rewrite\" "
 815                                 "statement outside target definition.\n",
 816                                 fname, lineno );
 817                         return 1;
 818                 }
 819
 820                 return rewrite_parse( mi->mi_targets[ i ].mt_rwmap.rwm_rw,
 821                                 fname, lineno, argc, argv );
 822
 823         /* objectclass/attribute mapping */
 824         } else if ( strcasecmp( argv[ 0 ], "map" ) == 0 ) {
 825                 int             i = mi->mi_ntargets - 1;
 826
 827                 if ( i < 0 ) {
 828                         fprintf( stderr,
 829         "%s: line %d: need \"uri\" directive first\n",
 830                                 fname, lineno );
 831                         return 1;
 832                 }
 833
 834                 return ldap_back_map_config( &mi->mi_targets[ i ].mt_rwmap.rwm_oc,
 835                                 &mi->mi_targets[ i ].mt_rwmap.rwm_at,
 836                                 fname, lineno, argc, argv );
 837
 838         } else if ( strcasecmp( argv[ 0 ], "nretries" ) == 0 ) {
 839                 int             i = mi->mi_ntargets - 1;
 840                 int             nretries = META_RETRY_UNDEFINED;
 841
 842                 if ( argc != 2 ) {
 843                         fprintf( stderr,
 844         "%s: line %d: need value in \"nretries <value>\"\n",
 845                                 fname, lineno );
 846                         return 1;
 847                 }
 848
 849                 if ( strcasecmp( argv[ 1 ], "forever" ) == 0 ) {
 850                         nretries = META_RETRY_FOREVER;
 851
 852                 } else if ( strcasecmp( argv[ 1 ], "never" ) == 0 ) {
 853                         nretries = META_RETRY_NEVER;
 854
 855                 } else {
 856                         char    *next;
 857
 858                         nretries = strtol( argv[ 1 ], &next, 10 );
 859                         if ( next == argv[ 1 ] || next[ 0 ] != '\0' ) {
 860                                 fprintf( stderr,
 861         "%s: line %d: unable to parse value \"%s\" in \"nretries <value>\"\n",
 862                                         fname, lineno, argv[ 1 ] );
 863                                 return 1;
 864                         }
 865                 }
 866
 867                 if ( i < 0 ) {
 868                         mi->mi_nretries = nretries;
 869
 870                 } else {
 871                         mi->mi_targets[ i ].mt_nretries = nretries;
 872                 }
 873
 874         /* anything else */
 875         } else {
 876                 return SLAP_CONF_UNKNOWN;
 877         }
 878         return 0;
 879 }
 880
 881 int
 882 ldap_back_map_config(
 883                 struct ldapmap  *oc_map,
 884                 struct ldapmap  *at_map,
 885                 const char      *fname,
 886                 int             lineno,
 887                 int             argc,
 888                 char            **argv )
 889 {
 890         struct ldapmap          *map;
 891         struct ldapmapping      *mapping;
 892         char                    *src, *dst;
 893         int                     is_oc = 0;
 894
 895         if ( argc < 3 || argc > 4 ) {
 896                 fprintf( stderr,
 897         "%s: line %d: syntax is \"map {objectclass | attribute} [<local> | *] {<foreign> | *}\"\n",
 898                         fname, lineno );
 899                 return 1;
 900         }
 901
 902         if ( strcasecmp( argv[ 1 ], "objectclass" ) == 0 ) {
 903                 map = oc_map;
 904                 is_oc = 1;
 905
 906         } else if ( strcasecmp( argv[ 1 ], "attribute" ) == 0 ) {
 907                 map = at_map;
 908
 909         } else {
 910                 fprintf( stderr, "%s: line %d: syntax is "
 911                         "\"map {objectclass | attribute} [<local> | *] "
 912                         "{<foreign> | *}\"\n",
 913                         fname, lineno );
 914                 return 1;
 915         }
 916
 917         if ( strcmp( argv[ 2 ], "*" ) == 0 ) {
 918                 if ( argc < 4 || strcmp( argv[ 3 ], "*" ) == 0 ) {
 919                         map->drop_missing = ( argc < 4 );
 920                         return 0;
 921                 }
 922                 src = dst = argv[ 3 ];
 923
 924         } else if ( argc < 4 ) {
 925                 src = "";
 926                 dst = argv[ 2 ];
 927
 928         } else {
 929                 src = argv[ 2 ];
 930                 dst = ( strcmp( argv[ 3 ], "*" ) == 0 ? src : argv[ 3 ] );
 931         }
 932
 933         if ( ( map == at_map )
 934                         && ( strcasecmp( src, "objectclass" ) == 0
 935                         || strcasecmp( dst, "objectclass" ) == 0 ) )
 936         {
 937                 fprintf( stderr,
 938                         "%s: line %d: objectclass attribute cannot be mapped\n",
 939                         fname, lineno );
 940         }
 941
 942         mapping = (struct ldapmapping *)ch_calloc( 2,
 943                 sizeof(struct ldapmapping) );
 944         if ( mapping == NULL ) {
 945                 fprintf( stderr,
 946                         "%s: line %d: out of memory\n",
 947                         fname, lineno );
 948                 return 1;
 949         }
 950         ber_str2bv( src, 0, 1, &mapping[ 0 ].src );
 951         ber_str2bv( dst, 0, 1, &mapping[ 0 ].dst );
 952         mapping[ 1 ].src = mapping[ 0 ].dst;
 953         mapping[ 1 ].dst = mapping[ 0 ].src;
 954
 955         /*
 956          * schema check
 957          */
 958         if ( is_oc ) {
 959                 if ( src[ 0 ] != '\0' ) {
 960                         if ( oc_bvfind( &mapping[ 0 ].src ) == NULL ) {
 961                                 fprintf( stderr,
 962         "%s: line %d: warning, source objectClass '%s' "
 963         "should be defined in schema\n",
 964                                         fname, lineno, src );
 965
 966                                 /*
 967                                  * FIXME: this should become an err
 968                                  */
 969                                 goto error_return;
 970                         }
 971                 }
 972
 973                 if ( oc_bvfind( &mapping[ 0 ].dst ) == NULL ) {
 974                         fprintf( stderr,
 975         "%s: line %d: warning, destination objectClass '%s' "
 976         "is not defined in schema\n",
 977                                 fname, lineno, dst );
 978                 }
 979         } else {
 980                 int                     rc;
 981                 const char              *text = NULL;
 982                 AttributeDescription    *ad = NULL;
 983
 984                 if ( src[ 0 ] != '\0' ) {
 985                         rc = slap_bv2ad( &mapping[ 0 ].src, &ad, &text );
 986                         if ( rc != LDAP_SUCCESS ) {
 987                                 fprintf( stderr,
 988         "%s: line %d: warning, source attributeType '%s' "
 989         "should be defined in schema\n",
 990                                         fname, lineno, src );
 991
 992                                 /*
 993                                  * FIXME: this should become an err
 994                                  */
 995                                 /*
 996                                  * we create a fake "proxied" ad
 997                                  * and add it here.
 998                                  */
 999
1000                                 rc = slap_bv2undef_ad( &mapping[ 0 ].src,
1001                                                 &ad, &text, SLAP_AD_PROXIED );
1002                                 if ( rc != LDAP_SUCCESS ) {
1003                                         fprintf( stderr,
1004         "%s: line %d: source attributeType '%s': %d (%s)\n",
1005                                                 fname, lineno, src,
1006                                                 rc, text ? text : "" );
1007                                         goto error_return;
1008                                 }
1009                         }
1010
1011                         ad = NULL;
1012                 }
1013
1014                 rc = slap_bv2ad( &mapping[ 0 ].dst, &ad, &text );
1015                 if ( rc != LDAP_SUCCESS ) {
1016                         fprintf( stderr,
1017         "%s: line %d: warning, destination attributeType '%s' "
1018         "is not defined in schema\n",
1019                                 fname, lineno, dst );
1020
1021                         /*
1022                          * we create a fake "proxied" ad
1023                          * and add it here.
1024                          */
1025
1026                         rc = slap_bv2undef_ad( &mapping[ 0 ].dst,
1027                                         &ad, &text, SLAP_AD_PROXIED );
1028                         if ( rc != LDAP_SUCCESS ) {
1029                                 fprintf( stderr,
1030         "%s: line %d: source attributeType '%s': %d (%s)\n",
1031                                         fname, lineno, dst,
1032                                         rc, text ? text : "" );
1033                                 return 1;
1034                         }
1035                 }
1036         }
1037
1038         if ( (src[ 0 ] != '\0' && avl_find( map->map, (caddr_t)&mapping[ 0 ], mapping_cmp ) != NULL)
1039                         || avl_find( map->remap, (caddr_t)&mapping[ 1 ], mapping_cmp ) != NULL)
1040         {
1041                 fprintf( stderr,
1042                         "%s: line %d: duplicate mapping found" SLAPD_CONF_UNKNOWN_IGNORED ".\n",
1043                         fname, lineno );
1044                 goto error_return;
1045         }
1046
1047         if ( src[ 0 ] != '\0' ) {
1048                 avl_insert( &map->map, (caddr_t)&mapping[ 0 ],
1049                                         mapping_cmp, mapping_dup );
1050         }
1051         avl_insert( &map->remap, (caddr_t)&mapping[ 1 ],
1052                                 mapping_cmp, mapping_dup );
1053
1054         return 0;
1055
1056 error_return:;
1057         if ( mapping ) {
1058                 ch_free( mapping[ 0 ].src.bv_val );
1059                 ch_free( mapping[ 0 ].dst.bv_val );
1060                 ch_free( mapping );
1061         }
1062
1063         return 1;
1064 }
1065
1066
1067 #ifdef ENABLE_REWRITE
1068 static char *
1069 suffix_massage_regexize( const char *s )
1070 {
1071         char *res, *ptr;
1072         const char *p, *r;
1073         int i;
1074
1075         if ( s[ 0 ] == '\0' ) {
1076                 return ch_strdup( "^(.+)$" );
1077         }
1078
1079         for ( i = 0, p = s;
1080                         ( r = strchr( p, ',' ) ) != NULL;
1081                         p = r + 1, i++ )
1082                 ;
1083
1084         res = ch_calloc( sizeof( char ),
1085                         strlen( s )
1086                         + STRLENOF( "((.+),)?" )
1087                         + STRLENOF( "[ ]?" ) * i
1088                         + STRLENOF( "$" ) + 1 );
1089
1090         ptr = lutil_strcopy( res, "((.+),)?" );
1091         for ( i = 0, p = s;
1092                         ( r = strchr( p, ',' ) ) != NULL;
1093                         p = r + 1 , i++ ) {
1094                 ptr = lutil_strncopy( ptr, p, r - p + 1 );
1095                 ptr = lutil_strcopy( ptr, "[ ]?" );
1096
1097                 if ( r[ 1 ] == ' ' ) {
1098                         r++;
1099                 }
1100         }
1101         ptr = lutil_strcopy( ptr, p );
1102         ptr[ 0 ] = '$';
1103         ptr++;
1104         ptr[ 0 ] = '\0';
1105
1106         return res;
1107 }
1108
1109 static char *
1110 suffix_massage_patternize( const char *s, const char *p )
1111 {
1112         ber_len_t       len;
1113         char            *res, *ptr;
1114
1115         len = strlen( p );
1116
1117         if ( s[ 0 ] == '\0' ) {
1118                 len++;
1119         }
1120
1121         res = ch_calloc( sizeof( char ), len + STRLENOF( "%1" ) + 1 );
1122         if ( res == NULL ) {
1123                 return NULL;
1124         }
1125
1126         ptr = lutil_strcopy( res, ( p[ 0 ] == '\0' ? "%2" : "%1" ) );
1127         if ( s[ 0 ] == '\0' ) {
1128                 ptr[ 0 ] = ',';
1129                 ptr++;
1130         }
1131         lutil_strcopy( ptr, p );
1132
1133         return res;
1134 }
1135
1136 int
1137 suffix_massage_config(
1138                 struct rewrite_info *info,
1139                 struct berval *pvnc,
1140                 struct berval *nvnc,
1141                 struct berval *prnc,
1142                 struct berval *nrnc
1143 )
1144 {
1145         char *rargv[ 5 ];
1146         int line = 0;
1147
1148         rargv[ 0 ] = "rewriteEngine";
1149         rargv[ 1 ] = "on";
1150         rargv[ 2 ] = NULL;
1151         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1152
1153         rargv[ 0 ] = "rewriteContext";
1154         rargv[ 1 ] = "default";
1155         rargv[ 2 ] = NULL;
1156         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1157
1158         rargv[ 0 ] = "rewriteRule";
1159         rargv[ 1 ] = suffix_massage_regexize( pvnc->bv_val );
1160         rargv[ 2 ] = suffix_massage_patternize( pvnc->bv_val, prnc->bv_val );
1161         rargv[ 3 ] = ":";
1162         rargv[ 4 ] = NULL;
1163         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1164         ch_free( rargv[ 1 ] );
1165         ch_free( rargv[ 2 ] );
1166
1167         if ( BER_BVISEMPTY( pvnc ) ) {
1168                 rargv[ 0 ] = "rewriteRule";
1169                 rargv[ 1 ] = "^$";
1170                 rargv[ 2 ] = prnc->bv_val;
1171                 rargv[ 3 ] = ":";
1172                 rargv[ 4 ] = NULL;
1173                 rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1174         }
1175
1176         rargv[ 0 ] = "rewriteContext";
1177         rargv[ 1 ] = "searchEntryDN";
1178         rargv[ 2 ] = NULL;
1179         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1180
1181         rargv[ 0 ] = "rewriteRule";
1182         rargv[ 1 ] = suffix_massage_regexize( prnc->bv_val );
1183         rargv[ 2 ] = suffix_massage_patternize( prnc->bv_val, pvnc->bv_val );
1184         rargv[ 3 ] = ":";
1185         rargv[ 4 ] = NULL;
1186         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1187         ch_free( rargv[ 1 ] );
1188         ch_free( rargv[ 2 ] );
1189
1190         if ( BER_BVISEMPTY( prnc ) ) {
1191                 rargv[ 0 ] = "rewriteRule";
1192                 rargv[ 1 ] = "^$";
1193                 rargv[ 2 ] = pvnc->bv_val;
1194                 rargv[ 3 ] = ":";
1195                 rargv[ 4 ] = NULL;
1196                 rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1197         }
1198
1199         /* backward compatibility */
1200         rargv[ 0 ] = "rewriteContext";
1201         rargv[ 1 ] = "searchResult";
1202         rargv[ 2 ] = "alias";
1203         rargv[ 3 ] = "searchEntryDN";
1204         rargv[ 4 ] = NULL;
1205         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1206
1207         rargv[ 0 ] = "rewriteContext";
1208         rargv[ 1 ] = "matchedDN";
1209         rargv[ 2 ] = "alias";
1210         rargv[ 3 ] = "searchEntryDN";
1211         rargv[ 4 ] = NULL;
1212         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1213
1214         rargv[ 0 ] = "rewriteContext";
1215         rargv[ 1 ] = "searchAttrDN";
1216         rargv[ 2 ] = "alias";
1217         rargv[ 3 ] = "searchEntryDN";
1218         rargv[ 4 ] = NULL;
1219         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1220
1221         /* NOTE: this corresponds to #undef'ining RWM_REFERRAL_REWRITE;
1222          * see servers/slapd/overlays/rwm.h for details */
1223         rargv[ 0 ] = "rewriteContext";
1224         rargv[ 1 ] = "referralAttrDN";
1225         rargv[ 2 ] = NULL;
1226         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1227
1228         rargv[ 0 ] = "rewriteContext";
1229         rargv[ 1 ] = "referralDN";
1230         rargv[ 2 ] = NULL;
1231         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1232
1233         return 0;
1234 }
1235 #endif /* ENABLE_REWRITE */
1236