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}