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 int
  73 meta_back_db_config(
  74                 BackendDB       *be,
  75                 const char      *fname,
  76                 int             lineno,
  77                 int             argc,
  78                 char            **argv
  79 )
  80 {
  81         metainfo_t      *mi = ( metainfo_t * )be->be_private;
  82
  83         if ( mi == NULL ) {
  84                 fprintf( stderr,
  85         "%s: line %d: meta backend info is null!\n",
  86                     fname, lineno );
  87                 return 1;
  88         }
  89
  90         /* URI of server to query */
  91         if ( strcasecmp( argv[ 0 ], "uri" ) == 0 ) {
  92                 int             i = mi->mi_ntargets;
  93 #if 0
  94                 int             j;
  95 #endif /* uncomment if uri MUST be a branch of suffix */
  96                 LDAPURLDesc     *ludp, *tmpludp;
  97                 struct berval   dn;
  98                 int             rc;
  99                 int             c;
 100
 101                 if ( argc != 2 ) {
 102                         fprintf( stderr,
 103         "%s: line %d: missing address"
 104         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 105                                 fname, lineno );
 106                         return 1;
 107                 }
 108
 109                 ++mi->mi_ntargets;
 110
 111                 mi->mi_targets = ( metatarget_t * )ch_realloc( mi->mi_targets,
 112                         sizeof( metatarget_t ) * mi->mi_ntargets );
 113                 if ( mi->mi_targets == NULL ) {
 114                         fprintf( stderr,
 115         "%s: line %d: out of memory while storing server name"
 116         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 117                                 fname, lineno );
 118                         return 1;
 119                 }
 120
 121                 if ( new_target( &mi->mi_targets[ i ] ) != 0 ) {
 122                         fprintf( stderr,
 123         "%s: line %d: unable to init server"
 124         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 125                                 fname, lineno );
 126                         return 1;
 127                 }
 128
 129                 mi->mi_targets[ i ].mt_nretries = mi->mi_nretries;
 130                 mi->mi_targets[ i ].mt_flags = mi->flags;
 131                 mi->mi_targets[ i ].mt_version = mi->mi_version;
 132
 133                 for ( c = 0; c < META_OP_LAST; c++ ) {
 134                         mi->mi_targets[ i ].mt_timeout[ c ] = mi->mi_timeout[ c ];
 135                 }
 136
 137                 /*
 138                  * uri MUST be legal!
 139                  */
 140                 if ( ldap_url_parselist_ext( &ludp, argv[ 1 ], "\t" ) != LDAP_SUCCESS ) {
 141                         fprintf( stderr,
 142         "%s: line %d: unable to parse URI"
 143         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 144                                 fname, lineno );
 145                         return 1;
 146                 }
 147
 148                 /*
 149                  * uri MUST have the <dn> part!
 150                  */
 151                 if ( ludp->lud_dn == NULL || ludp->lud_dn[ 0 ] == '\0' ) {
 152                         fprintf( stderr,
 153         "%s: line %d: missing <naming context> "
 154         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 155                                 fname, lineno );
 156                         return 1;
 157                 }
 158
 159                 /*
 160                  * copies and stores uri and suffix
 161                  */
 162                 dn.bv_val = ludp->lud_dn;
 163                 dn.bv_len = strlen( ludp->lud_dn );
 164
 165                 rc = dnPrettyNormal( NULL, &dn, &mi->mi_targets[ i ].mt_psuffix,
 166                         &mi->mi_targets[ i ].mt_nsuffix, NULL );
 167                 if( rc != LDAP_SUCCESS ) {
 168                         fprintf( stderr, "%s: line %d: "
 169                                         "target '%s' DN is invalid\n",
 170                                         fname, lineno, argv[ 1 ] );
 171                         return( 1 );
 172                 }
 173
 174                 ludp->lud_dn[ 0 ] = '\0';
 175
 176                 /* check all, to apply the scope check on the first one */
 177                 for ( tmpludp = ludp; tmpludp; tmpludp = tmpludp->lud_next ) {
 178                         if ( tmpludp->lud_dn != NULL && tmpludp->lud_dn[ 0 ] != '\0' ) {
 179                                 fprintf( stderr, "%s: line %d: "
 180                                                 "multiple URIs must have "
 181                                                 "no DN part\n",
 182                                         fname, lineno );
 183                                 return( 1 );
 184
 185                         }
 186
 187                         if ( tmpludp->lud_scope == LDAP_SCOPE_BASE ) {
 188                                 tmpludp->lud_scope = LDAP_SCOPE_DEFAULT;
 189                         }
 190                 }
 191
 192                 mi->mi_targets[ i ].mt_uri = ldap_url_list2urls( ludp );
 193                 ldap_free_urllist( ludp );
 194                 if ( mi->mi_targets[ i ].mt_uri == NULL) {
 195                         fprintf( stderr, "%s: line %d: no memory?\n",
 196                                         fname, lineno );
 197                         return( 1 );
 198                 }
 199
 200                 /*
 201                  * uri MUST be a branch of suffix!
 202                  */
 203 #if 0 /* too strict a constraint */
 204                 if ( select_backend( &mi->mi_targets[ i ].suffix, 0, 0 ) != be ) {
 205                         fprintf( stderr,
 206         "%s: line %d: <naming context> of URI does not refer to current backend"
 207         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 208                                 fname, lineno );
 209                         return 1;
 210                 }
 211 #else
 212                 /*
 213                  * uri MUST be a branch of a suffix!
 214                  */
 215                 if ( select_backend( &mi->mi_targets[ i ].mt_nsuffix, 0, 0 ) == NULL ) {
 216                         fprintf( stderr,
 217         "%s: line %d: <naming context> of URI does not resolve to a backend"
 218         " in \"uri <protocol>://<server>[:port]/<naming context>\" line\n",
 219                                 fname, lineno );
 220                         return 1;
 221                 }
 222 #endif
 223
 224         /* default target directive */
 225         } else if ( strcasecmp( argv[ 0 ], "default-target" ) == 0 ) {
 226                 int             i = mi->mi_ntargets - 1;
 227
 228                 if ( argc == 1 ) {
 229                         if ( i < 0 ) {
 230                                 fprintf( stderr,
 231         "%s: line %d: \"default-target\" alone need be"
 232         " inside a \"uri\" directive\n",
 233                                         fname, lineno );
 234                                 return 1;
 235                         }
 236                         mi->mi_defaulttarget = i;
 237                 } else {
 238                         if ( strcasecmp( argv[ 1 ], "none" ) == 0 ) {
 239                                 if ( i >= 0 ) {
 240                                         fprintf( stderr,
 241         "%s: line %d: \"default-target none\""
 242         " should go before uri definitions\n",
 243                                                 fname, lineno );
 244                                 }
 245                                 mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
 246
 247                         } else {
 248                                 char    *next;
 249                                 int     n = strtol( argv[ 1 ], &next, 10 );
 250                                 if ( n < 0 || n >= i - 1 ) {
 251                                         fprintf( stderr,
 252         "%s: line %d: illegal target number %d\n",
 253                                                 fname, lineno, n );
 254                                         return 1;
 255                                 }
 256                                 mi->mi_defaulttarget = n;
 257                         }
 258                 }
 259
 260         /* ttl of dn cache */
 261         } else if ( strcasecmp( argv[ 0 ], "dncache-ttl" ) == 0 ) {
 262                 if ( argc != 2 ) {
 263                         fprintf( stderr,
 264         "%s: line %d: missing ttl in \"dncache-ttl <ttl>\" line\n",
 265                                 fname, lineno );
 266                         return 1;
 267                 }
 268
 269                 if ( strcasecmp( argv[ 1 ], "forever" ) == 0 ) {
 270                         mi->mi_cache.ttl = META_DNCACHE_FOREVER;
 271                 } else if ( strcasecmp( argv[ 1 ], "disabled" ) == 0 ) {
 272                         mi->mi_cache.ttl = META_DNCACHE_DISABLED;
 273                 } else {
 274                         mi->mi_cache.ttl = atol( argv[ 1 ] );
 275                 }
 276
 277         /* network timeout when connecting to ldap servers */
 278         } else if ( strcasecmp( argv[ 0 ], "network-timeout" ) == 0 ) {
 279                 if ( argc != 2 ) {
 280                         fprintf( stderr,
 281         "%s: line %d: missing network timeout in \"network-timeout <seconds>\" line\n",
 282                                 fname, lineno );
 283                         return 1;
 284                 }
 285                 mi->mi_network_timeout = atol(argv[ 1 ]);
 286
 287         /* name to use for meta_back_group */
 288         } else if ( strcasecmp( argv[ 0 ], "acl-authcDN" ) == 0
 289                         || strcasecmp( argv[ 0 ], "binddn" ) == 0 )
 290         {
 291                 int             i = mi->mi_ntargets - 1;
 292                 struct berval   dn;
 293
 294                 if ( i < 0 ) {
 295                         fprintf( stderr,
 296         "%s: line %d: need \"uri\" directive first\n",
 297                                 fname, lineno );
 298                         return 1;
 299                 }
 300
 301                 if ( argc != 2 ) {
 302                         fprintf( stderr,
 303         "%s: line %d: missing name in \"binddn <name>\" line\n",
 304                                 fname, lineno );
 305                         return 1;
 306                 }
 307
 308                 if ( strcasecmp( argv[ 0 ], "binddn" ) == 0 ) {
 309                         fprintf( stderr, "%s: line %d: "
 310                                 "\"binddn\" statement is deprecated; "
 311                                 "use \"acl-authcDN\" instead\n",
 312                                 fname, lineno );
 313                         /* FIXME: some day we'll need to throw an error */
 314                 }
 315
 316                 dn.bv_val = argv[ 1 ];
 317                 dn.bv_len = strlen( argv[ 1 ] );
 318                 if ( dnNormalize( 0, NULL, NULL, &dn, &mi->mi_targets[ i ].mt_binddn,
 319                         NULL ) != LDAP_SUCCESS )
 320                 {
 321                         fprintf( stderr, "%s: line %d: "
 322                                         "bind DN '%s' is invalid\n",
 323                                         fname, lineno, argv[ 1 ] );
 324                         return( 1 );
 325                 }
 326
 327         /* password to use for meta_back_group */
 328         } else if ( strcasecmp( argv[ 0 ], "acl-passwd" ) == 0
 329                         || strcasecmp( argv[ 0 ], "bindpw" ) == 0 )
 330         {
 331                 int             i = mi->mi_ntargets - 1;
 332
 333                 if ( i < 0 ) {
 334                         fprintf( stderr,
 335         "%s: line %d: need \"uri\" directive first\n",
 336                                 fname, lineno );
 337                         return 1;
 338                 }
 339
 340                 if ( argc != 2 ) {
 341                         fprintf( stderr,
 342         "%s: line %d: missing password in \"bindpw <password>\" line\n",
 343                             fname, lineno );
 344                         return 1;
 345                 }
 346
 347                 if ( strcasecmp( argv[ 0 ], "bindpw" ) == 0 ) {
 348                         fprintf( stderr, "%s: line %d: "
 349                                 "\"bindpw\" statement is deprecated; "
 350                                 "use \"acl-passwd\" instead\n",
 351                                 fname, lineno );
 352                         /* FIXME: some day we'll need to throw an error */
 353                 }
 354
 355                 ber_str2bv( argv[ 1 ], 0L, 1, &mi->mi_targets[ i ].mt_bindpw );
 356
 357         /* save bind creds for referral rebinds? */
 358         } else if ( strcasecmp( argv[ 0 ], "rebind-as-user" ) == 0 ) {
 359                 if ( argc > 2 ) {
 360                         fprintf( stderr,
 361         "%s: line %d: \"rebind-as-user {NO|yes}\" takes 1 argument.\n",
 362                             fname, lineno );
 363                         return( 1 );
 364                 }
 365
 366                 if ( argc == 1 ) {
 367                         fprintf( stderr,
 368         "%s: line %d: deprecated use of \"rebind-as-user {NO|yes}\" with no arguments.\n",
 369                             fname, lineno );
 370                         mi->flags |= LDAP_BACK_F_SAVECRED;
 371
 372                 } else {
 373                         if ( strcasecmp( argv[ 1 ], "no" ) == 0 ) {
 374                                 mi->flags &= ~LDAP_BACK_F_SAVECRED;
 375
 376                         } else if ( strcasecmp( argv[ 1 ], "yes" ) == 0 ) {
 377                                 mi->flags |= LDAP_BACK_F_SAVECRED;
 378
 379                         } else {
 380                                 fprintf( stderr,
 381         "%s: line %d: \"rebind-as-user {NO|yes}\" unknown argument \"%s\".\n",
 382                                     fname, lineno, argv[ 1 ] );
 383                                 return 1;
 384                         }
 385                 }
 386
 387         } else if ( strcasecmp( argv[ 0 ], "chase-referrals" ) == 0 ) {
 388                 unsigned        *flagsp = mi->mi_ntargets ?
 389                                 &mi->mi_targets[ mi->mi_ntargets - 1 ].mt_flags
 390                                 : &mi->flags;
 391
 392                 if ( argc != 2 ) {
 393                         fprintf( stderr,
 394         "%s: line %d: \"chase-referrals\" needs 1 argument.\n",
 395                                         fname, lineno );
 396                         return( 1 );
 397                 }
 398
 399                 /* this is the default; we add it because the default might change... */
 400                 if ( strcasecmp( argv[ 1 ], "yes" ) == 0 ) {
 401                         *flagsp |= LDAP_BACK_F_CHASE_REFERRALS;
 402
 403                 } else if ( strcasecmp( argv[ 1 ], "no" ) == 0 ) {
 404                         *flagsp &= ~LDAP_BACK_F_CHASE_REFERRALS;
 405
 406                 } else {
 407                         fprintf( stderr,
 408                 "%s: line %d: \"chase-referrals {YES|no}\": unknown argument \"%s\".\n",
 409                                         fname, lineno, argv[ 1 ] );
 410                         return( 1 );
 411                 }
 412
 413         } else if ( strcasecmp( argv[ 0 ], "tls" ) == 0 ) {
 414                 unsigned        *flagsp = mi->mi_ntargets ?
 415                                 &mi->mi_targets[ mi->mi_ntargets - 1 ].mt_flags
 416                                 : &mi->flags;
 417
 418                 if ( argc != 2 ) {
 419                         fprintf( stderr,
 420                 "%s: line %d: \"tls <what>\" needs 1 argument.\n",
 421                                         fname, lineno );
 422                         return( 1 );
 423                 }
 424
 425                 /* start */
 426                 if ( strcasecmp( argv[ 1 ], "start" ) == 0 ) {
 427                         *flagsp |= ( LDAP_BACK_F_USE_TLS | LDAP_BACK_F_TLS_CRITICAL );
 428
 429                 /* try start tls */
 430                 } else if ( strcasecmp( argv[ 1 ], "try-start" ) == 0 ) {
 431                         *flagsp &= ~LDAP_BACK_F_TLS_CRITICAL;
 432                         *flagsp |= LDAP_BACK_F_USE_TLS;
 433
 434                 /* propagate start tls */
 435                 } else if ( strcasecmp( argv[ 1 ], "propagate" ) == 0 ) {
 436                         *flagsp |= ( LDAP_BACK_F_PROPAGATE_TLS | LDAP_BACK_F_TLS_CRITICAL );
 437
 438                 /* try start tls */
 439                 } else if ( strcasecmp( argv[ 1 ], "try-propagate" ) == 0 ) {
 440                         *flagsp &= ~LDAP_BACK_F_TLS_CRITICAL;
 441                         *flagsp |= LDAP_BACK_F_PROPAGATE_TLS;
 442
 443                 } else {
 444                         fprintf( stderr,
 445                 "%s: line %d: \"tls <what>\": unknown argument \"%s\".\n",
 446                                         fname, lineno, argv[ 1 ] );
 447                         return( 1 );
 448                 }
 449
 450         } else if ( strcasecmp( argv[ 0 ], "t-f-support" ) == 0 ) {
 451                 unsigned        *flagsp = mi->mi_ntargets ?
 452                                 &mi->mi_targets[ mi->mi_ntargets - 1 ].mt_flags
 453                                 : &mi->flags;
 454
 455                 if ( argc != 2 ) {
 456                         fprintf( stderr,
 457                 "%s: line %d: \"t-f-support {NO|yes|discover}\" needs 1 argument.\n",
 458                                         fname, lineno );
 459                         return( 1 );
 460                 }
 461
 462                 if ( strcasecmp( argv[ 1 ], "no" ) == 0 ) {
 463                         *flagsp &= ~(LDAP_BACK_F_SUPPORT_T_F|LDAP_BACK_F_SUPPORT_T_F_DISCOVER);
 464
 465                 } else if ( strcasecmp( argv[ 1 ], "yes" ) == 0 ) {
 466                         *flagsp |= LDAP_BACK_F_SUPPORT_T_F;
 467
 468                 } else if ( strcasecmp( argv[ 1 ], "discover" ) == 0 ) {
 469                         *flagsp |= LDAP_BACK_F_SUPPORT_T_F_DISCOVER;
 470
 471                 } else {
 472                         fprintf( stderr,
 473         "%s: line %d: unknown value \"%s\" for \"t-f-support {no|yes|discover}\".\n",
 474                                 fname, lineno, argv[ 1 ] );
 475                         return 1;
 476                 }
 477
 478         /* onerr? */
 479         } else if ( strcasecmp( argv[ 0 ], "onerr" ) == 0 ) {
 480                 if ( argc != 2 ) {
 481                         fprintf( stderr,
 482         "%s: line %d: \"onerr {CONTINUE|stop}\" takes 1 argument\n",
 483                             fname, lineno );
 484                         return( 1 );
 485                 }
 486
 487                 if ( strcasecmp( argv[ 1 ], "continue" ) == 0 ) {
 488                         mi->flags &= ~META_BACK_F_ONERR_STOP;
 489
 490                 } else if ( strcasecmp( argv[ 1 ], "stop" ) == 0 ) {
 491                         mi->flags |= META_BACK_F_ONERR_STOP;
 492
 493                 } else {
 494                         fprintf( stderr,
 495         "%s: line %d: \"onerr {CONTINUE|stop}\": invalid arg \"%s\".\n",
 496                                 fname, lineno, argv[ 1 ] );
 497                         return 1;
 498                 }
 499
 500         } else if ( strcasecmp( argv[ 0 ], "timeout" ) == 0 ) {
 501                 char    *sep, *next;
 502                 time_t  *tv = mi->mi_ntargets ?
 503                                 mi->mi_targets[ mi->mi_ntargets - 1 ].mt_timeout
 504                                 : mi->mi_timeout;
 505                 int     c;
 506
 507                 if ( argc < 2 ) {
 508                         fprintf( stderr,
 509         "%s: line %d: \"timeout [{add|delete|modify|modrdn}=]<val> [...]\" takes at least 1 argument\n",
 510                             fname, lineno );
 511                         return( 1 );
 512                 }
 513
 514                 for ( c = 1; c < argc; c++ ) {
 515                         time_t  *t = NULL, val;
 516
 517                         sep = strchr( argv[ c ], '=' );
 518                         if ( sep != NULL ) {
 519                                 size_t  len = sep - argv[ c ];
 520
 521                                 if ( strncasecmp( argv[ c ], "add", len ) == 0 ) {
 522                                         t = &tv[ META_OP_ADD ];
 523                                 } else if ( strncasecmp( argv[ c ], "delete", len ) == 0 ) {
 524                                         t = &tv[ META_OP_DELETE ];
 525                                 } else if ( strncasecmp( argv[ c ], "modify", len ) == 0 ) {
 526                                         t = &tv[ META_OP_MODIFY ];
 527                                 } else if ( strncasecmp( argv[ c ], "modrdn", len ) == 0 ) {
 528                                         t = &tv[ META_OP_MODRDN ];
 529                                 } else {
 530                                         fprintf( stderr,
 531                 "%s: line %d: unknown operation \"%s\" for timeout #%d.\n",
 532                                                 fname, lineno, argv[ c ], c );
 533                                         return 1;
 534                                 }
 535                                 sep++;
 536
 537                         } else {
 538                                 sep = argv[ c ];
 539                         }
 540
 541                         val = strtoul( sep, &next, 10 );
 542                         if ( next == sep || next[ 0 ] != '\0' ) {
 543                                 fprintf( stderr,
 544                 "%s: line %d: unable to parse value \"%s\" for timeout.\n",
 545                                         fname, lineno, sep );
 546                                 return 1;
 547                         }
 548
 549                         if ( t ) {
 550                                 *t = val;
 551
 552                         } else {
 553                                 int     i;
 554
 555                                 for ( i = 0; i < META_OP_LAST; i++ ) {
 556                                         tv[ i ] = val;
 557                                 }
 558                         }
 559                 }
 560
 561         /* name to use as pseudo-root dn */
 562         } else if ( strcasecmp( argv[ 0 ], "pseudorootdn" ) == 0 ) {
 563                 int             i = mi->mi_ntargets - 1;
 564                 struct berval   dn;
 565
 566                 if ( i < 0 ) {
 567                         fprintf( stderr,
 568         "%s: line %d: need \"uri\" directive first\n",
 569                                 fname, lineno );
 570                         return 1;
 571                 }
 572
 573                 if ( argc != 2 ) {
 574                         fprintf( stderr,
 575         "%s: line %d: missing name in \"pseudorootdn <name>\" line\n",
 576                                 fname, lineno );
 577                         return 1;
 578                 }
 579
 580                 dn.bv_val = argv[ 1 ];
 581                 dn.bv_len = strlen( argv[ 1 ] );
 582                 if ( dnNormalize( 0, NULL, NULL, &dn,
 583                         &mi->mi_targets[ i ].mt_pseudorootdn, NULL ) != LDAP_SUCCESS )
 584                 {
 585                         fprintf( stderr, "%s: line %d: "
 586                                         "pseudoroot DN '%s' is invalid\n",
 587                                         fname, lineno, argv[ 1 ] );
 588                         return( 1 );
 589                 }
 590
 591         /* password to use as pseudo-root */
 592         } else if ( strcasecmp( argv[ 0 ], "pseudorootpw" ) == 0 ) {
 593                 int             i = mi->mi_ntargets - 1;
 594
 595                 if ( i < 0 ) {
 596                         fprintf( stderr,
 597         "%s: line %d: need \"uri\" directive first\n",
 598                                 fname, lineno );
 599                         return 1;
 600                 }
 601
 602                 if ( argc != 2 ) {
 603                         fprintf( stderr,
 604         "%s: line %d: missing password in \"pseudorootpw <password>\" line\n",
 605                             fname, lineno );
 606                         return 1;
 607                 }
 608                 ber_str2bv( argv[ 1 ], 0L, 1, &mi->mi_targets[ i ].mt_pseudorootpw );
 609
 610         /* dn massaging */
 611         } else if ( strcasecmp( argv[ 0 ], "suffixmassage" ) == 0 ) {
 612                 BackendDB       *tmp_be;
 613                 int             i = mi->mi_ntargets - 1;
 614                 struct berval   dn, nvnc, pvnc, nrnc, prnc;
 615
 616                 if ( i < 0 ) {
 617                         fprintf( stderr,
 618         "%s: line %d: need \"uri\" directive first\n",
 619                                 fname, lineno );
 620                         return 1;
 621                 }
 622
 623                 /*
 624                  * syntax:
 625                  *
 626                  *      suffixmassage <suffix> <massaged suffix>
 627                  *
 628                  * the <suffix> field must be defined as a valid suffix
 629                  * (or suffixAlias?) for the current database;
 630                  * the <massaged suffix> shouldn't have already been
 631                  * defined as a valid suffix or suffixAlias for the
 632                  * current server
 633                  */
 634                 if ( argc != 3 ) {
 635                         fprintf( stderr,
 636         "%s: line %d: syntax is \"suffixMassage <suffix> <massaged suffix>\"\n",
 637                                 fname, lineno );
 638                         return 1;
 639                 }
 640
 641                 dn.bv_val = argv[ 1 ];
 642                 dn.bv_len = strlen( argv[ 1 ] );
 643                 if ( dnPrettyNormal( NULL, &dn, &pvnc, &nvnc, NULL ) != LDAP_SUCCESS ) {
 644                         fprintf( stderr, "%s: line %d: "
 645                                         "suffix '%s' is invalid\n",
 646                                         fname, lineno, argv[ 1 ] );
 647                         return 1;
 648                 }
 649
 650                 tmp_be = select_backend( &nvnc, 0, 0 );
 651                 if ( tmp_be != NULL && tmp_be != be ) {
 652                         fprintf( stderr,
 653         "%s: line %d: suffix already in use by another backend in"
 654         " \"suffixMassage <suffix> <massaged suffix>\"\n",
 655                                 fname, lineno );
 656                         free( pvnc.bv_val );
 657                         free( nvnc.bv_val );
 658                         return 1;
 659                 }
 660
 661                 dn.bv_val = argv[ 2 ];
 662                 dn.bv_len = strlen( argv[ 2 ] );
 663                 if ( dnPrettyNormal( NULL, &dn, &prnc, &nrnc, NULL ) != LDAP_SUCCESS ) {
 664                         fprintf( stderr, "%s: line %d: "
 665                                         "massaged suffix '%s' is invalid\n",
 666                                         fname, lineno, argv[ 2 ] );
 667                         free( pvnc.bv_val );
 668                         free( nvnc.bv_val );
 669                         return 1;
 670                 }
 671
 672 #if 0
 673                 tmp_be = select_backend( &nrnc, 0, 0 );
 674                 if ( tmp_be != NULL ) {
 675                         fprintf( stderr,
 676         "%s: line %d: massaged suffix already in use by another backend in"
 677         " \"suffixMassage <suffix> <massaged suffix>\"\n",
 678                                 fname, lineno );
 679                         free( pvnc.bv_val );
 680                         free( nvnc.bv_val );
 681                         free( prnc.bv_val );
 682                         free( nrnc.bv_val );
 683                         return 1;
 684                 }
 685 #endif
 686
 687                 /*
 688                  * The suffix massaging is emulated by means of the
 689                  * rewrite capabilities
 690                  * FIXME: no extra rewrite capabilities should be added
 691                  * to the database
 692                  */
 693                 return suffix_massage_config( mi->mi_targets[ i ].mt_rwmap.rwm_rw,
 694                                 &pvnc, &nvnc, &prnc, &nrnc );
 695
 696         /* rewrite stuff ... */
 697         } else if ( strncasecmp( argv[ 0 ], "rewrite", 7 ) == 0 ) {
 698                 int             i = mi->mi_ntargets - 1;
 699
 700                 if ( i < 0 ) {
 701                         fprintf( stderr, "%s: line %d: \"rewrite\" "
 702                                 "statement outside target definition.\n",
 703                                 fname, lineno );
 704                         return 1;
 705                 }
 706
 707                 return rewrite_parse( mi->mi_targets[ i ].mt_rwmap.rwm_rw,
 708                                 fname, lineno, argc, argv );
 709
 710         /* objectclass/attribute mapping */
 711         } else if ( strcasecmp( argv[ 0 ], "map" ) == 0 ) {
 712                 int             i = mi->mi_ntargets - 1;
 713
 714                 if ( i < 0 ) {
 715                         fprintf( stderr,
 716         "%s: line %d: need \"uri\" directive first\n",
 717                                 fname, lineno );
 718                         return 1;
 719                 }
 720
 721                 return ldap_back_map_config( &mi->mi_targets[ i ].mt_rwmap.rwm_oc,
 722                                 &mi->mi_targets[ i ].mt_rwmap.rwm_at,
 723                                 fname, lineno, argc, argv );
 724
 725         } else if ( strcasecmp( argv[ 0 ], "nretries" ) == 0 ) {
 726                 int             i = mi->mi_ntargets - 1;
 727                 int             nretries = META_RETRY_UNDEFINED;
 728
 729                 if ( argc != 2 ) {
 730                         fprintf( stderr,
 731         "%s: line %d: need value in \"nretries <value>\"\n",
 732                                 fname, lineno );
 733                         return 1;
 734                 }
 735
 736                 if ( strcasecmp( argv[ 1 ], "forever" ) == 0 ) {
 737                         nretries = META_RETRY_FOREVER;
 738
 739                 } else if ( strcasecmp( argv[ 1 ], "never" ) == 0 ) {
 740                         nretries = META_RETRY_NEVER;
 741
 742                 } else {
 743                         char    *next;
 744
 745                         nretries = strtol( argv[ 1 ], &next, 10 );
 746                         if ( next == argv[ 1 ] || next[ 0 ] != '\0' ) {
 747                                 fprintf( stderr,
 748         "%s: line %d: unable to parse value \"%s\" in \"nretries <value>\"\n",
 749                                         fname, lineno, argv[ 1 ] );
 750                                 return 1;
 751                         }
 752                 }
 753
 754                 if ( i < 0 ) {
 755                         mi->mi_nretries = nretries;
 756
 757                 } else {
 758                         mi->mi_targets[ i ].mt_nretries = nretries;
 759                 }
 760
 761         /* anything else */
 762         } else {
 763                 return SLAP_CONF_UNKNOWN;
 764         }
 765         return 0;
 766 }
 767
 768 int
 769 ldap_back_map_config(
 770                 struct ldapmap  *oc_map,
 771                 struct ldapmap  *at_map,
 772                 const char      *fname,
 773                 int             lineno,
 774                 int             argc,
 775                 char            **argv )
 776 {
 777         struct ldapmap          *map;
 778         struct ldapmapping      *mapping;
 779         char                    *src, *dst;
 780         int                     is_oc = 0;
 781
 782         if ( argc < 3 || argc > 4 ) {
 783                 fprintf( stderr,
 784         "%s: line %d: syntax is \"map {objectclass | attribute} [<local> | *] {<foreign> | *}\"\n",
 785                         fname, lineno );
 786                 return 1;
 787         }
 788
 789         if ( strcasecmp( argv[ 1 ], "objectclass" ) == 0 ) {
 790                 map = oc_map;
 791                 is_oc = 1;
 792
 793         } else if ( strcasecmp( argv[ 1 ], "attribute" ) == 0 ) {
 794                 map = at_map;
 795
 796         } else {
 797                 fprintf( stderr, "%s: line %d: syntax is "
 798                         "\"map {objectclass | attribute} [<local> | *] "
 799                         "{<foreign> | *}\"\n",
 800                         fname, lineno );
 801                 return 1;
 802         }
 803
 804         if ( strcmp( argv[ 2 ], "*" ) == 0 ) {
 805                 if ( argc < 4 || strcmp( argv[ 3 ], "*" ) == 0 ) {
 806                         map->drop_missing = ( argc < 4 );
 807                         return 0;
 808                 }
 809                 src = dst = argv[ 3 ];
 810
 811         } else if ( argc < 4 ) {
 812                 src = "";
 813                 dst = argv[ 2 ];
 814
 815         } else {
 816                 src = argv[ 2 ];
 817                 dst = ( strcmp( argv[ 3 ], "*" ) == 0 ? src : argv[ 3 ] );
 818         }
 819
 820         if ( ( map == at_map )
 821                         && ( strcasecmp( src, "objectclass" ) == 0
 822                         || strcasecmp( dst, "objectclass" ) == 0 ) )
 823         {
 824                 fprintf( stderr,
 825                         "%s: line %d: objectclass attribute cannot be mapped\n",
 826                         fname, lineno );
 827         }
 828
 829         mapping = (struct ldapmapping *)ch_calloc( 2,
 830                 sizeof(struct ldapmapping) );
 831         if ( mapping == NULL ) {
 832                 fprintf( stderr,
 833                         "%s: line %d: out of memory\n",
 834                         fname, lineno );
 835                 return 1;
 836         }
 837         ber_str2bv( src, 0, 1, &mapping->src );
 838         ber_str2bv( dst, 0, 1, &mapping->dst );
 839         mapping[ 1 ].src = mapping->dst;
 840         mapping[ 1 ].dst = mapping->src;
 841
 842         /*
 843          * schema check
 844          */
 845         if ( is_oc ) {
 846                 if ( src[ 0 ] != '\0' ) {
 847                         if ( oc_bvfind( &mapping->src ) == NULL ) {
 848                                 fprintf( stderr,
 849         "%s: line %d: warning, source objectClass '%s' "
 850         "should be defined in schema\n",
 851                                         fname, lineno, src );
 852
 853                                 /*
 854                                  * FIXME: this should become an err
 855                                  */
 856                                 goto error_return;
 857                         }
 858                 }
 859
 860                 if ( oc_bvfind( &mapping->dst ) == NULL ) {
 861                         fprintf( stderr,
 862         "%s: line %d: warning, destination objectClass '%s' "
 863         "is not defined in schema\n",
 864                                 fname, lineno, dst );
 865                 }
 866         } else {
 867                 int                     rc;
 868                 const char              *text = NULL;
 869                 AttributeDescription    *ad = NULL;
 870
 871                 if ( src[ 0 ] != '\0' ) {
 872                         rc = slap_bv2ad( &mapping->src, &ad, &text );
 873                         if ( rc != LDAP_SUCCESS ) {
 874                                 fprintf( stderr,
 875         "%s: line %d: warning, source attributeType '%s' "
 876         "should be defined in schema\n",
 877                                         fname, lineno, src );
 878
 879                                 /*
 880                                  * FIXME: this should become an err
 881                                  */
 882                                 goto error_return;
 883                         }
 884
 885                         ad = NULL;
 886                 }
 887
 888                 rc = slap_bv2ad( &mapping->dst, &ad, &text );
 889                 if ( rc != LDAP_SUCCESS ) {
 890                         fprintf( stderr,
 891         "%s: line %d: warning, destination attributeType '%s' "
 892         "is not defined in schema\n",
 893                                 fname, lineno, dst );
 894                 }
 895         }
 896
 897         if ( (src[ 0 ] != '\0' && avl_find( map->map, (caddr_t)mapping, mapping_cmp ) != NULL)
 898                         || avl_find( map->remap, (caddr_t)&mapping[ 1 ], mapping_cmp ) != NULL)
 899         {
 900                 fprintf( stderr,
 901                         "%s: line %d: duplicate mapping found" SLAPD_CONF_UNKNOWN_IGNORED ".\n",
 902                         fname, lineno );
 903                 goto error_return;
 904         }
 905
 906         if ( src[ 0 ] != '\0' ) {
 907                 avl_insert( &map->map, (caddr_t)mapping,
 908                                         mapping_cmp, mapping_dup );
 909         }
 910         avl_insert( &map->remap, (caddr_t)&mapping[ 1 ],
 911                                 mapping_cmp, mapping_dup );
 912
 913         return 0;
 914
 915 error_return:;
 916         if ( mapping ) {
 917                 ch_free( mapping->src.bv_val );
 918                 ch_free( mapping->dst.bv_val );
 919                 ch_free( mapping );
 920         }
 921
 922         return 1;
 923 }
 924
 925
 926 #ifdef ENABLE_REWRITE
 927 static char *
 928 suffix_massage_regexize( const char *s )
 929 {
 930         char *res, *ptr;
 931         const char *p, *r;
 932         int i;
 933
 934         for ( i = 0, p = s;
 935                         ( r = strchr( p, ',' ) ) != NULL;
 936                         p = r + 1, i++ )
 937                 ;
 938
 939         res = ch_calloc( sizeof( char ),
 940                         strlen( s )
 941                         + STRLENOF( "(.+,)?" )
 942                         + STRLENOF( "[ ]?" ) * i + 1 );
 943
 944         ptr = lutil_strcopy( res, "(.+,)?" );
 945         for ( i = 0, p = s;
 946                         ( r = strchr( p, ',' ) ) != NULL;
 947                         p = r + 1 , i++ ) {
 948                 ptr = lutil_strncopy( ptr, p, r - p + 1 );
 949                 ptr = lutil_strcopy( ptr, "[ ]?" );
 950
 951                 if ( r[ 1 ] == ' ' ) {
 952                         r++;
 953                 }
 954         }
 955         lutil_strcopy( ptr, p );
 956
 957         return res;
 958 }
 959
 960 static char *
 961 suffix_massage_patternize( const char *s )
 962 {
 963         ber_len_t       len;
 964         char            *res;
 965
 966         len = strlen( s );
 967
 968         res = ch_calloc( sizeof( char ), len + STRLENOF( "%1" ) + 1 );
 969         if ( res == NULL ) {
 970                 return NULL;
 971         }
 972
 973         strcpy( res, "%1" );
 974         strcpy( &res[ STRLENOF( "%1" ) ], s );
 975
 976         return res;
 977 }
 978
 979 int
 980 suffix_massage_config(
 981                 struct rewrite_info *info,
 982                 struct berval *pvnc,
 983                 struct berval *nvnc,
 984                 struct berval *prnc,
 985                 struct berval *nrnc
 986 )
 987 {
 988         char *rargv[ 5 ];
 989         int line = 0;
 990
 991         rargv[ 0 ] = "rewriteEngine";
 992         rargv[ 1 ] = "on";
 993         rargv[ 2 ] = NULL;
 994         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
 995
 996         rargv[ 0 ] = "rewriteContext";
 997         rargv[ 1 ] = "default";
 998         rargv[ 2 ] = NULL;
 999         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1000
1001         rargv[ 0 ] = "rewriteRule";
1002         rargv[ 1 ] = suffix_massage_regexize( pvnc->bv_val );
1003         rargv[ 2 ] = suffix_massage_patternize( prnc->bv_val );
1004         rargv[ 3 ] = ":";
1005         rargv[ 4 ] = NULL;
1006         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1007         ch_free( rargv[ 1 ] );
1008         ch_free( rargv[ 2 ] );
1009
1010         rargv[ 0 ] = "rewriteContext";
1011         rargv[ 1 ] = "searchEntryDN";
1012         rargv[ 2 ] = NULL;
1013         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1014
1015         rargv[ 0 ] = "rewriteRule";
1016         rargv[ 1 ] = suffix_massage_regexize( prnc->bv_val );
1017         rargv[ 2 ] = suffix_massage_patternize( pvnc->bv_val );
1018         rargv[ 3 ] = ":";
1019         rargv[ 4 ] = NULL;
1020         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1021         ch_free( rargv[ 1 ] );
1022         ch_free( rargv[ 2 ] );
1023
1024         /* backward compatibility */
1025         rargv[ 0 ] = "rewriteContext";
1026         rargv[ 1 ] = "searchResult";
1027         rargv[ 2 ] = "alias";
1028         rargv[ 3 ] = "searchEntryDN";
1029         rargv[ 4 ] = NULL;
1030         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1031
1032         rargv[ 0 ] = "rewriteContext";
1033         rargv[ 1 ] = "matchedDN";
1034         rargv[ 2 ] = "alias";
1035         rargv[ 3 ] = "searchEntryDN";
1036         rargv[ 4 ] = NULL;
1037         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1038
1039         rargv[ 0 ] = "rewriteContext";
1040         rargv[ 1 ] = "searchAttrDN";
1041         rargv[ 2 ] = "alias";
1042         rargv[ 3 ] = "searchEntryDN";
1043         rargv[ 4 ] = NULL;
1044         rewrite_parse( info, "<suffix massage>", ++line, 4, rargv );
1045
1046         /* NOTE: this corresponds to #undef'ining RWM_REFERRAL_REWRITE;
1047          * see servers/slapd/overlays/rwm.h for details */
1048         rargv[ 0 ] = "rewriteContext";
1049         rargv[ 1 ] = "referralAttrDN";
1050         rargv[ 2 ] = NULL;
1051         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1052
1053         rargv[ 0 ] = "rewriteContext";
1054         rargv[ 1 ] = "referralDN";
1055         rargv[ 2 ] = NULL;
1056         rewrite_parse( info, "<suffix massage>", ++line, 2, rargv );
1057
1058         return 0;
1059 }
1060 #endif /* ENABLE_REWRITE */
1061