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