001/* 002 * The contents of this file are subject to the terms of the Common Development and 003 * Distribution License (the License). You may not use this file except in compliance with the 004 * License. 005 * 006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the 007 * specific language governing permission and limitations under the License. 008 * 009 * When distributing Covered Software, include this CDDL Header Notice in each file and include 010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL 011 * Header, with the fields enclosed by brackets [] replaced by your own identifying 012 * information: "Portions Copyright [year] [name of copyright owner]". 013 * 014 * Copyright 2008 Sun Microsystems, Inc. 015 */ 016package org.forgerock.opendj.server.config.meta; 017 018 019 020import org.forgerock.opendj.config.AdministratorAction; 021import org.forgerock.opendj.config.AggregationPropertyDefinition; 022import org.forgerock.opendj.config.AliasDefaultBehaviorProvider; 023import org.forgerock.opendj.config.BooleanPropertyDefinition; 024import org.forgerock.opendj.config.ClassPropertyDefinition; 025import org.forgerock.opendj.config.client.ConcurrentModificationException; 026import org.forgerock.opendj.config.client.ManagedObject; 027import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException; 028import org.forgerock.opendj.config.client.OperationRejectedException; 029import org.forgerock.opendj.config.conditions.Conditions; 030import org.forgerock.opendj.config.DefaultBehaviorProvider; 031import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider; 032import org.forgerock.opendj.config.EnumPropertyDefinition; 033import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException; 034import org.forgerock.opendj.config.ManagedObjectDefinition; 035import org.forgerock.opendj.config.PropertyOption; 036import org.forgerock.opendj.config.PropertyProvider; 037import org.forgerock.opendj.config.server.ConfigurationChangeListener; 038import org.forgerock.opendj.config.server.ServerManagedObject; 039import org.forgerock.opendj.config.StringPropertyDefinition; 040import org.forgerock.opendj.config.Tag; 041import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider; 042import org.forgerock.opendj.ldap.DN; 043import org.forgerock.opendj.ldap.LdapException; 044import org.forgerock.opendj.server.config.client.GSSAPISASLMechanismHandlerCfgClient; 045import org.forgerock.opendj.server.config.client.IdentityMapperCfgClient; 046import org.forgerock.opendj.server.config.server.GSSAPISASLMechanismHandlerCfg; 047import org.forgerock.opendj.server.config.server.IdentityMapperCfg; 048import org.forgerock.opendj.server.config.server.SASLMechanismHandlerCfg; 049 050 051 052/** 053 * An interface for querying the GSSAPI SASL Mechanism Handler managed 054 * object definition meta information. 055 * <p> 056 * The GSSAPI SASL mechanism performs all processing related to SASL 057 * GSSAPI authentication using Kerberos V5. 058 */ 059public final class GSSAPISASLMechanismHandlerCfgDefn extends ManagedObjectDefinition<GSSAPISASLMechanismHandlerCfgClient, GSSAPISASLMechanismHandlerCfg> { 060 061 /** The singleton configuration definition instance. */ 062 private static final GSSAPISASLMechanismHandlerCfgDefn INSTANCE = new GSSAPISASLMechanismHandlerCfgDefn(); 063 064 065 066 /** 067 * Defines the set of permissable values for the "quality-of-protection" property. 068 * <p> 069 * The name of a property that specifies the quality of protection 070 * the server will support. 071 */ 072 public static enum QualityOfProtection { 073 074 /** 075 * Quality of protection equals authentication with integrity and 076 * confidentiality protection. 077 */ 078 CONFIDENTIALITY("confidentiality"), 079 080 081 082 /** 083 * Quality of protection equals authentication with integrity 084 * protection. 085 */ 086 INTEGRITY("integrity"), 087 088 089 090 /** 091 * QOP equals authentication only. 092 */ 093 NONE("none"); 094 095 096 097 /** String representation of the value. */ 098 private final String name; 099 100 101 102 /** Private constructor. */ 103 private QualityOfProtection(String name) { this.name = name; } 104 105 106 107 /** {@inheritDoc} */ 108 public String toString() { return name; } 109 110 } 111 112 113 114 /** The "identity-mapper" property definition. */ 115 private static final AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> PD_IDENTITY_MAPPER; 116 117 118 119 /** The "java-class" property definition. */ 120 private static final ClassPropertyDefinition PD_JAVA_CLASS; 121 122 123 124 /** The "kdc-address" property definition. */ 125 private static final StringPropertyDefinition PD_KDC_ADDRESS; 126 127 128 129 /** The "keytab" property definition. */ 130 private static final StringPropertyDefinition PD_KEYTAB; 131 132 133 134 /** The "principal-name" property definition. */ 135 private static final StringPropertyDefinition PD_PRINCIPAL_NAME; 136 137 138 139 /** The "quality-of-protection" property definition. */ 140 private static final EnumPropertyDefinition<QualityOfProtection> PD_QUALITY_OF_PROTECTION; 141 142 143 144 /** The "realm" property definition. */ 145 private static final StringPropertyDefinition PD_REALM; 146 147 148 149 /** The "server-fqdn" property definition. */ 150 private static final StringPropertyDefinition PD_SERVER_FQDN; 151 152 153 154 /** Build the "identity-mapper" property definition. */ 155 static { 156 AggregationPropertyDefinition.Builder<IdentityMapperCfgClient, IdentityMapperCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "identity-mapper"); 157 builder.setOption(PropertyOption.MANDATORY); 158 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "identity-mapper")); 159 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 160 builder.setParentPath("/"); 161 builder.setRelationDefinition("identity-mapper"); 162 builder.setTargetNeedsEnablingCondition(Conditions.contains("enabled", "true")); 163 builder.setTargetIsEnabledCondition(Conditions.contains("enabled", "true")); 164 PD_IDENTITY_MAPPER = builder.getInstance(); 165 INSTANCE.registerPropertyDefinition(PD_IDENTITY_MAPPER); 166 INSTANCE.registerConstraint(PD_IDENTITY_MAPPER.getSourceConstraint()); 167 } 168 169 170 171 /** Build the "java-class" property definition. */ 172 static { 173 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class"); 174 builder.setOption(PropertyOption.MANDATORY); 175 builder.setOption(PropertyOption.ADVANCED); 176 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class")); 177 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.extensions.GSSAPISASLMechanismHandler"); 178 builder.setDefaultBehaviorProvider(provider); 179 builder.addInstanceOf("org.opends.server.api.SASLMechanismHandler"); 180 PD_JAVA_CLASS = builder.getInstance(); 181 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 182 } 183 184 185 186 /** Build the "kdc-address" property definition. */ 187 static { 188 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "kdc-address"); 189 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "kdc-address")); 190 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "kdc-address")); 191 PD_KDC_ADDRESS = builder.getInstance(); 192 INSTANCE.registerPropertyDefinition(PD_KDC_ADDRESS); 193 } 194 195 196 197 /** Build the "keytab" property definition. */ 198 static { 199 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "keytab"); 200 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "keytab")); 201 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "keytab")); 202 PD_KEYTAB = builder.getInstance(); 203 INSTANCE.registerPropertyDefinition(PD_KEYTAB); 204 } 205 206 207 208 /** Build the "principal-name" property definition. */ 209 static { 210 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "principal-name"); 211 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "principal-name")); 212 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "principal-name")); 213 PD_PRINCIPAL_NAME = builder.getInstance(); 214 INSTANCE.registerPropertyDefinition(PD_PRINCIPAL_NAME); 215 } 216 217 218 219 /** Build the "quality-of-protection" property definition. */ 220 static { 221 EnumPropertyDefinition.Builder<QualityOfProtection> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "quality-of-protection"); 222 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "quality-of-protection")); 223 DefaultBehaviorProvider<QualityOfProtection> provider = new DefinedDefaultBehaviorProvider<QualityOfProtection>("none"); 224 builder.setDefaultBehaviorProvider(provider); 225 builder.setEnumClass(QualityOfProtection.class); 226 PD_QUALITY_OF_PROTECTION = builder.getInstance(); 227 INSTANCE.registerPropertyDefinition(PD_QUALITY_OF_PROTECTION); 228 } 229 230 231 232 /** Build the "realm" property definition. */ 233 static { 234 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "realm"); 235 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "realm")); 236 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "realm")); 237 PD_REALM = builder.getInstance(); 238 INSTANCE.registerPropertyDefinition(PD_REALM); 239 } 240 241 242 243 /** Build the "server-fqdn" property definition. */ 244 static { 245 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "server-fqdn"); 246 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "server-fqdn")); 247 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "server-fqdn")); 248 PD_SERVER_FQDN = builder.getInstance(); 249 INSTANCE.registerPropertyDefinition(PD_SERVER_FQDN); 250 } 251 252 253 254 // Register the tags associated with this managed object definition. 255 static { 256 INSTANCE.registerTag(Tag.valueOf("security")); 257 } 258 259 260 261 /** 262 * Get the GSSAPI SASL Mechanism Handler configuration definition 263 * singleton. 264 * 265 * @return Returns the GSSAPI SASL Mechanism Handler configuration 266 * definition singleton. 267 */ 268 public static GSSAPISASLMechanismHandlerCfgDefn getInstance() { 269 return INSTANCE; 270 } 271 272 273 274 /** 275 * Private constructor. 276 */ 277 private GSSAPISASLMechanismHandlerCfgDefn() { 278 super("gssapi-sasl-mechanism-handler", SASLMechanismHandlerCfgDefn.getInstance()); 279 } 280 281 282 283 /** {@inheritDoc} */ 284 public GSSAPISASLMechanismHandlerCfgClient createClientConfiguration( 285 ManagedObject<? extends GSSAPISASLMechanismHandlerCfgClient> impl) { 286 return new GSSAPISASLMechanismHandlerCfgClientImpl(impl); 287 } 288 289 290 291 /** {@inheritDoc} */ 292 public GSSAPISASLMechanismHandlerCfg createServerConfiguration( 293 ServerManagedObject<? extends GSSAPISASLMechanismHandlerCfg> impl) { 294 return new GSSAPISASLMechanismHandlerCfgServerImpl(impl); 295 } 296 297 298 299 /** {@inheritDoc} */ 300 public Class<GSSAPISASLMechanismHandlerCfg> getServerConfigurationClass() { 301 return GSSAPISASLMechanismHandlerCfg.class; 302 } 303 304 305 306 /** 307 * Get the "enabled" property definition. 308 * <p> 309 * Indicates whether the SASL mechanism handler is enabled for use. 310 * 311 * @return Returns the "enabled" property definition. 312 */ 313 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 314 return SASLMechanismHandlerCfgDefn.getInstance().getEnabledPropertyDefinition(); 315 } 316 317 318 319 /** 320 * Get the "identity-mapper" property definition. 321 * <p> 322 * Specifies the name of the identity mapper that is to be used with 323 * this SASL mechanism handler to match the Kerberos principal 324 * included in the SASL bind request to the corresponding user in the 325 * directory. 326 * 327 * @return Returns the "identity-mapper" property definition. 328 */ 329 public AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> getIdentityMapperPropertyDefinition() { 330 return PD_IDENTITY_MAPPER; 331 } 332 333 334 335 /** 336 * Get the "java-class" property definition. 337 * <p> 338 * Specifies the fully-qualified name of the Java class that 339 * provides the SASL mechanism handler implementation. 340 * 341 * @return Returns the "java-class" property definition. 342 */ 343 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 344 return PD_JAVA_CLASS; 345 } 346 347 348 349 /** 350 * Get the "kdc-address" property definition. 351 * <p> 352 * Specifies the address of the KDC that is to be used for Kerberos 353 * processing. 354 * <p> 355 * If provided, this property must be a fully-qualified 356 * DNS-resolvable name. If this property is not provided, then the 357 * server attempts to determine it from the system-wide Kerberos 358 * configuration. 359 * 360 * @return Returns the "kdc-address" property definition. 361 */ 362 public StringPropertyDefinition getKdcAddressPropertyDefinition() { 363 return PD_KDC_ADDRESS; 364 } 365 366 367 368 /** 369 * Get the "keytab" property definition. 370 * <p> 371 * Specifies the path to the keytab file that should be used for 372 * Kerberos processing. 373 * <p> 374 * If provided, this is either an absolute path or one that is 375 * relative to the server instance root. 376 * 377 * @return Returns the "keytab" property definition. 378 */ 379 public StringPropertyDefinition getKeytabPropertyDefinition() { 380 return PD_KEYTAB; 381 } 382 383 384 385 /** 386 * Get the "principal-name" property definition. 387 * <p> 388 * Specifies the principal name. 389 * <p> 390 * It can either be a simple user name or a service name such as 391 * host/example.com. If this property is not provided, then the 392 * server attempts to build the principal name by appending the fully 393 * qualified domain name to the string "ldap/". 394 * 395 * @return Returns the "principal-name" property definition. 396 */ 397 public StringPropertyDefinition getPrincipalNamePropertyDefinition() { 398 return PD_PRINCIPAL_NAME; 399 } 400 401 402 403 /** 404 * Get the "quality-of-protection" property definition. 405 * <p> 406 * The name of a property that specifies the quality of protection 407 * the server will support. 408 * 409 * @return Returns the "quality-of-protection" property definition. 410 */ 411 public EnumPropertyDefinition<QualityOfProtection> getQualityOfProtectionPropertyDefinition() { 412 return PD_QUALITY_OF_PROTECTION; 413 } 414 415 416 417 /** 418 * Get the "realm" property definition. 419 * <p> 420 * Specifies the realm to be used for GSSAPI authentication. 421 * 422 * @return Returns the "realm" property definition. 423 */ 424 public StringPropertyDefinition getRealmPropertyDefinition() { 425 return PD_REALM; 426 } 427 428 429 430 /** 431 * Get the "server-fqdn" property definition. 432 * <p> 433 * Specifies the DNS-resolvable fully-qualified domain name for the 434 * system. 435 * 436 * @return Returns the "server-fqdn" property definition. 437 */ 438 public StringPropertyDefinition getServerFqdnPropertyDefinition() { 439 return PD_SERVER_FQDN; 440 } 441 442 443 444 /** 445 * Managed object client implementation. 446 */ 447 private static class GSSAPISASLMechanismHandlerCfgClientImpl implements 448 GSSAPISASLMechanismHandlerCfgClient { 449 450 /** Private implementation. */ 451 private ManagedObject<? extends GSSAPISASLMechanismHandlerCfgClient> impl; 452 453 454 455 /** Private constructor. */ 456 private GSSAPISASLMechanismHandlerCfgClientImpl( 457 ManagedObject<? extends GSSAPISASLMechanismHandlerCfgClient> impl) { 458 this.impl = impl; 459 } 460 461 462 463 /** {@inheritDoc} */ 464 public Boolean isEnabled() { 465 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 466 } 467 468 469 470 /** {@inheritDoc} */ 471 public void setEnabled(boolean value) { 472 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 473 } 474 475 476 477 /** {@inheritDoc} */ 478 public String getIdentityMapper() { 479 return impl.getPropertyValue(INSTANCE.getIdentityMapperPropertyDefinition()); 480 } 481 482 483 484 /** {@inheritDoc} */ 485 public void setIdentityMapper(String value) { 486 impl.setPropertyValue(INSTANCE.getIdentityMapperPropertyDefinition(), value); 487 } 488 489 490 491 /** {@inheritDoc} */ 492 public String getJavaClass() { 493 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 494 } 495 496 497 498 /** {@inheritDoc} */ 499 public void setJavaClass(String value) { 500 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 501 } 502 503 504 505 /** {@inheritDoc} */ 506 public String getKdcAddress() { 507 return impl.getPropertyValue(INSTANCE.getKdcAddressPropertyDefinition()); 508 } 509 510 511 512 /** {@inheritDoc} */ 513 public void setKdcAddress(String value) { 514 impl.setPropertyValue(INSTANCE.getKdcAddressPropertyDefinition(), value); 515 } 516 517 518 519 /** {@inheritDoc} */ 520 public String getKeytab() { 521 return impl.getPropertyValue(INSTANCE.getKeytabPropertyDefinition()); 522 } 523 524 525 526 /** {@inheritDoc} */ 527 public void setKeytab(String value) { 528 impl.setPropertyValue(INSTANCE.getKeytabPropertyDefinition(), value); 529 } 530 531 532 533 /** {@inheritDoc} */ 534 public String getPrincipalName() { 535 return impl.getPropertyValue(INSTANCE.getPrincipalNamePropertyDefinition()); 536 } 537 538 539 540 /** {@inheritDoc} */ 541 public void setPrincipalName(String value) { 542 impl.setPropertyValue(INSTANCE.getPrincipalNamePropertyDefinition(), value); 543 } 544 545 546 547 /** {@inheritDoc} */ 548 public QualityOfProtection getQualityOfProtection() { 549 return impl.getPropertyValue(INSTANCE.getQualityOfProtectionPropertyDefinition()); 550 } 551 552 553 554 /** {@inheritDoc} */ 555 public void setQualityOfProtection(QualityOfProtection value) { 556 impl.setPropertyValue(INSTANCE.getQualityOfProtectionPropertyDefinition(), value); 557 } 558 559 560 561 /** {@inheritDoc} */ 562 public String getRealm() { 563 return impl.getPropertyValue(INSTANCE.getRealmPropertyDefinition()); 564 } 565 566 567 568 /** {@inheritDoc} */ 569 public void setRealm(String value) { 570 impl.setPropertyValue(INSTANCE.getRealmPropertyDefinition(), value); 571 } 572 573 574 575 /** {@inheritDoc} */ 576 public String getServerFqdn() { 577 return impl.getPropertyValue(INSTANCE.getServerFqdnPropertyDefinition()); 578 } 579 580 581 582 /** {@inheritDoc} */ 583 public void setServerFqdn(String value) { 584 impl.setPropertyValue(INSTANCE.getServerFqdnPropertyDefinition(), value); 585 } 586 587 588 589 /** {@inheritDoc} */ 590 public ManagedObjectDefinition<? extends GSSAPISASLMechanismHandlerCfgClient, ? extends GSSAPISASLMechanismHandlerCfg> definition() { 591 return INSTANCE; 592 } 593 594 595 596 /** {@inheritDoc} */ 597 public PropertyProvider properties() { 598 return impl; 599 } 600 601 602 603 /** {@inheritDoc} */ 604 public void commit() throws ManagedObjectAlreadyExistsException, 605 MissingMandatoryPropertiesException, ConcurrentModificationException, 606 OperationRejectedException, LdapException { 607 impl.commit(); 608 } 609 610 611 612 /** {@inheritDoc} */ 613 public String toString() { 614 return impl.toString(); 615 } 616 } 617 618 619 620 /** 621 * Managed object server implementation. 622 */ 623 private static class GSSAPISASLMechanismHandlerCfgServerImpl implements 624 GSSAPISASLMechanismHandlerCfg { 625 626 /** Private implementation. */ 627 private ServerManagedObject<? extends GSSAPISASLMechanismHandlerCfg> impl; 628 629 /** The value of the "enabled" property. */ 630 private final boolean pEnabled; 631 632 /** The value of the "identity-mapper" property. */ 633 private final String pIdentityMapper; 634 635 /** The value of the "java-class" property. */ 636 private final String pJavaClass; 637 638 /** The value of the "kdc-address" property. */ 639 private final String pKdcAddress; 640 641 /** The value of the "keytab" property. */ 642 private final String pKeytab; 643 644 /** The value of the "principal-name" property. */ 645 private final String pPrincipalName; 646 647 /** The value of the "quality-of-protection" property. */ 648 private final QualityOfProtection pQualityOfProtection; 649 650 /** The value of the "realm" property. */ 651 private final String pRealm; 652 653 /** The value of the "server-fqdn" property. */ 654 private final String pServerFqdn; 655 656 657 658 /** Private constructor. */ 659 private GSSAPISASLMechanismHandlerCfgServerImpl(ServerManagedObject<? extends GSSAPISASLMechanismHandlerCfg> impl) { 660 this.impl = impl; 661 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 662 this.pIdentityMapper = impl.getPropertyValue(INSTANCE.getIdentityMapperPropertyDefinition()); 663 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 664 this.pKdcAddress = impl.getPropertyValue(INSTANCE.getKdcAddressPropertyDefinition()); 665 this.pKeytab = impl.getPropertyValue(INSTANCE.getKeytabPropertyDefinition()); 666 this.pPrincipalName = impl.getPropertyValue(INSTANCE.getPrincipalNamePropertyDefinition()); 667 this.pQualityOfProtection = impl.getPropertyValue(INSTANCE.getQualityOfProtectionPropertyDefinition()); 668 this.pRealm = impl.getPropertyValue(INSTANCE.getRealmPropertyDefinition()); 669 this.pServerFqdn = impl.getPropertyValue(INSTANCE.getServerFqdnPropertyDefinition()); 670 } 671 672 673 674 /** {@inheritDoc} */ 675 public void addGSSAPIChangeListener( 676 ConfigurationChangeListener<GSSAPISASLMechanismHandlerCfg> listener) { 677 impl.registerChangeListener(listener); 678 } 679 680 681 682 /** {@inheritDoc} */ 683 public void removeGSSAPIChangeListener( 684 ConfigurationChangeListener<GSSAPISASLMechanismHandlerCfg> listener) { 685 impl.deregisterChangeListener(listener); 686 } 687 /** {@inheritDoc} */ 688 public void addChangeListener( 689 ConfigurationChangeListener<SASLMechanismHandlerCfg> listener) { 690 impl.registerChangeListener(listener); 691 } 692 693 694 695 /** {@inheritDoc} */ 696 public void removeChangeListener( 697 ConfigurationChangeListener<SASLMechanismHandlerCfg> listener) { 698 impl.deregisterChangeListener(listener); 699 } 700 701 702 703 /** {@inheritDoc} */ 704 public boolean isEnabled() { 705 return pEnabled; 706 } 707 708 709 710 /** {@inheritDoc} */ 711 public String getIdentityMapper() { 712 return pIdentityMapper; 713 } 714 715 716 717 /** 718 * {@inheritDoc} 719 */ 720 public DN getIdentityMapperDN() { 721 String value = getIdentityMapper(); 722 if (value == null) return null; 723 return INSTANCE.getIdentityMapperPropertyDefinition().getChildDN(value); 724 } 725 726 727 728 /** {@inheritDoc} */ 729 public String getJavaClass() { 730 return pJavaClass; 731 } 732 733 734 735 /** {@inheritDoc} */ 736 public String getKdcAddress() { 737 return pKdcAddress; 738 } 739 740 741 742 /** {@inheritDoc} */ 743 public String getKeytab() { 744 return pKeytab; 745 } 746 747 748 749 /** {@inheritDoc} */ 750 public String getPrincipalName() { 751 return pPrincipalName; 752 } 753 754 755 756 /** {@inheritDoc} */ 757 public QualityOfProtection getQualityOfProtection() { 758 return pQualityOfProtection; 759 } 760 761 762 763 /** {@inheritDoc} */ 764 public String getRealm() { 765 return pRealm; 766 } 767 768 769 770 /** {@inheritDoc} */ 771 public String getServerFqdn() { 772 return pServerFqdn; 773 } 774 775 776 777 /** {@inheritDoc} */ 778 public Class<? extends GSSAPISASLMechanismHandlerCfg> configurationClass() { 779 return GSSAPISASLMechanismHandlerCfg.class; 780 } 781 782 783 784 /** {@inheritDoc} */ 785 public DN dn() { 786 return impl.getDN(); 787 } 788 789 790 791 /** {@inheritDoc} */ 792 public String toString() { 793 return impl.toString(); 794 } 795 } 796}