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