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