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 java.util.Collection;
021import java.util.SortedSet;
022import org.forgerock.opendj.config.AdministratorAction;
023import org.forgerock.opendj.config.AggregationPropertyDefinition;
024import org.forgerock.opendj.config.AliasDefaultBehaviorProvider;
025import org.forgerock.opendj.config.BooleanPropertyDefinition;
026import org.forgerock.opendj.config.client.ConcurrentModificationException;
027import org.forgerock.opendj.config.client.ManagedObject;
028import org.forgerock.opendj.config.client.MissingMandatoryPropertiesException;
029import org.forgerock.opendj.config.client.OperationRejectedException;
030import org.forgerock.opendj.config.conditions.Conditions;
031import org.forgerock.opendj.config.DefaultBehaviorProvider;
032import org.forgerock.opendj.config.DefinedDefaultBehaviorProvider;
033import org.forgerock.opendj.config.DurationPropertyDefinition;
034import org.forgerock.opendj.config.EnumPropertyDefinition;
035import org.forgerock.opendj.config.IntegerPropertyDefinition;
036import org.forgerock.opendj.config.ManagedObjectAlreadyExistsException;
037import org.forgerock.opendj.config.ManagedObjectDefinition;
038import org.forgerock.opendj.config.PropertyOption;
039import org.forgerock.opendj.config.PropertyProvider;
040import org.forgerock.opendj.config.server.ConfigurationChangeListener;
041import org.forgerock.opendj.config.server.ServerManagedObject;
042import org.forgerock.opendj.config.SizePropertyDefinition;
043import org.forgerock.opendj.config.StringPropertyDefinition;
044import org.forgerock.opendj.config.Tag;
045import org.forgerock.opendj.config.TopCfgDefn;
046import org.forgerock.opendj.config.UndefinedDefaultBehaviorProvider;
047import org.forgerock.opendj.ldap.DN;
048import org.forgerock.opendj.ldap.LdapException;
049import org.forgerock.opendj.server.config.client.GlobalCfgClient;
050import org.forgerock.opendj.server.config.client.IdentityMapperCfgClient;
051import org.forgerock.opendj.server.config.client.PasswordPolicyCfgClient;
052import org.forgerock.opendj.server.config.server.GlobalCfg;
053import org.forgerock.opendj.server.config.server.IdentityMapperCfg;
054import org.forgerock.opendj.server.config.server.PasswordPolicyCfg;
055
056
057
058/**
059 * An interface for querying the Global Configuration managed object
060 * definition meta information.
061 * <p>
062 * The Global Configuration contains properties that affect the
063 * overall operation of the OpenDJ.
064 */
065public final class GlobalCfgDefn extends ManagedObjectDefinition<GlobalCfgClient, GlobalCfg> {
066
067  /** The singleton configuration definition instance. */
068  private static final GlobalCfgDefn INSTANCE = new GlobalCfgDefn();
069
070
071
072  /**
073   * Defines the set of permissable values for the "disabled-privilege" property.
074   * <p>
075   * Specifies the name of a privilege that should not be evaluated by
076   * the server.
077   * <p>
078   * If a privilege is disabled, then it is assumed that all clients
079   * (including unauthenticated clients) have that privilege.
080   */
081  public static enum DisabledPrivilege {
082
083    /**
084     * Allows the user to request that the server process backup
085     * tasks.
086     */
087    BACKEND_BACKUP("backend-backup"),
088
089
090
091    /**
092     * Allows the user to request that the server process restore
093     * tasks.
094     */
095    BACKEND_RESTORE("backend-restore"),
096
097
098
099    /**
100     * Allows the associated user to bypass access control checks
101     * performed by the server.
102     */
103    BYPASS_ACL("bypass-acl"),
104
105
106
107    /**
108     * Allows the associated user to bypass server lockdown mode.
109     */
110    BYPASS_LOCKDOWN("bypass-lockdown"),
111
112
113
114    /**
115     * Allows the user to cancel operations in progress on other
116     * client connections.
117     */
118    CANCEL_REQUEST("cancel-request"),
119
120
121
122    /**
123     * The privilege that provides the ability to perform read
124     * operations on the changelog
125     */
126    CHANGELOG_READ("changelog-read"),
127
128
129
130    /**
131     * Allows the associated user to read the server configuration.
132     */
133    CONFIG_READ("config-read"),
134
135
136
137    /**
138     * Allows the associated user to update the server configuration.
139     * The config-read privilege is also required.
140     */
141    CONFIG_WRITE("config-write"),
142
143
144
145    /**
146     * Allows the user to participate in data synchronization.
147     */
148    DATA_SYNC("data-sync"),
149
150
151
152    /**
153     * Allows the user to terminate other client connections.
154     */
155    DISCONNECT_CLIENT("disconnect-client"),
156
157
158
159    /**
160     * Allows the associated user to subscribe to receive JMX
161     * notifications.
162     */
163    JMX_NOTIFY("jmx-notify"),
164
165
166
167    /**
168     * Allows the associated user to perform JMX read operations.
169     */
170    JMX_READ("jmx-read"),
171
172
173
174    /**
175     * Allows the associated user to perform JMX write operations.
176     */
177    JMX_WRITE("jmx-write"),
178
179
180
181    /**
182     * Allows the user to request that the server process LDIF export
183     * tasks.
184     */
185    LDIF_EXPORT("ldif-export"),
186
187
188
189    /**
190     * Allows the user to request that the server process LDIF import
191     * tasks.
192     */
193    LDIF_IMPORT("ldif-import"),
194
195
196
197    /**
198     * Allows the associated user to modify the server's access
199     * control configuration.
200     */
201    MODIFY_ACL("modify-acl"),
202
203
204
205    /**
206     * Allows the user to reset user passwords.
207     */
208    PASSWORD_RESET("password-reset"),
209
210
211
212    /**
213     * Allows the user to make changes to the set of defined root
214     * privileges, as well as to grant and revoke privileges for users.
215     */
216    PRIVILEGE_CHANGE("privilege-change"),
217
218
219
220    /**
221     * Allows the user to use the proxied authorization control, or to
222     * perform a bind that specifies an alternate authorization
223     * identity.
224     */
225    PROXIED_AUTH("proxied-auth"),
226
227
228
229    /**
230     * Allows the user to place and bring the server of lockdown mode.
231     */
232    SERVER_LOCKDOWN("server-lockdown"),
233
234
235
236    /**
237     * Allows the user to request that the server perform an in-core
238     * restart.
239     */
240    SERVER_RESTART("server-restart"),
241
242
243
244    /**
245     * Allows the user to request that the server shut down.
246     */
247    SERVER_SHUTDOWN("server-shutdown"),
248
249
250
251    /**
252     * Allows the associated user to perform LDAP subentry write
253     * operations.
254     */
255    SUBENTRY_WRITE("subentry-write"),
256
257
258
259    /**
260     * Allows the user to request that the server process a search
261     * that cannot be optimized using server indexes.
262     */
263    UNINDEXED_SEARCH("unindexed-search"),
264
265
266
267    /**
268     * Allows the user to make changes to the server schema.
269     */
270    UPDATE_SCHEMA("update-schema");
271
272
273
274    /** String representation of the value. */
275    private final String name;
276
277
278
279    /** Private constructor. */
280    private DisabledPrivilege(String name) { this.name = name; }
281
282
283
284    /** {@inheritDoc} */
285    public String toString() { return name; }
286
287  }
288
289
290
291  /**
292   * Defines the set of permissable values for the "etime-resolution" property.
293   * <p>
294   * Specifies the resolution to use for operation elapsed processing
295   * time (etime) measurements.
296   */
297  public static enum EtimeResolution {
298
299    /**
300     * Use millisecond resolution.
301     */
302    MILLISECONDS("milliseconds"),
303
304
305
306    /**
307     * Use nanosecond resolution.
308     */
309    NANOSECONDS("nanoseconds");
310
311
312
313    /** String representation of the value. */
314    private final String name;
315
316
317
318    /** Private constructor. */
319    private EtimeResolution(String name) { this.name = name; }
320
321
322
323    /** {@inheritDoc} */
324    public String toString() { return name; }
325
326  }
327
328
329
330  /**
331   * Defines the set of permissable values for the "invalid-attribute-syntax-behavior" property.
332   * <p>
333   * Specifies how the directory server should handle operations
334   * whenever an attribute value violates the associated attribute
335   * syntax.
336   */
337  public static enum InvalidAttributeSyntaxBehavior {
338
339    /**
340     * The directory server silently accepts attribute values that are
341     * invalid according to their associated syntax. Matching
342     * operations targeting those values may not behave as expected.
343     */
344    ACCEPT("accept"),
345
346
347
348    /**
349     * The directory server rejects attribute values that are invalid
350     * according to their associated syntax.
351     */
352    REJECT("reject"),
353
354
355
356    /**
357     * The directory server accepts attribute values that are invalid
358     * according to their associated syntax, but also logs a warning
359     * message to the error log. Matching operations targeting those
360     * values may not behave as expected.
361     */
362    WARN("warn");
363
364
365
366    /** String representation of the value. */
367    private final String name;
368
369
370
371    /** Private constructor. */
372    private InvalidAttributeSyntaxBehavior(String name) { this.name = name; }
373
374
375
376    /** {@inheritDoc} */
377    public String toString() { return name; }
378
379  }
380
381
382
383  /**
384   * Defines the set of permissable values for the "single-structural-objectclass-behavior" property.
385   * <p>
386   * Specifies how the directory server should handle operations an
387   * entry does not contain a structural object class or contains
388   * multiple structural classes.
389   */
390  public static enum SingleStructuralObjectclassBehavior {
391
392    /**
393     * The directory server silently accepts entries that do not
394     * contain exactly one structural object class. Certain schema
395     * features that depend on the entry's structural class may not
396     * behave as expected.
397     */
398    ACCEPT("accept"),
399
400
401
402    /**
403     * The directory server rejects entries that do not contain
404     * exactly one structural object class.
405     */
406    REJECT("reject"),
407
408
409
410    /**
411     * The directory server accepts entries that do not contain
412     * exactly one structural object class, but also logs a warning
413     * message to the error log. Certain schema features that depend on
414     * the entry's structural class may not behave as expected.
415     */
416    WARN("warn");
417
418
419
420    /** String representation of the value. */
421    private final String name;
422
423
424
425    /** Private constructor. */
426    private SingleStructuralObjectclassBehavior(String name) { this.name = name; }
427
428
429
430    /** {@inheritDoc} */
431    public String toString() { return name; }
432
433  }
434
435
436
437  /**
438   * Defines the set of permissable values for the "writability-mode" property.
439   * <p>
440   * Specifies the kinds of write operations the directory server can
441   * process.
442   */
443  public static enum WritabilityMode {
444
445    /**
446     * The directory server rejects all write operations that are
447     * requested of it, regardless of their origin.
448     */
449    DISABLED("disabled"),
450
451
452
453    /**
454     * The directory server attempts to process all write operations
455     * that are requested of it, regardless of their origin.
456     */
457    ENABLED("enabled"),
458
459
460
461    /**
462     * The directory server attempts to process write operations
463     * requested as internal operations or through synchronization, but
464     * rejects any such operations requested from external clients.
465     */
466    INTERNAL_ONLY("internal-only");
467
468
469
470    /** String representation of the value. */
471    private final String name;
472
473
474
475    /** Private constructor. */
476    private WritabilityMode(String name) { this.name = name; }
477
478
479
480    /** {@inheritDoc} */
481    public String toString() { return name; }
482
483  }
484
485
486
487  /** The "add-missing-rdn-attributes" property definition. */
488  private static final BooleanPropertyDefinition PD_ADD_MISSING_RDN_ATTRIBUTES;
489
490
491
492  /** The "allow-attribute-name-exceptions" property definition. */
493  private static final BooleanPropertyDefinition PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS;
494
495
496
497  /** The "allowed-task" property definition. */
498  private static final StringPropertyDefinition PD_ALLOWED_TASK;
499
500
501
502  /** The "bind-with-dn-requires-password" property definition. */
503  private static final BooleanPropertyDefinition PD_BIND_WITH_DN_REQUIRES_PASSWORD;
504
505
506
507  /** The "check-schema" property definition. */
508  private static final BooleanPropertyDefinition PD_CHECK_SCHEMA;
509
510
511
512  /** The "default-password-policy" property definition. */
513  private static final AggregationPropertyDefinition<PasswordPolicyCfgClient, PasswordPolicyCfg> PD_DEFAULT_PASSWORD_POLICY;
514
515
516
517  /** The "disabled-privilege" property definition. */
518  private static final EnumPropertyDefinition<DisabledPrivilege> PD_DISABLED_PRIVILEGE;
519
520
521
522  /** The "etime-resolution" property definition. */
523  private static final EnumPropertyDefinition<EtimeResolution> PD_ETIME_RESOLUTION;
524
525
526
527  /** The "idle-time-limit" property definition. */
528  private static final DurationPropertyDefinition PD_IDLE_TIME_LIMIT;
529
530
531
532  /** The "invalid-attribute-syntax-behavior" property definition. */
533  private static final EnumPropertyDefinition<InvalidAttributeSyntaxBehavior> PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR;
534
535
536
537  /** The "lookthrough-limit" property definition. */
538  private static final IntegerPropertyDefinition PD_LOOKTHROUGH_LIMIT;
539
540
541
542  /** The "max-allowed-client-connections" property definition. */
543  private static final IntegerPropertyDefinition PD_MAX_ALLOWED_CLIENT_CONNECTIONS;
544
545
546
547  /** The "max-internal-buffer-size" property definition. */
548  private static final SizePropertyDefinition PD_MAX_INTERNAL_BUFFER_SIZE;
549
550
551
552  /** The "max-psearches" property definition. */
553  private static final IntegerPropertyDefinition PD_MAX_PSEARCHES;
554
555
556
557  /** The "notify-abandoned-operations" property definition. */
558  private static final BooleanPropertyDefinition PD_NOTIFY_ABANDONED_OPERATIONS;
559
560
561
562  /** The "proxied-authorization-identity-mapper" property definition. */
563  private static final AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER;
564
565
566
567  /** The "reject-unauthenticated-requests" property definition. */
568  private static final BooleanPropertyDefinition PD_REJECT_UNAUTHENTICATED_REQUESTS;
569
570
571
572  /** The "return-bind-error-messages" property definition. */
573  private static final BooleanPropertyDefinition PD_RETURN_BIND_ERROR_MESSAGES;
574
575
576
577  /** The "save-config-on-successful-startup" property definition. */
578  private static final BooleanPropertyDefinition PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP;
579
580
581
582  /** The "server-error-result-code" property definition. */
583  private static final IntegerPropertyDefinition PD_SERVER_ERROR_RESULT_CODE;
584
585
586
587  /** The "single-structural-objectclass-behavior" property definition. */
588  private static final EnumPropertyDefinition<SingleStructuralObjectclassBehavior> PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR;
589
590
591
592  /** The "size-limit" property definition. */
593  private static final IntegerPropertyDefinition PD_SIZE_LIMIT;
594
595
596
597  /** The "smtp-server" property definition. */
598  private static final StringPropertyDefinition PD_SMTP_SERVER;
599
600
601
602  /** The "time-limit" property definition. */
603  private static final DurationPropertyDefinition PD_TIME_LIMIT;
604
605
606
607  /** The "trust-transaction-ids" property definition. */
608  private static final BooleanPropertyDefinition PD_TRUST_TRANSACTION_IDS;
609
610
611
612  /** The "writability-mode" property definition. */
613  private static final EnumPropertyDefinition<WritabilityMode> PD_WRITABILITY_MODE;
614
615
616
617  /** Build the "add-missing-rdn-attributes" property definition. */
618  static {
619      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "add-missing-rdn-attributes");
620      builder.setOption(PropertyOption.ADVANCED);
621      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "add-missing-rdn-attributes"));
622      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
623      builder.setDefaultBehaviorProvider(provider);
624      PD_ADD_MISSING_RDN_ATTRIBUTES = builder.getInstance();
625      INSTANCE.registerPropertyDefinition(PD_ADD_MISSING_RDN_ATTRIBUTES);
626  }
627
628
629
630  /** Build the "allow-attribute-name-exceptions" property definition. */
631  static {
632      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "allow-attribute-name-exceptions");
633      builder.setOption(PropertyOption.ADVANCED);
634      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allow-attribute-name-exceptions"));
635      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
636      builder.setDefaultBehaviorProvider(provider);
637      PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS = builder.getInstance();
638      INSTANCE.registerPropertyDefinition(PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS);
639  }
640
641
642
643  /** Build the "allowed-task" property definition. */
644  static {
645      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "allowed-task");
646      builder.setOption(PropertyOption.MULTI_VALUED);
647      builder.setOption(PropertyOption.ADVANCED);
648      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allowed-task"));
649      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "allowed-task"));
650      PD_ALLOWED_TASK = builder.getInstance();
651      INSTANCE.registerPropertyDefinition(PD_ALLOWED_TASK);
652  }
653
654
655
656  /** Build the "bind-with-dn-requires-password" property definition. */
657  static {
658      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "bind-with-dn-requires-password");
659      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "bind-with-dn-requires-password"));
660      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
661      builder.setDefaultBehaviorProvider(provider);
662      PD_BIND_WITH_DN_REQUIRES_PASSWORD = builder.getInstance();
663      INSTANCE.registerPropertyDefinition(PD_BIND_WITH_DN_REQUIRES_PASSWORD);
664  }
665
666
667
668  /** Build the "check-schema" property definition. */
669  static {
670      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "check-schema");
671      builder.setOption(PropertyOption.ADVANCED);
672      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "check-schema"));
673      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
674      builder.setDefaultBehaviorProvider(provider);
675      PD_CHECK_SCHEMA = builder.getInstance();
676      INSTANCE.registerPropertyDefinition(PD_CHECK_SCHEMA);
677  }
678
679
680
681  /** Build the "default-password-policy" property definition. */
682  static {
683      AggregationPropertyDefinition.Builder<PasswordPolicyCfgClient, PasswordPolicyCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "default-password-policy");
684      builder.setOption(PropertyOption.MANDATORY);
685      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "default-password-policy"));
686      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
687      builder.setParentPath("/");
688      builder.setRelationDefinition("password-policy");
689      PD_DEFAULT_PASSWORD_POLICY = builder.getInstance();
690      INSTANCE.registerPropertyDefinition(PD_DEFAULT_PASSWORD_POLICY);
691      INSTANCE.registerConstraint(PD_DEFAULT_PASSWORD_POLICY.getSourceConstraint());
692  }
693
694
695
696  /** Build the "disabled-privilege" property definition. */
697  static {
698      EnumPropertyDefinition.Builder<DisabledPrivilege> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "disabled-privilege");
699      builder.setOption(PropertyOption.MULTI_VALUED);
700      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disabled-privilege"));
701      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<DisabledPrivilege>(INSTANCE, "disabled-privilege"));
702      builder.setEnumClass(DisabledPrivilege.class);
703      PD_DISABLED_PRIVILEGE = builder.getInstance();
704      INSTANCE.registerPropertyDefinition(PD_DISABLED_PRIVILEGE);
705  }
706
707
708
709  /** Build the "etime-resolution" property definition. */
710  static {
711      EnumPropertyDefinition.Builder<EtimeResolution> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "etime-resolution");
712      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "etime-resolution"));
713      DefaultBehaviorProvider<EtimeResolution> provider = new DefinedDefaultBehaviorProvider<EtimeResolution>("milliseconds");
714      builder.setDefaultBehaviorProvider(provider);
715      builder.setEnumClass(EtimeResolution.class);
716      PD_ETIME_RESOLUTION = builder.getInstance();
717      INSTANCE.registerPropertyDefinition(PD_ETIME_RESOLUTION);
718  }
719
720
721
722  /** Build the "idle-time-limit" property definition. */
723  static {
724      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "idle-time-limit");
725      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "idle-time-limit"));
726      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("0 seconds");
727      builder.setDefaultBehaviorProvider(provider);
728      builder.setBaseUnit("ms");
729      builder.setLowerLimit("0");
730      PD_IDLE_TIME_LIMIT = builder.getInstance();
731      INSTANCE.registerPropertyDefinition(PD_IDLE_TIME_LIMIT);
732  }
733
734
735
736  /** Build the "invalid-attribute-syntax-behavior" property definition. */
737  static {
738      EnumPropertyDefinition.Builder<InvalidAttributeSyntaxBehavior> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "invalid-attribute-syntax-behavior");
739      builder.setOption(PropertyOption.ADVANCED);
740      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "invalid-attribute-syntax-behavior"));
741      DefaultBehaviorProvider<InvalidAttributeSyntaxBehavior> provider = new DefinedDefaultBehaviorProvider<InvalidAttributeSyntaxBehavior>("reject");
742      builder.setDefaultBehaviorProvider(provider);
743      builder.setEnumClass(InvalidAttributeSyntaxBehavior.class);
744      PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR = builder.getInstance();
745      INSTANCE.registerPropertyDefinition(PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR);
746  }
747
748
749
750  /** Build the "lookthrough-limit" property definition. */
751  static {
752      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "lookthrough-limit");
753      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "lookthrough-limit"));
754      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("5000");
755      builder.setDefaultBehaviorProvider(provider);
756      builder.setLowerLimit(0);
757      PD_LOOKTHROUGH_LIMIT = builder.getInstance();
758      INSTANCE.registerPropertyDefinition(PD_LOOKTHROUGH_LIMIT);
759  }
760
761
762
763  /** Build the "max-allowed-client-connections" property definition. */
764  static {
765      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-allowed-client-connections");
766      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-allowed-client-connections"));
767      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("0");
768      builder.setDefaultBehaviorProvider(provider);
769      builder.setLowerLimit(0);
770      PD_MAX_ALLOWED_CLIENT_CONNECTIONS = builder.getInstance();
771      INSTANCE.registerPropertyDefinition(PD_MAX_ALLOWED_CLIENT_CONNECTIONS);
772  }
773
774
775
776  /** Build the "max-internal-buffer-size" property definition. */
777  static {
778      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "max-internal-buffer-size");
779      builder.setOption(PropertyOption.ADVANCED);
780      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-internal-buffer-size"));
781      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("32 KB");
782      builder.setDefaultBehaviorProvider(provider);
783      builder.setUpperLimit("1 GB");
784      builder.setLowerLimit("512 B");
785      PD_MAX_INTERNAL_BUFFER_SIZE = builder.getInstance();
786      INSTANCE.registerPropertyDefinition(PD_MAX_INTERNAL_BUFFER_SIZE);
787  }
788
789
790
791  /** Build the "max-psearches" property definition. */
792  static {
793      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "max-psearches");
794      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-psearches"));
795      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("-1");
796      builder.setDefaultBehaviorProvider(provider);
797      builder.setAllowUnlimited(true);
798      builder.setLowerLimit(0);
799      PD_MAX_PSEARCHES = builder.getInstance();
800      INSTANCE.registerPropertyDefinition(PD_MAX_PSEARCHES);
801  }
802
803
804
805  /** Build the "notify-abandoned-operations" property definition. */
806  static {
807      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "notify-abandoned-operations");
808      builder.setOption(PropertyOption.ADVANCED);
809      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "notify-abandoned-operations"));
810      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
811      builder.setDefaultBehaviorProvider(provider);
812      PD_NOTIFY_ABANDONED_OPERATIONS = builder.getInstance();
813      INSTANCE.registerPropertyDefinition(PD_NOTIFY_ABANDONED_OPERATIONS);
814  }
815
816
817
818  /** Build the "proxied-authorization-identity-mapper" property definition. */
819  static {
820      AggregationPropertyDefinition.Builder<IdentityMapperCfgClient, IdentityMapperCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "proxied-authorization-identity-mapper");
821      builder.setOption(PropertyOption.MANDATORY);
822      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "proxied-authorization-identity-mapper"));
823      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>());
824      builder.setParentPath("/");
825      builder.setRelationDefinition("identity-mapper");
826      builder.setTargetIsEnabledCondition(Conditions.contains("enabled", "true"));
827      PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER = builder.getInstance();
828      INSTANCE.registerPropertyDefinition(PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER);
829      INSTANCE.registerConstraint(PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER.getSourceConstraint());
830  }
831
832
833
834  /** Build the "reject-unauthenticated-requests" property definition. */
835  static {
836      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "reject-unauthenticated-requests");
837      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "reject-unauthenticated-requests"));
838      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
839      builder.setDefaultBehaviorProvider(provider);
840      PD_REJECT_UNAUTHENTICATED_REQUESTS = builder.getInstance();
841      INSTANCE.registerPropertyDefinition(PD_REJECT_UNAUTHENTICATED_REQUESTS);
842  }
843
844
845
846  /** Build the "return-bind-error-messages" property definition. */
847  static {
848      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "return-bind-error-messages");
849      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "return-bind-error-messages"));
850      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
851      builder.setDefaultBehaviorProvider(provider);
852      PD_RETURN_BIND_ERROR_MESSAGES = builder.getInstance();
853      INSTANCE.registerPropertyDefinition(PD_RETURN_BIND_ERROR_MESSAGES);
854  }
855
856
857
858  /** Build the "save-config-on-successful-startup" property definition. */
859  static {
860      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "save-config-on-successful-startup");
861      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "save-config-on-successful-startup"));
862      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true");
863      builder.setDefaultBehaviorProvider(provider);
864      PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP = builder.getInstance();
865      INSTANCE.registerPropertyDefinition(PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP);
866  }
867
868
869
870  /** Build the "server-error-result-code" property definition. */
871  static {
872      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "server-error-result-code");
873      builder.setOption(PropertyOption.ADVANCED);
874      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "server-error-result-code"));
875      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("80");
876      builder.setDefaultBehaviorProvider(provider);
877      builder.setLowerLimit(0);
878      PD_SERVER_ERROR_RESULT_CODE = builder.getInstance();
879      INSTANCE.registerPropertyDefinition(PD_SERVER_ERROR_RESULT_CODE);
880  }
881
882
883
884  /** Build the "single-structural-objectclass-behavior" property definition. */
885  static {
886      EnumPropertyDefinition.Builder<SingleStructuralObjectclassBehavior> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "single-structural-objectclass-behavior");
887      builder.setOption(PropertyOption.ADVANCED);
888      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "single-structural-objectclass-behavior"));
889      DefaultBehaviorProvider<SingleStructuralObjectclassBehavior> provider = new DefinedDefaultBehaviorProvider<SingleStructuralObjectclassBehavior>("reject");
890      builder.setDefaultBehaviorProvider(provider);
891      builder.setEnumClass(SingleStructuralObjectclassBehavior.class);
892      PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR = builder.getInstance();
893      INSTANCE.registerPropertyDefinition(PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR);
894  }
895
896
897
898  /** Build the "size-limit" property definition. */
899  static {
900      IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "size-limit");
901      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "size-limit"));
902      DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("1000");
903      builder.setDefaultBehaviorProvider(provider);
904      builder.setLowerLimit(0);
905      PD_SIZE_LIMIT = builder.getInstance();
906      INSTANCE.registerPropertyDefinition(PD_SIZE_LIMIT);
907  }
908
909
910
911  /** Build the "smtp-server" property definition. */
912  static {
913      StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "smtp-server");
914      builder.setOption(PropertyOption.MULTI_VALUED);
915      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "smtp-server"));
916      builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "smtp-server"));
917      builder.setPattern("^.+(:[0-9]+)?$", "HOST[:PORT]");
918      PD_SMTP_SERVER = builder.getInstance();
919      INSTANCE.registerPropertyDefinition(PD_SMTP_SERVER);
920  }
921
922
923
924  /** Build the "time-limit" property definition. */
925  static {
926      DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "time-limit");
927      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "time-limit"));
928      DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("60 seconds");
929      builder.setDefaultBehaviorProvider(provider);
930      builder.setBaseUnit("s");
931      builder.setLowerLimit("0");
932      PD_TIME_LIMIT = builder.getInstance();
933      INSTANCE.registerPropertyDefinition(PD_TIME_LIMIT);
934  }
935
936
937
938  /** Build the "trust-transaction-ids" property definition. */
939  static {
940      BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "trust-transaction-ids");
941      builder.setOption(PropertyOption.ADVANCED);
942      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "trust-transaction-ids"));
943      DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false");
944      builder.setDefaultBehaviorProvider(provider);
945      PD_TRUST_TRANSACTION_IDS = builder.getInstance();
946      INSTANCE.registerPropertyDefinition(PD_TRUST_TRANSACTION_IDS);
947  }
948
949
950
951  /** Build the "writability-mode" property definition. */
952  static {
953      EnumPropertyDefinition.Builder<WritabilityMode> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "writability-mode");
954      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "writability-mode"));
955      DefaultBehaviorProvider<WritabilityMode> provider = new DefinedDefaultBehaviorProvider<WritabilityMode>("enabled");
956      builder.setDefaultBehaviorProvider(provider);
957      builder.setEnumClass(WritabilityMode.class);
958      PD_WRITABILITY_MODE = builder.getInstance();
959      INSTANCE.registerPropertyDefinition(PD_WRITABILITY_MODE);
960  }
961
962
963
964  // Register the tags associated with this managed object definition.
965  static {
966    INSTANCE.registerTag(Tag.valueOf("core-server"));
967  }
968
969
970
971  /**
972   * Get the Global Configuration configuration definition singleton.
973   *
974   * @return Returns the Global Configuration configuration definition
975   *         singleton.
976   */
977  public static GlobalCfgDefn getInstance() {
978    return INSTANCE;
979  }
980
981
982
983  /**
984   * Private constructor.
985   */
986  private GlobalCfgDefn() {
987    super("global", TopCfgDefn.getInstance());
988  }
989
990
991
992  /** {@inheritDoc} */
993  public GlobalCfgClient createClientConfiguration(
994      ManagedObject<? extends GlobalCfgClient> impl) {
995    return new GlobalCfgClientImpl(impl);
996  }
997
998
999
1000  /** {@inheritDoc} */
1001  public GlobalCfg createServerConfiguration(
1002      ServerManagedObject<? extends GlobalCfg> impl) {
1003    return new GlobalCfgServerImpl(impl);
1004  }
1005
1006
1007
1008  /** {@inheritDoc} */
1009  public Class<GlobalCfg> getServerConfigurationClass() {
1010    return GlobalCfg.class;
1011  }
1012
1013
1014
1015  /**
1016   * Get the "add-missing-rdn-attributes" property definition.
1017   * <p>
1018   * Indicates whether the directory server should automatically add
1019   * any attribute values contained in the entry's RDN into that entry
1020   * when processing an add request.
1021   *
1022   * @return Returns the "add-missing-rdn-attributes" property definition.
1023   */
1024  public BooleanPropertyDefinition getAddMissingRDNAttributesPropertyDefinition() {
1025    return PD_ADD_MISSING_RDN_ATTRIBUTES;
1026  }
1027
1028
1029
1030  /**
1031   * Get the "allow-attribute-name-exceptions" property definition.
1032   * <p>
1033   * Indicates whether the directory server should allow underscores
1034   * in attribute names and allow attribute names to begin with numeric
1035   * digits (both of which are violations of the LDAP standards).
1036   *
1037   * @return Returns the "allow-attribute-name-exceptions" property definition.
1038   */
1039  public BooleanPropertyDefinition getAllowAttributeNameExceptionsPropertyDefinition() {
1040    return PD_ALLOW_ATTRIBUTE_NAME_EXCEPTIONS;
1041  }
1042
1043
1044
1045  /**
1046   * Get the "allowed-task" property definition.
1047   * <p>
1048   * Specifies the fully-qualified name of a Java class that may be
1049   * invoked in the server.
1050   * <p>
1051   * Any attempt to invoke a task not included in the list of allowed
1052   * tasks is rejected.
1053   *
1054   * @return Returns the "allowed-task" property definition.
1055   */
1056  public StringPropertyDefinition getAllowedTaskPropertyDefinition() {
1057    return PD_ALLOWED_TASK;
1058  }
1059
1060
1061
1062  /**
1063   * Get the "bind-with-dn-requires-password" property definition.
1064   * <p>
1065   * Indicates whether the directory server should reject any simple
1066   * bind request that contains a DN but no password.
1067   * <p>
1068   * Although such bind requests are technically allowed by the LDAPv3
1069   * specification (and should be treated as anonymous simple
1070   * authentication), they may introduce security problems in
1071   * applications that do not verify that the client actually provided
1072   * a password.
1073   *
1074   * @return Returns the "bind-with-dn-requires-password" property definition.
1075   */
1076  public BooleanPropertyDefinition getBindWithDNRequiresPasswordPropertyDefinition() {
1077    return PD_BIND_WITH_DN_REQUIRES_PASSWORD;
1078  }
1079
1080
1081
1082  /**
1083   * Get the "check-schema" property definition.
1084   * <p>
1085   * Indicates whether schema enforcement is active.
1086   * <p>
1087   * When schema enforcement is activated, the directory server
1088   * ensures that all operations result in entries are valid according
1089   * to the defined server schema. It is strongly recommended that this
1090   * option be left enabled to prevent the inadvertent addition of
1091   * invalid data into the server.
1092   *
1093   * @return Returns the "check-schema" property definition.
1094   */
1095  public BooleanPropertyDefinition getCheckSchemaPropertyDefinition() {
1096    return PD_CHECK_SCHEMA;
1097  }
1098
1099
1100
1101  /**
1102   * Get the "default-password-policy" property definition.
1103   * <p>
1104   * Specifies the name of the password policy that is in effect for
1105   * users whose entries do not specify an alternate password policy
1106   * (either via a real or virtual attribute).
1107   * <p>
1108   * In addition, the default password policy will be used for
1109   * providing default parameters for sub-entry based password policies
1110   * when not provided or supported by the sub-entry itself. This
1111   * property must reference a password policy and no other type of
1112   * authentication policy.
1113   *
1114   * @return Returns the "default-password-policy" property definition.
1115   */
1116  public AggregationPropertyDefinition<PasswordPolicyCfgClient, PasswordPolicyCfg> getDefaultPasswordPolicyPropertyDefinition() {
1117    return PD_DEFAULT_PASSWORD_POLICY;
1118  }
1119
1120
1121
1122  /**
1123   * Get the "disabled-privilege" property definition.
1124   * <p>
1125   * Specifies the name of a privilege that should not be evaluated by
1126   * the server.
1127   * <p>
1128   * If a privilege is disabled, then it is assumed that all clients
1129   * (including unauthenticated clients) have that privilege.
1130   *
1131   * @return Returns the "disabled-privilege" property definition.
1132   */
1133  public EnumPropertyDefinition<DisabledPrivilege> getDisabledPrivilegePropertyDefinition() {
1134    return PD_DISABLED_PRIVILEGE;
1135  }
1136
1137
1138
1139  /**
1140   * Get the "etime-resolution" property definition.
1141   * <p>
1142   * Specifies the resolution to use for operation elapsed processing
1143   * time (etime) measurements.
1144   *
1145   * @return Returns the "etime-resolution" property definition.
1146   */
1147  public EnumPropertyDefinition<EtimeResolution> getEtimeResolutionPropertyDefinition() {
1148    return PD_ETIME_RESOLUTION;
1149  }
1150
1151
1152
1153  /**
1154   * Get the "idle-time-limit" property definition.
1155   * <p>
1156   * Specifies the maximum length of time that a client connection may
1157   * remain established since its last completed operation.
1158   * <p>
1159   * A value of "0 seconds" indicates that no idle time limit is
1160   * enforced.
1161   *
1162   * @return Returns the "idle-time-limit" property definition.
1163   */
1164  public DurationPropertyDefinition getIdleTimeLimitPropertyDefinition() {
1165    return PD_IDLE_TIME_LIMIT;
1166  }
1167
1168
1169
1170  /**
1171   * Get the "invalid-attribute-syntax-behavior" property definition.
1172   * <p>
1173   * Specifies how the directory server should handle operations
1174   * whenever an attribute value violates the associated attribute
1175   * syntax.
1176   *
1177   * @return Returns the "invalid-attribute-syntax-behavior" property definition.
1178   */
1179  public EnumPropertyDefinition<InvalidAttributeSyntaxBehavior> getInvalidAttributeSyntaxBehaviorPropertyDefinition() {
1180    return PD_INVALID_ATTRIBUTE_SYNTAX_BEHAVIOR;
1181  }
1182
1183
1184
1185  /**
1186   * Get the "lookthrough-limit" property definition.
1187   * <p>
1188   * Specifies the maximum number of entries that the directory server
1189   * should "look through" in the course of processing a search
1190   * request.
1191   * <p>
1192   * This includes any entry that the server must examine in the
1193   * course of processing the request, regardless of whether it
1194   * actually matches the search criteria. A value of 0 indicates that
1195   * no lookthrough limit is enforced. Note that this is the default
1196   * server-wide limit, but it may be overridden on a per-user basis
1197   * using the ds-rlim-lookthrough-limit operational attribute.
1198   *
1199   * @return Returns the "lookthrough-limit" property definition.
1200   */
1201  public IntegerPropertyDefinition getLookthroughLimitPropertyDefinition() {
1202    return PD_LOOKTHROUGH_LIMIT;
1203  }
1204
1205
1206
1207  /**
1208   * Get the "max-allowed-client-connections" property definition.
1209   * <p>
1210   * Specifies the maximum number of client connections that may be
1211   * established at any given time
1212   * <p>
1213   * A value of 0 indicates that unlimited client connection is
1214   * allowed.
1215   *
1216   * @return Returns the "max-allowed-client-connections" property definition.
1217   */
1218  public IntegerPropertyDefinition getMaxAllowedClientConnectionsPropertyDefinition() {
1219    return PD_MAX_ALLOWED_CLIENT_CONNECTIONS;
1220  }
1221
1222
1223
1224  /**
1225   * Get the "max-internal-buffer-size" property definition.
1226   * <p>
1227   * The threshold capacity beyond which internal cached buffers used
1228   * for encoding and decoding entries and protocol messages will be
1229   * trimmed after use.
1230   * <p>
1231   * Individual buffers may grow very large when encoding and decoding
1232   * large entries and protocol messages and should be reduced in size
1233   * when they are no longer needed. This setting specifies the
1234   * threshold at which a buffer is determined to have grown too big
1235   * and should be trimmed down after use.
1236   *
1237   * @return Returns the "max-internal-buffer-size" property definition.
1238   */
1239  public SizePropertyDefinition getMaxInternalBufferSizePropertyDefinition() {
1240    return PD_MAX_INTERNAL_BUFFER_SIZE;
1241  }
1242
1243
1244
1245  /**
1246   * Get the "max-psearches" property definition.
1247   * <p>
1248   * Defines the maximum number of concurrent persistent searches that
1249   * can be performed on directory server
1250   * <p>
1251   * The persistent search mechanism provides an active channel
1252   * through which entries that change, and information about the
1253   * changes that occur, can be communicated. Because each persistent
1254   * search operation consumes resources, limiting the number of
1255   * simultaneous persistent searches keeps the performance impact
1256   * minimal. A value of -1 indicates that there is no limit on the
1257   * persistent searches.
1258   *
1259   * @return Returns the "max-psearches" property definition.
1260   */
1261  public IntegerPropertyDefinition getMaxPsearchesPropertyDefinition() {
1262    return PD_MAX_PSEARCHES;
1263  }
1264
1265
1266
1267  /**
1268   * Get the "notify-abandoned-operations" property definition.
1269   * <p>
1270   * Indicates whether the directory server should send a response to
1271   * any operation that is interrupted via an abandon request.
1272   * <p>
1273   * The LDAP specification states that abandoned operations should
1274   * not receive any response, but this may cause problems with client
1275   * applications that always expect to receive a response to each
1276   * request.
1277   *
1278   * @return Returns the "notify-abandoned-operations" property definition.
1279   */
1280  public BooleanPropertyDefinition getNotifyAbandonedOperationsPropertyDefinition() {
1281    return PD_NOTIFY_ABANDONED_OPERATIONS;
1282  }
1283
1284
1285
1286  /**
1287   * Get the "proxied-authorization-identity-mapper" property definition.
1288   * <p>
1289   * Specifies the name of the identity mapper to map authorization ID
1290   * values (using the "u:" form) provided in the proxied authorization
1291   * control to the corresponding user entry.
1292   *
1293   * @return Returns the "proxied-authorization-identity-mapper" property definition.
1294   */
1295  public AggregationPropertyDefinition<IdentityMapperCfgClient, IdentityMapperCfg> getProxiedAuthorizationIdentityMapperPropertyDefinition() {
1296    return PD_PROXIED_AUTHORIZATION_IDENTITY_MAPPER;
1297  }
1298
1299
1300
1301  /**
1302   * Get the "reject-unauthenticated-requests" property definition.
1303   * <p>
1304   * Indicates whether the directory server should reject any request
1305   * (other than bind or StartTLS requests) received from a client that
1306   * has not yet been authenticated, whose last authentication attempt
1307   * was unsuccessful, or whose last authentication attempt used
1308   * anonymous authentication.
1309   *
1310   * @return Returns the "reject-unauthenticated-requests" property definition.
1311   */
1312  public BooleanPropertyDefinition getRejectUnauthenticatedRequestsPropertyDefinition() {
1313    return PD_REJECT_UNAUTHENTICATED_REQUESTS;
1314  }
1315
1316
1317
1318  /**
1319   * Get the "return-bind-error-messages" property definition.
1320   * <p>
1321   * Indicates whether responses for failed bind operations should
1322   * include a message string providing the reason for the
1323   * authentication failure.
1324   * <p>
1325   * Note that these messages may include information that could
1326   * potentially be used by an attacker. If this option is disabled,
1327   * then these messages appears only in the server's access log.
1328   *
1329   * @return Returns the "return-bind-error-messages" property definition.
1330   */
1331  public BooleanPropertyDefinition getReturnBindErrorMessagesPropertyDefinition() {
1332    return PD_RETURN_BIND_ERROR_MESSAGES;
1333  }
1334
1335
1336
1337  /**
1338   * Get the "save-config-on-successful-startup" property definition.
1339   * <p>
1340   * Indicates whether the directory server should save a copy of its
1341   * configuration whenever the startup process completes successfully.
1342   * <p>
1343   * This ensures that the server provides a "last known good"
1344   * configuration, which can be used as a reference (or copied into
1345   * the active config) if the server fails to start with the current
1346   * "active" configuration.
1347   *
1348   * @return Returns the "save-config-on-successful-startup" property definition.
1349   */
1350  public BooleanPropertyDefinition getSaveConfigOnSuccessfulStartupPropertyDefinition() {
1351    return PD_SAVE_CONFIG_ON_SUCCESSFUL_STARTUP;
1352  }
1353
1354
1355
1356  /**
1357   * Get the "server-error-result-code" property definition.
1358   * <p>
1359   * Specifies the numeric value of the result code when request
1360   * processing fails due to an internal server error.
1361   *
1362   * @return Returns the "server-error-result-code" property definition.
1363   */
1364  public IntegerPropertyDefinition getServerErrorResultCodePropertyDefinition() {
1365    return PD_SERVER_ERROR_RESULT_CODE;
1366  }
1367
1368
1369
1370  /**
1371   * Get the "single-structural-objectclass-behavior" property definition.
1372   * <p>
1373   * Specifies how the directory server should handle operations an
1374   * entry does not contain a structural object class or contains
1375   * multiple structural classes.
1376   *
1377   * @return Returns the "single-structural-objectclass-behavior" property definition.
1378   */
1379  public EnumPropertyDefinition<SingleStructuralObjectclassBehavior> getSingleStructuralObjectclassBehaviorPropertyDefinition() {
1380    return PD_SINGLE_STRUCTURAL_OBJECTCLASS_BEHAVIOR;
1381  }
1382
1383
1384
1385  /**
1386   * Get the "size-limit" property definition.
1387   * <p>
1388   * Specifies the maximum number of entries that can be returned to
1389   * the client during a single search operation.
1390   * <p>
1391   * A value of 0 indicates that no size limit is enforced. Note that
1392   * this is the default server-wide limit, but it may be overridden on
1393   * a per-user basis using the ds-rlim-size-limit operational
1394   * attribute.
1395   *
1396   * @return Returns the "size-limit" property definition.
1397   */
1398  public IntegerPropertyDefinition getSizeLimitPropertyDefinition() {
1399    return PD_SIZE_LIMIT;
1400  }
1401
1402
1403
1404  /**
1405   * Get the "smtp-server" property definition.
1406   * <p>
1407   * Specifies the address (and optional port number) for a mail
1408   * server that can be used to send email messages via SMTP.
1409   * <p>
1410   * It may be an IP address or resolvable hostname, optionally
1411   * followed by a colon and a port number.
1412   *
1413   * @return Returns the "smtp-server" property definition.
1414   */
1415  public StringPropertyDefinition getSMTPServerPropertyDefinition() {
1416    return PD_SMTP_SERVER;
1417  }
1418
1419
1420
1421  /**
1422   * Get the "time-limit" property definition.
1423   * <p>
1424   * Specifies the maximum length of time that should be spent
1425   * processing a single search operation.
1426   * <p>
1427   * A value of 0 seconds indicates that no time limit is enforced.
1428   * Note that this is the default server-wide time limit, but it may
1429   * be overridden on a per-user basis using the ds-rlim-time-limit
1430   * operational attribute.
1431   *
1432   * @return Returns the "time-limit" property definition.
1433   */
1434  public DurationPropertyDefinition getTimeLimitPropertyDefinition() {
1435    return PD_TIME_LIMIT;
1436  }
1437
1438
1439
1440  /**
1441   * Get the "trust-transaction-ids" property definition.
1442   * <p>
1443   * Indicates whether the directory server should trust the
1444   * transaction ids that may be received from requests, either through
1445   * a LDAP control or through a HTTP header.
1446   *
1447   * @return Returns the "trust-transaction-ids" property definition.
1448   */
1449  public BooleanPropertyDefinition getTrustTransactionIdsPropertyDefinition() {
1450    return PD_TRUST_TRANSACTION_IDS;
1451  }
1452
1453
1454
1455  /**
1456   * Get the "writability-mode" property definition.
1457   * <p>
1458   * Specifies the kinds of write operations the directory server can
1459   * process.
1460   *
1461   * @return Returns the "writability-mode" property definition.
1462   */
1463  public EnumPropertyDefinition<WritabilityMode> getWritabilityModePropertyDefinition() {
1464    return PD_WRITABILITY_MODE;
1465  }
1466
1467
1468
1469  /**
1470   * Managed object client implementation.
1471   */
1472  private static class GlobalCfgClientImpl implements
1473    GlobalCfgClient {
1474
1475    /** Private implementation. */
1476    private ManagedObject<? extends GlobalCfgClient> impl;
1477
1478
1479
1480    /** Private constructor. */
1481    private GlobalCfgClientImpl(
1482        ManagedObject<? extends GlobalCfgClient> impl) {
1483      this.impl = impl;
1484    }
1485
1486
1487
1488    /** {@inheritDoc} */
1489    public boolean isAddMissingRDNAttributes() {
1490      return impl.getPropertyValue(INSTANCE.getAddMissingRDNAttributesPropertyDefinition());
1491    }
1492
1493
1494
1495    /** {@inheritDoc} */
1496    public void setAddMissingRDNAttributes(Boolean value) {
1497      impl.setPropertyValue(INSTANCE.getAddMissingRDNAttributesPropertyDefinition(), value);
1498    }
1499
1500
1501
1502    /** {@inheritDoc} */
1503    public boolean isAllowAttributeNameExceptions() {
1504      return impl.getPropertyValue(INSTANCE.getAllowAttributeNameExceptionsPropertyDefinition());
1505    }
1506
1507
1508
1509    /** {@inheritDoc} */
1510    public void setAllowAttributeNameExceptions(Boolean value) {
1511      impl.setPropertyValue(INSTANCE.getAllowAttributeNameExceptionsPropertyDefinition(), value);
1512    }
1513
1514
1515
1516    /** {@inheritDoc} */
1517    public SortedSet<String> getAllowedTask() {
1518      return impl.getPropertyValues(INSTANCE.getAllowedTaskPropertyDefinition());
1519    }
1520
1521
1522
1523    /** {@inheritDoc} */
1524    public void setAllowedTask(Collection<String> values) {
1525      impl.setPropertyValues(INSTANCE.getAllowedTaskPropertyDefinition(), values);
1526    }
1527
1528
1529
1530    /** {@inheritDoc} */
1531    public boolean isBindWithDNRequiresPassword() {
1532      return impl.getPropertyValue(INSTANCE.getBindWithDNRequiresPasswordPropertyDefinition());
1533    }
1534
1535
1536
1537    /** {@inheritDoc} */
1538    public void setBindWithDNRequiresPassword(Boolean value) {
1539      impl.setPropertyValue(INSTANCE.getBindWithDNRequiresPasswordPropertyDefinition(), value);
1540    }
1541
1542
1543
1544    /** {@inheritDoc} */
1545    public boolean isCheckSchema() {
1546      return impl.getPropertyValue(INSTANCE.getCheckSchemaPropertyDefinition());
1547    }
1548
1549
1550
1551    /** {@inheritDoc} */
1552    public void setCheckSchema(Boolean value) {
1553      impl.setPropertyValue(INSTANCE.getCheckSchemaPropertyDefinition(), value);
1554    }
1555
1556
1557
1558    /** {@inheritDoc} */
1559    public String getDefaultPasswordPolicy() {
1560      return impl.getPropertyValue(INSTANCE.getDefaultPasswordPolicyPropertyDefinition());
1561    }
1562
1563
1564
1565    /** {@inheritDoc} */
1566    public void setDefaultPasswordPolicy(String value) {
1567      impl.setPropertyValue(INSTANCE.getDefaultPasswordPolicyPropertyDefinition(), value);
1568    }
1569
1570
1571
1572    /** {@inheritDoc} */
1573    public SortedSet<DisabledPrivilege> getDisabledPrivilege() {
1574      return impl.getPropertyValues(INSTANCE.getDisabledPrivilegePropertyDefinition());
1575    }
1576
1577
1578
1579    /** {@inheritDoc} */
1580    public void setDisabledPrivilege(Collection<DisabledPrivilege> values) {
1581      impl.setPropertyValues(INSTANCE.getDisabledPrivilegePropertyDefinition(), values);
1582    }
1583
1584
1585
1586    /** {@inheritDoc} */
1587    public EtimeResolution getEtimeResolution() {
1588      return impl.getPropertyValue(INSTANCE.getEtimeResolutionPropertyDefinition());
1589    }
1590
1591
1592
1593    /** {@inheritDoc} */
1594    public void setEtimeResolution(EtimeResolution value) {
1595      impl.setPropertyValue(INSTANCE.getEtimeResolutionPropertyDefinition(), value);
1596    }
1597
1598
1599
1600    /** {@inheritDoc} */
1601    public long getIdleTimeLimit() {
1602      return impl.getPropertyValue(INSTANCE.getIdleTimeLimitPropertyDefinition());
1603    }
1604
1605
1606
1607    /** {@inheritDoc} */
1608    public void setIdleTimeLimit(Long value) {
1609      impl.setPropertyValue(INSTANCE.getIdleTimeLimitPropertyDefinition(), value);
1610    }
1611
1612
1613
1614    /** {@inheritDoc} */
1615    public InvalidAttributeSyntaxBehavior getInvalidAttributeSyntaxBehavior() {
1616      return impl.getPropertyValue(INSTANCE.getInvalidAttributeSyntaxBehaviorPropertyDefinition());
1617    }
1618
1619
1620
1621    /** {@inheritDoc} */
1622    public void setInvalidAttributeSyntaxBehavior(InvalidAttributeSyntaxBehavior value) {
1623      impl.setPropertyValue(INSTANCE.getInvalidAttributeSyntaxBehaviorPropertyDefinition(), value);
1624    }
1625
1626
1627
1628    /** {@inheritDoc} */
1629    public int getLookthroughLimit() {
1630      return impl.getPropertyValue(INSTANCE.getLookthroughLimitPropertyDefinition());
1631    }
1632
1633
1634
1635    /** {@inheritDoc} */
1636    public void setLookthroughLimit(Integer value) {
1637      impl.setPropertyValue(INSTANCE.getLookthroughLimitPropertyDefinition(), value);
1638    }
1639
1640
1641
1642    /** {@inheritDoc} */
1643    public int getMaxAllowedClientConnections() {
1644      return impl.getPropertyValue(INSTANCE.getMaxAllowedClientConnectionsPropertyDefinition());
1645    }
1646
1647
1648
1649    /** {@inheritDoc} */
1650    public void setMaxAllowedClientConnections(Integer value) {
1651      impl.setPropertyValue(INSTANCE.getMaxAllowedClientConnectionsPropertyDefinition(), value);
1652    }
1653
1654
1655
1656    /** {@inheritDoc} */
1657    public long getMaxInternalBufferSize() {
1658      return impl.getPropertyValue(INSTANCE.getMaxInternalBufferSizePropertyDefinition());
1659    }
1660
1661
1662
1663    /** {@inheritDoc} */
1664    public void setMaxInternalBufferSize(Long value) {
1665      impl.setPropertyValue(INSTANCE.getMaxInternalBufferSizePropertyDefinition(), value);
1666    }
1667
1668
1669
1670    /** {@inheritDoc} */
1671    public int getMaxPsearches() {
1672      return impl.getPropertyValue(INSTANCE.getMaxPsearchesPropertyDefinition());
1673    }
1674
1675
1676
1677    /** {@inheritDoc} */
1678    public void setMaxPsearches(Integer value) {
1679      impl.setPropertyValue(INSTANCE.getMaxPsearchesPropertyDefinition(), value);
1680    }
1681
1682
1683
1684    /** {@inheritDoc} */
1685    public boolean isNotifyAbandonedOperations() {
1686      return impl.getPropertyValue(INSTANCE.getNotifyAbandonedOperationsPropertyDefinition());
1687    }
1688
1689
1690
1691    /** {@inheritDoc} */
1692    public void setNotifyAbandonedOperations(Boolean value) {
1693      impl.setPropertyValue(INSTANCE.getNotifyAbandonedOperationsPropertyDefinition(), value);
1694    }
1695
1696
1697
1698    /** {@inheritDoc} */
1699    public String getProxiedAuthorizationIdentityMapper() {
1700      return impl.getPropertyValue(INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition());
1701    }
1702
1703
1704
1705    /** {@inheritDoc} */
1706    public void setProxiedAuthorizationIdentityMapper(String value) {
1707      impl.setPropertyValue(INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition(), value);
1708    }
1709
1710
1711
1712    /** {@inheritDoc} */
1713    public boolean isRejectUnauthenticatedRequests() {
1714      return impl.getPropertyValue(INSTANCE.getRejectUnauthenticatedRequestsPropertyDefinition());
1715    }
1716
1717
1718
1719    /** {@inheritDoc} */
1720    public void setRejectUnauthenticatedRequests(Boolean value) {
1721      impl.setPropertyValue(INSTANCE.getRejectUnauthenticatedRequestsPropertyDefinition(), value);
1722    }
1723
1724
1725
1726    /** {@inheritDoc} */
1727    public boolean isReturnBindErrorMessages() {
1728      return impl.getPropertyValue(INSTANCE.getReturnBindErrorMessagesPropertyDefinition());
1729    }
1730
1731
1732
1733    /** {@inheritDoc} */
1734    public void setReturnBindErrorMessages(Boolean value) {
1735      impl.setPropertyValue(INSTANCE.getReturnBindErrorMessagesPropertyDefinition(), value);
1736    }
1737
1738
1739
1740    /** {@inheritDoc} */
1741    public boolean isSaveConfigOnSuccessfulStartup() {
1742      return impl.getPropertyValue(INSTANCE.getSaveConfigOnSuccessfulStartupPropertyDefinition());
1743    }
1744
1745
1746
1747    /** {@inheritDoc} */
1748    public void setSaveConfigOnSuccessfulStartup(Boolean value) {
1749      impl.setPropertyValue(INSTANCE.getSaveConfigOnSuccessfulStartupPropertyDefinition(), value);
1750    }
1751
1752
1753
1754    /** {@inheritDoc} */
1755    public int getServerErrorResultCode() {
1756      return impl.getPropertyValue(INSTANCE.getServerErrorResultCodePropertyDefinition());
1757    }
1758
1759
1760
1761    /** {@inheritDoc} */
1762    public void setServerErrorResultCode(Integer value) {
1763      impl.setPropertyValue(INSTANCE.getServerErrorResultCodePropertyDefinition(), value);
1764    }
1765
1766
1767
1768    /** {@inheritDoc} */
1769    public SingleStructuralObjectclassBehavior getSingleStructuralObjectclassBehavior() {
1770      return impl.getPropertyValue(INSTANCE.getSingleStructuralObjectclassBehaviorPropertyDefinition());
1771    }
1772
1773
1774
1775    /** {@inheritDoc} */
1776    public void setSingleStructuralObjectclassBehavior(SingleStructuralObjectclassBehavior value) {
1777      impl.setPropertyValue(INSTANCE.getSingleStructuralObjectclassBehaviorPropertyDefinition(), value);
1778    }
1779
1780
1781
1782    /** {@inheritDoc} */
1783    public int getSizeLimit() {
1784      return impl.getPropertyValue(INSTANCE.getSizeLimitPropertyDefinition());
1785    }
1786
1787
1788
1789    /** {@inheritDoc} */
1790    public void setSizeLimit(Integer value) {
1791      impl.setPropertyValue(INSTANCE.getSizeLimitPropertyDefinition(), value);
1792    }
1793
1794
1795
1796    /** {@inheritDoc} */
1797    public SortedSet<String> getSMTPServer() {
1798      return impl.getPropertyValues(INSTANCE.getSMTPServerPropertyDefinition());
1799    }
1800
1801
1802
1803    /** {@inheritDoc} */
1804    public void setSMTPServer(Collection<String> values) {
1805      impl.setPropertyValues(INSTANCE.getSMTPServerPropertyDefinition(), values);
1806    }
1807
1808
1809
1810    /** {@inheritDoc} */
1811    public long getTimeLimit() {
1812      return impl.getPropertyValue(INSTANCE.getTimeLimitPropertyDefinition());
1813    }
1814
1815
1816
1817    /** {@inheritDoc} */
1818    public void setTimeLimit(Long value) {
1819      impl.setPropertyValue(INSTANCE.getTimeLimitPropertyDefinition(), value);
1820    }
1821
1822
1823
1824    /** {@inheritDoc} */
1825    public boolean isTrustTransactionIds() {
1826      return impl.getPropertyValue(INSTANCE.getTrustTransactionIdsPropertyDefinition());
1827    }
1828
1829
1830
1831    /** {@inheritDoc} */
1832    public void setTrustTransactionIds(Boolean value) {
1833      impl.setPropertyValue(INSTANCE.getTrustTransactionIdsPropertyDefinition(), value);
1834    }
1835
1836
1837
1838    /** {@inheritDoc} */
1839    public WritabilityMode getWritabilityMode() {
1840      return impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
1841    }
1842
1843
1844
1845    /** {@inheritDoc} */
1846    public void setWritabilityMode(WritabilityMode value) {
1847      impl.setPropertyValue(INSTANCE.getWritabilityModePropertyDefinition(), value);
1848    }
1849
1850
1851
1852    /** {@inheritDoc} */
1853    public ManagedObjectDefinition<? extends GlobalCfgClient, ? extends GlobalCfg> definition() {
1854      return INSTANCE;
1855    }
1856
1857
1858
1859    /** {@inheritDoc} */
1860    public PropertyProvider properties() {
1861      return impl;
1862    }
1863
1864
1865
1866    /** {@inheritDoc} */
1867    public void commit() throws ManagedObjectAlreadyExistsException,
1868        MissingMandatoryPropertiesException, ConcurrentModificationException,
1869        OperationRejectedException, LdapException {
1870      impl.commit();
1871    }
1872
1873
1874
1875    /** {@inheritDoc} */
1876    public String toString() {
1877      return impl.toString();
1878    }
1879  }
1880
1881
1882
1883  /**
1884   * Managed object server implementation.
1885   */
1886  private static class GlobalCfgServerImpl implements
1887    GlobalCfg {
1888
1889    /** Private implementation. */
1890    private ServerManagedObject<? extends GlobalCfg> impl;
1891
1892    /** The value of the "add-missing-rdn-attributes" property. */
1893    private final boolean pAddMissingRDNAttributes;
1894
1895    /** The value of the "allow-attribute-name-exceptions" property. */
1896    private final boolean pAllowAttributeNameExceptions;
1897
1898    /** The value of the "allowed-task" property. */
1899    private final SortedSet<String> pAllowedTask;
1900
1901    /** The value of the "bind-with-dn-requires-password" property. */
1902    private final boolean pBindWithDNRequiresPassword;
1903
1904    /** The value of the "check-schema" property. */
1905    private final boolean pCheckSchema;
1906
1907    /** The value of the "default-password-policy" property. */
1908    private final String pDefaultPasswordPolicy;
1909
1910    /** The value of the "disabled-privilege" property. */
1911    private final SortedSet<DisabledPrivilege> pDisabledPrivilege;
1912
1913    /** The value of the "etime-resolution" property. */
1914    private final EtimeResolution pEtimeResolution;
1915
1916    /** The value of the "idle-time-limit" property. */
1917    private final long pIdleTimeLimit;
1918
1919    /** The value of the "invalid-attribute-syntax-behavior" property. */
1920    private final InvalidAttributeSyntaxBehavior pInvalidAttributeSyntaxBehavior;
1921
1922    /** The value of the "lookthrough-limit" property. */
1923    private final int pLookthroughLimit;
1924
1925    /** The value of the "max-allowed-client-connections" property. */
1926    private final int pMaxAllowedClientConnections;
1927
1928    /** The value of the "max-internal-buffer-size" property. */
1929    private final long pMaxInternalBufferSize;
1930
1931    /** The value of the "max-psearches" property. */
1932    private final int pMaxPsearches;
1933
1934    /** The value of the "notify-abandoned-operations" property. */
1935    private final boolean pNotifyAbandonedOperations;
1936
1937    /** The value of the "proxied-authorization-identity-mapper" property. */
1938    private final String pProxiedAuthorizationIdentityMapper;
1939
1940    /** The value of the "reject-unauthenticated-requests" property. */
1941    private final boolean pRejectUnauthenticatedRequests;
1942
1943    /** The value of the "return-bind-error-messages" property. */
1944    private final boolean pReturnBindErrorMessages;
1945
1946    /** The value of the "save-config-on-successful-startup" property. */
1947    private final boolean pSaveConfigOnSuccessfulStartup;
1948
1949    /** The value of the "server-error-result-code" property. */
1950    private final int pServerErrorResultCode;
1951
1952    /** The value of the "single-structural-objectclass-behavior" property. */
1953    private final SingleStructuralObjectclassBehavior pSingleStructuralObjectclassBehavior;
1954
1955    /** The value of the "size-limit" property. */
1956    private final int pSizeLimit;
1957
1958    /** The value of the "smtp-server" property. */
1959    private final SortedSet<String> pSMTPServer;
1960
1961    /** The value of the "time-limit" property. */
1962    private final long pTimeLimit;
1963
1964    /** The value of the "trust-transaction-ids" property. */
1965    private final boolean pTrustTransactionIds;
1966
1967    /** The value of the "writability-mode" property. */
1968    private final WritabilityMode pWritabilityMode;
1969
1970
1971
1972    /** Private constructor. */
1973    private GlobalCfgServerImpl(ServerManagedObject<? extends GlobalCfg> impl) {
1974      this.impl = impl;
1975      this.pAddMissingRDNAttributes = impl.getPropertyValue(INSTANCE.getAddMissingRDNAttributesPropertyDefinition());
1976      this.pAllowAttributeNameExceptions = impl.getPropertyValue(INSTANCE.getAllowAttributeNameExceptionsPropertyDefinition());
1977      this.pAllowedTask = impl.getPropertyValues(INSTANCE.getAllowedTaskPropertyDefinition());
1978      this.pBindWithDNRequiresPassword = impl.getPropertyValue(INSTANCE.getBindWithDNRequiresPasswordPropertyDefinition());
1979      this.pCheckSchema = impl.getPropertyValue(INSTANCE.getCheckSchemaPropertyDefinition());
1980      this.pDefaultPasswordPolicy = impl.getPropertyValue(INSTANCE.getDefaultPasswordPolicyPropertyDefinition());
1981      this.pDisabledPrivilege = impl.getPropertyValues(INSTANCE.getDisabledPrivilegePropertyDefinition());
1982      this.pEtimeResolution = impl.getPropertyValue(INSTANCE.getEtimeResolutionPropertyDefinition());
1983      this.pIdleTimeLimit = impl.getPropertyValue(INSTANCE.getIdleTimeLimitPropertyDefinition());
1984      this.pInvalidAttributeSyntaxBehavior = impl.getPropertyValue(INSTANCE.getInvalidAttributeSyntaxBehaviorPropertyDefinition());
1985      this.pLookthroughLimit = impl.getPropertyValue(INSTANCE.getLookthroughLimitPropertyDefinition());
1986      this.pMaxAllowedClientConnections = impl.getPropertyValue(INSTANCE.getMaxAllowedClientConnectionsPropertyDefinition());
1987      this.pMaxInternalBufferSize = impl.getPropertyValue(INSTANCE.getMaxInternalBufferSizePropertyDefinition());
1988      this.pMaxPsearches = impl.getPropertyValue(INSTANCE.getMaxPsearchesPropertyDefinition());
1989      this.pNotifyAbandonedOperations = impl.getPropertyValue(INSTANCE.getNotifyAbandonedOperationsPropertyDefinition());
1990      this.pProxiedAuthorizationIdentityMapper = impl.getPropertyValue(INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition());
1991      this.pRejectUnauthenticatedRequests = impl.getPropertyValue(INSTANCE.getRejectUnauthenticatedRequestsPropertyDefinition());
1992      this.pReturnBindErrorMessages = impl.getPropertyValue(INSTANCE.getReturnBindErrorMessagesPropertyDefinition());
1993      this.pSaveConfigOnSuccessfulStartup = impl.getPropertyValue(INSTANCE.getSaveConfigOnSuccessfulStartupPropertyDefinition());
1994      this.pServerErrorResultCode = impl.getPropertyValue(INSTANCE.getServerErrorResultCodePropertyDefinition());
1995      this.pSingleStructuralObjectclassBehavior = impl.getPropertyValue(INSTANCE.getSingleStructuralObjectclassBehaviorPropertyDefinition());
1996      this.pSizeLimit = impl.getPropertyValue(INSTANCE.getSizeLimitPropertyDefinition());
1997      this.pSMTPServer = impl.getPropertyValues(INSTANCE.getSMTPServerPropertyDefinition());
1998      this.pTimeLimit = impl.getPropertyValue(INSTANCE.getTimeLimitPropertyDefinition());
1999      this.pTrustTransactionIds = impl.getPropertyValue(INSTANCE.getTrustTransactionIdsPropertyDefinition());
2000      this.pWritabilityMode = impl.getPropertyValue(INSTANCE.getWritabilityModePropertyDefinition());
2001    }
2002
2003
2004
2005    /** {@inheritDoc} */
2006    public void addChangeListener(
2007        ConfigurationChangeListener<GlobalCfg> listener) {
2008      impl.registerChangeListener(listener);
2009    }
2010
2011
2012
2013    /** {@inheritDoc} */
2014    public void removeChangeListener(
2015        ConfigurationChangeListener<GlobalCfg> listener) {
2016      impl.deregisterChangeListener(listener);
2017    }
2018
2019
2020
2021    /** {@inheritDoc} */
2022    public boolean isAddMissingRDNAttributes() {
2023      return pAddMissingRDNAttributes;
2024    }
2025
2026
2027
2028    /** {@inheritDoc} */
2029    public boolean isAllowAttributeNameExceptions() {
2030      return pAllowAttributeNameExceptions;
2031    }
2032
2033
2034
2035    /** {@inheritDoc} */
2036    public SortedSet<String> getAllowedTask() {
2037      return pAllowedTask;
2038    }
2039
2040
2041
2042    /** {@inheritDoc} */
2043    public boolean isBindWithDNRequiresPassword() {
2044      return pBindWithDNRequiresPassword;
2045    }
2046
2047
2048
2049    /** {@inheritDoc} */
2050    public boolean isCheckSchema() {
2051      return pCheckSchema;
2052    }
2053
2054
2055
2056    /** {@inheritDoc} */
2057    public String getDefaultPasswordPolicy() {
2058      return pDefaultPasswordPolicy;
2059    }
2060
2061
2062
2063    /**
2064     * {@inheritDoc}
2065     */
2066    public DN getDefaultPasswordPolicyDN() {
2067      String value = getDefaultPasswordPolicy();
2068      if (value == null) return null;
2069      return INSTANCE.getDefaultPasswordPolicyPropertyDefinition().getChildDN(value);
2070    }
2071
2072
2073
2074    /** {@inheritDoc} */
2075    public SortedSet<DisabledPrivilege> getDisabledPrivilege() {
2076      return pDisabledPrivilege;
2077    }
2078
2079
2080
2081    /** {@inheritDoc} */
2082    public EtimeResolution getEtimeResolution() {
2083      return pEtimeResolution;
2084    }
2085
2086
2087
2088    /** {@inheritDoc} */
2089    public long getIdleTimeLimit() {
2090      return pIdleTimeLimit;
2091    }
2092
2093
2094
2095    /** {@inheritDoc} */
2096    public InvalidAttributeSyntaxBehavior getInvalidAttributeSyntaxBehavior() {
2097      return pInvalidAttributeSyntaxBehavior;
2098    }
2099
2100
2101
2102    /** {@inheritDoc} */
2103    public int getLookthroughLimit() {
2104      return pLookthroughLimit;
2105    }
2106
2107
2108
2109    /** {@inheritDoc} */
2110    public int getMaxAllowedClientConnections() {
2111      return pMaxAllowedClientConnections;
2112    }
2113
2114
2115
2116    /** {@inheritDoc} */
2117    public long getMaxInternalBufferSize() {
2118      return pMaxInternalBufferSize;
2119    }
2120
2121
2122
2123    /** {@inheritDoc} */
2124    public int getMaxPsearches() {
2125      return pMaxPsearches;
2126    }
2127
2128
2129
2130    /** {@inheritDoc} */
2131    public boolean isNotifyAbandonedOperations() {
2132      return pNotifyAbandonedOperations;
2133    }
2134
2135
2136
2137    /** {@inheritDoc} */
2138    public String getProxiedAuthorizationIdentityMapper() {
2139      return pProxiedAuthorizationIdentityMapper;
2140    }
2141
2142
2143
2144    /**
2145     * {@inheritDoc}
2146     */
2147    public DN getProxiedAuthorizationIdentityMapperDN() {
2148      String value = getProxiedAuthorizationIdentityMapper();
2149      if (value == null) return null;
2150      return INSTANCE.getProxiedAuthorizationIdentityMapperPropertyDefinition().getChildDN(value);
2151    }
2152
2153
2154
2155    /** {@inheritDoc} */
2156    public boolean isRejectUnauthenticatedRequests() {
2157      return pRejectUnauthenticatedRequests;
2158    }
2159
2160
2161
2162    /** {@inheritDoc} */
2163    public boolean isReturnBindErrorMessages() {
2164      return pReturnBindErrorMessages;
2165    }
2166
2167
2168
2169    /** {@inheritDoc} */
2170    public boolean isSaveConfigOnSuccessfulStartup() {
2171      return pSaveConfigOnSuccessfulStartup;
2172    }
2173
2174
2175
2176    /** {@inheritDoc} */
2177    public int getServerErrorResultCode() {
2178      return pServerErrorResultCode;
2179    }
2180
2181
2182
2183    /** {@inheritDoc} */
2184    public SingleStructuralObjectclassBehavior getSingleStructuralObjectclassBehavior() {
2185      return pSingleStructuralObjectclassBehavior;
2186    }
2187
2188
2189
2190    /** {@inheritDoc} */
2191    public int getSizeLimit() {
2192      return pSizeLimit;
2193    }
2194
2195
2196
2197    /** {@inheritDoc} */
2198    public SortedSet<String> getSMTPServer() {
2199      return pSMTPServer;
2200    }
2201
2202
2203
2204    /** {@inheritDoc} */
2205    public long getTimeLimit() {
2206      return pTimeLimit;
2207    }
2208
2209
2210
2211    /** {@inheritDoc} */
2212    public boolean isTrustTransactionIds() {
2213      return pTrustTransactionIds;
2214    }
2215
2216
2217
2218    /** {@inheritDoc} */
2219    public WritabilityMode getWritabilityMode() {
2220      return pWritabilityMode;
2221    }
2222
2223
2224
2225    /** {@inheritDoc} */
2226    public Class<? extends GlobalCfg> configurationClass() {
2227      return GlobalCfg.class;
2228    }
2229
2230
2231
2232    /** {@inheritDoc} */
2233    public DN dn() {
2234      return impl.getDN();
2235    }
2236
2237
2238
2239    /** {@inheritDoc} */
2240    public String toString() {
2241      return impl.toString();
2242    }
2243  }
2244}