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