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