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