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}