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 010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE 011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE. 012 * See the License for the specific language governing permissions 013 * and limitations under the License. 014 * 015 * When distributing Covered Code, include this CDDL HEADER in each 016 * file and include the License file at 017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable, 018 * add the following below this CDDL HEADER, with the fields enclosed 019 * by brackets "[]" replaced with your own identifying information: 020 * Portions Copyright [yyyy] [name of copyright owner] 021 * 022 * CDDL HEADER END 023 * 024 * 025 * Copyright 2008 Sun Microsystems, Inc. 026 */ 027 package org.opends.server.admin.std.meta; 028 029 030 031 import java.net.InetAddress; 032 import java.util.Collection; 033 import java.util.SortedSet; 034 import org.opends.server.admin.AdministratorAction; 035 import org.opends.server.admin.AggregationPropertyDefinition; 036 import org.opends.server.admin.AliasDefaultBehaviorProvider; 037 import org.opends.server.admin.BooleanPropertyDefinition; 038 import org.opends.server.admin.ClassPropertyDefinition; 039 import org.opends.server.admin.client.AuthorizationException; 040 import org.opends.server.admin.client.CommunicationException; 041 import org.opends.server.admin.client.ConcurrentModificationException; 042 import org.opends.server.admin.client.ManagedObject; 043 import org.opends.server.admin.client.MissingMandatoryPropertiesException; 044 import org.opends.server.admin.client.OperationRejectedException; 045 import org.opends.server.admin.condition.Conditions; 046 import org.opends.server.admin.DefaultBehaviorProvider; 047 import org.opends.server.admin.DefinedDefaultBehaviorProvider; 048 import org.opends.server.admin.DurationPropertyDefinition; 049 import org.opends.server.admin.EnumPropertyDefinition; 050 import org.opends.server.admin.GenericConstraint; 051 import org.opends.server.admin.IntegerPropertyDefinition; 052 import org.opends.server.admin.IPAddressMaskPropertyDefinition; 053 import org.opends.server.admin.IPAddressPropertyDefinition; 054 import org.opends.server.admin.ManagedObjectAlreadyExistsException; 055 import org.opends.server.admin.ManagedObjectDefinition; 056 import org.opends.server.admin.PropertyOption; 057 import org.opends.server.admin.PropertyProvider; 058 import org.opends.server.admin.server.ConfigurationChangeListener; 059 import org.opends.server.admin.server.ServerManagedObject; 060 import org.opends.server.admin.SizePropertyDefinition; 061 import org.opends.server.admin.std.client.KeyManagerProviderCfgClient; 062 import org.opends.server.admin.std.client.LDAPConnectionHandlerCfgClient; 063 import org.opends.server.admin.std.client.TrustManagerProviderCfgClient; 064 import org.opends.server.admin.std.server.ConnectionHandlerCfg; 065 import org.opends.server.admin.std.server.KeyManagerProviderCfg; 066 import org.opends.server.admin.std.server.LDAPConnectionHandlerCfg; 067 import org.opends.server.admin.std.server.TrustManagerProviderCfg; 068 import org.opends.server.admin.StringPropertyDefinition; 069 import org.opends.server.admin.Tag; 070 import org.opends.server.admin.UndefinedDefaultBehaviorProvider; 071 import org.opends.server.types.AddressMask; 072 import org.opends.server.types.DN; 073 074 075 076 /** 077 * An interface for querying the LDAP Connection Handler managed 078 * object definition meta information. 079 * <p> 080 * The LDAP Connection Handler is used to interact with clients using 081 * LDAP. 082 */ 083 public final class LDAPConnectionHandlerCfgDefn extends ManagedObjectDefinition<LDAPConnectionHandlerCfgClient, LDAPConnectionHandlerCfg> { 084 085 // The singleton configuration definition instance. 086 private static final LDAPConnectionHandlerCfgDefn INSTANCE = new LDAPConnectionHandlerCfgDefn(); 087 088 089 090 /** 091 * Defines the set of permissable values for the "ssl-client-auth-policy" property. 092 * <p> 093 * Specifies the policy that the LDAP Connection Handler should use 094 * regarding client SSL certificates. 095 * <p> 096 * This is only applicable if clients are allowed to use SSL. 097 */ 098 public static enum SSLClientAuthPolicy { 099 100 /** 101 * Clients are not required to provide their own certificates when 102 * performing SSL negotiation. 103 */ 104 DISABLED("disabled"), 105 106 107 108 /** 109 * Clients are requested to provide their own certificates when 110 * performing SSL negotiation, but still accept the connection even 111 * if the client does not provide a certificate. 112 */ 113 OPTIONAL("optional"), 114 115 116 117 /** 118 * Clients are required to provide their own certificates when 119 * performing SSL negotiation and are refused access if the do not 120 * provide a certificate. 121 */ 122 REQUIRED("required"); 123 124 125 126 // String representation of the value. 127 private final String name; 128 129 130 131 // Private constructor. 132 private SSLClientAuthPolicy(String name) { this.name = name; } 133 134 135 136 /** 137 * {@inheritDoc} 138 */ 139 public String toString() { return name; } 140 141 } 142 143 144 145 // The "accept-backlog" property definition. 146 private static final IntegerPropertyDefinition PD_ACCEPT_BACKLOG; 147 148 149 150 // The "allow-ldap-v2" property definition. 151 private static final BooleanPropertyDefinition PD_ALLOW_LDAP_V2; 152 153 154 155 // The "allow-start-tls" property definition. 156 private static final BooleanPropertyDefinition PD_ALLOW_START_TLS; 157 158 159 160 // The "allow-tcp-reuse-address" property definition. 161 private static final BooleanPropertyDefinition PD_ALLOW_TCP_REUSE_ADDRESS; 162 163 164 165 // The "java-class" property definition. 166 private static final ClassPropertyDefinition PD_JAVA_CLASS; 167 168 169 170 // The "keep-stats" property definition. 171 private static final BooleanPropertyDefinition PD_KEEP_STATS; 172 173 174 175 // The "key-manager-provider" property definition. 176 private static final AggregationPropertyDefinition<KeyManagerProviderCfgClient, KeyManagerProviderCfg> PD_KEY_MANAGER_PROVIDER; 177 178 179 180 // The "listen-address" property definition. 181 private static final IPAddressPropertyDefinition PD_LISTEN_ADDRESS; 182 183 184 185 // The "listen-port" property definition. 186 private static final IntegerPropertyDefinition PD_LISTEN_PORT; 187 188 189 190 // The "max-blocked-write-time-limit" property definition. 191 private static final DurationPropertyDefinition PD_MAX_BLOCKED_WRITE_TIME_LIMIT; 192 193 194 195 // The "max-request-size" property definition. 196 private static final SizePropertyDefinition PD_MAX_REQUEST_SIZE; 197 198 199 200 // The "num-request-handlers" property definition. 201 private static final IntegerPropertyDefinition PD_NUM_REQUEST_HANDLERS; 202 203 204 205 // The "send-rejection-notice" property definition. 206 private static final BooleanPropertyDefinition PD_SEND_REJECTION_NOTICE; 207 208 209 210 // The "ssl-cert-nickname" property definition. 211 private static final StringPropertyDefinition PD_SSL_CERT_NICKNAME; 212 213 214 215 // The "ssl-cipher-suite" property definition. 216 private static final StringPropertyDefinition PD_SSL_CIPHER_SUITE; 217 218 219 220 // The "ssl-client-auth-policy" property definition. 221 private static final EnumPropertyDefinition<SSLClientAuthPolicy> PD_SSL_CLIENT_AUTH_POLICY; 222 223 224 225 // The "ssl-protocol" property definition. 226 private static final StringPropertyDefinition PD_SSL_PROTOCOL; 227 228 229 230 // The "trust-manager-provider" property definition. 231 private static final AggregationPropertyDefinition<TrustManagerProviderCfgClient, TrustManagerProviderCfg> PD_TRUST_MANAGER_PROVIDER; 232 233 234 235 // The "use-ssl" property definition. 236 private static final BooleanPropertyDefinition PD_USE_SSL; 237 238 239 240 // The "use-tcp-keep-alive" property definition. 241 private static final BooleanPropertyDefinition PD_USE_TCP_KEEP_ALIVE; 242 243 244 245 // The "use-tcp-no-delay" property definition. 246 private static final BooleanPropertyDefinition PD_USE_TCP_NO_DELAY; 247 248 249 250 // Build the "accept-backlog" property definition. 251 static { 252 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "accept-backlog"); 253 builder.setOption(PropertyOption.ADVANCED); 254 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "accept-backlog")); 255 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("128"); 256 builder.setDefaultBehaviorProvider(provider); 257 builder.setLowerLimit(1); 258 PD_ACCEPT_BACKLOG = builder.getInstance(); 259 INSTANCE.registerPropertyDefinition(PD_ACCEPT_BACKLOG); 260 } 261 262 263 264 // Build the "allow-ldap-v2" property definition. 265 static { 266 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "allow-ldap-v2"); 267 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allow-ldap-v2")); 268 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 269 builder.setDefaultBehaviorProvider(provider); 270 PD_ALLOW_LDAP_V2 = builder.getInstance(); 271 INSTANCE.registerPropertyDefinition(PD_ALLOW_LDAP_V2); 272 } 273 274 275 276 // Build the "allow-start-tls" property definition. 277 static { 278 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "allow-start-tls"); 279 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "allow-start-tls")); 280 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 281 builder.setDefaultBehaviorProvider(provider); 282 PD_ALLOW_START_TLS = builder.getInstance(); 283 INSTANCE.registerPropertyDefinition(PD_ALLOW_START_TLS); 284 } 285 286 287 288 // Build the "allow-tcp-reuse-address" property definition. 289 static { 290 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "allow-tcp-reuse-address"); 291 builder.setOption(PropertyOption.ADVANCED); 292 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "allow-tcp-reuse-address")); 293 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 294 builder.setDefaultBehaviorProvider(provider); 295 PD_ALLOW_TCP_REUSE_ADDRESS = builder.getInstance(); 296 INSTANCE.registerPropertyDefinition(PD_ALLOW_TCP_REUSE_ADDRESS); 297 } 298 299 300 301 // Build the "java-class" property definition. 302 static { 303 ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class"); 304 builder.setOption(PropertyOption.MANDATORY); 305 builder.setOption(PropertyOption.ADVANCED); 306 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "java-class")); 307 DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.protocols.ldap.LDAPConnectionHandler"); 308 builder.setDefaultBehaviorProvider(provider); 309 builder.addInstanceOf("org.opends.server.api.ConnectionHandler"); 310 PD_JAVA_CLASS = builder.getInstance(); 311 INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS); 312 } 313 314 315 316 // Build the "keep-stats" property definition. 317 static { 318 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "keep-stats"); 319 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "keep-stats")); 320 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 321 builder.setDefaultBehaviorProvider(provider); 322 PD_KEEP_STATS = builder.getInstance(); 323 INSTANCE.registerPropertyDefinition(PD_KEEP_STATS); 324 } 325 326 327 328 // Build the "key-manager-provider" property definition. 329 static { 330 AggregationPropertyDefinition.Builder<KeyManagerProviderCfgClient, KeyManagerProviderCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "key-manager-provider"); 331 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "key-manager-provider")); 332 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 333 builder.setParentPath("/"); 334 builder.setRelationDefinition("key-manager-provider"); 335 PD_KEY_MANAGER_PROVIDER = builder.getInstance(); 336 INSTANCE.registerPropertyDefinition(PD_KEY_MANAGER_PROVIDER); 337 INSTANCE.registerConstraint(PD_KEY_MANAGER_PROVIDER.getSourceConstraint()); 338 } 339 340 341 342 // Build the "listen-address" property definition. 343 static { 344 IPAddressPropertyDefinition.Builder builder = IPAddressPropertyDefinition.createBuilder(INSTANCE, "listen-address"); 345 builder.setOption(PropertyOption.MULTI_VALUED); 346 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "listen-address")); 347 DefaultBehaviorProvider<InetAddress> provider = new DefinedDefaultBehaviorProvider<InetAddress>("0.0.0.0"); 348 builder.setDefaultBehaviorProvider(provider); 349 PD_LISTEN_ADDRESS = builder.getInstance(); 350 INSTANCE.registerPropertyDefinition(PD_LISTEN_ADDRESS); 351 } 352 353 354 355 // Build the "listen-port" property definition. 356 static { 357 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "listen-port"); 358 builder.setOption(PropertyOption.MANDATORY); 359 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "listen-port")); 360 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Integer>()); 361 builder.setUpperLimit(65535); 362 builder.setLowerLimit(1); 363 PD_LISTEN_PORT = builder.getInstance(); 364 INSTANCE.registerPropertyDefinition(PD_LISTEN_PORT); 365 } 366 367 368 369 // Build the "max-blocked-write-time-limit" property definition. 370 static { 371 DurationPropertyDefinition.Builder builder = DurationPropertyDefinition.createBuilder(INSTANCE, "max-blocked-write-time-limit"); 372 builder.setOption(PropertyOption.ADVANCED); 373 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-blocked-write-time-limit")); 374 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("2 minutes"); 375 builder.setDefaultBehaviorProvider(provider); 376 builder.setBaseUnit("ms"); 377 builder.setLowerLimit("0"); 378 PD_MAX_BLOCKED_WRITE_TIME_LIMIT = builder.getInstance(); 379 INSTANCE.registerPropertyDefinition(PD_MAX_BLOCKED_WRITE_TIME_LIMIT); 380 } 381 382 383 384 // Build the "max-request-size" property definition. 385 static { 386 SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "max-request-size"); 387 builder.setOption(PropertyOption.ADVANCED); 388 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "max-request-size")); 389 DefaultBehaviorProvider<Long> provider = new DefinedDefaultBehaviorProvider<Long>("5 megabytes"); 390 builder.setDefaultBehaviorProvider(provider); 391 builder.setUpperLimit("2147483647b"); 392 PD_MAX_REQUEST_SIZE = builder.getInstance(); 393 INSTANCE.registerPropertyDefinition(PD_MAX_REQUEST_SIZE); 394 } 395 396 397 398 // Build the "num-request-handlers" property definition. 399 static { 400 IntegerPropertyDefinition.Builder builder = IntegerPropertyDefinition.createBuilder(INSTANCE, "num-request-handlers"); 401 builder.setOption(PropertyOption.ADVANCED); 402 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "num-request-handlers")); 403 DefaultBehaviorProvider<Integer> provider = new DefinedDefaultBehaviorProvider<Integer>("2"); 404 builder.setDefaultBehaviorProvider(provider); 405 builder.setLowerLimit(1); 406 PD_NUM_REQUEST_HANDLERS = builder.getInstance(); 407 INSTANCE.registerPropertyDefinition(PD_NUM_REQUEST_HANDLERS); 408 } 409 410 411 412 // Build the "send-rejection-notice" property definition. 413 static { 414 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "send-rejection-notice"); 415 builder.setOption(PropertyOption.ADVANCED); 416 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "send-rejection-notice")); 417 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 418 builder.setDefaultBehaviorProvider(provider); 419 PD_SEND_REJECTION_NOTICE = builder.getInstance(); 420 INSTANCE.registerPropertyDefinition(PD_SEND_REJECTION_NOTICE); 421 } 422 423 424 425 // Build the "ssl-cert-nickname" property definition. 426 static { 427 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-cert-nickname"); 428 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "ssl-cert-nickname")); 429 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-cert-nickname")); 430 PD_SSL_CERT_NICKNAME = builder.getInstance(); 431 INSTANCE.registerPropertyDefinition(PD_SSL_CERT_NICKNAME); 432 } 433 434 435 436 // Build the "ssl-cipher-suite" property definition. 437 static { 438 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-cipher-suite"); 439 builder.setOption(PropertyOption.MULTI_VALUED); 440 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "ssl-cipher-suite")); 441 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-cipher-suite")); 442 PD_SSL_CIPHER_SUITE = builder.getInstance(); 443 INSTANCE.registerPropertyDefinition(PD_SSL_CIPHER_SUITE); 444 } 445 446 447 448 // Build the "ssl-client-auth-policy" property definition. 449 static { 450 EnumPropertyDefinition.Builder<SSLClientAuthPolicy> builder = EnumPropertyDefinition.createBuilder(INSTANCE, "ssl-client-auth-policy"); 451 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "ssl-client-auth-policy")); 452 DefaultBehaviorProvider<SSLClientAuthPolicy> provider = new DefinedDefaultBehaviorProvider<SSLClientAuthPolicy>("optional"); 453 builder.setDefaultBehaviorProvider(provider); 454 builder.setEnumClass(SSLClientAuthPolicy.class); 455 PD_SSL_CLIENT_AUTH_POLICY = builder.getInstance(); 456 INSTANCE.registerPropertyDefinition(PD_SSL_CLIENT_AUTH_POLICY); 457 } 458 459 460 461 // Build the "ssl-protocol" property definition. 462 static { 463 StringPropertyDefinition.Builder builder = StringPropertyDefinition.createBuilder(INSTANCE, "ssl-protocol"); 464 builder.setOption(PropertyOption.MULTI_VALUED); 465 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "ssl-protocol")); 466 builder.setDefaultBehaviorProvider(new AliasDefaultBehaviorProvider<String>(INSTANCE, "ssl-protocol")); 467 PD_SSL_PROTOCOL = builder.getInstance(); 468 INSTANCE.registerPropertyDefinition(PD_SSL_PROTOCOL); 469 } 470 471 472 473 // Build the "trust-manager-provider" property definition. 474 static { 475 AggregationPropertyDefinition.Builder<TrustManagerProviderCfgClient, TrustManagerProviderCfg> builder = AggregationPropertyDefinition.createBuilder(INSTANCE, "trust-manager-provider"); 476 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "trust-manager-provider")); 477 builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<String>()); 478 builder.setParentPath("/"); 479 builder.setRelationDefinition("trust-manager-provider"); 480 PD_TRUST_MANAGER_PROVIDER = builder.getInstance(); 481 INSTANCE.registerPropertyDefinition(PD_TRUST_MANAGER_PROVIDER); 482 INSTANCE.registerConstraint(PD_TRUST_MANAGER_PROVIDER.getSourceConstraint()); 483 } 484 485 486 487 // Build the "use-ssl" property definition. 488 static { 489 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "use-ssl"); 490 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.COMPONENT_RESTART, INSTANCE, "use-ssl")); 491 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("false"); 492 builder.setDefaultBehaviorProvider(provider); 493 PD_USE_SSL = builder.getInstance(); 494 INSTANCE.registerPropertyDefinition(PD_USE_SSL); 495 } 496 497 498 499 // Build the "use-tcp-keep-alive" property definition. 500 static { 501 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "use-tcp-keep-alive"); 502 builder.setOption(PropertyOption.ADVANCED); 503 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "use-tcp-keep-alive")); 504 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 505 builder.setDefaultBehaviorProvider(provider); 506 PD_USE_TCP_KEEP_ALIVE = builder.getInstance(); 507 INSTANCE.registerPropertyDefinition(PD_USE_TCP_KEEP_ALIVE); 508 } 509 510 511 512 // Build the "use-tcp-no-delay" property definition. 513 static { 514 BooleanPropertyDefinition.Builder builder = BooleanPropertyDefinition.createBuilder(INSTANCE, "use-tcp-no-delay"); 515 builder.setOption(PropertyOption.ADVANCED); 516 builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "use-tcp-no-delay")); 517 DefaultBehaviorProvider<Boolean> provider = new DefinedDefaultBehaviorProvider<Boolean>("true"); 518 builder.setDefaultBehaviorProvider(provider); 519 PD_USE_TCP_NO_DELAY = builder.getInstance(); 520 INSTANCE.registerPropertyDefinition(PD_USE_TCP_NO_DELAY); 521 } 522 523 524 525 // Register the tags associated with this managed object definition. 526 static { 527 INSTANCE.registerTag(Tag.valueOf("core-server")); 528 } 529 530 531 532 // Register the constraints associated with this managed object definition. 533 static { 534 INSTANCE.registerConstraint(new GenericConstraint(INSTANCE, 1, Conditions.implies(Conditions.contains("enabled", "true"), Conditions.implies(Conditions.or(Conditions.contains("use-ssl", "true"), Conditions.contains("allow-start-tls", "true")), Conditions.isPresent("key-manager-provider"))))); 535 INSTANCE.registerConstraint(new GenericConstraint(INSTANCE, 2, Conditions.implies(Conditions.contains("enabled", "true"), Conditions.implies(Conditions.or(Conditions.contains("use-ssl", "true"), Conditions.contains("allow-start-tls", "true")), Conditions.isPresent("trust-manager-provider"))))); 536 INSTANCE.registerConstraint(new GenericConstraint(INSTANCE, 3, Conditions.implies(Conditions.contains("enabled", "true"), Conditions.not(Conditions.and(Conditions.contains("use-ssl", "true"), Conditions.contains("allow-start-tls", "true")))))); 537 } 538 539 540 541 /** 542 * Get the LDAP Connection Handler configuration definition 543 * singleton. 544 * 545 * @return Returns the LDAP Connection Handler configuration 546 * definition singleton. 547 */ 548 public static LDAPConnectionHandlerCfgDefn getInstance() { 549 return INSTANCE; 550 } 551 552 553 554 /** 555 * Private constructor. 556 */ 557 private LDAPConnectionHandlerCfgDefn() { 558 super("ldap-connection-handler", ConnectionHandlerCfgDefn.getInstance()); 559 } 560 561 562 563 /** 564 * {@inheritDoc} 565 */ 566 public LDAPConnectionHandlerCfgClient createClientConfiguration( 567 ManagedObject<? extends LDAPConnectionHandlerCfgClient> impl) { 568 return new LDAPConnectionHandlerCfgClientImpl(impl); 569 } 570 571 572 573 /** 574 * {@inheritDoc} 575 */ 576 public LDAPConnectionHandlerCfg createServerConfiguration( 577 ServerManagedObject<? extends LDAPConnectionHandlerCfg> impl) { 578 return new LDAPConnectionHandlerCfgServerImpl(impl); 579 } 580 581 582 583 /** 584 * {@inheritDoc} 585 */ 586 public Class<LDAPConnectionHandlerCfg> getServerConfigurationClass() { 587 return LDAPConnectionHandlerCfg.class; 588 } 589 590 591 592 /** 593 * Get the "accept-backlog" property definition. 594 * <p> 595 * Specifies the maximum number of pending connection attempts that 596 * are allowed to queue up in the accept backlog before the server 597 * starts rejecting new connection attempts. 598 * <p> 599 * This is primarily an issue for cases in which a large number of 600 * connections are established to the server in a very short period 601 * of time (for example, a benchmark utility that creates a large 602 * number of client threads that each have their own connection to 603 * the server) and the connection handler is unable to keep up with 604 * the rate at which the new connections are established. 605 * 606 * @return Returns the "accept-backlog" property definition. 607 */ 608 public IntegerPropertyDefinition getAcceptBacklogPropertyDefinition() { 609 return PD_ACCEPT_BACKLOG; 610 } 611 612 613 614 /** 615 * Get the "allowed-client" property definition. 616 * <p> 617 * Specifies a set of address masks that determines the addresses of 618 * the clients that are allowed to establish connections to this 619 * connection handler. 620 * 621 * @return Returns the "allowed-client" property definition. 622 */ 623 public IPAddressMaskPropertyDefinition getAllowedClientPropertyDefinition() { 624 return ConnectionHandlerCfgDefn.getInstance().getAllowedClientPropertyDefinition(); 625 } 626 627 628 629 /** 630 * Get the "allow-ldap-v2" property definition. 631 * <p> 632 * Indicates whether connections from LDAPv2 clients are allowed. 633 * <p> 634 * If LDAPv2 clients are allowed, then only a minimal degree of 635 * special support are provided for them to ensure that 636 * LDAPv3-specific protocol elements (for example, Configuration 637 * Guide 25 controls, extended response messages, intermediate 638 * response messages, referrals) are not sent to an LDAPv2 client. 639 * 640 * @return Returns the "allow-ldap-v2" property definition. 641 */ 642 public BooleanPropertyDefinition getAllowLDAPV2PropertyDefinition() { 643 return PD_ALLOW_LDAP_V2; 644 } 645 646 647 648 /** 649 * Get the "allow-start-tls" property definition. 650 * <p> 651 * Indicates whether clients are allowed to use StartTLS. 652 * <p> 653 * If enabled, the LDAP Connection Handler allows clients to use the 654 * StartTLS extended operation to initiate secure communication over 655 * an otherwise insecure channel. Note that this is only allowed if 656 * the LDAP Connection Handler is not configured to use SSL, and if 657 * the server is configured with a valid key manager provider and a 658 * valid trust manager provider. 659 * 660 * @return Returns the "allow-start-tls" property definition. 661 */ 662 public BooleanPropertyDefinition getAllowStartTLSPropertyDefinition() { 663 return PD_ALLOW_START_TLS; 664 } 665 666 667 668 /** 669 * Get the "allow-tcp-reuse-address" property definition. 670 * <p> 671 * Indicates whether the LDAP Connection Handler should reuse socket 672 * descriptors. 673 * <p> 674 * If enabled, the SO_REUSEADDR socket option is used on the server 675 * listen socket to potentially allow the reuse of socket descriptors 676 * for clients in a TIME_WAIT state. This may help the server avoid 677 * temporarily running out of socket descriptors in cases in which a 678 * very large number of short-lived connections have been established 679 * from the same client system. 680 * 681 * @return Returns the "allow-tcp-reuse-address" property definition. 682 */ 683 public BooleanPropertyDefinition getAllowTCPReuseAddressPropertyDefinition() { 684 return PD_ALLOW_TCP_REUSE_ADDRESS; 685 } 686 687 688 689 /** 690 * Get the "denied-client" property definition. 691 * <p> 692 * Specifies a set of address masks that determines the addresses of 693 * the clients that are not allowed to establish connections to this 694 * connection handler. 695 * <p> 696 * If both allowed and denied client masks are defined and a client 697 * connection matches one or more masks in both lists, then the 698 * connection is denied. If only a denied list is specified, then any 699 * client not matching a mask in that list is allowed. 700 * 701 * @return Returns the "denied-client" property definition. 702 */ 703 public IPAddressMaskPropertyDefinition getDeniedClientPropertyDefinition() { 704 return ConnectionHandlerCfgDefn.getInstance().getDeniedClientPropertyDefinition(); 705 } 706 707 708 709 /** 710 * Get the "enabled" property definition. 711 * <p> 712 * Indicates whether the LDAP Connection Handler is enabled. 713 * 714 * @return Returns the "enabled" property definition. 715 */ 716 public BooleanPropertyDefinition getEnabledPropertyDefinition() { 717 return ConnectionHandlerCfgDefn.getInstance().getEnabledPropertyDefinition(); 718 } 719 720 721 722 /** 723 * Get the "java-class" property definition. 724 * <p> 725 * Specifies the fully-qualified name of the Java class that 726 * provides the LDAP Connection Handler implementation. 727 * 728 * @return Returns the "java-class" property definition. 729 */ 730 public ClassPropertyDefinition getJavaClassPropertyDefinition() { 731 return PD_JAVA_CLASS; 732 } 733 734 735 736 /** 737 * Get the "keep-stats" property definition. 738 * <p> 739 * Indicates whether the LDAP Connection Handler should keep 740 * statistics. 741 * <p> 742 * If enabled, the LDAP Connection Handler maintains statistics 743 * about the number and types of operations requested over LDAP and 744 * the amount of data sent and received. 745 * 746 * @return Returns the "keep-stats" property definition. 747 */ 748 public BooleanPropertyDefinition getKeepStatsPropertyDefinition() { 749 return PD_KEEP_STATS; 750 } 751 752 753 754 /** 755 * Get the "key-manager-provider" property definition. 756 * <p> 757 * Specifies the name of the key manager that should be used with 758 * this LDAP Connection Handler . 759 * 760 * @return Returns the "key-manager-provider" property definition. 761 */ 762 public AggregationPropertyDefinition<KeyManagerProviderCfgClient, KeyManagerProviderCfg> getKeyManagerProviderPropertyDefinition() { 763 return PD_KEY_MANAGER_PROVIDER; 764 } 765 766 767 768 /** 769 * Get the "listen-address" property definition. 770 * <p> 771 * Specifies the address or set of addresses on which this LDAP 772 * Connection Handler should listen for connections from LDAP 773 * clients. 774 * <p> 775 * Multiple addresses may be provided as separate values for this 776 * attribute. If no values are provided, then the LDAP Connection 777 * Handler listens on all interfaces. 778 * 779 * @return Returns the "listen-address" property definition. 780 */ 781 public IPAddressPropertyDefinition getListenAddressPropertyDefinition() { 782 return PD_LISTEN_ADDRESS; 783 } 784 785 786 787 /** 788 * Get the "listen-port" property definition. 789 * <p> 790 * Specifies the port number on which the LDAP Connection Handler 791 * will listen for connections from clients. 792 * <p> 793 * Only a single port number may be provided. 794 * 795 * @return Returns the "listen-port" property definition. 796 */ 797 public IntegerPropertyDefinition getListenPortPropertyDefinition() { 798 return PD_LISTEN_PORT; 799 } 800 801 802 803 /** 804 * Get the "max-blocked-write-time-limit" property definition. 805 * <p> 806 * Specifies the maximum length of time that attempts to write data 807 * to LDAP clients should be allowed to block. 808 * <p> 809 * If an attempt to write data to a client takes longer than this 810 * length of time, then the client connection is terminated. 811 * 812 * @return Returns the "max-blocked-write-time-limit" property definition. 813 */ 814 public DurationPropertyDefinition getMaxBlockedWriteTimeLimitPropertyDefinition() { 815 return PD_MAX_BLOCKED_WRITE_TIME_LIMIT; 816 } 817 818 819 820 /** 821 * Get the "max-request-size" property definition. 822 * <p> 823 * Specifies the size of the largest LDAP request message that will 824 * be allowed by this LDAP Connection handler. 825 * <p> 826 * This property is analogous to the maxBERSize configuration 827 * attribute of the Sun Java System Directory Server. This can help 828 * prevent denial-of-service attacks by clients that indicate they 829 * send extremely large requests to the server causing it to attempt 830 * to allocate large amounts of memory. 831 * 832 * @return Returns the "max-request-size" property definition. 833 */ 834 public SizePropertyDefinition getMaxRequestSizePropertyDefinition() { 835 return PD_MAX_REQUEST_SIZE; 836 } 837 838 839 840 /** 841 * Get the "num-request-handlers" property definition. 842 * <p> 843 * Specifies the number of request handlers that are used to read 844 * requests from clients. 845 * <p> 846 * The LDAP Connection Handler uses one thread to accept new 847 * connections from clients, but uses one or more additional threads 848 * to read requests from existing client connections. This ensures 849 * that new requests are read efficiently and that the connection 850 * handler itself does not become a bottleneck when the server is 851 * under heavy load from many clients at the same time. 852 * 853 * @return Returns the "num-request-handlers" property definition. 854 */ 855 public IntegerPropertyDefinition getNumRequestHandlersPropertyDefinition() { 856 return PD_NUM_REQUEST_HANDLERS; 857 } 858 859 860 861 /** 862 * Get the "send-rejection-notice" property definition. 863 * <p> 864 * Indicates whether the LDAP Connection Handler should send a 865 * notice of disconnection extended response message to the client if 866 * a new connection is rejected for some reason. 867 * <p> 868 * The extended response message may provide an explanation 869 * indicating the reason that the connection was rejected. 870 * 871 * @return Returns the "send-rejection-notice" property definition. 872 */ 873 public BooleanPropertyDefinition getSendRejectionNoticePropertyDefinition() { 874 return PD_SEND_REJECTION_NOTICE; 875 } 876 877 878 879 /** 880 * Get the "ssl-cert-nickname" property definition. 881 * <p> 882 * Specifies the nickname (also called the alias) of the certificate 883 * that the LDAP Connection Handler should use when performing SSL 884 * communication. 885 * <p> 886 * This is only applicable when the LDAP Connection Handler is 887 * configured to use SSL. 888 * 889 * @return Returns the "ssl-cert-nickname" property definition. 890 */ 891 public StringPropertyDefinition getSSLCertNicknamePropertyDefinition() { 892 return PD_SSL_CERT_NICKNAME; 893 } 894 895 896 897 /** 898 * Get the "ssl-cipher-suite" property definition. 899 * <p> 900 * Specifies the names of the SSL cipher suites that are allowed for 901 * use in SSL or StartTLS communication. 902 * 903 * @return Returns the "ssl-cipher-suite" property definition. 904 */ 905 public StringPropertyDefinition getSSLCipherSuitePropertyDefinition() { 906 return PD_SSL_CIPHER_SUITE; 907 } 908 909 910 911 /** 912 * Get the "ssl-client-auth-policy" property definition. 913 * <p> 914 * Specifies the policy that the LDAP Connection Handler should use 915 * regarding client SSL certificates. 916 * <p> 917 * This is only applicable if clients are allowed to use SSL. 918 * 919 * @return Returns the "ssl-client-auth-policy" property definition. 920 */ 921 public EnumPropertyDefinition<SSLClientAuthPolicy> getSSLClientAuthPolicyPropertyDefinition() { 922 return PD_SSL_CLIENT_AUTH_POLICY; 923 } 924 925 926 927 /** 928 * Get the "ssl-protocol" property definition. 929 * <p> 930 * Specifies the names of the SSL protocols that are allowed for use 931 * in SSL or StartTLS communication. 932 * 933 * @return Returns the "ssl-protocol" property definition. 934 */ 935 public StringPropertyDefinition getSSLProtocolPropertyDefinition() { 936 return PD_SSL_PROTOCOL; 937 } 938 939 940 941 /** 942 * Get the "trust-manager-provider" property definition. 943 * <p> 944 * Specifies the name of the trust manager that should be used with 945 * the LDAP Connection Handler . 946 * 947 * @return Returns the "trust-manager-provider" property definition. 948 */ 949 public AggregationPropertyDefinition<TrustManagerProviderCfgClient, TrustManagerProviderCfg> getTrustManagerProviderPropertyDefinition() { 950 return PD_TRUST_MANAGER_PROVIDER; 951 } 952 953 954 955 /** 956 * Get the "use-ssl" property definition. 957 * <p> 958 * Indicates whether the LDAP Connection Handler should use SSL. 959 * <p> 960 * If enabled, the LDAP Connection Handler will use SSL to encrypt 961 * communication with the clients. 962 * 963 * @return Returns the "use-ssl" property definition. 964 */ 965 public BooleanPropertyDefinition getUseSSLPropertyDefinition() { 966 return PD_USE_SSL; 967 } 968 969 970 971 /** 972 * Get the "use-tcp-keep-alive" property definition. 973 * <p> 974 * Indicates whether the LDAP Connection Handler should use TCP 975 * keep-alive. 976 * <p> 977 * If enabled, the SO_KEEPALIVE socket option is used to indicate 978 * that TCP keepalive messages should periodically be sent to the 979 * client to verify that the associated connection is still valid. 980 * This may also help prevent cases in which intermediate network 981 * hardware could silently drop an otherwise idle client connection, 982 * provided that the keepalive interval configured in the underlying 983 * operating system is smaller than the timeout enforced by the 984 * network hardware. 985 * 986 * @return Returns the "use-tcp-keep-alive" property definition. 987 */ 988 public BooleanPropertyDefinition getUseTCPKeepAlivePropertyDefinition() { 989 return PD_USE_TCP_KEEP_ALIVE; 990 } 991 992 993 994 /** 995 * Get the "use-tcp-no-delay" property definition. 996 * <p> 997 * Indicates whether the LDAP Connection Handler should use TCP 998 * no-delay. 999 * <p> 1000 * If enabled, the TCP_NODELAY socket option is used to ensure that 1001 * response messages to the client are sent immediately rather than 1002 * potentially waiting to determine whether additional response 1003 * messages can be sent in the same packet. In most cases, using the 1004 * TCP_NODELAY socket option provides better performance and lower 1005 * response times, but disabling it may help for some cases in which 1006 * the server sends a large number of entries to a client in response 1007 * to a search request. 1008 * 1009 * @return Returns the "use-tcp-no-delay" property definition. 1010 */ 1011 public BooleanPropertyDefinition getUseTCPNoDelayPropertyDefinition() { 1012 return PD_USE_TCP_NO_DELAY; 1013 } 1014 1015 1016 1017 /** 1018 * Managed object client implementation. 1019 */ 1020 private static class LDAPConnectionHandlerCfgClientImpl implements 1021 LDAPConnectionHandlerCfgClient { 1022 1023 // Private implementation. 1024 private ManagedObject<? extends LDAPConnectionHandlerCfgClient> impl; 1025 1026 1027 1028 // Private constructor. 1029 private LDAPConnectionHandlerCfgClientImpl( 1030 ManagedObject<? extends LDAPConnectionHandlerCfgClient> impl) { 1031 this.impl = impl; 1032 } 1033 1034 1035 1036 /** 1037 * {@inheritDoc} 1038 */ 1039 public int getAcceptBacklog() { 1040 return impl.getPropertyValue(INSTANCE.getAcceptBacklogPropertyDefinition()); 1041 } 1042 1043 1044 1045 /** 1046 * {@inheritDoc} 1047 */ 1048 public void setAcceptBacklog(Integer value) { 1049 impl.setPropertyValue(INSTANCE.getAcceptBacklogPropertyDefinition(), value); 1050 } 1051 1052 1053 1054 /** 1055 * {@inheritDoc} 1056 */ 1057 public SortedSet<AddressMask> getAllowedClient() { 1058 return impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition()); 1059 } 1060 1061 1062 1063 /** 1064 * {@inheritDoc} 1065 */ 1066 public void setAllowedClient(Collection<AddressMask> values) { 1067 impl.setPropertyValues(INSTANCE.getAllowedClientPropertyDefinition(), values); 1068 } 1069 1070 1071 1072 /** 1073 * {@inheritDoc} 1074 */ 1075 public boolean isAllowLDAPV2() { 1076 return impl.getPropertyValue(INSTANCE.getAllowLDAPV2PropertyDefinition()); 1077 } 1078 1079 1080 1081 /** 1082 * {@inheritDoc} 1083 */ 1084 public void setAllowLDAPV2(Boolean value) { 1085 impl.setPropertyValue(INSTANCE.getAllowLDAPV2PropertyDefinition(), value); 1086 } 1087 1088 1089 1090 /** 1091 * {@inheritDoc} 1092 */ 1093 public boolean isAllowStartTLS() { 1094 return impl.getPropertyValue(INSTANCE.getAllowStartTLSPropertyDefinition()); 1095 } 1096 1097 1098 1099 /** 1100 * {@inheritDoc} 1101 */ 1102 public void setAllowStartTLS(Boolean value) { 1103 impl.setPropertyValue(INSTANCE.getAllowStartTLSPropertyDefinition(), value); 1104 } 1105 1106 1107 1108 /** 1109 * {@inheritDoc} 1110 */ 1111 public boolean isAllowTCPReuseAddress() { 1112 return impl.getPropertyValue(INSTANCE.getAllowTCPReuseAddressPropertyDefinition()); 1113 } 1114 1115 1116 1117 /** 1118 * {@inheritDoc} 1119 */ 1120 public void setAllowTCPReuseAddress(Boolean value) { 1121 impl.setPropertyValue(INSTANCE.getAllowTCPReuseAddressPropertyDefinition(), value); 1122 } 1123 1124 1125 1126 /** 1127 * {@inheritDoc} 1128 */ 1129 public SortedSet<AddressMask> getDeniedClient() { 1130 return impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition()); 1131 } 1132 1133 1134 1135 /** 1136 * {@inheritDoc} 1137 */ 1138 public void setDeniedClient(Collection<AddressMask> values) { 1139 impl.setPropertyValues(INSTANCE.getDeniedClientPropertyDefinition(), values); 1140 } 1141 1142 1143 1144 /** 1145 * {@inheritDoc} 1146 */ 1147 public Boolean isEnabled() { 1148 return impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 1149 } 1150 1151 1152 1153 /** 1154 * {@inheritDoc} 1155 */ 1156 public void setEnabled(boolean value) { 1157 impl.setPropertyValue(INSTANCE.getEnabledPropertyDefinition(), value); 1158 } 1159 1160 1161 1162 /** 1163 * {@inheritDoc} 1164 */ 1165 public String getJavaClass() { 1166 return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 1167 } 1168 1169 1170 1171 /** 1172 * {@inheritDoc} 1173 */ 1174 public void setJavaClass(String value) { 1175 impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value); 1176 } 1177 1178 1179 1180 /** 1181 * {@inheritDoc} 1182 */ 1183 public boolean isKeepStats() { 1184 return impl.getPropertyValue(INSTANCE.getKeepStatsPropertyDefinition()); 1185 } 1186 1187 1188 1189 /** 1190 * {@inheritDoc} 1191 */ 1192 public void setKeepStats(Boolean value) { 1193 impl.setPropertyValue(INSTANCE.getKeepStatsPropertyDefinition(), value); 1194 } 1195 1196 1197 1198 /** 1199 * {@inheritDoc} 1200 */ 1201 public String getKeyManagerProvider() { 1202 return impl.getPropertyValue(INSTANCE.getKeyManagerProviderPropertyDefinition()); 1203 } 1204 1205 1206 1207 /** 1208 * {@inheritDoc} 1209 */ 1210 public void setKeyManagerProvider(String value) { 1211 impl.setPropertyValue(INSTANCE.getKeyManagerProviderPropertyDefinition(), value); 1212 } 1213 1214 1215 1216 /** 1217 * {@inheritDoc} 1218 */ 1219 public SortedSet<InetAddress> getListenAddress() { 1220 return impl.getPropertyValues(INSTANCE.getListenAddressPropertyDefinition()); 1221 } 1222 1223 1224 1225 /** 1226 * {@inheritDoc} 1227 */ 1228 public void setListenAddress(Collection<InetAddress> values) { 1229 impl.setPropertyValues(INSTANCE.getListenAddressPropertyDefinition(), values); 1230 } 1231 1232 1233 1234 /** 1235 * {@inheritDoc} 1236 */ 1237 public Integer getListenPort() { 1238 return impl.getPropertyValue(INSTANCE.getListenPortPropertyDefinition()); 1239 } 1240 1241 1242 1243 /** 1244 * {@inheritDoc} 1245 */ 1246 public void setListenPort(int value) { 1247 impl.setPropertyValue(INSTANCE.getListenPortPropertyDefinition(), value); 1248 } 1249 1250 1251 1252 /** 1253 * {@inheritDoc} 1254 */ 1255 public long getMaxBlockedWriteTimeLimit() { 1256 return impl.getPropertyValue(INSTANCE.getMaxBlockedWriteTimeLimitPropertyDefinition()); 1257 } 1258 1259 1260 1261 /** 1262 * {@inheritDoc} 1263 */ 1264 public void setMaxBlockedWriteTimeLimit(Long value) { 1265 impl.setPropertyValue(INSTANCE.getMaxBlockedWriteTimeLimitPropertyDefinition(), value); 1266 } 1267 1268 1269 1270 /** 1271 * {@inheritDoc} 1272 */ 1273 public long getMaxRequestSize() { 1274 return impl.getPropertyValue(INSTANCE.getMaxRequestSizePropertyDefinition()); 1275 } 1276 1277 1278 1279 /** 1280 * {@inheritDoc} 1281 */ 1282 public void setMaxRequestSize(Long value) { 1283 impl.setPropertyValue(INSTANCE.getMaxRequestSizePropertyDefinition(), value); 1284 } 1285 1286 1287 1288 /** 1289 * {@inheritDoc} 1290 */ 1291 public int getNumRequestHandlers() { 1292 return impl.getPropertyValue(INSTANCE.getNumRequestHandlersPropertyDefinition()); 1293 } 1294 1295 1296 1297 /** 1298 * {@inheritDoc} 1299 */ 1300 public void setNumRequestHandlers(Integer value) { 1301 impl.setPropertyValue(INSTANCE.getNumRequestHandlersPropertyDefinition(), value); 1302 } 1303 1304 1305 1306 /** 1307 * {@inheritDoc} 1308 */ 1309 public boolean isSendRejectionNotice() { 1310 return impl.getPropertyValue(INSTANCE.getSendRejectionNoticePropertyDefinition()); 1311 } 1312 1313 1314 1315 /** 1316 * {@inheritDoc} 1317 */ 1318 public void setSendRejectionNotice(Boolean value) { 1319 impl.setPropertyValue(INSTANCE.getSendRejectionNoticePropertyDefinition(), value); 1320 } 1321 1322 1323 1324 /** 1325 * {@inheritDoc} 1326 */ 1327 public String getSSLCertNickname() { 1328 return impl.getPropertyValue(INSTANCE.getSSLCertNicknamePropertyDefinition()); 1329 } 1330 1331 1332 1333 /** 1334 * {@inheritDoc} 1335 */ 1336 public void setSSLCertNickname(String value) { 1337 impl.setPropertyValue(INSTANCE.getSSLCertNicknamePropertyDefinition(), value); 1338 } 1339 1340 1341 1342 /** 1343 * {@inheritDoc} 1344 */ 1345 public SortedSet<String> getSSLCipherSuite() { 1346 return impl.getPropertyValues(INSTANCE.getSSLCipherSuitePropertyDefinition()); 1347 } 1348 1349 1350 1351 /** 1352 * {@inheritDoc} 1353 */ 1354 public void setSSLCipherSuite(Collection<String> values) { 1355 impl.setPropertyValues(INSTANCE.getSSLCipherSuitePropertyDefinition(), values); 1356 } 1357 1358 1359 1360 /** 1361 * {@inheritDoc} 1362 */ 1363 public SSLClientAuthPolicy getSSLClientAuthPolicy() { 1364 return impl.getPropertyValue(INSTANCE.getSSLClientAuthPolicyPropertyDefinition()); 1365 } 1366 1367 1368 1369 /** 1370 * {@inheritDoc} 1371 */ 1372 public void setSSLClientAuthPolicy(SSLClientAuthPolicy value) { 1373 impl.setPropertyValue(INSTANCE.getSSLClientAuthPolicyPropertyDefinition(), value); 1374 } 1375 1376 1377 1378 /** 1379 * {@inheritDoc} 1380 */ 1381 public SortedSet<String> getSSLProtocol() { 1382 return impl.getPropertyValues(INSTANCE.getSSLProtocolPropertyDefinition()); 1383 } 1384 1385 1386 1387 /** 1388 * {@inheritDoc} 1389 */ 1390 public void setSSLProtocol(Collection<String> values) { 1391 impl.setPropertyValues(INSTANCE.getSSLProtocolPropertyDefinition(), values); 1392 } 1393 1394 1395 1396 /** 1397 * {@inheritDoc} 1398 */ 1399 public String getTrustManagerProvider() { 1400 return impl.getPropertyValue(INSTANCE.getTrustManagerProviderPropertyDefinition()); 1401 } 1402 1403 1404 1405 /** 1406 * {@inheritDoc} 1407 */ 1408 public void setTrustManagerProvider(String value) { 1409 impl.setPropertyValue(INSTANCE.getTrustManagerProviderPropertyDefinition(), value); 1410 } 1411 1412 1413 1414 /** 1415 * {@inheritDoc} 1416 */ 1417 public boolean isUseSSL() { 1418 return impl.getPropertyValue(INSTANCE.getUseSSLPropertyDefinition()); 1419 } 1420 1421 1422 1423 /** 1424 * {@inheritDoc} 1425 */ 1426 public void setUseSSL(Boolean value) { 1427 impl.setPropertyValue(INSTANCE.getUseSSLPropertyDefinition(), value); 1428 } 1429 1430 1431 1432 /** 1433 * {@inheritDoc} 1434 */ 1435 public boolean isUseTCPKeepAlive() { 1436 return impl.getPropertyValue(INSTANCE.getUseTCPKeepAlivePropertyDefinition()); 1437 } 1438 1439 1440 1441 /** 1442 * {@inheritDoc} 1443 */ 1444 public void setUseTCPKeepAlive(Boolean value) { 1445 impl.setPropertyValue(INSTANCE.getUseTCPKeepAlivePropertyDefinition(), value); 1446 } 1447 1448 1449 1450 /** 1451 * {@inheritDoc} 1452 */ 1453 public boolean isUseTCPNoDelay() { 1454 return impl.getPropertyValue(INSTANCE.getUseTCPNoDelayPropertyDefinition()); 1455 } 1456 1457 1458 1459 /** 1460 * {@inheritDoc} 1461 */ 1462 public void setUseTCPNoDelay(Boolean value) { 1463 impl.setPropertyValue(INSTANCE.getUseTCPNoDelayPropertyDefinition(), value); 1464 } 1465 1466 1467 1468 /** 1469 * {@inheritDoc} 1470 */ 1471 public ManagedObjectDefinition<? extends LDAPConnectionHandlerCfgClient, ? extends LDAPConnectionHandlerCfg> definition() { 1472 return INSTANCE; 1473 } 1474 1475 1476 1477 /** 1478 * {@inheritDoc} 1479 */ 1480 public PropertyProvider properties() { 1481 return impl; 1482 } 1483 1484 1485 1486 /** 1487 * {@inheritDoc} 1488 */ 1489 public void commit() throws ManagedObjectAlreadyExistsException, 1490 MissingMandatoryPropertiesException, ConcurrentModificationException, 1491 OperationRejectedException, AuthorizationException, 1492 CommunicationException { 1493 impl.commit(); 1494 } 1495 1496 } 1497 1498 1499 1500 /** 1501 * Managed object server implementation. 1502 */ 1503 private static class LDAPConnectionHandlerCfgServerImpl implements 1504 LDAPConnectionHandlerCfg { 1505 1506 // Private implementation. 1507 private ServerManagedObject<? extends LDAPConnectionHandlerCfg> impl; 1508 1509 // The value of the "accept-backlog" property. 1510 private final int pAcceptBacklog; 1511 1512 // The value of the "allowed-client" property. 1513 private final SortedSet<AddressMask> pAllowedClient; 1514 1515 // The value of the "allow-ldap-v2" property. 1516 private final boolean pAllowLDAPV2; 1517 1518 // The value of the "allow-start-tls" property. 1519 private final boolean pAllowStartTLS; 1520 1521 // The value of the "allow-tcp-reuse-address" property. 1522 private final boolean pAllowTCPReuseAddress; 1523 1524 // The value of the "denied-client" property. 1525 private final SortedSet<AddressMask> pDeniedClient; 1526 1527 // The value of the "enabled" property. 1528 private final boolean pEnabled; 1529 1530 // The value of the "java-class" property. 1531 private final String pJavaClass; 1532 1533 // The value of the "keep-stats" property. 1534 private final boolean pKeepStats; 1535 1536 // The value of the "key-manager-provider" property. 1537 private final String pKeyManagerProvider; 1538 1539 // The value of the "listen-address" property. 1540 private final SortedSet<InetAddress> pListenAddress; 1541 1542 // The value of the "listen-port" property. 1543 private final int pListenPort; 1544 1545 // The value of the "max-blocked-write-time-limit" property. 1546 private final long pMaxBlockedWriteTimeLimit; 1547 1548 // The value of the "max-request-size" property. 1549 private final long pMaxRequestSize; 1550 1551 // The value of the "num-request-handlers" property. 1552 private final int pNumRequestHandlers; 1553 1554 // The value of the "send-rejection-notice" property. 1555 private final boolean pSendRejectionNotice; 1556 1557 // The value of the "ssl-cert-nickname" property. 1558 private final String pSSLCertNickname; 1559 1560 // The value of the "ssl-cipher-suite" property. 1561 private final SortedSet<String> pSSLCipherSuite; 1562 1563 // The value of the "ssl-client-auth-policy" property. 1564 private final SSLClientAuthPolicy pSSLClientAuthPolicy; 1565 1566 // The value of the "ssl-protocol" property. 1567 private final SortedSet<String> pSSLProtocol; 1568 1569 // The value of the "trust-manager-provider" property. 1570 private final String pTrustManagerProvider; 1571 1572 // The value of the "use-ssl" property. 1573 private final boolean pUseSSL; 1574 1575 // The value of the "use-tcp-keep-alive" property. 1576 private final boolean pUseTCPKeepAlive; 1577 1578 // The value of the "use-tcp-no-delay" property. 1579 private final boolean pUseTCPNoDelay; 1580 1581 1582 1583 // Private constructor. 1584 private LDAPConnectionHandlerCfgServerImpl(ServerManagedObject<? extends LDAPConnectionHandlerCfg> impl) { 1585 this.impl = impl; 1586 this.pAcceptBacklog = impl.getPropertyValue(INSTANCE.getAcceptBacklogPropertyDefinition()); 1587 this.pAllowedClient = impl.getPropertyValues(INSTANCE.getAllowedClientPropertyDefinition()); 1588 this.pAllowLDAPV2 = impl.getPropertyValue(INSTANCE.getAllowLDAPV2PropertyDefinition()); 1589 this.pAllowStartTLS = impl.getPropertyValue(INSTANCE.getAllowStartTLSPropertyDefinition()); 1590 this.pAllowTCPReuseAddress = impl.getPropertyValue(INSTANCE.getAllowTCPReuseAddressPropertyDefinition()); 1591 this.pDeniedClient = impl.getPropertyValues(INSTANCE.getDeniedClientPropertyDefinition()); 1592 this.pEnabled = impl.getPropertyValue(INSTANCE.getEnabledPropertyDefinition()); 1593 this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition()); 1594 this.pKeepStats = impl.getPropertyValue(INSTANCE.getKeepStatsPropertyDefinition()); 1595 this.pKeyManagerProvider = impl.getPropertyValue(INSTANCE.getKeyManagerProviderPropertyDefinition()); 1596 this.pListenAddress = impl.getPropertyValues(INSTANCE.getListenAddressPropertyDefinition()); 1597 this.pListenPort = impl.getPropertyValue(INSTANCE.getListenPortPropertyDefinition()); 1598 this.pMaxBlockedWriteTimeLimit = impl.getPropertyValue(INSTANCE.getMaxBlockedWriteTimeLimitPropertyDefinition()); 1599 this.pMaxRequestSize = impl.getPropertyValue(INSTANCE.getMaxRequestSizePropertyDefinition()); 1600 this.pNumRequestHandlers = impl.getPropertyValue(INSTANCE.getNumRequestHandlersPropertyDefinition()); 1601 this.pSendRejectionNotice = impl.getPropertyValue(INSTANCE.getSendRejectionNoticePropertyDefinition()); 1602 this.pSSLCertNickname = impl.getPropertyValue(INSTANCE.getSSLCertNicknamePropertyDefinition()); 1603 this.pSSLCipherSuite = impl.getPropertyValues(INSTANCE.getSSLCipherSuitePropertyDefinition()); 1604 this.pSSLClientAuthPolicy = impl.getPropertyValue(INSTANCE.getSSLClientAuthPolicyPropertyDefinition()); 1605 this.pSSLProtocol = impl.getPropertyValues(INSTANCE.getSSLProtocolPropertyDefinition()); 1606 this.pTrustManagerProvider = impl.getPropertyValue(INSTANCE.getTrustManagerProviderPropertyDefinition()); 1607 this.pUseSSL = impl.getPropertyValue(INSTANCE.getUseSSLPropertyDefinition()); 1608 this.pUseTCPKeepAlive = impl.getPropertyValue(INSTANCE.getUseTCPKeepAlivePropertyDefinition()); 1609 this.pUseTCPNoDelay = impl.getPropertyValue(INSTANCE.getUseTCPNoDelayPropertyDefinition()); 1610 } 1611 1612 1613 1614 /** 1615 * {@inheritDoc} 1616 */ 1617 public void addLDAPChangeListener( 1618 ConfigurationChangeListener<LDAPConnectionHandlerCfg> listener) { 1619 impl.registerChangeListener(listener); 1620 } 1621 1622 1623 1624 /** 1625 * {@inheritDoc} 1626 */ 1627 public void removeLDAPChangeListener( 1628 ConfigurationChangeListener<LDAPConnectionHandlerCfg> listener) { 1629 impl.deregisterChangeListener(listener); 1630 } 1631 /** 1632 * {@inheritDoc} 1633 */ 1634 public void addChangeListener( 1635 ConfigurationChangeListener<ConnectionHandlerCfg> listener) { 1636 impl.registerChangeListener(listener); 1637 } 1638 1639 1640 1641 /** 1642 * {@inheritDoc} 1643 */ 1644 public void removeChangeListener( 1645 ConfigurationChangeListener<ConnectionHandlerCfg> listener) { 1646 impl.deregisterChangeListener(listener); 1647 } 1648 1649 1650 1651 /** 1652 * {@inheritDoc} 1653 */ 1654 public int getAcceptBacklog() { 1655 return pAcceptBacklog; 1656 } 1657 1658 1659 1660 /** 1661 * {@inheritDoc} 1662 */ 1663 public SortedSet<AddressMask> getAllowedClient() { 1664 return pAllowedClient; 1665 } 1666 1667 1668 1669 /** 1670 * {@inheritDoc} 1671 */ 1672 public boolean isAllowLDAPV2() { 1673 return pAllowLDAPV2; 1674 } 1675 1676 1677 1678 /** 1679 * {@inheritDoc} 1680 */ 1681 public boolean isAllowStartTLS() { 1682 return pAllowStartTLS; 1683 } 1684 1685 1686 1687 /** 1688 * {@inheritDoc} 1689 */ 1690 public boolean isAllowTCPReuseAddress() { 1691 return pAllowTCPReuseAddress; 1692 } 1693 1694 1695 1696 /** 1697 * {@inheritDoc} 1698 */ 1699 public SortedSet<AddressMask> getDeniedClient() { 1700 return pDeniedClient; 1701 } 1702 1703 1704 1705 /** 1706 * {@inheritDoc} 1707 */ 1708 public boolean isEnabled() { 1709 return pEnabled; 1710 } 1711 1712 1713 1714 /** 1715 * {@inheritDoc} 1716 */ 1717 public String getJavaClass() { 1718 return pJavaClass; 1719 } 1720 1721 1722 1723 /** 1724 * {@inheritDoc} 1725 */ 1726 public boolean isKeepStats() { 1727 return pKeepStats; 1728 } 1729 1730 1731 1732 /** 1733 * {@inheritDoc} 1734 */ 1735 public String getKeyManagerProvider() { 1736 return pKeyManagerProvider; 1737 } 1738 1739 1740 1741 /** 1742 * {@inheritDoc} 1743 */ 1744 public DN getKeyManagerProviderDN() { 1745 String value = getKeyManagerProvider(); 1746 if (value == null) return null; 1747 return INSTANCE.getKeyManagerProviderPropertyDefinition().getChildDN(value); 1748 } 1749 1750 1751 1752 /** 1753 * {@inheritDoc} 1754 */ 1755 public SortedSet<InetAddress> getListenAddress() { 1756 return pListenAddress; 1757 } 1758 1759 1760 1761 /** 1762 * {@inheritDoc} 1763 */ 1764 public int getListenPort() { 1765 return pListenPort; 1766 } 1767 1768 1769 1770 /** 1771 * {@inheritDoc} 1772 */ 1773 public long getMaxBlockedWriteTimeLimit() { 1774 return pMaxBlockedWriteTimeLimit; 1775 } 1776 1777 1778 1779 /** 1780 * {@inheritDoc} 1781 */ 1782 public long getMaxRequestSize() { 1783 return pMaxRequestSize; 1784 } 1785 1786 1787 1788 /** 1789 * {@inheritDoc} 1790 */ 1791 public int getNumRequestHandlers() { 1792 return pNumRequestHandlers; 1793 } 1794 1795 1796 1797 /** 1798 * {@inheritDoc} 1799 */ 1800 public boolean isSendRejectionNotice() { 1801 return pSendRejectionNotice; 1802 } 1803 1804 1805 1806 /** 1807 * {@inheritDoc} 1808 */ 1809 public String getSSLCertNickname() { 1810 return pSSLCertNickname; 1811 } 1812 1813 1814 1815 /** 1816 * {@inheritDoc} 1817 */ 1818 public SortedSet<String> getSSLCipherSuite() { 1819 return pSSLCipherSuite; 1820 } 1821 1822 1823 1824 /** 1825 * {@inheritDoc} 1826 */ 1827 public SSLClientAuthPolicy getSSLClientAuthPolicy() { 1828 return pSSLClientAuthPolicy; 1829 } 1830 1831 1832 1833 /** 1834 * {@inheritDoc} 1835 */ 1836 public SortedSet<String> getSSLProtocol() { 1837 return pSSLProtocol; 1838 } 1839 1840 1841 1842 /** 1843 * {@inheritDoc} 1844 */ 1845 public String getTrustManagerProvider() { 1846 return pTrustManagerProvider; 1847 } 1848 1849 1850 1851 /** 1852 * {@inheritDoc} 1853 */ 1854 public DN getTrustManagerProviderDN() { 1855 String value = getTrustManagerProvider(); 1856 if (value == null) return null; 1857 return INSTANCE.getTrustManagerProviderPropertyDefinition().getChildDN(value); 1858 } 1859 1860 1861 1862 /** 1863 * {@inheritDoc} 1864 */ 1865 public boolean isUseSSL() { 1866 return pUseSSL; 1867 } 1868 1869 1870 1871 /** 1872 * {@inheritDoc} 1873 */ 1874 public boolean isUseTCPKeepAlive() { 1875 return pUseTCPKeepAlive; 1876 } 1877 1878 1879 1880 /** 1881 * {@inheritDoc} 1882 */ 1883 public boolean isUseTCPNoDelay() { 1884 return pUseTCPNoDelay; 1885 } 1886 1887 1888 1889 /** 1890 * {@inheritDoc} 1891 */ 1892 public Class<? extends LDAPConnectionHandlerCfg> configurationClass() { 1893 return LDAPConnectionHandlerCfg.class; 1894 } 1895 1896 1897 1898 /** 1899 * {@inheritDoc} 1900 */ 1901 public DN dn() { 1902 return impl.getDN(); 1903 } 1904 1905 } 1906 }